Merge branch 'master' of ssh://crater.dragonflybsd.org/repository/git/dragonfly
[dragonfly.git] / contrib / gcc-3.4 / gcc / opts.c
CommitLineData
003757ed
MD
1/* Command line option handling.
2 Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
3 Contributed by Neil Booth.
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 2, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING. If not, write to the Free
19Software Foundation, 59 Temple Place - Suite 330, Boston, MA
2002111-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
41/* Value of the -G xx switch, and whether it was passed or not. */
42unsigned HOST_WIDE_INT g_switch_value;
43bool g_switch_set;
44
45/* True if we should exit after parsing options. */
46bool exit_after_options;
47
48/* If -version. */
49bool version_flag;
50
51/* Print various extra warnings. -W/-Wextra. */
52bool extra_warnings;
53
54/* Don't print warning messages. -w. */
55bool inhibit_warnings;
56
57/* Treat warnings as errors. -Werror. */
58bool warnings_are_errors;
59
60/* Warn if a function returns an aggregate, since there are often
61 incompatible calling conventions for doing this. */
62bool warn_aggregate_return;
63
64/* Nonzero means warn about pointer casts that increase the required
65 alignment of the target type (and might therefore lead to a crash
66 due to a misaligned access). */
67bool warn_cast_align;
68
69/* Nonzero means warn about uses of __attribute__((deprecated))
70 declarations. */
71bool warn_deprecated_decl = true;
72
73/* Warn when an optimization pass is disabled. */
74bool warn_disabled_optimization;
75
76/* Nonzero means warn if inline function is too large. */
77bool warn_inline;
78
79/* True to warn about any objects definitions whose size is larger
80 than N bytes. Also want about function definitions whose returned
81 values are larger than N bytes, where N is `larger_than_size'. */
82bool warn_larger_than;
83HOST_WIDE_INT larger_than_size;
84
85/* Warn about functions which might be candidates for attribute noreturn. */
86bool warn_missing_noreturn;
87
88/* True to warn about code which is never reached. */
89bool warn_notreached;
90
91/* Warn if packed attribute on struct is unnecessary and inefficient. */
92bool warn_packed;
93
94/* Warn when gcc pads a structure to an alignment boundary. */
95bool warn_padded;
96
97/* True means warn about all declarations which shadow others. */
98bool warn_shadow;
99
100/* Nonzero means warn about constructs which might not be
101 strict-aliasing safe. */
102bool warn_strict_aliasing;
103
104/* True to warn if a switch on an enum, that does not have a default
105 case, fails to have a case for every enum value. */
106bool warn_switch;
107
108/* Warn if a switch does not have a default case. */
109bool warn_switch_default;
110
111/* Warn if a switch on an enum fails to have a case for every enum
112 value (regardless of the presence or otherwise of a default case). */
113bool warn_switch_enum;
114
115/* Don't suppress warnings from system headers. -Wsystem-headers. */
116bool warn_system_headers;
117
118/* True to warn about variables used before they are initialized. */
119int warn_uninitialized;
120
121/* True to warn about unused variables, functions et.al. */
122bool warn_unused_function;
123bool warn_unused_label;
124bool warn_unused_parameter;
125bool warn_unused_variable;
126bool warn_unused_value;
127
128/* Hack for cooperation between set_Wunused and set_Wextra. */
129static bool maybe_warn_unused_parameter;
130
131/* Type(s) of debugging information we are producing (if any). See
132 flags.h for the definitions of the different possible types of
133 debugging information. */
134enum debug_info_type write_symbols = NO_DEBUG;
135
136/* Level of debugging information we are producing. See flags.h for
137 the definitions of the different possible levels. */
138enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
139
140/* Nonzero means use GNU-only extensions in the generated symbolic
141 debugging information. Currently, this only has an effect when
142 write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
143bool use_gnu_debug_info_extensions;
144
145/* Columns of --help display. */
146static unsigned int columns = 80;
147
148/* What to print when a switch has no documentation. */
149static const char undocumented_msg[] = N_("This switch lacks documentation");
150
151/* Used for bookkeeping on whether user set these flags so
152 -fprofile-use/-fprofile-generate does not use them. */
153static bool profile_arc_flag_set, flag_profile_values_set;
154static bool flag_unroll_loops_set, flag_tracer_set;
155static bool flag_value_profile_transformations_set;
156static bool flag_peel_loops_set, flag_branch_probabilities_set;
157
158/* Input file names. */
159const char **in_fnames;
160unsigned num_in_fnames;
161
162static size_t find_opt (const char *, int);
163static int common_handle_option (size_t scode, const char *arg, int value);
164static void handle_param (const char *);
165static void set_Wextra (int);
166static unsigned int handle_option (const char **argv, unsigned int lang_mask);
167static char *write_langs (unsigned int lang_mask);
168static void complain_wrong_lang (const char *, const struct cl_option *,
169 unsigned int lang_mask);
170static void handle_options (unsigned int, const char **, unsigned int);
171static void wrap_help (const char *help, const char *item, unsigned int);
172static void print_help (void);
173static void print_param_help (void);
174static void print_filtered_help (unsigned int flag);
175static unsigned int print_switch (const char *text, unsigned int indent);
176static void set_debug_level (enum debug_info_type type, int extended,
177 const char *arg);
178
179/* Perform a binary search to find which option the command-line INPUT
180 matches. Returns its index in the option array, and N_OPTS
181 (cl_options_count) on failure.
182
183 This routine is quite subtle. A normal binary search is not good
184 enough because some options can be suffixed with an argument, and
185 multiple sub-matches can occur, e.g. input of "-pedantic" matching
186 the initial substring of "-pedantic-errors".
187
188 A more complicated example is -gstabs. It should match "-g" with
189 an argument of "stabs". Suppose, however, that the number and list
190 of switches are such that the binary search tests "-gen-decls"
191 before having tested "-g". This doesn't match, and as "-gen-decls"
192 is less than "-gstabs", it will become the lower bound of the
193 binary search range, and "-g" will never be seen. To resolve this
194 issue, opts.sh makes "-gen-decls" point, via the back_chain member,
195 to "-g" so that failed searches that end between "-gen-decls" and
196 the lexicographically subsequent switch know to go back and see if
197 "-g" causes a match (which it does in this example).
198
199 This search is done in such a way that the longest match for the
200 front end in question wins. If there is no match for the current
201 front end, the longest match for a different front end is returned
202 (or N_OPTS if none) and the caller emits an error message. */
203static size_t
204find_opt (const char *input, int lang_mask)
205{
206 size_t mn, mx, md, opt_len;
207 size_t match_wrong_lang;
208 int comp;
209
210 mn = 0;
211 mx = cl_options_count;
212
213 /* Find mn such this lexicographical inequality holds:
214 cl_options[mn] <= input < cl_options[mn + 1]. */
215 while (mx - mn > 1)
216 {
217 md = (mn + mx) / 2;
218 opt_len = cl_options[md].opt_len;
219 comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
220
221 if (comp < 0)
222 mx = md;
223 else
224 mn = md;
225 }
226
227 /* This is the switch that is the best match but for a different
228 front end, or cl_options_count if there is no match at all. */
229 match_wrong_lang = cl_options_count;
230
231 /* Backtrace the chain of possible matches, returning the longest
232 one, if any, that fits best. With current GCC switches, this
233 loop executes at most twice. */
234 do
235 {
236 const struct cl_option *opt = &cl_options[mn];
237
238 /* Is this switch a prefix of the input? */
239 if (!strncmp (input, opt->opt_text + 1, opt->opt_len))
240 {
241 /* If language is OK, and the match is exact or the switch
242 takes a joined argument, return it. */
243 if ((opt->flags & lang_mask)
244 && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
245 return mn;
246
247 /* If we haven't remembered a prior match, remember this
248 one. Any prior match is necessarily better. */
249 if (match_wrong_lang == cl_options_count)
250 match_wrong_lang = mn;
251 }
252
253 /* Try the next possibility. This is cl_options_count if there
254 are no more. */
255 mn = opt->back_chain;
256 }
257 while (mn != cl_options_count);
258
259 /* Return the best wrong match, or cl_options_count if none. */
260 return match_wrong_lang;
261}
262
263/* If ARG is a non-negative integer made up solely of digits, return its
264 value, otherwise return -1. */
265static int
266integral_argument (const char *arg)
267{
268 const char *p = arg;
269
270 while (*p && ISDIGIT (*p))
271 p++;
272
273 if (*p == '\0')
274 return atoi (arg);
275
276 return -1;
277}
278
279/* Return a malloced slash-separated list of languages in MASK. */
280static char *
281write_langs (unsigned int mask)
282{
283 unsigned int n = 0, len = 0;
284 const char *lang_name;
285 char *result;
286
287 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
288 if (mask & (1U << n))
289 len += strlen (lang_name) + 1;
290
291 result = xmalloc (len);
292 len = 0;
293 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
294 if (mask & (1U << n))
295 {
296 if (len)
297 result[len++] = '/';
298 strcpy (result + len, lang_name);
299 len += strlen (lang_name);
300 }
301
302 result[len] = 0;
303
304 return result;
305}
306
307/* Complain that switch OPT_INDEX does not apply to this front end. */
308static void
309complain_wrong_lang (const char *text, const struct cl_option *option,
310 unsigned int lang_mask)
311{
312 char *ok_langs, *bad_lang;
313
314 ok_langs = write_langs (option->flags);
315 bad_lang = write_langs (lang_mask);
316
317 /* Eventually this should become a hard error IMO. */
318 warning ("command line option \"%s\" is valid for %s but not for %s",
319 text, ok_langs, bad_lang);
320
321 free (ok_langs);
322 free (bad_lang);
323}
324
325/* Handle the switch beginning at ARGV for the language indicated by
326 LANG_MASK. Returns the number of switches consumed. */
327static unsigned int
328handle_option (const char **argv, unsigned int lang_mask)
329{
330 size_t opt_index;
331 const char *opt, *arg = 0;
332 char *dup = 0;
333 int value = 1;
334 unsigned int result = 0;
335 const struct cl_option *option;
336
337 opt = argv[0];
338
339 /* Drop the "no-" from negative switches. */
340 if ((opt[1] == 'W' || opt[1] == 'f')
341 && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
342 {
343 size_t len = strlen (opt) - 3;
344
345 dup = xmalloc (len + 1);
346 dup[0] = '-';
347 dup[1] = opt[1];
348 memcpy (dup + 2, opt + 5, len - 2 + 1);
349 opt = dup;
350 value = 0;
351 }
352
353 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON);
354 if (opt_index == cl_options_count)
355 goto done;
356
357 option = &cl_options[opt_index];
358
359 /* Reject negative form of switches that don't take negatives as
360 unrecognized. */
361 if (!value && (option->flags & CL_REJECT_NEGATIVE))
362 goto done;
363
364 /* We've recognized this switch. */
365 result = 1;
366
367 /* Sort out any argument the switch takes. */
368 if (option->flags & CL_JOINED)
369 {
370 /* Have arg point to the original switch. This is because
371 some code, such as disable_builtin_function, expects its
372 argument to be persistent until the program exits. */
373 arg = argv[0] + cl_options[opt_index].opt_len + 1;
374 if (!value)
375 arg += strlen ("no-");
376
377 if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
378 {
379 if (option->flags & CL_SEPARATE)
380 {
381 arg = argv[1];
382 result = 2;
383 }
384 else
385 /* Missing argument. */
386 arg = NULL;
387 }
388 }
389 else if (option->flags & CL_SEPARATE)
390 {
391 arg = argv[1];
392 result = 2;
393 }
394
395 /* Now we've swallowed any potential argument, complain if this
396 is a switch for a different front end. */
397 if (!(option->flags & (lang_mask | CL_COMMON)))
398 {
399 complain_wrong_lang (argv[0], option, lang_mask);
400 goto done;
401 }
402
403 if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
404 {
405 if (!(*lang_hooks.missing_argument) (opt, opt_index))
406 error ("missing argument to \"%s\"", opt);
407 goto done;
408 }
409
410 /* If the switch takes an integer, convert it. */
411 if (arg && (option->flags & CL_UINTEGER))
412 {
413 value = integral_argument (arg);
414 if (value == -1)
415 {
416 error ("argument to \"%s\" should be a non-negative integer",
417 option->opt_text);
418 goto done;
419 }
420 }
421
422 if (option->flags & lang_mask)
423 if ((*lang_hooks.handle_option) (opt_index, arg, value) == 0)
424 result = 0;
425
426 if (result && (option->flags & CL_COMMON))
427 if (common_handle_option (opt_index, arg, value) == 0)
428 result = 0;
429
430 done:
431 if (dup)
432 free (dup);
433 return result;
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. */
439static void
440handle_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/* Handle FILENAME from the command line. */
469void
470add_input_filename (const char *filename)
471{
472 num_in_fnames++;
473 in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));
474 in_fnames[num_in_fnames - 1] = filename;
475}
476
477/* Parse command line options and set default flag values. Do minimal
478 options processing. */
479void
480decode_options (unsigned int argc, const char **argv)
481{
482 unsigned int i, lang_mask;
483
484 /* Perform language-specific options initialization. */
485 lang_mask = (*lang_hooks.init_options) (argc, argv);
486
487 lang_hooks.initialize_diagnostics (global_dc);
488
489 /* Scan to see what optimization level has been specified. That will
490 determine the default value of many flags. */
491 for (i = 1; i < argc; i++)
492 {
493 if (!strcmp (argv[i], "-O"))
494 {
495 optimize = 1;
496 optimize_size = 0;
497 }
498 else if (argv[i][0] == '-' && argv[i][1] == 'O')
499 {
500 /* Handle -Os, -O2, -O3, -O69, ... */
501 const char *p = &argv[i][2];
502
503 if ((p[0] == 's') && (p[1] == 0))
504 {
505 optimize_size = 1;
506
507 /* Optimizing for size forces optimize to be 2. */
508 optimize = 2;
509 }
510 else
511 {
512 const int optimize_val = read_integral_parameter (p, p - 2, -1);
513 if (optimize_val != -1)
514 {
515 optimize = optimize_val;
516 optimize_size = 0;
517 }
518 }
519 }
520 }
521
522 if (!optimize)
523 {
524 flag_merge_constants = 0;
525 }
526
527 if (optimize >= 1)
528 {
529 flag_defer_pop = 1;
530 flag_thread_jumps = 1;
531#ifdef DELAY_SLOTS
532 flag_delayed_branch = 1;
533#endif
534#ifdef CAN_DEBUG_WITHOUT_FP
535 flag_omit_frame_pointer = 1;
536#endif
537 flag_guess_branch_prob = 1;
538 flag_cprop_registers = 1;
539 flag_loop_optimize = 1;
540 flag_if_conversion = 1;
541 flag_if_conversion2 = 1;
542 }
543
544 if (optimize >= 2)
545 {
546 flag_crossjumping = 1;
547 flag_optimize_sibling_calls = 1;
548 flag_cse_follow_jumps = 1;
549 flag_cse_skip_blocks = 1;
550 flag_gcse = 1;
551 flag_expensive_optimizations = 1;
552 flag_strength_reduce = 1;
553 flag_rerun_cse_after_loop = 1;
554 flag_rerun_loop_opt = 1;
555 flag_caller_saves = 1;
556 flag_force_mem = 1;
557 flag_peephole2 = 1;
558#ifdef INSN_SCHEDULING
559 flag_schedule_insns = 1;
560 flag_schedule_insns_after_reload = 1;
561#endif
562 flag_regmove = 1;
563 flag_strict_aliasing = 1;
564 flag_delete_null_pointer_checks = 1;
565 flag_reorder_blocks = 1;
566 flag_reorder_functions = 1;
567 flag_unit_at_a_time = 1;
568 }
569
570 if (optimize >= 3)
571 {
572 flag_inline_functions = 1;
573 flag_rename_registers = 1;
574 flag_unswitch_loops = 1;
575 flag_web = 1;
576 }
577
578 if (optimize < 2 || optimize_size)
579 {
580 align_loops = 1;
581 align_jumps = 1;
582 align_labels = 1;
583 align_functions = 1;
584
585 /* Don't reorder blocks when optimizing for size because extra
586 jump insns may be created; also barrier may create extra padding.
587
588 More correctly we should have a block reordering mode that tried
589 to minimize the combined size of all the jumps. This would more
590 or less automatically remove extra jumps, but would also try to
591 use more short jumps instead of long jumps. */
592 flag_reorder_blocks = 0;
593 }
594
595 /* Initialize whether `char' is signed. */
596 flag_signed_char = DEFAULT_SIGNED_CHAR;
597#ifdef DEFAULT_SHORT_ENUMS
598 /* Initialize how much space enums occupy, by default. */
599 flag_short_enums = DEFAULT_SHORT_ENUMS;
600#endif
601
602 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
603 modify it. */
604 target_flags = 0;
605 set_target_switch ("");
606
607 /* Unwind tables are always present in an ABI-conformant IA-64
608 object file, so the default should be ON. */
609#ifdef IA64_UNWIND_INFO
610 flag_unwind_tables = IA64_UNWIND_INFO;
611#endif
612
613#ifdef OPTIMIZATION_OPTIONS
614 /* Allow default optimizations to be specified on a per-machine basis. */
615 OPTIMIZATION_OPTIONS (optimize, optimize_size);
616#endif
617
618 handle_options (argc, argv, lang_mask);
619
620 if (flag_pie)
621 flag_pic = flag_pie;
622 if (flag_pic && !flag_pie)
623 flag_shlib = 1;
624
625 if (flag_no_inline == 2)
626 flag_no_inline = 0;
627 else
628 flag_really_no_inline = flag_no_inline;
629
630 /* Set flag_no_inline before the post_options () hook. The C front
631 ends use it to determine tree inlining defaults. FIXME: such
632 code should be lang-independent when all front ends use tree
633 inlining, in which case it, and this condition, should be moved
634 to the top of process_options() instead. */
635 if (optimize == 0)
636 {
637 /* Inlining does not work if not optimizing,
638 so force it not to be done. */
639 flag_no_inline = 1;
640 warn_inline = 0;
641
642 /* The c_decode_option function and decode_option hook set
643 this to `2' if -Wall is used, so we can avoid giving out
644 lots of errors for people who don't realize what -Wall does. */
645 if (warn_uninitialized == 1)
646 warning ("-Wuninitialized is not supported without -O");
647 }
648
649 if (flag_really_no_inline == 2)
650 flag_really_no_inline = flag_no_inline;
651}
652
653/* Handle target- and language-independent options. Return zero to
654 generate an "unknown option" message. */
655static int
656common_handle_option (size_t scode, const char *arg,
657 int value ATTRIBUTE_UNUSED)
658{
659 enum opt_code code = (enum opt_code) scode;
660
661 switch (code)
662 {
663 default:
664 abort ();
665
666 case OPT__help:
667 print_help ();
668 exit_after_options = true;
669 break;
670
671 case OPT__param:
672 handle_param (arg);
673 break;
674
675 case OPT__target_help:
676 display_target_options ();
677 exit_after_options = true;
678 break;
679
680 case OPT__version:
681 print_version (stderr, "");
682 exit_after_options = true;
683 break;
684
685 case OPT_G:
686 g_switch_value = value;
687 g_switch_set = true;
688 break;
689
690 case OPT_O:
691 case OPT_Os:
692 /* Currently handled in a prescan. */
693 break;
694
695 case OPT_W:
696 /* For backward compatibility, -W is the same as -Wextra. */
697 set_Wextra (value);
698 break;
699
700 case OPT_Waggregate_return:
701 warn_aggregate_return = value;
702 break;
703
704 case OPT_Wcast_align:
705 warn_cast_align = value;
706 break;
707
708 case OPT_Wdeprecated_declarations:
709 warn_deprecated_decl = value;
710 break;
711
712 case OPT_Wdisabled_optimization:
713 warn_disabled_optimization = value;
714 break;
715
716 case OPT_Werror:
717 warnings_are_errors = value;
718 break;
719
720 case OPT_Wextra:
721 set_Wextra (value);
722 break;
723
724 case OPT_Winline:
725 warn_inline = value;
726 break;
727
728 case OPT_Wlarger_than_:
729 larger_than_size = value;
730 warn_larger_than = value != -1;
731 break;
732
733 case OPT_Wmissing_noreturn:
734 warn_missing_noreturn = value;
735 break;
736
737 case OPT_Wpacked:
738 warn_packed = value;
739 break;
740
741 case OPT_Wpadded:
742 warn_padded = value;
743 break;
744
745 case OPT_Wshadow:
746 warn_shadow = value;
747 break;
748
749 case OPT_Wstrict_aliasing:
750 warn_strict_aliasing = value;
751 break;
752
753 case OPT_Wswitch:
754 warn_switch = value;
755 break;
756
757 case OPT_Wswitch_default:
758 warn_switch_default = value;
759 break;
760
761 case OPT_Wswitch_enum:
762 warn_switch_enum = value;
763 break;
764
765 case OPT_Wsystem_headers:
766 warn_system_headers = value;
767 break;
768
769 case OPT_Wuninitialized:
770 warn_uninitialized = value;
771 break;
772
773 case OPT_Wunreachable_code:
774 warn_notreached = value;
775 break;
776
777 case OPT_Wunused:
778 set_Wunused (value);
779 break;
780
781 case OPT_Wunused_function:
782 warn_unused_function = value;
783 break;
784
785 case OPT_Wunused_label:
786 warn_unused_label = value;
787 break;
788
789 case OPT_Wunused_parameter:
790 warn_unused_parameter = value;
791 break;
792
793 case OPT_Wunused_value:
794 warn_unused_value = value;
795 break;
796
797 case OPT_Wunused_variable:
798 warn_unused_variable = value;
799 break;
800
801 case OPT_aux_info:
802 case OPT_aux_info_:
803 aux_info_file_name = arg;
804 flag_gen_aux_info = 1;
805 break;
806
807 case OPT_auxbase:
808 aux_base_name = arg;
809 break;
810
811 case OPT_auxbase_strip:
812 {
813 char *tmp = xstrdup (arg);
814 strip_off_ending (tmp, strlen (tmp));
815 if (tmp[0])
816 aux_base_name = tmp;
817 }
818 break;
819
820 case OPT_d:
821 decode_d_option (arg);
822 break;
823
824 case OPT_dumpbase:
825 dump_base_name = arg;
826 break;
827
828 case OPT_fPIC:
829 flag_pic = value + value;
830 break;
831
832 case OPT_fPIE:
833 flag_pie = value + value;
834 break;
835
836 case OPT_fabi_version_:
837 flag_abi_version = value;
838 break;
839
840 case OPT_falign_functions:
841 align_functions = !value;
842 break;
843
844 case OPT_falign_functions_:
845 align_functions = value;
846 break;
847
848 case OPT_falign_jumps:
849 align_jumps = !value;
850 break;
851
852 case OPT_falign_jumps_:
853 align_jumps = value;
854 break;
855
856 case OPT_falign_labels:
857 align_labels = !value;
858 break;
859
860 case OPT_falign_labels_:
861 align_labels = value;
862 break;
863
864 case OPT_falign_loops:
865 align_loops = !value;
866 break;
867
868 case OPT_falign_loops_:
869 align_loops = value;
870 break;
871
872 case OPT_fargument_alias:
873 flag_argument_noalias = !value;
874 break;
875
876 case OPT_fargument_noalias:
877 flag_argument_noalias = value;
878 break;
879
880 case OPT_fargument_noalias_global:
881 flag_argument_noalias = value + value;
882 break;
883
884 case OPT_fasynchronous_unwind_tables:
885 flag_asynchronous_unwind_tables = value;
886 break;
887
888 case OPT_fbounds_check:
889 flag_bounds_check = value;
890 break;
891
892 case OPT_fbranch_count_reg:
893 flag_branch_on_count_reg = value;
894 break;
895
896 case OPT_fbranch_probabilities:
897 flag_branch_probabilities_set = true;
898 flag_branch_probabilities = value;
899 break;
900
901 case OPT_fbranch_target_load_optimize:
902 flag_branch_target_load_optimize = value;
903 break;
904
905 case OPT_fbranch_target_load_optimize2:
906 flag_branch_target_load_optimize2 = value;
907 break;
908
909 case OPT_fcall_used_:
910 fix_register (arg, 0, 1);
911 break;
912
913 case OPT_fcall_saved_:
914 fix_register (arg, 0, 0);
915 break;
916
917 case OPT_fcaller_saves:
918 flag_caller_saves = value;
919 break;
920
921 case OPT_fcommon:
922 flag_no_common = !value;
923 break;
924
925 case OPT_fcprop_registers:
926 flag_cprop_registers = value;
927 break;
928
929 case OPT_fcrossjumping:
930 flag_crossjumping = value;
931 break;
932
933 case OPT_fcse_follow_jumps:
934 flag_cse_follow_jumps = value;
935 break;
936
937 case OPT_fcse_skip_blocks:
938 flag_cse_skip_blocks = value;
939 break;
940
941 case OPT_fdata_sections:
942 flag_data_sections = value;
943 break;
944
945 case OPT_fdefer_pop:
946 flag_defer_pop = value;
947 break;
948
949 case OPT_fdelayed_branch:
950 flag_delayed_branch = value;
951 break;
952
953 case OPT_fdelete_null_pointer_checks:
954 flag_delete_null_pointer_checks = value;
955 break;
956
957 case OPT_fdiagnostics_show_location_:
958 if (!strcmp (arg, "once"))
959 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
960 else if (!strcmp (arg, "every-line"))
961 diagnostic_prefixing_rule (global_dc)
962 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
963 else
964 return 0;
965 break;
966
967 case OPT_fdump_unnumbered:
968 flag_dump_unnumbered = value;
969 break;
970
971 case OPT_feliminate_dwarf2_dups:
972 flag_eliminate_dwarf2_dups = value;
973 break;
974
975 case OPT_feliminate_unused_debug_types:
976 flag_eliminate_unused_debug_types = value;
977 break;
978
979 case OPT_feliminate_unused_debug_symbols:
980 flag_debug_only_used_symbols = value;
981 break;
982
983 case OPT_fexceptions:
984 flag_exceptions = value;
985 break;
986
987 case OPT_fexpensive_optimizations:
988 flag_expensive_optimizations = value;
989 break;
990
991 case OPT_ffast_math:
992 set_fast_math_flags (value);
993 break;
994
995 case OPT_ffinite_math_only:
996 flag_finite_math_only = value;
997 break;
998
999 case OPT_ffixed_:
1000 fix_register (arg, 1, 1);
1001 break;
1002
1003 case OPT_ffunction_cse:
1004 flag_no_function_cse = !value;
1005 break;
1006
1007 case OPT_ffloat_store:
1008 flag_float_store = value;
1009 break;
1010
1011 case OPT_fforce_addr:
1012 flag_force_addr = value;
1013 break;
1014
1015 case OPT_fforce_mem:
1016 flag_force_mem = value;
1017 break;
1018
1019 case OPT_ffunction_sections:
1020 flag_function_sections = value;
1021 break;
1022
1023 case OPT_fgcse:
1024 flag_gcse = value;
1025 break;
1026
1027 case OPT_fgcse_lm:
1028 flag_gcse_lm = value;
1029 break;
1030
1031 case OPT_fgcse_sm:
1032 flag_gcse_sm = value;
1033 break;
1034
1035 case OPT_fgcse_las:
1036 flag_gcse_las = value;
1037 break;
1038
1039 case OPT_fguess_branch_probability:
1040 flag_guess_branch_prob = value;
1041 break;
1042
1043 case OPT_fident:
1044 flag_no_ident = !value;
1045 break;
1046
1047 case OPT_fif_conversion:
1048 flag_if_conversion = value;
1049 break;
1050
1051 case OPT_fif_conversion2:
1052 flag_if_conversion2 = value;
1053 break;
1054
1055 case OPT_finhibit_size_directive:
1056 flag_inhibit_size_directive = value;
1057 break;
1058
1059 case OPT_finline:
1060 flag_no_inline = !value;
1061 break;
1062
1063 case OPT_finline_functions:
1064 flag_inline_functions = value;
1065 break;
1066
1067 case OPT_finline_limit_:
1068 case OPT_finline_limit_eq:
1069 set_param_value ("max-inline-insns-single", value / 2);
1070 set_param_value ("max-inline-insns-auto", value / 2);
1071 set_param_value ("max-inline-insns-rtl", value);
1072 break;
1073
1074 case OPT_finstrument_functions:
1075 flag_instrument_function_entry_exit = value;
1076 break;
1077
1078 case OPT_fkeep_inline_functions:
1079 flag_keep_inline_functions =value;
1080 break;
1081
1082 case OPT_fkeep_static_consts:
1083 flag_keep_static_consts = value;
1084 break;
1085
1086 case OPT_fleading_underscore:
1087 flag_leading_underscore = value;
1088 break;
1089
1090 case OPT_floop_optimize:
1091 flag_loop_optimize = value;
1092 break;
1093
1094 case OPT_fmath_errno:
1095 flag_errno_math = value;
1096 break;
1097
1098 case OPT_fmem_report:
1099 mem_report = value;
1100 break;
1101
1102 case OPT_fmerge_all_constants:
1103 flag_merge_constants = value + value;
1104 break;
1105
1106 case OPT_fmerge_constants:
1107 flag_merge_constants = value;
1108 break;
1109
1110 case OPT_fmessage_length_:
1111 pp_set_line_maximum_length (global_dc->printer, value);
1112 break;
1113
1114 case OPT_fmove_all_movables:
1115 flag_move_all_movables = value;
1116 break;
1117
1118 case OPT_fnew_ra:
1119 flag_new_regalloc = value;
1120 break;
1121
1122 case OPT_fnon_call_exceptions:
1123 flag_non_call_exceptions = value;
1124 break;
1125
1126 case OPT_fold_unroll_all_loops:
1127 flag_old_unroll_all_loops = value;
1128 break;
1129
1130 case OPT_fold_unroll_loops:
1131 flag_old_unroll_loops = value;
1132 break;
1133
1134 case OPT_fomit_frame_pointer:
1135 flag_omit_frame_pointer = value;
1136 break;
1137
1138 case OPT_foptimize_register_move:
1139 flag_regmove = value;
1140 break;
1141
1142 case OPT_foptimize_sibling_calls:
1143 flag_optimize_sibling_calls = value;
1144 break;
1145
1146 case OPT_fpack_struct:
1147 flag_pack_struct = value;
1148 break;
1149
1150 case OPT_fpeel_loops:
1151 flag_peel_loops_set = true;
1152 flag_peel_loops = value;
1153 break;
1154
1155 case OPT_fpcc_struct_return:
1156 flag_pcc_struct_return = value;
1157 break;
1158
1159 case OPT_fpeephole:
1160 flag_no_peephole = !value;
1161 break;
1162
1163 case OPT_fpeephole2:
1164 flag_peephole2 = value;
1165 break;
1166
1167 case OPT_fpic:
1168 flag_pic = value;
1169 break;
1170
1171 case OPT_fpie:
1172 flag_pie = value;
1173 break;
1174
1175 case OPT_fprefetch_loop_arrays:
1176 flag_prefetch_loop_arrays = value;
1177 break;
1178
1179 case OPT_fprofile:
1180 profile_flag = value;
1181 break;
1182
1183 case OPT_fprofile_arcs:
1184 profile_arc_flag_set = true;
1185 profile_arc_flag = value;
1186 break;
1187
1188 case OPT_fprofile_use:
1189 if (!flag_branch_probabilities_set)
1190 flag_branch_probabilities = value;
1191 if (!flag_profile_values_set)
1192 flag_profile_values = value;
1193 if (!flag_unroll_loops_set)
1194 flag_unroll_loops = value;
1195 if (!flag_peel_loops_set)
1196 flag_peel_loops = value;
1197 if (!flag_tracer_set)
1198 flag_tracer = value;
1199 if (!flag_value_profile_transformations_set)
1200 flag_value_profile_transformations = value;
1201 break;
1202
1203 case OPT_fprofile_generate:
1204 if (!profile_arc_flag_set)
1205 profile_arc_flag = value;
1206 if (!flag_profile_values_set)
1207 flag_profile_values = value;
1208 if (!flag_value_profile_transformations_set)
1209 flag_value_profile_transformations = value;
1210 break;
1211
1212 case OPT_fprofile_values:
1213 flag_profile_values_set = true;
1214 flag_profile_values = value;
1215 break;
1216
1217 case OPT_fvpt:
1218 flag_value_profile_transformations_set = value;
1219 flag_value_profile_transformations = value;
1220 break;
1221
1222 case OPT_frandom_seed:
1223 /* The real switch is -fno-random-seed. */
1224 if (value)
1225 return 0;
1226 flag_random_seed = NULL;
1227 break;
1228
1229 case OPT_frandom_seed_:
1230 flag_random_seed = arg;
1231 break;
1232
1233 case OPT_freduce_all_givs:
1234 flag_reduce_all_givs = value;
1235 break;
1236
1237 case OPT_freg_struct_return:
1238 flag_pcc_struct_return = !value;
1239 break;
1240
1241 case OPT_fregmove:
1242 flag_regmove = value;
1243 break;
1244
1245 case OPT_frename_registers:
1246 flag_rename_registers = value;
1247 break;
1248
1249 case OPT_freorder_blocks:
1250 flag_reorder_blocks = value;
1251 break;
1252
1253 case OPT_freorder_functions:
1254 flag_reorder_functions = value;
1255 break;
1256
1257 case OPT_frerun_cse_after_loop:
1258 flag_rerun_cse_after_loop = value;
1259 break;
1260
1261 case OPT_frerun_loop_opt:
1262 flag_rerun_loop_opt = value;
1263 break;
1264
1265 case OPT_frounding_math:
1266 flag_rounding_math = value;
1267 break;
1268
1269 case OPT_fsched_interblock:
1270 flag_schedule_interblock = value;
1271 break;
1272
1273 case OPT_fsched_spec:
1274 flag_schedule_speculative = value;
1275 break;
1276
1277 case OPT_fsched_spec_load:
1278 flag_schedule_speculative_load = value;
1279 break;
1280
1281 case OPT_fsched_spec_load_dangerous:
1282 flag_schedule_speculative_load_dangerous = value;
1283 break;
1284
1285 case OPT_fsched_verbose_:
1286#ifdef INSN_SCHEDULING
1287 fix_sched_param ("verbose", arg);
1288 break;
1289#else
1290 return 0;
1291#endif
1292
1293 case OPT_fsched2_use_superblocks:
1294 flag_sched2_use_superblocks = value;
1295 break;
1296
1297 case OPT_fsched2_use_traces:
1298 flag_sched2_use_traces = value;
1299 break;
1300
1301 case OPT_fschedule_insns:
1302 flag_schedule_insns = value;
1303 break;
1304
1305 case OPT_fschedule_insns2:
1306 flag_schedule_insns_after_reload = value;
1307 break;
1308
1309 case OPT_fsched_stalled_insns:
1310 flag_sched_stalled_insns = value;
1311 break;
1312
1313 case OPT_fsched_stalled_insns_:
1314 flag_sched_stalled_insns = value;
1315 if (flag_sched_stalled_insns == 0)
1316 flag_sched_stalled_insns = -1;
1317 break;
1318
1319 case OPT_fsched_stalled_insns_dep:
1320 flag_sched_stalled_insns_dep = 1;
1321 break;
1322
1323 case OPT_fsched_stalled_insns_dep_:
1324 flag_sched_stalled_insns_dep = value;
1325 break;
1326
1327 case OPT_fshared_data:
1328 flag_shared_data = value;
1329 break;
1330
1331 case OPT_fsignaling_nans:
1332 flag_signaling_nans = value;
1333 break;
1334
1335 case OPT_fsingle_precision_constant:
1336 flag_single_precision_constant = value;
1337 break;
1338
1339 case OPT_fstack_check:
1340 flag_stack_check = value;
1341 break;
1342
1343 case OPT_fstack_limit:
1344 /* The real switch is -fno-stack-limit. */
1345 if (value)
1346 return 0;
1347 stack_limit_rtx = NULL_RTX;
1348 break;
1349
1350 case OPT_fstack_limit_register_:
1351 {
1352 int reg = decode_reg_name (arg);
1353 if (reg < 0)
1354 error ("unrecognized register name \"%s\"", arg);
1355 else
1356 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1357 }
1358 break;
1359
1360 case OPT_fstack_limit_symbol_:
1361 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1362 break;
1363
1364 case OPT_fstrength_reduce:
1365 flag_strength_reduce = value;
1366 break;
1367
1368 case OPT_fstrict_aliasing:
1369 flag_strict_aliasing = value;
1370 break;
1371
1372 case OPT_fsyntax_only:
1373 flag_syntax_only = value;
1374 break;
1375
1376 case OPT_ftest_coverage:
1377 flag_test_coverage = value;
1378 break;
1379
1380 case OPT_fthread_jumps:
1381 flag_thread_jumps = value;
1382 break;
1383
1384 case OPT_ftime_report:
1385 time_report = value;
1386 break;
1387
1388 case OPT_ftls_model_:
1389 if (!strcmp (arg, "global-dynamic"))
1390 flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1391 else if (!strcmp (arg, "local-dynamic"))
1392 flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1393 else if (!strcmp (arg, "initial-exec"))
1394 flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1395 else if (!strcmp (arg, "local-exec"))
1396 flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1397 else
1398 warning ("unknown tls-model \"%s\"", arg);
1399 break;
1400
1401 case OPT_ftracer:
1402 flag_tracer_set = true;
1403 flag_tracer = value;
1404 break;
1405
1406 case OPT_ftrapping_math:
1407 flag_trapping_math = value;
1408 break;
1409
1410 case OPT_ftrapv:
1411 flag_trapv = value;
1412 break;
1413
1414 case OPT_funit_at_a_time:
1415 flag_unit_at_a_time = value;
1416 break;
1417
1418 case OPT_funroll_all_loops:
1419 flag_unroll_all_loops = value;
1420 break;
1421
1422 case OPT_funroll_loops:
1423 flag_unroll_loops_set = true;
1424 flag_unroll_loops = value;
1425 break;
1426
1427 case OPT_funsafe_math_optimizations:
1428 flag_unsafe_math_optimizations = value;
1429 break;
1430
1431 case OPT_funswitch_loops:
1432 flag_unswitch_loops = value;
1433 break;
1434
1435 case OPT_funwind_tables:
1436 flag_unwind_tables = value;
1437 break;
1438
1439 case OPT_fverbose_asm:
1440 flag_verbose_asm = value;
1441 break;
1442
1443 case OPT_fweb:
1444 flag_web = value;
1445 break;
1446
1447 case OPT_fwrapv:
1448 flag_wrapv = value;
1449 break;
1450
1451 case OPT_fwritable_strings:
1452 flag_writable_strings = value;
1453 if (flag_writable_strings)
1454 inform ("-fwritable-strings is deprecated; "
1455 "see documentation for details");
1456 break;
1457
1458 case OPT_fzero_initialized_in_bss:
1459 flag_zero_initialized_in_bss = value;
1460 break;
1461
1462 case OPT_g:
1463 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
1464 break;
1465
1466 case OPT_gcoff:
1467 set_debug_level (SDB_DEBUG, false, arg);
1468 break;
1469
1470 case OPT_gdwarf_2:
1471 set_debug_level (DWARF2_DEBUG, false, arg);
1472 break;
1473
1474 case OPT_ggdb:
1475 set_debug_level (NO_DEBUG, 2, arg);
1476 break;
1477
1478 case OPT_gstabs:
1479 case OPT_gstabs_:
1480 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
1481 break;
1482
1483 case OPT_gvms:
1484 set_debug_level (VMS_DEBUG, false, arg);
1485 break;
1486
1487 case OPT_gxcoff:
1488 case OPT_gxcoff_:
1489 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
1490 break;
1491
1492 case OPT_m:
1493 set_target_switch (arg);
1494 break;
1495
1496 case OPT_o:
1497 asm_file_name = arg;
1498 break;
1499
1500 case OPT_p:
1501 profile_flag = 1;
1502 break;
1503
1504 case OPT_pedantic:
1505 pedantic = 1;
1506 break;
1507
1508 case OPT_pedantic_errors:
1509 flag_pedantic_errors = pedantic = 1;
1510 break;
1511
1512 case OPT_quiet:
1513 quiet_flag = 1;
1514 break;
1515
1516 case OPT_version:
1517 version_flag = 1;
1518 break;
1519
1520 case OPT_w:
1521 inhibit_warnings = true;
1522 break;
1523 }
1524
1525 return 1;
1526}
1527
1528/* Handle --param NAME=VALUE. */
1529static void
1530handle_param (const char *carg)
1531{
1532 char *equal, *arg;
1533 int value;
1534
1535 arg = xstrdup (carg);
1536 equal = strchr (arg, '=');
1537 if (!equal)
1538 error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1539 else
1540 {
1541 value = integral_argument (equal + 1);
1542 if (value == -1)
1543 error ("invalid --param value `%s'", equal + 1);
1544 else
1545 {
1546 *equal = '\0';
1547 set_param_value (arg, value);
1548 }
1549 }
1550
1551 free (arg);
1552}
1553
1554/* Handle -W and -Wextra. */
1555static void
1556set_Wextra (int setting)
1557{
1558 extra_warnings = setting;
1559 warn_unused_value = setting;
1560 warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1561
1562 /* We save the value of warn_uninitialized, since if they put
1563 -Wuninitialized on the command line, we need to generate a
1564 warning about not using it without also specifying -O. */
1565 if (setting == 0)
1566 warn_uninitialized = 0;
1567 else if (warn_uninitialized != 1)
1568 warn_uninitialized = 2;
1569}
1570
1571/* Initialize unused warning flags. */
1572void
1573set_Wunused (int setting)
1574{
1575 warn_unused_function = setting;
1576 warn_unused_label = setting;
1577 /* Unused function parameter warnings are reported when either
1578 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1579 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1580 otherwise set maybe_warn_extra_parameter, which will be picked up
1581 by set_Wextra. */
1582 maybe_warn_unused_parameter = setting;
1583 warn_unused_parameter = (setting && extra_warnings);
1584 warn_unused_variable = setting;
1585 warn_unused_value = setting;
1586}
1587
1588/* The following routines are useful in setting all the flags that
1589 -ffast-math and -fno-fast-math imply. */
1590void
1591set_fast_math_flags (int set)
1592{
1593 flag_trapping_math = !set;
1594 flag_unsafe_math_optimizations = set;
1595 flag_finite_math_only = set;
1596 flag_errno_math = !set;
1597 if (set)
1598 {
1599 flag_signaling_nans = 0;
1600 flag_rounding_math = 0;
1601 }
1602}
1603
1604/* Return true iff flags are set as if -ffast-math. */
1605bool
1606fast_math_flags_set_p (void)
1607{
1608 return (!flag_trapping_math
1609 && flag_unsafe_math_optimizations
1610 && flag_finite_math_only
1611 && !flag_errno_math);
1612}
1613
1614/* Handle a debug output -g switch. EXTENDED is true or false to support
1615 extended output (2 is special and means "-ggdb" was given). */
1616static void
1617set_debug_level (enum debug_info_type type, int extended, const char *arg)
1618{
1619 static bool type_explicit;
1620
1621 use_gnu_debug_info_extensions = extended;
1622
1623 if (type == NO_DEBUG)
1624 {
1625 if (write_symbols == NO_DEBUG)
1626 {
1627 write_symbols = PREFERRED_DEBUGGING_TYPE;
1628
1629 if (extended == 2)
1630 {
1631#ifdef DWARF2_DEBUGGING_INFO
1632 write_symbols = DWARF2_DEBUG;
1633#elif defined DBX_DEBUGGING_INFO
1634 write_symbols = DBX_DEBUG;
1635#endif
1636 }
1637
1638 if (write_symbols == NO_DEBUG)
1639 warning ("target system does not support debug output");
1640 }
1641 }
1642 else
1643 {
1644 /* Does it conflict with an already selected type? */
1645 if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1646 error ("debug format \"%s\" conflicts with prior selection",
1647 debug_type_names[type]);
1648 write_symbols = type;
1649 type_explicit = true;
1650 }
1651
1652 /* A debug flag without a level defaults to level 2. */
1653 if (*arg == '\0')
1654 {
1655 if (!debug_info_level)
1656 debug_info_level = 2;
1657 }
1658 else
1659 {
1660 debug_info_level = integral_argument (arg);
1661 if (debug_info_level == (unsigned int) -1)
1662 error ("unrecognised debug output level \"%s\"", arg);
1663 else if (debug_info_level > 3)
1664 error ("debug output level %s is too high", arg);
1665 }
1666}
1667
1668/* Output --help text. */
1669static void
1670print_help (void)
1671{
1672 size_t i;
1673 const char *p;
1674
1675 GET_ENVIRONMENT (p, "COLUMNS");
1676 if (p)
1677 {
1678 int value = atoi (p);
1679 if (value > 0)
1680 columns = value;
1681 }
1682
1683 puts (_("The following options are language-independent:\n"));
1684
1685 print_filtered_help (CL_COMMON);
1686 print_param_help ();
1687
1688 for (i = 0; lang_names[i]; i++)
1689 {
1690 printf (_("The %s front end recognizes the following options:\n\n"),
1691 lang_names[i]);
1692 print_filtered_help (1U << i);
1693 }
1694
1695 display_target_options ();
1696}
1697
1698/* Print the help for --param. */
1699static void
1700print_param_help (void)
1701{
1702 size_t i;
1703
1704 puts (_("The --param option recognizes the following as parameters:\n"));
1705
1706 for (i = 0; i < LAST_PARAM; i++)
1707 {
1708 const char *help = compiler_params[i].help;
1709 const char *param = compiler_params[i].option;
1710
1711 if (help == NULL || *help == '\0')
1712 help = undocumented_msg;
1713
1714 /* Get the translation. */
1715 help = _(help);
1716
1717 wrap_help (help, param, strlen (param));
1718 }
1719
1720 putchar ('\n');
1721}
1722
1723/* Print help for a specific front-end, etc. */
1724static void
1725print_filtered_help (unsigned int flag)
1726{
1727 unsigned int i, len, filter, indent = 0;
1728 bool duplicates = false;
1729 const char *help, *opt, *tab;
1730 static char *printed;
1731
1732 if (flag == CL_COMMON)
1733 {
1734 filter = flag;
1735 if (!printed)
1736 printed = xmalloc (cl_options_count);
1737 memset (printed, 0, cl_options_count);
1738 }
1739 else
1740 {
1741 /* Don't print COMMON options twice. */
1742 filter = flag | CL_COMMON;
1743
1744 for (i = 0; i < cl_options_count; i++)
1745 {
1746 if ((cl_options[i].flags & filter) != flag)
1747 continue;
1748
1749 /* Skip help for internal switches. */
1750 if (cl_options[i].flags & CL_UNDOCUMENTED)
1751 continue;
1752
1753 /* Skip switches that have already been printed, mark them to be
1754 listed later. */
1755 if (printed[i])
1756 {
1757 duplicates = true;
1758 indent = print_switch (cl_options[i].opt_text, indent);
1759 }
1760 }
1761
1762 if (duplicates)
1763 {
1764 putchar ('\n');
1765 putchar ('\n');
1766 }
1767 }
1768
1769 for (i = 0; i < cl_options_count; i++)
1770 {
1771 if ((cl_options[i].flags & filter) != flag)
1772 continue;
1773
1774 /* Skip help for internal switches. */
1775 if (cl_options[i].flags & CL_UNDOCUMENTED)
1776 continue;
1777
1778 /* Skip switches that have already been printed. */
1779 if (printed[i])
1780 continue;
1781
1782 printed[i] = true;
1783
1784 help = cl_options[i].help;
1785 if (!help)
1786 help = undocumented_msg;
1787
1788 /* Get the translation. */
1789 help = _(help);
1790
1791 tab = strchr (help, '\t');
1792 if (tab)
1793 {
1794 len = tab - help;
1795 opt = help;
1796 help = tab + 1;
1797 }
1798 else
1799 {
1800 opt = cl_options[i].opt_text;
1801 len = strlen (opt);
1802 }
1803
1804 wrap_help (help, opt, len);
1805 }
1806
1807 putchar ('\n');
1808}
1809
1810/* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1811 word-wrapped HELP in a second column. */
1812static unsigned int
1813print_switch (const char *text, unsigned int indent)
1814{
1815 unsigned int len = strlen (text) + 1; /* trailing comma */
1816
1817 if (indent)
1818 {
1819 putchar (',');
1820 if (indent + len > columns)
1821 {
1822 putchar ('\n');
1823 putchar (' ');
1824 indent = 1;
1825 }
1826 }
1827 else
1828 putchar (' ');
1829
1830 putchar (' ');
1831 fputs (text, stdout);
1832
1833 return indent + len + 1;
1834}
1835
1836/* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1837 word-wrapped HELP in a second column. */
1838static void
1839wrap_help (const char *help, const char *item, unsigned int item_width)
1840{
1841 unsigned int col_width = 27;
1842 unsigned int remaining, room, len;
1843
1844 remaining = strlen (help);
1845
1846 do
1847 {
1848 room = columns - 3 - MAX (col_width, item_width);
1849 if (room > columns)
1850 room = 0;
1851 len = remaining;
1852
1853 if (room < len)
1854 {
1855 unsigned int i;
1856
1857 for (i = 0; help[i]; i++)
1858 {
1859 if (i >= room && len != remaining)
1860 break;
1861 if (help[i] == ' ')
1862 len = i;
1863 else if ((help[i] == '-' || help[i] == '/')
1864 && help[i + 1] != ' '
1865 && i > 0 && ISALPHA (help[i - 1]))
1866 len = i + 1;
1867 }
1868 }
1869
1870 printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
1871 item_width = 0;
1872 while (help[len] == ' ')
1873 len++;
1874 help += len;
1875 remaining -= len;
1876 }
1877 while (remaining);
1878}