1 /* Command line option handling.
2 Copyright (C) 2002, 2003 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 /* Input file names. */
152 const char **in_fnames;
153 unsigned num_in_fnames;
155 static size_t find_opt (const char *, int);
156 static int common_handle_option (size_t scode, const char *arg, int value);
157 static void handle_param (const char *);
158 static void set_Wextra (int);
159 static unsigned int handle_option (const char **argv, unsigned int lang_mask);
160 static char *write_langs (unsigned int lang_mask);
161 static void complain_wrong_lang (const char *, const struct cl_option *,
162 unsigned int lang_mask);
163 static void handle_options (unsigned int, const char **, unsigned int);
164 static void wrap_help (const char *help, const char *item, unsigned int);
165 static void print_help (void);
166 static void print_param_help (void);
167 static void print_filtered_help (unsigned int flag);
168 static unsigned int print_switch (const char *text, unsigned int indent);
169 static void set_debug_level (enum debug_info_type type, int extended,
172 /* Perform a binary search to find which option the command-line INPUT
173 matches. Returns its index in the option array, and N_OPTS
174 (cl_options_count) on failure.
176 This routine is quite subtle. A normal binary search is not good
177 enough because some options can be suffixed with an argument, and
178 multiple sub-matches can occur, e.g. input of "-pedantic" matching
179 the initial substring of "-pedantic-errors".
181 A more complicated example is -gstabs. It should match "-g" with
182 an argument of "stabs". Suppose, however, that the number and list
183 of switches are such that the binary search tests "-gen-decls"
184 before having tested "-g". This doesn't match, and as "-gen-decls"
185 is less than "-gstabs", it will become the lower bound of the
186 binary search range, and "-g" will never be seen. To resolve this
187 issue, opts.sh makes "-gen-decls" point, via the back_chain member,
188 to "-g" so that failed searches that end between "-gen-decls" and
189 the lexicographically subsequent switch know to go back and see if
190 "-g" causes a match (which it does in this example).
192 This search is done in such a way that the longest match for the
193 front end in question wins. If there is no match for the current
194 front end, the longest match for a different front end is returned
195 (or N_OPTS if none) and the caller emits an error message. */
197 find_opt (const char *input, int lang_mask)
199 size_t mn, mx, md, opt_len;
200 size_t match_wrong_lang;
204 mx = cl_options_count;
206 /* Find mn such this lexicographical inequality holds:
207 cl_options[mn] <= input < cl_options[mn + 1]. */
211 opt_len = cl_options[md].opt_len;
212 comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
220 /* This is the switch that is the best match but for a different
221 front end, or cl_options_count if there is no match at all. */
222 match_wrong_lang = cl_options_count;
224 /* Backtrace the chain of possible matches, returning the longest
225 one, if any, that fits best. With current GCC switches, this
226 loop executes at most twice. */
229 const struct cl_option *opt = &cl_options[mn];
231 /* Is this switch a prefix of the input? */
232 if (!strncmp (input, opt->opt_text + 1, opt->opt_len))
234 /* If language is OK, and the match is exact or the switch
235 takes a joined argument, return it. */
236 if ((opt->flags & lang_mask)
237 && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
240 /* If we haven't remembered a prior match, remember this
241 one. Any prior match is necessarily better. */
242 if (match_wrong_lang == cl_options_count)
243 match_wrong_lang = mn;
246 /* Try the next possibility. This is cl_options_count if there
248 mn = opt->back_chain;
250 while (mn != cl_options_count);
252 /* Return the best wrong match, or cl_options_count if none. */
253 return match_wrong_lang;
256 /* If ARG is a non-negative integer made up solely of digits, return its
257 value, otherwise return -1. */
259 integral_argument (const char *arg)
263 while (*p && ISDIGIT (*p))
272 /* Return a malloced slash-separated list of languages in MASK. */
274 write_langs (unsigned int mask)
276 unsigned int n = 0, len = 0;
277 const char *lang_name;
280 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
281 if (mask & (1U << n))
282 len += strlen (lang_name) + 1;
284 result = xmalloc (len);
286 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
287 if (mask & (1U << n))
291 strcpy (result + len, lang_name);
292 len += strlen (lang_name);
300 /* Complain that switch OPT_INDEX does not apply to this front end. */
302 complain_wrong_lang (const char *text, const struct cl_option *option,
303 unsigned int lang_mask)
305 char *ok_langs, *bad_lang;
307 ok_langs = write_langs (option->flags);
308 bad_lang = write_langs (lang_mask);
310 /* Eventually this should become a hard error IMO. */
311 warning ("command line option \"%s\" is valid for %s but not for %s",
312 text, ok_langs, bad_lang);
318 /* Handle the switch beginning at ARGV for the language indicated by
319 LANG_MASK. Returns the number of switches consumed. */
321 handle_option (const char **argv, unsigned int lang_mask)
324 const char *opt, *arg = 0;
327 unsigned int result = 0;
328 const struct cl_option *option;
332 /* Drop the "no-" from negative switches. */
333 if ((opt[1] == 'W' || opt[1] == 'f')
334 && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
336 size_t len = strlen (opt) - 3;
338 dup = xmalloc (len + 1);
341 memcpy (dup + 2, opt + 5, len - 2 + 1);
346 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON);
347 if (opt_index == cl_options_count)
350 option = &cl_options[opt_index];
352 /* Reject negative form of switches that don't take negatives as
354 if (!value && (option->flags & CL_REJECT_NEGATIVE))
357 /* We've recognized this switch. */
360 /* Sort out any argument the switch takes. */
361 if (option->flags & CL_JOINED)
363 /* Have arg point to the original switch. This is because
364 some code, such as disable_builtin_function, expects its
365 argument to be persistent until the program exits. */
366 arg = argv[0] + cl_options[opt_index].opt_len + 1;
368 arg += strlen ("no-");
370 if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
372 if (option->flags & CL_SEPARATE)
378 /* Missing argument. */
382 else if (option->flags & CL_SEPARATE)
388 /* Now we've swallowed any potential argument, complain if this
389 is a switch for a different front end. */
390 if (!(option->flags & (lang_mask | CL_COMMON)))
392 complain_wrong_lang (argv[0], option, lang_mask);
396 if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
398 if (!(*lang_hooks.missing_argument) (opt, opt_index))
399 error ("missing argument to \"%s\"", opt);
403 /* If the switch takes an integer, convert it. */
404 if (arg && (option->flags & CL_UINTEGER))
406 value = integral_argument (arg);
409 error ("argument to \"%s\" should be a non-negative integer",
415 if (option->flags & lang_mask)
416 if ((*lang_hooks.handle_option) (opt_index, arg, value) == 0)
419 if (result && (option->flags & CL_COMMON))
420 if (common_handle_option (opt_index, arg, value) == 0)
429 /* Decode and handle the vector of command line options. LANG_MASK
430 contains has a single bit set representing the current
433 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
437 for (i = 1; i < argc; i += n)
439 const char *opt = argv[i];
441 /* Interpret "-" or a non-switch as a file name. */
442 if (opt[0] != '-' || opt[1] == '\0')
444 main_input_filename = opt;
445 add_input_filename (opt);
450 n = handle_option (argv + i, lang_mask);
455 error ("unrecognized command line option \"%s\"", opt);
460 /* Handle FILENAME from the command line. */
462 add_input_filename (const char *filename)
465 in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));
466 in_fnames[num_in_fnames - 1] = filename;
469 /* Parse command line options and set default flag values. Do minimal
470 options processing. */
472 decode_options (unsigned int argc, const char **argv)
474 unsigned int i, lang_mask;
476 /* Perform language-specific options initialization. */
477 lang_mask = (*lang_hooks.init_options) (argc, argv);
479 lang_hooks.initialize_diagnostics (global_dc);
481 /* Scan to see what optimization level has been specified. That will
482 determine the default value of many flags. */
483 for (i = 1; i < argc; i++)
485 if (!strcmp (argv[i], "-O"))
490 else if (argv[i][0] == '-' && argv[i][1] == 'O')
492 /* Handle -Os, -O2, -O3, -O69, ... */
493 const char *p = &argv[i][2];
495 if ((p[0] == 's') && (p[1] == 0))
499 /* Optimizing for size forces optimize to be 2. */
504 const int optimize_val = read_integral_parameter (p, p - 2, -1);
505 if (optimize_val != -1)
507 optimize = optimize_val;
516 flag_merge_constants = 0;
522 flag_thread_jumps = 1;
524 flag_delayed_branch = 1;
526 #ifdef CAN_DEBUG_WITHOUT_FP
527 flag_omit_frame_pointer = 1;
529 flag_guess_branch_prob = 1;
530 flag_cprop_registers = 1;
531 flag_loop_optimize = 1;
532 flag_crossjumping = 1;
533 flag_if_conversion = 1;
534 flag_if_conversion2 = 1;
539 flag_optimize_sibling_calls = 1;
540 flag_cse_follow_jumps = 1;
541 flag_cse_skip_blocks = 1;
543 flag_expensive_optimizations = 1;
544 flag_strength_reduce = 1;
545 flag_rerun_cse_after_loop = 1;
546 flag_rerun_loop_opt = 1;
547 flag_caller_saves = 1;
550 #ifdef INSN_SCHEDULING
551 flag_schedule_insns = 1;
552 flag_schedule_insns_after_reload = 1;
555 flag_strict_aliasing = 1;
556 flag_delete_null_pointer_checks = 1;
557 flag_reorder_blocks = 1;
558 flag_reorder_functions = 1;
559 flag_unit_at_a_time = 1;
564 flag_inline_functions = 1;
565 flag_rename_registers = 1;
566 flag_unswitch_loops = 1;
570 if (optimize < 2 || optimize_size)
577 /* Don't reorder blocks when optimizing for size because extra
578 jump insns may be created; also barrier may create extra padding.
580 More correctly we should have a block reordering mode that tried
581 to minimize the combined size of all the jumps. This would more
582 or less automatically remove extra jumps, but would also try to
583 use more short jumps instead of long jumps. */
584 flag_reorder_blocks = 0;
587 /* Initialize whether `char' is signed. */
588 flag_signed_char = DEFAULT_SIGNED_CHAR;
589 #ifdef DEFAULT_SHORT_ENUMS
590 /* Initialize how much space enums occupy, by default. */
591 flag_short_enums = DEFAULT_SHORT_ENUMS;
594 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
597 set_target_switch ("");
599 /* Unwind tables are always present in an ABI-conformant IA-64
600 object file, so the default should be ON. */
601 #ifdef IA64_UNWIND_INFO
602 flag_unwind_tables = IA64_UNWIND_INFO;
605 #ifdef OPTIMIZATION_OPTIONS
606 /* Allow default optimizations to be specified on a per-machine basis. */
607 OPTIMIZATION_OPTIONS (optimize, optimize_size);
610 handle_options (argc, argv, lang_mask);
614 if (flag_pic && !flag_pie)
617 if (flag_no_inline == 2)
620 flag_really_no_inline = flag_no_inline;
622 /* Set flag_no_inline before the post_options () hook. The C front
623 ends use it to determine tree inlining defaults. FIXME: such
624 code should be lang-independent when all front ends use tree
625 inlining, in which case it, and this condition, should be moved
626 to the top of process_options() instead. */
629 /* Inlining does not work if not optimizing,
630 so force it not to be done. */
634 /* The c_decode_option function and decode_option hook set
635 this to `2' if -Wall is used, so we can avoid giving out
636 lots of errors for people who don't realize what -Wall does. */
637 if (warn_uninitialized == 1)
638 warning ("-Wuninitialized is not supported without -O");
641 if (flag_really_no_inline == 2)
642 flag_really_no_inline = flag_no_inline;
645 /* Handle target- and language-independent options. Return zero to
646 generate an "unknown option" message. */
648 common_handle_option (size_t scode, const char *arg,
649 int value ATTRIBUTE_UNUSED)
651 enum opt_code code = (enum opt_code) scode;
660 exit_after_options = true;
667 case OPT__target_help:
668 display_target_options ();
669 exit_after_options = true;
673 print_version (stderr, "");
674 exit_after_options = true;
678 g_switch_value = value;
684 /* Currently handled in a prescan. */
688 /* For backward compatibility, -W is the same as -Wextra. */
692 case OPT_Waggregate_return:
693 warn_aggregate_return = value;
696 case OPT_Wcast_align:
697 warn_cast_align = value;
700 case OPT_Wdeprecated_declarations:
701 warn_deprecated_decl = value;
704 case OPT_Wdisabled_optimization:
705 warn_disabled_optimization = value;
709 warnings_are_errors = value;
720 case OPT_Wlarger_than_:
721 larger_than_size = value;
722 warn_larger_than = value != -1;
725 case OPT_Wmissing_noreturn:
726 warn_missing_noreturn = value;
741 case OPT_Wstrict_aliasing:
742 warn_strict_aliasing = value;
749 case OPT_Wswitch_default:
750 warn_switch_default = value;
753 case OPT_Wswitch_enum:
754 warn_switch_enum = value;
757 case OPT_Wsystem_headers:
758 warn_system_headers = value;
761 case OPT_Wuninitialized:
762 warn_uninitialized = value;
765 case OPT_Wunreachable_code:
766 warn_notreached = value;
773 case OPT_Wunused_function:
774 warn_unused_function = value;
777 case OPT_Wunused_label:
778 warn_unused_label = value;
781 case OPT_Wunused_parameter:
782 warn_unused_parameter = value;
785 case OPT_Wunused_value:
786 warn_unused_value = value;
789 case OPT_Wunused_variable:
790 warn_unused_variable = value;
795 aux_info_file_name = arg;
796 flag_gen_aux_info = 1;
803 case OPT_auxbase_strip:
805 char *tmp = xstrdup (arg);
806 strip_off_ending (tmp, strlen (tmp));
813 decode_d_option (arg);
817 dump_base_name = arg;
821 flag_pic = value + value;
825 flag_pie = value + value;
828 case OPT_falign_functions:
829 align_functions = !value;
832 case OPT_falign_functions_:
833 align_functions = value;
836 case OPT_falign_jumps:
837 align_jumps = !value;
840 case OPT_falign_jumps_:
844 case OPT_falign_labels:
845 align_labels = !value;
848 case OPT_falign_labels_:
849 align_labels = value;
852 case OPT_falign_loops:
853 align_loops = !value;
856 case OPT_falign_loops_:
860 case OPT_fargument_alias:
861 flag_argument_noalias = !value;
864 case OPT_fargument_noalias:
865 flag_argument_noalias = value;
868 case OPT_fargument_noalias_global:
869 flag_argument_noalias = value + value;
872 case OPT_fasynchronous_unwind_tables:
873 flag_asynchronous_unwind_tables = value;
876 case OPT_fbounds_check:
877 flag_bounds_check = value;
880 case OPT_fbranch_count_reg:
881 flag_branch_on_count_reg = value;
884 case OPT_fbranch_probabilities:
885 flag_branch_probabilities = value;
888 case OPT_fbranch_target_load_optimize:
889 flag_branch_target_load_optimize = value;
892 case OPT_fbranch_target_load_optimize2:
893 flag_branch_target_load_optimize2 = value;
896 case OPT_fcall_used_:
897 fix_register (arg, 0, 1);
900 case OPT_fcall_saved_:
901 fix_register (arg, 0, 0);
904 case OPT_fcaller_saves:
905 flag_caller_saves = value;
909 flag_no_common = !value;
912 case OPT_fcprop_registers:
913 flag_cprop_registers = value;
916 case OPT_fcrossjumping:
917 flag_crossjumping = value;
920 case OPT_fcse_follow_jumps:
921 flag_cse_follow_jumps = value;
924 case OPT_fcse_skip_blocks:
925 flag_cse_skip_blocks = value;
928 case OPT_fdata_sections:
929 flag_data_sections = value;
933 flag_defer_pop = value;
936 case OPT_fdelayed_branch:
937 flag_delayed_branch = value;
940 case OPT_fdelete_null_pointer_checks:
941 flag_delete_null_pointer_checks = value;
944 case OPT_fdiagnostics_show_location_:
945 if (!strcmp (arg, "once"))
946 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
947 else if (!strcmp (arg, "every-line"))
948 diagnostic_prefixing_rule (global_dc)
949 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
954 case OPT_fdump_unnumbered:
955 flag_dump_unnumbered = value;
958 case OPT_feliminate_dwarf2_dups:
959 flag_eliminate_dwarf2_dups = value;
962 case OPT_feliminate_unused_debug_types:
963 flag_eliminate_unused_debug_types = value;
966 case OPT_feliminate_unused_debug_symbols:
967 flag_debug_only_used_symbols = value;
970 case OPT_fexceptions:
971 flag_exceptions = value;
974 case OPT_fexpensive_optimizations:
975 flag_expensive_optimizations = value;
979 set_fast_math_flags (value);
982 case OPT_ffinite_math_only:
983 flag_finite_math_only = value;
987 fix_register (arg, 1, 1);
990 case OPT_ffunction_cse:
991 flag_no_function_cse = !value;
994 case OPT_ffloat_store:
995 flag_float_store = value;
998 case OPT_fforce_addr:
999 flag_force_addr = value;
1002 case OPT_fforce_mem:
1003 flag_force_mem = value;
1006 case OPT_ffunction_sections:
1007 flag_function_sections = value;
1015 flag_gcse_lm = value;
1019 flag_gcse_sm = value;
1023 flag_gcse_las = value;
1026 case OPT_fgnu_linker:
1027 flag_gnu_linker = value;
1030 case OPT_fguess_branch_probability:
1031 flag_guess_branch_prob = value;
1035 flag_no_ident = !value;
1038 case OPT_fif_conversion:
1039 flag_if_conversion = value;
1042 case OPT_fif_conversion2:
1043 flag_if_conversion2 = value;
1046 case OPT_finhibit_size_directive:
1047 flag_inhibit_size_directive = value;
1051 flag_no_inline = !value;
1054 case OPT_finline_functions:
1055 flag_inline_functions = value;
1058 case OPT_finline_limit_:
1059 case OPT_finline_limit_eq:
1060 set_param_value ("max-inline-insns-single", value / 2);
1061 set_param_value ("max-inline-insns-auto", value / 2);
1062 set_param_value ("max-inline-insns-rtl", value);
1065 case OPT_finstrument_functions:
1066 flag_instrument_function_entry_exit = value;
1069 case OPT_fkeep_inline_functions:
1070 flag_keep_inline_functions =value;
1073 case OPT_fkeep_static_consts:
1074 flag_keep_static_consts = value;
1077 case OPT_fleading_underscore:
1078 flag_leading_underscore = value;
1081 case OPT_floop_optimize:
1082 flag_loop_optimize = value;
1085 case OPT_fmath_errno:
1086 flag_errno_math = value;
1089 case OPT_fmem_report:
1093 case OPT_fmerge_all_constants:
1094 flag_merge_constants = value + value;
1097 case OPT_fmerge_constants:
1098 flag_merge_constants = value;
1101 case OPT_fmessage_length_:
1102 pp_set_line_maximum_length (global_dc->printer, value);
1105 case OPT_fmove_all_movables:
1106 flag_move_all_movables = value;
1110 flag_new_regalloc = value;
1113 case OPT_fnon_call_exceptions:
1114 flag_non_call_exceptions = value;
1117 case OPT_fold_unroll_all_loops:
1118 flag_old_unroll_all_loops = value;
1121 case OPT_fold_unroll_loops:
1122 flag_old_unroll_loops = value;
1125 case OPT_fomit_frame_pointer:
1126 flag_omit_frame_pointer = value;
1129 case OPT_foptimize_register_move:
1130 flag_regmove = value;
1133 case OPT_foptimize_sibling_calls:
1134 flag_optimize_sibling_calls = value;
1137 case OPT_fpack_struct:
1138 flag_pack_struct = value;
1141 case OPT_fpeel_loops:
1142 flag_peel_loops = value;
1145 case OPT_fpcc_struct_return:
1146 flag_pcc_struct_return = value;
1150 flag_no_peephole = !value;
1153 case OPT_fpeephole2:
1154 flag_peephole2 = value;
1165 case OPT_fprefetch_loop_arrays:
1166 flag_prefetch_loop_arrays = value;
1170 profile_flag = value;
1173 case OPT_fprofile_arcs:
1174 profile_arc_flag = value;
1177 case OPT_fprofile_values:
1178 flag_profile_values = value;
1182 flag_value_profile_transformations = value;
1185 case OPT_frandom_seed:
1186 /* The real switch is -fno-random-seed. */
1189 flag_random_seed = NULL;
1192 case OPT_frandom_seed_:
1193 flag_random_seed = arg;
1196 case OPT_freduce_all_givs:
1197 flag_reduce_all_givs = value;
1200 case OPT_freg_struct_return:
1201 flag_pcc_struct_return = !value;
1205 flag_regmove = value;
1208 case OPT_frename_registers:
1209 flag_rename_registers = value;
1212 case OPT_freorder_blocks:
1213 flag_reorder_blocks = value;
1216 case OPT_freorder_functions:
1217 flag_reorder_functions = value;
1220 case OPT_frerun_cse_after_loop:
1221 flag_rerun_cse_after_loop = value;
1224 case OPT_frerun_loop_opt:
1225 flag_rerun_loop_opt = value;
1228 case OPT_frounding_math:
1229 flag_rounding_math = value;
1232 case OPT_fsched_interblock:
1233 flag_schedule_interblock = value;
1236 case OPT_fsched_spec:
1237 flag_schedule_speculative = value;
1240 case OPT_fsched_spec_load:
1241 flag_schedule_speculative_load = value;
1244 case OPT_fsched_spec_load_dangerous:
1245 flag_schedule_speculative_load_dangerous = value;
1248 case OPT_fsched_verbose_:
1249 #ifdef INSN_SCHEDULING
1250 fix_sched_param ("verbose", arg);
1256 case OPT_fsched2_use_superblocks:
1257 flag_sched2_use_superblocks = value;
1260 case OPT_fsched2_use_traces:
1261 flag_sched2_use_traces = value;
1264 case OPT_fschedule_insns:
1265 flag_schedule_insns = value;
1268 case OPT_fschedule_insns2:
1269 flag_schedule_insns_after_reload = value;
1272 case OPT_fsched_stalled_insns:
1273 flag_sched_stalled_insns = value;
1276 case OPT_fsched_stalled_insns_:
1277 flag_sched_stalled_insns = value;
1278 if (flag_sched_stalled_insns == 0)
1279 flag_sched_stalled_insns = -1;
1282 case OPT_fsched_stalled_insns_dep:
1283 flag_sched_stalled_insns_dep = 1;
1286 case OPT_fsched_stalled_insns_dep_:
1287 flag_sched_stalled_insns_dep = value;
1290 case OPT_fshared_data:
1291 flag_shared_data = value;
1294 case OPT_fsignaling_nans:
1295 flag_signaling_nans = value;
1298 case OPT_fsingle_precision_constant:
1299 flag_single_precision_constant = value;
1307 flag_ssa_ccp = value;
1311 flag_ssa_dce = value;
1314 case OPT_fstack_check:
1315 flag_stack_check = value;
1318 case OPT_fstack_limit:
1319 /* The real switch is -fno-stack-limit. */
1322 stack_limit_rtx = NULL_RTX;
1325 case OPT_fstack_limit_register_:
1327 int reg = decode_reg_name (arg);
1329 error ("unrecognized register name \"%s\"", arg);
1331 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1335 case OPT_fstack_limit_symbol_:
1336 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1339 case OPT_fstrength_reduce:
1340 flag_strength_reduce = value;
1343 case OPT_fstrict_aliasing:
1344 flag_strict_aliasing = value;
1347 case OPT_fsyntax_only:
1348 flag_syntax_only = value;
1351 case OPT_ftest_coverage:
1352 flag_test_coverage = value;
1355 case OPT_fthread_jumps:
1356 flag_thread_jumps = value;
1359 case OPT_ftime_report:
1360 time_report = value;
1363 case OPT_ftls_model_:
1364 if (!strcmp (arg, "global-dynamic"))
1365 flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1366 else if (!strcmp (arg, "local-dynamic"))
1367 flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1368 else if (!strcmp (arg, "initial-exec"))
1369 flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1370 else if (!strcmp (arg, "local-exec"))
1371 flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1373 warning ("unknown tls-model \"%s\"", arg);
1377 flag_tracer = value;
1380 case OPT_ftrapping_math:
1381 flag_trapping_math = value;
1388 case OPT_funit_at_a_time:
1389 flag_unit_at_a_time = value;
1392 case OPT_funroll_all_loops:
1393 flag_unroll_all_loops = value;
1396 case OPT_funroll_loops:
1397 flag_unroll_loops = value;
1400 case OPT_funsafe_math_optimizations:
1401 flag_unsafe_math_optimizations = value;
1404 case OPT_funswitch_loops:
1405 flag_unswitch_loops = value;
1408 case OPT_funwind_tables:
1409 flag_unwind_tables = value;
1412 case OPT_fverbose_asm:
1413 flag_verbose_asm = value;
1424 case OPT_fwritable_strings:
1425 flag_writable_strings = value;
1428 case OPT_fzero_initialized_in_bss:
1429 flag_zero_initialized_in_bss = value;
1433 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
1437 set_debug_level (SDB_DEBUG, false, arg);
1443 error ("use -gdwarf -gN for DWARF v1 level N, "
1444 "and -gdwarf-2 for DWARF v2" );
1450 set_debug_level (DWARF_DEBUG, code == OPT_gdwarf_, arg);
1454 set_debug_level (DWARF2_DEBUG, false, arg);
1458 set_debug_level (NO_DEBUG, 2, arg);
1463 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
1467 set_debug_level (VMS_DEBUG, false, arg);
1472 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
1476 set_target_switch (arg);
1480 asm_file_name = arg;
1491 case OPT_pedantic_errors:
1492 flag_pedantic_errors = pedantic = 1;
1504 inhibit_warnings = true;
1511 /* Handle --param NAME=VALUE. */
1513 handle_param (const char *carg)
1518 arg = xstrdup (carg);
1519 equal = strchr (arg, '=');
1521 error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1524 value = integral_argument (equal + 1);
1526 error ("invalid --param value `%s'", equal + 1);
1530 set_param_value (arg, value);
1537 /* Handle -W and -Wextra. */
1539 set_Wextra (int setting)
1541 extra_warnings = setting;
1542 warn_unused_value = setting;
1543 warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1545 /* We save the value of warn_uninitialized, since if they put
1546 -Wuninitialized on the command line, we need to generate a
1547 warning about not using it without also specifying -O. */
1549 warn_uninitialized = 0;
1550 else if (warn_uninitialized != 1)
1551 warn_uninitialized = 2;
1554 /* Initialize unused warning flags. */
1556 set_Wunused (int setting)
1558 warn_unused_function = setting;
1559 warn_unused_label = setting;
1560 /* Unused function parameter warnings are reported when either
1561 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1562 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1563 otherwise set maybe_warn_extra_parameter, which will be picked up
1565 maybe_warn_unused_parameter = setting;
1566 warn_unused_parameter = (setting && extra_warnings);
1567 warn_unused_variable = setting;
1568 warn_unused_value = setting;
1571 /* The following routines are useful in setting all the flags that
1572 -ffast-math and -fno-fast-math imply. */
1574 set_fast_math_flags (int set)
1576 flag_trapping_math = !set;
1577 flag_unsafe_math_optimizations = set;
1578 flag_finite_math_only = set;
1579 flag_errno_math = !set;
1582 flag_signaling_nans = 0;
1583 flag_rounding_math = 0;
1587 /* Return true iff flags are set as if -ffast-math. */
1589 fast_math_flags_set_p (void)
1591 return (!flag_trapping_math
1592 && flag_unsafe_math_optimizations
1593 && flag_finite_math_only
1594 && !flag_errno_math);
1597 /* Handle a debug output -g switch. EXTENDED is true or false to support
1598 extended output (2 is special and means "-ggdb" was given). */
1600 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1602 static bool type_explicit;
1604 use_gnu_debug_info_extensions = extended;
1606 if (type == NO_DEBUG)
1608 if (write_symbols == NO_DEBUG)
1610 write_symbols = PREFERRED_DEBUGGING_TYPE;
1614 #ifdef DWARF2_DEBUGGING_INFO
1615 write_symbols = DWARF2_DEBUG;
1616 #elif defined DBX_DEBUGGING_INFO
1617 write_symbols = DBX_DEBUG;
1621 if (write_symbols == NO_DEBUG)
1622 warning ("target system does not support debug output");
1627 /* Does it conflict with an already selected type? */
1628 if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1629 error ("debug format \"%s\" conflicts with prior selection",
1630 debug_type_names[type]);
1631 write_symbols = type;
1632 type_explicit = true;
1635 /* A debug flag without a level defaults to level 2. */
1638 if (!debug_info_level)
1639 debug_info_level = 2;
1643 debug_info_level = integral_argument (arg);
1644 if (debug_info_level == (unsigned int) -1)
1645 error ("unrecognised debug output level \"%s\"", arg);
1646 else if (debug_info_level > 3)
1647 error ("debug output level %s is too high", arg);
1651 /* Output --help text. */
1658 GET_ENVIRONMENT (p, "COLUMNS");
1661 int value = atoi (p);
1666 puts (_("The following options are language-independent:\n"));
1668 print_filtered_help (CL_COMMON);
1669 print_param_help ();
1671 for (i = 0; lang_names[i]; i++)
1673 printf (_("The %s front end recognizes the following options:\n\n"),
1675 print_filtered_help (1U << i);
1678 display_target_options ();
1681 /* Print the help for --param. */
1683 print_param_help (void)
1687 puts (_("The --param option recognizes the following as parameters:\n"));
1689 for (i = 0; i < LAST_PARAM; i++)
1691 const char *help = compiler_params[i].help;
1692 const char *param = compiler_params[i].option;
1694 if (help == NULL || *help == '\0')
1695 help = undocumented_msg;
1697 /* Get the translation. */
1700 wrap_help (help, param, strlen (param));
1706 /* Print help for a specific front-end, etc. */
1708 print_filtered_help (unsigned int flag)
1710 unsigned int i, len, filter, indent = 0;
1711 bool duplicates = false;
1712 const char *help, *opt, *tab;
1713 static char *printed;
1715 if (flag == CL_COMMON)
1719 printed = xmalloc (cl_options_count);
1720 memset (printed, 0, cl_options_count);
1724 /* Don't print COMMON options twice. */
1725 filter = flag | CL_COMMON;
1727 for (i = 0; i < cl_options_count; i++)
1729 if ((cl_options[i].flags & filter) != flag)
1732 /* Skip help for internal switches. */
1733 if (cl_options[i].flags & CL_UNDOCUMENTED)
1736 /* Skip switches that have already been printed, mark them to be
1741 indent = print_switch (cl_options[i].opt_text, indent);
1752 for (i = 0; i < cl_options_count; i++)
1754 if ((cl_options[i].flags & filter) != flag)
1757 /* Skip help for internal switches. */
1758 if (cl_options[i].flags & CL_UNDOCUMENTED)
1761 /* Skip switches that have already been printed. */
1767 help = cl_options[i].help;
1769 help = undocumented_msg;
1771 /* Get the translation. */
1774 tab = strchr (help, '\t');
1783 opt = cl_options[i].opt_text;
1787 wrap_help (help, opt, len);
1793 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1794 word-wrapped HELP in a second column. */
1796 print_switch (const char *text, unsigned int indent)
1798 unsigned int len = strlen (text) + 1; /* trailing comma */
1803 if (indent + len > columns)
1814 fputs (text, stdout);
1816 return indent + len + 1;
1819 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1820 word-wrapped HELP in a second column. */
1822 wrap_help (const char *help, const char *item, unsigned int item_width)
1824 unsigned int col_width = 27;
1825 unsigned int remaining, room, len;
1827 remaining = strlen (help);
1831 room = columns - 3 - MAX (col_width, item_width);
1840 for (i = 0; help[i]; i++)
1842 if (i >= room && len != remaining)
1846 else if ((help[i] == '-' || help[i] == '/')
1847 && help[i + 1] != ' '
1848 && ISALPHA (help[i - 1]))
1853 printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
1855 while (help[len] == ' ')