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. */
41 /* Value of the -G xx switch, and whether it was passed or not. */
42 unsigned HOST_WIDE_INT g_switch_value;
45 /* True if we should exit after parsing options. */
46 bool exit_after_options;
51 /* Print various extra warnings. -W/-Wextra. */
54 /* Don't print warning messages. -w. */
55 bool inhibit_warnings;
57 /* Treat warnings as errors. -Werror. */
58 bool warnings_are_errors;
60 /* Warn if a function returns an aggregate, since there are often
61 incompatible calling conventions for doing this. */
62 bool warn_aggregate_return;
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). */
69 /* Nonzero means warn about uses of __attribute__((deprecated))
71 bool warn_deprecated_decl = true;
73 /* Warn when an optimization pass is disabled. */
74 bool warn_disabled_optimization;
76 /* Nonzero means warn if inline function is too large. */
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'. */
82 bool warn_larger_than;
83 HOST_WIDE_INT larger_than_size;
85 /* Warn about functions which might be candidates for attribute noreturn. */
86 bool warn_missing_noreturn;
88 /* True to warn about code which is never reached. */
91 /* Warn if packed attribute on struct is unnecessary and inefficient. */
94 /* Warn when gcc pads a structure to an alignment boundary. */
97 /* True means warn about all declarations which shadow others. */
100 /* Nonzero means warn about constructs which might not be
101 strict-aliasing safe. */
102 bool warn_strict_aliasing;
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. */
108 /* Warn if a switch does not have a default case. */
109 bool warn_switch_default;
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). */
113 bool warn_switch_enum;
115 /* Don't suppress warnings from system headers. -Wsystem-headers. */
116 bool warn_system_headers;
118 /* True to warn about variables used before they are initialized. */
119 int warn_uninitialized;
121 /* True to warn about unused variables, functions et.al. */
122 bool warn_unused_function;
123 bool warn_unused_label;
124 bool warn_unused_parameter;
125 bool warn_unused_variable;
126 bool warn_unused_value;
128 /* Hack for cooperation between set_Wunused and set_Wextra. */
129 static bool maybe_warn_unused_parameter;
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. */
134 enum debug_info_type write_symbols = NO_DEBUG;
136 /* Level of debugging information we are producing. See flags.h for
137 the definitions of the different possible levels. */
138 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
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. */
143 bool use_gnu_debug_info_extensions;
145 /* Columns of --help display. */
146 static unsigned int columns = 80;
148 /* What to print when a switch has no documentation. */
149 static const char undocumented_msg[] = N_("This switch lacks documentation");
151 /* Used for bookkeeping on whether user set these flags so
152 -fprofile-use/-fprofile-generate does not use them. */
153 static bool profile_arc_flag_set, flag_profile_values_set;
154 static bool flag_unroll_loops_set, flag_tracer_set;
155 static bool flag_value_profile_transformations_set;
156 static bool flag_peel_loops_set, flag_branch_probabilities_set;
158 /* Input file names. */
159 const char **in_fnames;
160 unsigned num_in_fnames;
162 static size_t find_opt (const char *, int);
163 static int common_handle_option (size_t scode, const char *arg, int value);
164 static void handle_param (const char *);
165 static void set_Wextra (int);
166 static unsigned int handle_option (const char **argv, unsigned int lang_mask);
167 static char *write_langs (unsigned int lang_mask);
168 static void complain_wrong_lang (const char *, const struct cl_option *,
169 unsigned int lang_mask);
170 static void handle_options (unsigned int, const char **, unsigned int);
171 static void wrap_help (const char *help, const char *item, unsigned int);
172 static void print_help (void);
173 static void print_param_help (void);
174 static void print_filtered_help (unsigned int flag);
175 static unsigned int print_switch (const char *text, unsigned int indent);
176 static void set_debug_level (enum debug_info_type type, int extended,
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.
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".
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).
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. */
204 find_opt (const char *input, int lang_mask)
206 size_t mn, mx, md, opt_len;
207 size_t match_wrong_lang;
211 mx = cl_options_count;
213 /* Find mn such this lexicographical inequality holds:
214 cl_options[mn] <= input < cl_options[mn + 1]. */
218 opt_len = cl_options[md].opt_len;
219 comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
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;
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. */
236 const struct cl_option *opt = &cl_options[mn];
238 /* Is this switch a prefix of the input? */
239 if (!strncmp (input, opt->opt_text + 1, opt->opt_len))
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)))
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;
253 /* Try the next possibility. This is cl_options_count if there
255 mn = opt->back_chain;
257 while (mn != cl_options_count);
259 /* Return the best wrong match, or cl_options_count if none. */
260 return match_wrong_lang;
263 /* If ARG is a non-negative integer made up solely of digits, return its
264 value, otherwise return -1. */
266 integral_argument (const char *arg)
270 while (*p && ISDIGIT (*p))
279 /* Return a malloced slash-separated list of languages in MASK. */
281 write_langs (unsigned int mask)
283 unsigned int n = 0, len = 0;
284 const char *lang_name;
287 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
288 if (mask & (1U << n))
289 len += strlen (lang_name) + 1;
291 result = xmalloc (len);
293 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
294 if (mask & (1U << n))
298 strcpy (result + len, lang_name);
299 len += strlen (lang_name);
307 /* Complain that switch OPT_INDEX does not apply to this front end. */
309 complain_wrong_lang (const char *text, const struct cl_option *option,
310 unsigned int lang_mask)
312 char *ok_langs, *bad_lang;
314 ok_langs = write_langs (option->flags);
315 bad_lang = write_langs (lang_mask);
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);
325 /* Handle the switch beginning at ARGV for the language indicated by
326 LANG_MASK. Returns the number of switches consumed. */
328 handle_option (const char **argv, unsigned int lang_mask)
331 const char *opt, *arg = 0;
334 unsigned int result = 0;
335 const struct cl_option *option;
339 /* Drop the "no-" from negative switches. */
340 if ((opt[1] == 'W' || opt[1] == 'f')
341 && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
343 size_t len = strlen (opt) - 3;
345 dup = xmalloc (len + 1);
348 memcpy (dup + 2, opt + 5, len - 2 + 1);
353 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON);
354 if (opt_index == cl_options_count)
357 option = &cl_options[opt_index];
359 /* Reject negative form of switches that don't take negatives as
361 if (!value && (option->flags & CL_REJECT_NEGATIVE))
364 /* We've recognized this switch. */
367 /* Sort out any argument the switch takes. */
368 if (option->flags & CL_JOINED)
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;
375 arg += strlen ("no-");
377 if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
379 if (option->flags & CL_SEPARATE)
385 /* Missing argument. */
389 else if (option->flags & CL_SEPARATE)
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)))
399 complain_wrong_lang (argv[0], option, lang_mask);
403 if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
405 if (!(*lang_hooks.missing_argument) (opt, opt_index))
406 error ("missing argument to \"%s\"", opt);
410 /* If the switch takes an integer, convert it. */
411 if (arg && (option->flags & CL_UINTEGER))
413 value = integral_argument (arg);
416 error ("argument to \"%s\" should be a non-negative integer",
422 if (option->flags & lang_mask)
423 if ((*lang_hooks.handle_option) (opt_index, arg, value) == 0)
426 if (result && (option->flags & CL_COMMON))
427 if (common_handle_option (opt_index, arg, value) == 0)
436 /* Decode and handle the vector of command line options. LANG_MASK
437 contains has a single bit set representing the current
440 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
444 for (i = 1; i < argc; i += n)
446 const char *opt = argv[i];
448 /* Interpret "-" or a non-switch as a file name. */
449 if (opt[0] != '-' || opt[1] == '\0')
451 if (main_input_filename == NULL)
452 main_input_filename = opt;
453 add_input_filename (opt);
458 n = handle_option (argv + i, lang_mask);
463 error ("unrecognized command line option \"%s\"", opt);
468 /* Handle FILENAME from the command line. */
470 add_input_filename (const char *filename)
473 in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));
474 in_fnames[num_in_fnames - 1] = filename;
477 /* Parse command line options and set default flag values. Do minimal
478 options processing. */
480 decode_options (unsigned int argc, const char **argv)
482 unsigned int i, lang_mask;
484 /* Perform language-specific options initialization. */
485 lang_mask = (*lang_hooks.init_options) (argc, argv);
487 lang_hooks.initialize_diagnostics (global_dc);
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++)
493 if (!strcmp (argv[i], "-O"))
498 else if (argv[i][0] == '-' && argv[i][1] == 'O')
500 /* Handle -Os, -O2, -O3, -O69, ... */
501 const char *p = &argv[i][2];
503 if ((p[0] == 's') && (p[1] == 0))
507 /* Optimizing for size forces optimize to be 2. */
512 const int optimize_val = read_integral_parameter (p, p - 2, -1);
513 if (optimize_val != -1)
515 optimize = optimize_val;
524 flag_merge_constants = 0;
530 flag_thread_jumps = 1;
532 flag_delayed_branch = 1;
534 #ifdef CAN_DEBUG_WITHOUT_FP
535 flag_omit_frame_pointer = 1;
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;
546 flag_crossjumping = 1;
547 flag_optimize_sibling_calls = 1;
548 flag_cse_follow_jumps = 1;
549 flag_cse_skip_blocks = 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;
558 #ifdef INSN_SCHEDULING
559 flag_schedule_insns = 1;
560 flag_schedule_insns_after_reload = 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;
572 flag_inline_functions = 1;
573 flag_rename_registers = 1;
574 flag_unswitch_loops = 1;
578 if (optimize < 2 || optimize_size)
585 /* Don't reorder blocks when optimizing for size because extra
586 jump insns may be created; also barrier may create extra padding.
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;
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;
602 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
605 set_target_switch ("");
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;
613 #ifdef OPTIMIZATION_OPTIONS
614 /* Allow default optimizations to be specified on a per-machine basis. */
615 OPTIMIZATION_OPTIONS (optimize, optimize_size);
618 handle_options (argc, argv, lang_mask);
622 if (flag_pic && !flag_pie)
625 if (flag_no_inline == 2)
628 flag_really_no_inline = flag_no_inline;
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. */
637 /* Inlining does not work if not optimizing,
638 so force it not to be done. */
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");
649 if (flag_really_no_inline == 2)
650 flag_really_no_inline = flag_no_inline;
653 /* Handle target- and language-independent options. Return zero to
654 generate an "unknown option" message. */
656 common_handle_option (size_t scode, const char *arg,
657 int value ATTRIBUTE_UNUSED)
659 enum opt_code code = (enum opt_code) scode;
668 exit_after_options = true;
675 case OPT__target_help:
676 display_target_options ();
677 exit_after_options = true;
681 print_version (stderr, "");
682 exit_after_options = true;
686 g_switch_value = value;
692 /* Currently handled in a prescan. */
696 /* For backward compatibility, -W is the same as -Wextra. */
700 case OPT_Waggregate_return:
701 warn_aggregate_return = value;
704 case OPT_Wcast_align:
705 warn_cast_align = value;
708 case OPT_Wdeprecated_declarations:
709 warn_deprecated_decl = value;
712 case OPT_Wdisabled_optimization:
713 warn_disabled_optimization = value;
717 warnings_are_errors = value;
728 case OPT_Wlarger_than_:
729 larger_than_size = value;
730 warn_larger_than = value != -1;
733 case OPT_Wmissing_noreturn:
734 warn_missing_noreturn = value;
749 case OPT_Wstrict_aliasing:
750 warn_strict_aliasing = value;
757 case OPT_Wswitch_default:
758 warn_switch_default = value;
761 case OPT_Wswitch_enum:
762 warn_switch_enum = value;
765 case OPT_Wsystem_headers:
766 warn_system_headers = value;
769 case OPT_Wuninitialized:
770 warn_uninitialized = value;
773 case OPT_Wunreachable_code:
774 warn_notreached = value;
781 case OPT_Wunused_function:
782 warn_unused_function = value;
785 case OPT_Wunused_label:
786 warn_unused_label = value;
789 case OPT_Wunused_parameter:
790 warn_unused_parameter = value;
793 case OPT_Wunused_value:
794 warn_unused_value = value;
797 case OPT_Wunused_variable:
798 warn_unused_variable = value;
803 aux_info_file_name = arg;
804 flag_gen_aux_info = 1;
811 case OPT_auxbase_strip:
813 char *tmp = xstrdup (arg);
814 strip_off_ending (tmp, strlen (tmp));
821 decode_d_option (arg);
825 dump_base_name = arg;
829 flag_pic = value + value;
833 flag_pie = value + value;
836 case OPT_fabi_version_:
837 flag_abi_version = value;
840 case OPT_falign_functions:
841 align_functions = !value;
844 case OPT_falign_functions_:
845 align_functions = value;
848 case OPT_falign_jumps:
849 align_jumps = !value;
852 case OPT_falign_jumps_:
856 case OPT_falign_labels:
857 align_labels = !value;
860 case OPT_falign_labels_:
861 align_labels = value;
864 case OPT_falign_loops:
865 align_loops = !value;
868 case OPT_falign_loops_:
872 case OPT_fargument_alias:
873 flag_argument_noalias = !value;
876 case OPT_fargument_noalias:
877 flag_argument_noalias = value;
880 case OPT_fargument_noalias_global:
881 flag_argument_noalias = value + value;
884 case OPT_fasynchronous_unwind_tables:
885 flag_asynchronous_unwind_tables = value;
888 case OPT_fbounds_check:
889 flag_bounds_check = value;
892 case OPT_fbranch_count_reg:
893 flag_branch_on_count_reg = value;
896 case OPT_fbranch_probabilities:
897 flag_branch_probabilities_set = true;
898 flag_branch_probabilities = value;
901 case OPT_fbranch_target_load_optimize:
902 flag_branch_target_load_optimize = value;
905 case OPT_fbranch_target_load_optimize2:
906 flag_branch_target_load_optimize2 = value;
909 case OPT_fbtr_bb_exclusive:
910 flag_btr_bb_exclusive = value;
913 case OPT_fcall_used_:
914 fix_register (arg, 0, 1);
917 case OPT_fcall_saved_:
918 fix_register (arg, 0, 0);
921 case OPT_fcaller_saves:
922 flag_caller_saves = value;
926 flag_no_common = !value;
929 case OPT_fcprop_registers:
930 flag_cprop_registers = value;
933 case OPT_fcrossjumping:
934 flag_crossjumping = value;
937 case OPT_fcse_follow_jumps:
938 flag_cse_follow_jumps = value;
941 case OPT_fcse_skip_blocks:
942 flag_cse_skip_blocks = value;
945 case OPT_fdata_sections:
946 flag_data_sections = value;
950 flag_defer_pop = value;
953 case OPT_fdelayed_branch:
954 flag_delayed_branch = value;
957 case OPT_fdelete_null_pointer_checks:
958 flag_delete_null_pointer_checks = value;
961 case OPT_fdiagnostics_show_location_:
962 if (!strcmp (arg, "once"))
963 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
964 else if (!strcmp (arg, "every-line"))
965 diagnostic_prefixing_rule (global_dc)
966 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
971 case OPT_fdump_unnumbered:
972 flag_dump_unnumbered = value;
975 case OPT_feliminate_dwarf2_dups:
976 flag_eliminate_dwarf2_dups = value;
979 case OPT_feliminate_unused_debug_types:
980 flag_eliminate_unused_debug_types = value;
983 case OPT_feliminate_unused_debug_symbols:
984 flag_debug_only_used_symbols = value;
987 case OPT_fexceptions:
988 flag_exceptions = value;
991 case OPT_fexpensive_optimizations:
992 flag_expensive_optimizations = value;
996 set_fast_math_flags (value);
999 case OPT_ffinite_math_only:
1000 flag_finite_math_only = value;
1004 fix_register (arg, 1, 1);
1007 case OPT_ffunction_cse:
1008 flag_no_function_cse = !value;
1011 case OPT_ffloat_store:
1012 flag_float_store = value;
1015 case OPT_fforce_addr:
1016 flag_force_addr = value;
1019 case OPT_fforce_mem:
1020 flag_force_mem = value;
1023 case OPT_ffunction_sections:
1024 flag_function_sections = value;
1032 flag_gcse_lm = value;
1036 flag_gcse_sm = value;
1040 flag_gcse_las = value;
1043 case OPT_fguess_branch_probability:
1044 flag_guess_branch_prob = value;
1048 flag_no_ident = !value;
1051 case OPT_fif_conversion:
1052 flag_if_conversion = value;
1055 case OPT_fif_conversion2:
1056 flag_if_conversion2 = value;
1059 case OPT_finhibit_size_directive:
1060 flag_inhibit_size_directive = value;
1064 flag_no_inline = !value;
1067 case OPT_finline_functions:
1068 flag_inline_functions = value;
1071 case OPT_finline_limit_:
1072 case OPT_finline_limit_eq:
1073 set_param_value ("max-inline-insns-single", value / 2);
1074 set_param_value ("max-inline-insns-auto", value / 2);
1075 set_param_value ("max-inline-insns-rtl", value);
1078 case OPT_finstrument_functions:
1079 flag_instrument_function_entry_exit = value;
1082 case OPT_fkeep_inline_functions:
1083 flag_keep_inline_functions =value;
1086 case OPT_fkeep_static_consts:
1087 flag_keep_static_consts = value;
1090 case OPT_fleading_underscore:
1091 flag_leading_underscore = value;
1094 case OPT_floop_optimize:
1095 flag_loop_optimize = value;
1098 case OPT_fmath_errno:
1099 flag_errno_math = value;
1102 case OPT_fmem_report:
1106 case OPT_fmerge_all_constants:
1107 flag_merge_constants = value + value;
1110 case OPT_fmerge_constants:
1111 flag_merge_constants = value;
1114 case OPT_fmessage_length_:
1115 pp_set_line_maximum_length (global_dc->printer, value);
1118 case OPT_fmove_all_movables:
1119 flag_move_all_movables = value;
1123 flag_new_regalloc = value;
1126 case OPT_fnon_call_exceptions:
1127 flag_non_call_exceptions = value;
1130 case OPT_fold_unroll_all_loops:
1131 flag_old_unroll_all_loops = value;
1134 case OPT_fold_unroll_loops:
1135 flag_old_unroll_loops = value;
1138 case OPT_fomit_frame_pointer:
1139 flag_omit_frame_pointer = value;
1142 case OPT_foptimize_register_move:
1143 flag_regmove = value;
1146 case OPT_foptimize_sibling_calls:
1147 flag_optimize_sibling_calls = value;
1150 case OPT_fpack_struct:
1151 flag_pack_struct = value;
1154 case OPT_fpeel_loops:
1155 flag_peel_loops_set = true;
1156 flag_peel_loops = value;
1159 case OPT_fpcc_struct_return:
1160 flag_pcc_struct_return = value;
1164 flag_no_peephole = !value;
1167 case OPT_fpeephole2:
1168 flag_peephole2 = value;
1179 case OPT_fprefetch_loop_arrays:
1180 flag_prefetch_loop_arrays = value;
1184 profile_flag = value;
1187 case OPT_fprofile_arcs:
1188 profile_arc_flag_set = true;
1189 profile_arc_flag = value;
1192 case OPT_fprofile_use:
1193 if (!flag_branch_probabilities_set)
1194 flag_branch_probabilities = value;
1195 if (!flag_profile_values_set)
1196 flag_profile_values = value;
1197 if (!flag_unroll_loops_set)
1198 flag_unroll_loops = value;
1199 if (!flag_peel_loops_set)
1200 flag_peel_loops = value;
1201 if (!flag_tracer_set)
1202 flag_tracer = value;
1203 if (!flag_value_profile_transformations_set)
1204 flag_value_profile_transformations = value;
1207 case OPT_fprofile_generate:
1208 if (!profile_arc_flag_set)
1209 profile_arc_flag = value;
1210 if (!flag_profile_values_set)
1211 flag_profile_values = value;
1212 if (!flag_value_profile_transformations_set)
1213 flag_value_profile_transformations = value;
1216 case OPT_fprofile_values:
1217 flag_profile_values_set = true;
1218 flag_profile_values = value;
1222 flag_value_profile_transformations_set = value;
1223 flag_value_profile_transformations = value;
1226 case OPT_frandom_seed:
1227 /* The real switch is -fno-random-seed. */
1230 flag_random_seed = NULL;
1233 case OPT_frandom_seed_:
1234 flag_random_seed = arg;
1237 case OPT_freduce_all_givs:
1238 flag_reduce_all_givs = value;
1241 case OPT_freg_struct_return:
1242 flag_pcc_struct_return = !value;
1246 flag_regmove = value;
1249 case OPT_frename_registers:
1250 flag_rename_registers = value;
1253 case OPT_freorder_blocks:
1254 flag_reorder_blocks = value;
1257 case OPT_freorder_functions:
1258 flag_reorder_functions = value;
1261 case OPT_frerun_cse_after_loop:
1262 flag_rerun_cse_after_loop = value;
1265 case OPT_frerun_loop_opt:
1266 flag_rerun_loop_opt = value;
1269 case OPT_frounding_math:
1270 flag_rounding_math = value;
1273 case OPT_fsched_interblock:
1274 flag_schedule_interblock = value;
1277 case OPT_fsched_spec:
1278 flag_schedule_speculative = value;
1281 case OPT_fsched_spec_load:
1282 flag_schedule_speculative_load = value;
1285 case OPT_fsched_spec_load_dangerous:
1286 flag_schedule_speculative_load_dangerous = value;
1289 case OPT_fsched_verbose_:
1290 #ifdef INSN_SCHEDULING
1291 fix_sched_param ("verbose", arg);
1297 case OPT_fsched2_use_superblocks:
1298 flag_sched2_use_superblocks = value;
1301 case OPT_fsched2_use_traces:
1302 flag_sched2_use_traces = value;
1305 case OPT_fschedule_insns:
1306 flag_schedule_insns = value;
1309 case OPT_fschedule_insns2:
1310 flag_schedule_insns_after_reload = value;
1313 case OPT_fsched_stalled_insns:
1314 flag_sched_stalled_insns = value;
1317 case OPT_fsched_stalled_insns_:
1318 flag_sched_stalled_insns = value;
1319 if (flag_sched_stalled_insns == 0)
1320 flag_sched_stalled_insns = -1;
1323 case OPT_fsched_stalled_insns_dep:
1324 flag_sched_stalled_insns_dep = 1;
1327 case OPT_fsched_stalled_insns_dep_:
1328 flag_sched_stalled_insns_dep = value;
1331 case OPT_fshared_data:
1332 flag_shared_data = value;
1335 case OPT_fsignaling_nans:
1336 flag_signaling_nans = value;
1339 case OPT_fsingle_precision_constant:
1340 flag_single_precision_constant = value;
1343 case OPT_fstack_check:
1344 flag_stack_check = value;
1347 case OPT_fstack_limit:
1348 /* The real switch is -fno-stack-limit. */
1351 stack_limit_rtx = NULL_RTX;
1354 case OPT_fstack_limit_register_:
1356 int reg = decode_reg_name (arg);
1358 error ("unrecognized register name \"%s\"", arg);
1360 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1364 case OPT_fstack_limit_symbol_:
1365 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1368 case OPT_fstrength_reduce:
1369 flag_strength_reduce = value;
1372 case OPT_fstrict_aliasing:
1373 flag_strict_aliasing = value;
1376 case OPT_fsyntax_only:
1377 flag_syntax_only = value;
1380 case OPT_ftest_coverage:
1381 flag_test_coverage = value;
1384 case OPT_fthread_jumps:
1385 flag_thread_jumps = value;
1388 case OPT_ftime_report:
1389 time_report = value;
1392 case OPT_ftls_model_:
1393 if (!strcmp (arg, "global-dynamic"))
1394 flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1395 else if (!strcmp (arg, "local-dynamic"))
1396 flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1397 else if (!strcmp (arg, "initial-exec"))
1398 flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1399 else if (!strcmp (arg, "local-exec"))
1400 flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1402 warning ("unknown tls-model \"%s\"", arg);
1406 flag_tracer_set = true;
1407 flag_tracer = value;
1410 case OPT_ftrapping_math:
1411 flag_trapping_math = value;
1418 case OPT_funit_at_a_time:
1419 flag_unit_at_a_time = value;
1422 case OPT_funroll_all_loops:
1423 flag_unroll_all_loops = value;
1426 case OPT_funroll_loops:
1427 flag_unroll_loops_set = true;
1428 flag_unroll_loops = value;
1431 case OPT_funsafe_math_optimizations:
1432 flag_unsafe_math_optimizations = value;
1435 case OPT_funswitch_loops:
1436 flag_unswitch_loops = value;
1439 case OPT_funwind_tables:
1440 flag_unwind_tables = value;
1443 case OPT_fvar_tracking:
1444 flag_var_tracking = value;
1447 case OPT_fverbose_asm:
1448 flag_verbose_asm = value;
1459 case OPT_fwritable_strings:
1460 flag_writable_strings = value;
1463 case OPT_fzero_initialized_in_bss:
1464 flag_zero_initialized_in_bss = value;
1468 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
1472 set_debug_level (SDB_DEBUG, false, arg);
1476 set_debug_level (DWARF2_DEBUG, false, arg);
1480 set_debug_level (NO_DEBUG, 2, arg);
1485 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
1489 set_debug_level (VMS_DEBUG, false, arg);
1494 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
1498 set_target_switch (arg);
1502 asm_file_name = arg;
1513 case OPT_pedantic_errors:
1514 flag_pedantic_errors = pedantic = 1;
1526 inhibit_warnings = true;
1533 /* Handle --param NAME=VALUE. */
1535 handle_param (const char *carg)
1540 arg = xstrdup (carg);
1541 equal = strchr (arg, '=');
1543 error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1546 value = integral_argument (equal + 1);
1548 error ("invalid --param value `%s'", equal + 1);
1552 set_param_value (arg, value);
1559 /* Handle -W and -Wextra. */
1561 set_Wextra (int setting)
1563 extra_warnings = setting;
1564 warn_unused_value = setting;
1565 warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1567 /* We save the value of warn_uninitialized, since if they put
1568 -Wuninitialized on the command line, we need to generate a
1569 warning about not using it without also specifying -O. */
1571 warn_uninitialized = 0;
1572 else if (warn_uninitialized != 1)
1573 warn_uninitialized = 2;
1576 /* Initialize unused warning flags. */
1578 set_Wunused (int setting)
1580 warn_unused_function = setting;
1581 warn_unused_label = setting;
1582 /* Unused function parameter warnings are reported when either
1583 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1584 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1585 otherwise set maybe_warn_extra_parameter, which will be picked up
1587 maybe_warn_unused_parameter = setting;
1588 warn_unused_parameter = (setting && extra_warnings);
1589 warn_unused_variable = setting;
1590 warn_unused_value = setting;
1593 /* The following routines are useful in setting all the flags that
1594 -ffast-math and -fno-fast-math imply. */
1596 set_fast_math_flags (int set)
1598 flag_trapping_math = !set;
1599 flag_unsafe_math_optimizations = set;
1600 flag_finite_math_only = set;
1601 flag_errno_math = !set;
1604 flag_signaling_nans = 0;
1605 flag_rounding_math = 0;
1609 /* Return true iff flags are set as if -ffast-math. */
1611 fast_math_flags_set_p (void)
1613 return (!flag_trapping_math
1614 && flag_unsafe_math_optimizations
1615 && flag_finite_math_only
1616 && !flag_errno_math);
1619 /* Handle a debug output -g switch. EXTENDED is true or false to support
1620 extended output (2 is special and means "-ggdb" was given). */
1622 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1624 static bool type_explicit;
1626 use_gnu_debug_info_extensions = extended;
1628 if (type == NO_DEBUG)
1630 if (write_symbols == NO_DEBUG)
1632 write_symbols = PREFERRED_DEBUGGING_TYPE;
1636 #ifdef DWARF2_DEBUGGING_INFO
1637 write_symbols = DWARF2_DEBUG;
1638 #elif defined DBX_DEBUGGING_INFO
1639 write_symbols = DBX_DEBUG;
1643 if (write_symbols == NO_DEBUG)
1644 warning ("target system does not support debug output");
1649 /* Does it conflict with an already selected type? */
1650 if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1651 error ("debug format \"%s\" conflicts with prior selection",
1652 debug_type_names[type]);
1653 write_symbols = type;
1654 type_explicit = true;
1657 /* A debug flag without a level defaults to level 2. */
1660 if (!debug_info_level)
1661 debug_info_level = 2;
1665 debug_info_level = integral_argument (arg);
1666 if (debug_info_level == (unsigned int) -1)
1667 error ("unrecognised debug output level \"%s\"", arg);
1668 else if (debug_info_level > 3)
1669 error ("debug output level %s is too high", arg);
1673 /* Output --help text. */
1680 GET_ENVIRONMENT (p, "COLUMNS");
1683 int value = atoi (p);
1688 puts (_("The following options are language-independent:\n"));
1690 print_filtered_help (CL_COMMON);
1691 print_param_help ();
1693 for (i = 0; lang_names[i]; i++)
1695 printf (_("The %s front end recognizes the following options:\n\n"),
1697 print_filtered_help (1U << i);
1700 display_target_options ();
1703 /* Print the help for --param. */
1705 print_param_help (void)
1709 puts (_("The --param option recognizes the following as parameters:\n"));
1711 for (i = 0; i < LAST_PARAM; i++)
1713 const char *help = compiler_params[i].help;
1714 const char *param = compiler_params[i].option;
1716 if (help == NULL || *help == '\0')
1717 help = undocumented_msg;
1719 /* Get the translation. */
1722 wrap_help (help, param, strlen (param));
1728 /* Print help for a specific front-end, etc. */
1730 print_filtered_help (unsigned int flag)
1732 unsigned int i, len, filter, indent = 0;
1733 bool duplicates = false;
1734 const char *help, *opt, *tab;
1735 static char *printed;
1737 if (flag == CL_COMMON)
1741 printed = xmalloc (cl_options_count);
1742 memset (printed, 0, cl_options_count);
1746 /* Don't print COMMON options twice. */
1747 filter = flag | CL_COMMON;
1749 for (i = 0; i < cl_options_count; i++)
1751 if ((cl_options[i].flags & filter) != flag)
1754 /* Skip help for internal switches. */
1755 if (cl_options[i].flags & CL_UNDOCUMENTED)
1758 /* Skip switches that have already been printed, mark them to be
1763 indent = print_switch (cl_options[i].opt_text, indent);
1774 for (i = 0; i < cl_options_count; i++)
1776 if ((cl_options[i].flags & filter) != flag)
1779 /* Skip help for internal switches. */
1780 if (cl_options[i].flags & CL_UNDOCUMENTED)
1783 /* Skip switches that have already been printed. */
1789 help = cl_options[i].help;
1791 help = undocumented_msg;
1793 /* Get the translation. */
1796 tab = strchr (help, '\t');
1805 opt = cl_options[i].opt_text;
1809 wrap_help (help, opt, len);
1815 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1816 word-wrapped HELP in a second column. */
1818 print_switch (const char *text, unsigned int indent)
1820 unsigned int len = strlen (text) + 1; /* trailing comma */
1825 if (indent + len > columns)
1836 fputs (text, stdout);
1838 return indent + len + 1;
1841 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1842 word-wrapped HELP in a second column. */
1844 wrap_help (const char *help, const char *item, unsigned int item_width)
1846 unsigned int col_width = 27;
1847 unsigned int remaining, room, len;
1849 remaining = strlen (help);
1853 room = columns - 3 - MAX (col_width, item_width);
1862 for (i = 0; help[i]; i++)
1864 if (i >= room && len != remaining)
1868 else if ((help[i] == '-' || help[i] == '/')
1869 && help[i + 1] != ' '
1870 && i > 0 && ISALPHA (help[i - 1]))
1875 printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
1877 while (help[len] == ' ')