1 /* Command line option handling.
2 Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
3 Contributed by Neil Booth.
5 This file is part of GCC.
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
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
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "coretypes.h"
31 #include "langhooks.h"
37 #include "diagnostic.h"
38 #include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
39 #include "insn-attr.h" /* For INSN_SCHEDULING. */
42 /* Value of the -G xx switch, and whether it was passed or not. */
43 unsigned HOST_WIDE_INT g_switch_value;
46 /* True if we should exit after parsing options. */
47 bool exit_after_options;
49 /* Print various extra warnings. -W/-Wextra. */
52 /* True to warn about any objects definitions whose size is larger
53 than N bytes. Also want about function definitions whose returned
54 values are larger than N bytes, where N is `larger_than_size'. */
55 bool warn_larger_than;
56 HOST_WIDE_INT larger_than_size;
58 /* Nonzero means warn about constructs which might not be
59 strict-aliasing safe. */
60 int warn_strict_aliasing;
62 /* Hack for cooperation between set_Wunused and set_Wextra. */
63 static bool maybe_warn_unused_parameter;
65 /* Type(s) of debugging information we are producing (if any). See
66 flags.h for the definitions of the different possible types of
67 debugging information. */
68 enum debug_info_type write_symbols = NO_DEBUG;
70 /* Level of debugging information we are producing. See flags.h for
71 the definitions of the different possible levels. */
72 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
74 /* Nonzero means use GNU-only extensions in the generated symbolic
75 debugging information. Currently, this only has an effect when
76 write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
77 bool use_gnu_debug_info_extensions;
79 /* The default visibility for all symbols (unless overridden) */
80 enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;
82 /* Global visibility options. */
83 struct visibility_flags visibility_options;
85 /* Columns of --help display. */
86 static unsigned int columns = 80;
88 /* What to print when a switch has no documentation. */
89 static const char undocumented_msg[] = N_("This switch lacks documentation");
91 /* Used for bookkeeping on whether user set these flags so
92 -fprofile-use/-fprofile-generate does not use them. */
93 static bool profile_arc_flag_set, flag_profile_values_set;
94 static bool flag_unroll_loops_set, flag_tracer_set;
95 static bool flag_value_profile_transformations_set;
96 bool flag_speculative_prefetching_set;
97 static bool flag_peel_loops_set, flag_branch_probabilities_set;
99 /* Input file names. */
100 const char **in_fnames;
101 unsigned num_in_fnames;
103 static size_t find_opt (const char *, int);
104 static int common_handle_option (size_t scode, const char *arg, int value);
105 static void handle_param (const char *);
106 static void set_Wextra (int);
107 static unsigned int handle_option (const char **argv, unsigned int lang_mask);
108 static char *write_langs (unsigned int lang_mask);
109 static void complain_wrong_lang (const char *, const struct cl_option *,
110 unsigned int lang_mask);
111 static void handle_options (unsigned int, const char **, unsigned int);
112 static void wrap_help (const char *help, const char *item, unsigned int);
113 static void print_help (void);
114 static void print_param_help (void);
115 static void print_filtered_help (unsigned int flag);
116 static unsigned int print_switch (const char *text, unsigned int indent);
117 static void set_debug_level (enum debug_info_type type, int extended,
120 /* Perform a binary search to find which option the command-line INPUT
121 matches. Returns its index in the option array, and N_OPTS
122 (cl_options_count) on failure.
124 This routine is quite subtle. A normal binary search is not good
125 enough because some options can be suffixed with an argument, and
126 multiple sub-matches can occur, e.g. input of "-pedantic" matching
127 the initial substring of "-pedantic-errors".
129 A more complicated example is -gstabs. It should match "-g" with
130 an argument of "stabs". Suppose, however, that the number and list
131 of switches are such that the binary search tests "-gen-decls"
132 before having tested "-g". This doesn't match, and as "-gen-decls"
133 is less than "-gstabs", it will become the lower bound of the
134 binary search range, and "-g" will never be seen. To resolve this
135 issue, opts.sh makes "-gen-decls" point, via the back_chain member,
136 to "-g" so that failed searches that end between "-gen-decls" and
137 the lexicographically subsequent switch know to go back and see if
138 "-g" causes a match (which it does in this example).
140 This search is done in such a way that the longest match for the
141 front end in question wins. If there is no match for the current
142 front end, the longest match for a different front end is returned
143 (or N_OPTS if none) and the caller emits an error message. */
145 find_opt (const char *input, int lang_mask)
147 size_t mn, mx, md, opt_len;
148 size_t match_wrong_lang;
152 mx = cl_options_count;
154 /* Find mn such this lexicographical inequality holds:
155 cl_options[mn] <= input < cl_options[mn + 1]. */
159 opt_len = cl_options[md].opt_len;
160 comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
168 /* This is the switch that is the best match but for a different
169 front end, or cl_options_count if there is no match at all. */
170 match_wrong_lang = cl_options_count;
172 /* Backtrace the chain of possible matches, returning the longest
173 one, if any, that fits best. With current GCC switches, this
174 loop executes at most twice. */
177 const struct cl_option *opt = &cl_options[mn];
179 /* Is this switch a prefix of the input? */
180 if (!strncmp (input, opt->opt_text + 1, opt->opt_len))
182 /* If language is OK, and the match is exact or the switch
183 takes a joined argument, return it. */
184 if ((opt->flags & lang_mask)
185 && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
188 /* If we haven't remembered a prior match, remember this
189 one. Any prior match is necessarily better. */
190 if (match_wrong_lang == cl_options_count)
191 match_wrong_lang = mn;
194 /* Try the next possibility. This is cl_options_count if there
196 mn = opt->back_chain;
198 while (mn != cl_options_count);
200 /* Return the best wrong match, or cl_options_count if none. */
201 return match_wrong_lang;
204 /* If ARG is a non-negative integer made up solely of digits, return its
205 value, otherwise return -1. */
207 integral_argument (const char *arg)
211 while (*p && ISDIGIT (*p))
220 /* Return a malloced slash-separated list of languages in MASK. */
222 write_langs (unsigned int mask)
224 unsigned int n = 0, len = 0;
225 const char *lang_name;
228 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
229 if (mask & (1U << n))
230 len += strlen (lang_name) + 1;
232 result = xmalloc (len);
234 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
235 if (mask & (1U << n))
239 strcpy (result + len, lang_name);
240 len += strlen (lang_name);
248 /* Complain that switch OPT_INDEX does not apply to this front end. */
250 complain_wrong_lang (const char *text, const struct cl_option *option,
251 unsigned int lang_mask)
253 char *ok_langs, *bad_lang;
255 ok_langs = write_langs (option->flags);
256 bad_lang = write_langs (lang_mask);
258 /* Eventually this should become a hard error IMO. */
259 warning ("command line option \"%s\" is valid for %s but not for %s",
260 text, ok_langs, bad_lang);
266 /* Handle the switch beginning at ARGV for the language indicated by
267 LANG_MASK. Returns the number of switches consumed. */
269 handle_option (const char **argv, unsigned int lang_mask)
272 const char *opt, *arg = 0;
275 unsigned int result = 0;
276 const struct cl_option *option;
280 /* Drop the "no-" from negative switches. */
281 if ((opt[1] == 'W' || opt[1] == 'f')
282 && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
284 size_t len = strlen (opt) - 3;
286 dup = xmalloc (len + 1);
289 memcpy (dup + 2, opt + 5, len - 2 + 1);
294 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON);
295 if (opt_index == cl_options_count)
298 option = &cl_options[opt_index];
300 /* Reject negative form of switches that don't take negatives as
302 if (!value && (option->flags & CL_REJECT_NEGATIVE))
305 /* We've recognized this switch. */
308 /* Sort out any argument the switch takes. */
309 if (option->flags & CL_JOINED)
311 /* Have arg point to the original switch. This is because
312 some code, such as disable_builtin_function, expects its
313 argument to be persistent until the program exits. */
314 arg = argv[0] + cl_options[opt_index].opt_len + 1;
316 arg += strlen ("no-");
318 if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
320 if (option->flags & CL_SEPARATE)
326 /* Missing argument. */
330 else if (option->flags & CL_SEPARATE)
336 /* Now we've swallowed any potential argument, complain if this
337 is a switch for a different front end. */
338 if (!(option->flags & (lang_mask | CL_COMMON)))
340 complain_wrong_lang (argv[0], option, lang_mask);
344 if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
346 if (!lang_hooks.missing_argument (opt, opt_index))
347 error ("missing argument to \"%s\"", opt);
351 /* If the switch takes an integer, convert it. */
352 if (arg && (option->flags & CL_UINTEGER))
354 value = integral_argument (arg);
357 error ("argument to \"%s\" should be a non-negative integer",
363 if (option->flag_var)
365 if (option->has_set_value)
368 *option->flag_var = option->set_value;
370 *option->flag_var = !option->set_value;
373 *option->flag_var = value;
376 if (option->flags & lang_mask)
377 if (lang_hooks.handle_option (opt_index, arg, value) == 0)
380 if (result && (option->flags & CL_COMMON))
381 if (common_handle_option (opt_index, arg, value) == 0)
390 /* Decode and handle the vector of command line options. LANG_MASK
391 contains has a single bit set representing the current
394 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
398 for (i = 1; i < argc; i += n)
400 const char *opt = argv[i];
402 /* Interpret "-" or a non-switch as a file name. */
403 if (opt[0] != '-' || opt[1] == '\0')
405 if (main_input_filename == NULL)
406 main_input_filename = opt;
407 add_input_filename (opt);
412 n = handle_option (argv + i, lang_mask);
417 error ("unrecognized command line option \"%s\"", opt);
422 /* Handle FILENAME from the command line. */
424 add_input_filename (const char *filename)
427 in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));
428 in_fnames[num_in_fnames - 1] = filename;
431 /* Parse command line options and set default flag values. Do minimal
432 options processing. */
434 decode_options (unsigned int argc, const char **argv)
436 unsigned int i, lang_mask;
438 /* Perform language-specific options initialization. */
439 lang_mask = lang_hooks.init_options (argc, argv);
441 lang_hooks.initialize_diagnostics (global_dc);
443 /* Scan to see what optimization level has been specified. That will
444 determine the default value of many flags. */
445 for (i = 1; i < argc; i++)
447 if (!strcmp (argv[i], "-O"))
452 else if (argv[i][0] == '-' && argv[i][1] == 'O')
454 /* Handle -Os, -O2, -O3, -O69, ... */
455 const char *p = &argv[i][2];
457 if ((p[0] == 's') && (p[1] == 0))
461 /* Optimizing for size forces optimize to be 2. */
466 const int optimize_val = read_integral_parameter (p, p - 2, -1);
467 if (optimize_val != -1)
469 optimize = optimize_val;
478 flag_merge_constants = 0;
484 flag_thread_jumps = 1;
486 flag_delayed_branch = 1;
488 #ifdef CAN_DEBUG_WITHOUT_FP
489 flag_omit_frame_pointer = 1;
491 flag_guess_branch_prob = 1;
492 flag_cprop_registers = 1;
493 flag_loop_optimize = 1;
494 flag_if_conversion = 1;
495 flag_if_conversion2 = 1;
501 flag_tree_live_range_split = 1;
503 flag_tree_copyrename = 1;
508 /* Loop header copying usually increases size of the code. This used
509 not to be true, since quite often it is possible to verify that
510 the condition is satisfied in the first iteration and therefore
511 to eliminate it. Jump threading handles these cases now. */
514 /* PRE tends to generate bigger code. */
521 flag_crossjumping = 1;
522 flag_optimize_sibling_calls = 1;
523 flag_cse_follow_jumps = 1;
524 flag_cse_skip_blocks = 1;
526 flag_expensive_optimizations = 1;
527 flag_strength_reduce = 1;
528 flag_rerun_cse_after_loop = 1;
529 flag_rerun_loop_opt = 1;
530 flag_caller_saves = 1;
533 #ifdef INSN_SCHEDULING
534 flag_schedule_insns = 1;
535 flag_schedule_insns_after_reload = 1;
538 flag_strict_aliasing = 1;
539 flag_delete_null_pointer_checks = 1;
540 flag_reorder_blocks = 1;
541 flag_reorder_functions = 1;
542 flag_unit_at_a_time = 1;
547 flag_inline_functions = 1;
548 flag_unswitch_loops = 1;
549 flag_gcse_after_reload = 1;
552 if (optimize < 2 || optimize_size)
559 /* Don't reorder blocks when optimizing for size because extra
560 jump insns may be created; also barrier may create extra padding.
562 More correctly we should have a block reordering mode that tried
563 to minimize the combined size of all the jumps. This would more
564 or less automatically remove extra jumps, but would also try to
565 use more short jumps instead of long jumps. */
566 flag_reorder_blocks = 0;
567 flag_reorder_blocks_and_partition = 0;
572 /* Inlining of very small functions usually reduces total size. */
573 set_param_value ("max-inline-insns-single", 5);
574 set_param_value ("max-inline-insns-auto", 5);
575 set_param_value ("max-inline-insns-rtl", 10);
576 flag_inline_functions = 1;
579 /* Initialize whether `char' is signed. */
580 flag_signed_char = DEFAULT_SIGNED_CHAR;
581 /* Set this to a special "uninitialized" value. The actual default is set
582 after target options have been processed. */
583 flag_short_enums = 2;
585 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
588 set_target_switch ("");
590 /* Unwind tables are always present when a target has ABI-specified unwind
591 tables, so the default should be ON. */
592 #ifdef TARGET_UNWIND_INFO
593 flag_unwind_tables = TARGET_UNWIND_INFO;
596 #ifdef OPTIMIZATION_OPTIONS
597 /* Allow default optimizations to be specified on a per-machine basis. */
598 OPTIMIZATION_OPTIONS (optimize, optimize_size);
601 handle_options (argc, argv, lang_mask);
605 if (flag_pic && !flag_pie)
608 if (flag_no_inline == 2)
611 flag_really_no_inline = flag_no_inline;
613 /* Set flag_no_inline before the post_options () hook. The C front
614 ends use it to determine tree inlining defaults. FIXME: such
615 code should be lang-independent when all front ends use tree
616 inlining, in which case it, and this condition, should be moved
617 to the top of process_options() instead. */
620 /* Inlining does not work if not optimizing,
621 so force it not to be done. */
625 /* The c_decode_option function and decode_option hook set
626 this to `2' if -Wall is used, so we can avoid giving out
627 lots of errors for people who don't realize what -Wall does. */
628 if (warn_uninitialized == 1)
629 warning ("-Wuninitialized is not supported without -O");
632 if (flag_really_no_inline == 2)
633 flag_really_no_inline = flag_no_inline;
635 /* The optimization to partition hot and cold basic blocks into separate
636 sections of the .o and executable files does not work (currently)
637 with exception handling. If flag_exceptions is turned on we need to
638 turn off the partitioning optimization. */
640 if (flag_exceptions && flag_reorder_blocks_and_partition)
643 ("-freorder-blocks-and-partition does not work with exceptions");
644 flag_reorder_blocks_and_partition = 0;
645 flag_reorder_blocks = 1;
648 /* The optimization to partition hot and cold basic blocks into
649 separate sections of the .o and executable files does not currently
650 work correctly with DWARF debugging turned on. Until this is fixed
651 we will disable the optimization when DWARF debugging is set. */
653 if (flag_reorder_blocks_and_partition && write_symbols == DWARF2_DEBUG)
656 ("-freorder-blocks-and-partition does not work with -g (currently)");
657 flag_reorder_blocks_and_partition = 0;
658 flag_reorder_blocks = 1;
662 /* Handle target- and language-independent options. Return zero to
663 generate an "unknown option" message. Only options that need
664 extra handling need to be listed here; if you simply want
665 VALUE assigned to a variable, it happens automatically. */
668 common_handle_option (size_t scode, const char *arg, int value)
670 enum opt_code code = (enum opt_code) scode;
676 exit_after_options = true;
683 case OPT__target_help:
684 display_target_options ();
685 exit_after_options = true;
689 print_version (stderr, "");
690 exit_after_options = true;
694 g_switch_value = value;
700 /* Currently handled in a prescan. */
704 /* For backward compatibility, -W is the same as -Wextra. */
712 case OPT_Wlarger_than_:
713 larger_than_size = value;
714 warn_larger_than = value != -1;
717 case OPT_Wstrict_aliasing:
718 case OPT_Wstrict_aliasing_:
719 warn_strict_aliasing = value;
728 aux_info_file_name = arg;
729 flag_gen_aux_info = 1;
736 case OPT_auxbase_strip:
738 char *tmp = xstrdup (arg);
739 strip_off_ending (tmp, strlen (tmp));
746 decode_d_option (arg);
750 dump_base_name = arg;
753 case OPT_falign_functions_:
754 align_functions = value;
757 case OPT_falign_jumps_:
761 case OPT_falign_labels_:
762 align_labels = value;
765 case OPT_falign_loops_:
769 case OPT_fbranch_probabilities:
770 flag_branch_probabilities_set = true;
773 case OPT_fcall_used_:
774 fix_register (arg, 0, 1);
777 case OPT_fcall_saved_:
778 fix_register (arg, 0, 0);
781 case OPT_fdiagnostics_show_location_:
782 if (!strcmp (arg, "once"))
783 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
784 else if (!strcmp (arg, "every-line"))
785 diagnostic_prefixing_rule (global_dc)
786 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
792 if (!dump_switch_p (arg))
797 set_fast_math_flags (value);
801 fix_register (arg, 1, 1);
804 case OPT_finline_limit_:
805 case OPT_finline_limit_eq:
806 set_param_value ("max-inline-insns-single", value / 2);
807 set_param_value ("max-inline-insns-auto", value / 2);
808 set_param_value ("max-inline-insns-rtl", value);
811 case OPT_fmessage_length_:
812 pp_set_line_maximum_length (global_dc->printer, value);
815 case OPT_fpack_struct_:
816 if (value <= 0 || (value & (value - 1)) || value > 16)
817 error("structure alignment must be a small power of two, not %d", value);
820 initial_max_fld_align = value;
821 maximum_field_alignment = value * BITS_PER_UNIT;
825 case OPT_fpeel_loops:
826 flag_peel_loops_set = true;
829 case OPT_fprofile_arcs:
830 profile_arc_flag_set = true;
833 case OPT_fprofile_use:
834 if (!flag_branch_probabilities_set)
835 flag_branch_probabilities = value;
836 if (!flag_profile_values_set)
837 flag_profile_values = value;
838 if (!flag_unroll_loops_set)
839 flag_unroll_loops = value;
840 if (!flag_peel_loops_set)
841 flag_peel_loops = value;
842 if (!flag_tracer_set)
844 if (!flag_value_profile_transformations_set)
845 flag_value_profile_transformations = value;
847 if (0 && !flag_speculative_prefetching_set)
848 flag_speculative_prefetching = value;
852 case OPT_fprofile_generate:
853 if (!profile_arc_flag_set)
854 profile_arc_flag = value;
855 if (!flag_profile_values_set)
856 flag_profile_values = value;
857 if (!flag_value_profile_transformations_set)
858 flag_value_profile_transformations = value;
859 if (!flag_unroll_loops_set)
860 flag_unroll_loops = value;
862 if (0 && !flag_speculative_prefetching_set)
863 flag_speculative_prefetching = value;
867 case OPT_fprofile_values:
868 flag_profile_values_set = true;
871 case OPT_fvisibility_:
873 if (!strcmp(arg, "default"))
874 default_visibility = VISIBILITY_DEFAULT;
875 else if (!strcmp(arg, "internal"))
876 default_visibility = VISIBILITY_INTERNAL;
877 else if (!strcmp(arg, "hidden"))
878 default_visibility = VISIBILITY_HIDDEN;
879 else if (!strcmp(arg, "protected"))
880 default_visibility = VISIBILITY_PROTECTED;
882 error ("unrecognised visibility value \"%s\"", arg);
887 flag_value_profile_transformations_set = true;
890 case OPT_fspeculative_prefetching:
891 flag_speculative_prefetching_set = true;
894 case OPT_frandom_seed:
895 /* The real switch is -fno-random-seed. */
898 flag_random_seed = NULL;
901 case OPT_frandom_seed_:
902 flag_random_seed = arg;
905 case OPT_fsched_verbose_:
906 #ifdef INSN_SCHEDULING
907 fix_sched_param ("verbose", arg);
913 case OPT_fsched_stalled_insns_:
914 flag_sched_stalled_insns = value;
915 if (flag_sched_stalled_insns == 0)
916 flag_sched_stalled_insns = -1;
919 case OPT_fsched_stalled_insns_dep_:
920 flag_sched_stalled_insns_dep = value;
923 case OPT_fstack_limit:
924 /* The real switch is -fno-stack-limit. */
927 stack_limit_rtx = NULL_RTX;
930 case OPT_fstack_limit_register_:
932 int reg = decode_reg_name (arg);
934 error ("unrecognized register name \"%s\"", arg);
936 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
940 case OPT_fstack_limit_symbol_:
941 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
944 case OPT_ftls_model_:
945 if (!strcmp (arg, "global-dynamic"))
946 flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
947 else if (!strcmp (arg, "local-dynamic"))
948 flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
949 else if (!strcmp (arg, "initial-exec"))
950 flag_tls_default = TLS_MODEL_INITIAL_EXEC;
951 else if (!strcmp (arg, "local-exec"))
952 flag_tls_default = TLS_MODEL_LOCAL_EXEC;
954 warning ("unknown tls-model \"%s\"", arg);
958 flag_tracer_set = true;
961 case OPT_funroll_loops:
962 flag_unroll_loops_set = true;
966 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
970 set_debug_level (SDB_DEBUG, false, arg);
974 set_debug_level (DWARF2_DEBUG, false, arg);
978 set_debug_level (NO_DEBUG, 2, arg);
983 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
987 set_debug_level (VMS_DEBUG, false, arg);
992 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
996 set_target_switch (arg);
1000 asm_file_name = arg;
1003 case OPT_pedantic_errors:
1004 flag_pedantic_errors = pedantic = 1;
1008 /* If the flag was handled in a standard way, assume the lack of
1009 processing here is intentional. */
1010 if (cl_options[scode].flag_var)
1019 /* Handle --param NAME=VALUE. */
1021 handle_param (const char *carg)
1026 arg = xstrdup (carg);
1027 equal = strchr (arg, '=');
1029 error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1032 value = integral_argument (equal + 1);
1034 error ("invalid --param value `%s'", equal + 1);
1038 set_param_value (arg, value);
1045 /* Handle -W and -Wextra. */
1047 set_Wextra (int setting)
1049 extra_warnings = setting;
1050 warn_unused_value = setting;
1051 warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1053 /* We save the value of warn_uninitialized, since if they put
1054 -Wuninitialized on the command line, we need to generate a
1055 warning about not using it without also specifying -O. */
1057 warn_uninitialized = 0;
1058 else if (warn_uninitialized != 1)
1059 warn_uninitialized = 2;
1062 /* Initialize unused warning flags. */
1064 set_Wunused (int setting)
1066 warn_unused_function = setting;
1067 warn_unused_label = setting;
1068 /* Unused function parameter warnings are reported when either
1069 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1070 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1071 otherwise set maybe_warn_extra_parameter, which will be picked up
1073 maybe_warn_unused_parameter = setting;
1074 warn_unused_parameter = (setting && extra_warnings);
1075 warn_unused_variable = setting;
1076 warn_unused_value = setting;
1079 /* The following routines are useful in setting all the flags that
1080 -ffast-math and -fno-fast-math imply. */
1082 set_fast_math_flags (int set)
1084 flag_trapping_math = !set;
1085 flag_unsafe_math_optimizations = set;
1086 flag_finite_math_only = set;
1087 flag_errno_math = !set;
1090 flag_signaling_nans = 0;
1091 flag_rounding_math = 0;
1095 /* Return true iff flags are set as if -ffast-math. */
1097 fast_math_flags_set_p (void)
1099 return (!flag_trapping_math
1100 && flag_unsafe_math_optimizations
1101 && flag_finite_math_only
1102 && !flag_errno_math);
1105 /* Handle a debug output -g switch. EXTENDED is true or false to support
1106 extended output (2 is special and means "-ggdb" was given). */
1108 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1110 static bool type_explicit;
1112 use_gnu_debug_info_extensions = extended;
1114 if (type == NO_DEBUG)
1116 if (write_symbols == NO_DEBUG)
1118 write_symbols = PREFERRED_DEBUGGING_TYPE;
1122 #ifdef DWARF2_DEBUGGING_INFO
1123 write_symbols = DWARF2_DEBUG;
1124 #elif defined DBX_DEBUGGING_INFO
1125 write_symbols = DBX_DEBUG;
1129 if (write_symbols == NO_DEBUG)
1130 warning ("target system does not support debug output");
1135 /* Does it conflict with an already selected type? */
1136 if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1137 error ("debug format \"%s\" conflicts with prior selection",
1138 debug_type_names[type]);
1139 write_symbols = type;
1140 type_explicit = true;
1143 /* A debug flag without a level defaults to level 2. */
1146 if (!debug_info_level)
1147 debug_info_level = 2;
1151 debug_info_level = integral_argument (arg);
1152 if (debug_info_level == (unsigned int) -1)
1153 error ("unrecognised debug output level \"%s\"", arg);
1154 else if (debug_info_level > 3)
1155 error ("debug output level %s is too high", arg);
1159 /* Output --help text. */
1166 GET_ENVIRONMENT (p, "COLUMNS");
1169 int value = atoi (p);
1174 puts (_("The following options are language-independent:\n"));
1176 print_filtered_help (CL_COMMON);
1177 print_param_help ();
1179 for (i = 0; lang_names[i]; i++)
1181 printf (_("The %s front end recognizes the following options:\n\n"),
1183 print_filtered_help (1U << i);
1186 display_target_options ();
1189 /* Print the help for --param. */
1191 print_param_help (void)
1195 puts (_("The --param option recognizes the following as parameters:\n"));
1197 for (i = 0; i < LAST_PARAM; i++)
1199 const char *help = compiler_params[i].help;
1200 const char *param = compiler_params[i].option;
1202 if (help == NULL || *help == '\0')
1203 help = undocumented_msg;
1205 /* Get the translation. */
1208 wrap_help (help, param, strlen (param));
1214 /* Print help for a specific front-end, etc. */
1216 print_filtered_help (unsigned int flag)
1218 unsigned int i, len, filter, indent = 0;
1219 bool duplicates = false;
1220 const char *help, *opt, *tab;
1221 static char *printed;
1223 if (flag == CL_COMMON)
1227 printed = xmalloc (cl_options_count);
1228 memset (printed, 0, cl_options_count);
1232 /* Don't print COMMON options twice. */
1233 filter = flag | CL_COMMON;
1235 for (i = 0; i < cl_options_count; i++)
1237 if ((cl_options[i].flags & filter) != flag)
1240 /* Skip help for internal switches. */
1241 if (cl_options[i].flags & CL_UNDOCUMENTED)
1244 /* Skip switches that have already been printed, mark them to be
1249 indent = print_switch (cl_options[i].opt_text, indent);
1260 for (i = 0; i < cl_options_count; i++)
1262 if ((cl_options[i].flags & filter) != flag)
1265 /* Skip help for internal switches. */
1266 if (cl_options[i].flags & CL_UNDOCUMENTED)
1269 /* Skip switches that have already been printed. */
1275 help = cl_options[i].help;
1277 help = undocumented_msg;
1279 /* Get the translation. */
1282 tab = strchr (help, '\t');
1291 opt = cl_options[i].opt_text;
1295 wrap_help (help, opt, len);
1301 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1302 word-wrapped HELP in a second column. */
1304 print_switch (const char *text, unsigned int indent)
1306 unsigned int len = strlen (text) + 1; /* trailing comma */
1311 if (indent + len > columns)
1322 fputs (text, stdout);
1324 return indent + len + 1;
1327 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1328 word-wrapped HELP in a second column. */
1330 wrap_help (const char *help, const char *item, unsigned int item_width)
1332 unsigned int col_width = 27;
1333 unsigned int remaining, room, len;
1335 remaining = strlen (help);
1339 room = columns - 3 - MAX (col_width, item_width);
1348 for (i = 0; help[i]; i++)
1350 if (i >= room && len != remaining)
1354 else if ((help[i] == '-' || help[i] == '/')
1355 && help[i + 1] != ' '
1356 && i > 0 && ISALPHA (help[i - 1]))
1361 printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
1363 while (help[len] == ' ')