1 /* Command line option handling.
2 Copyright (C) 2002, 2003, 2004, 2005 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, 51 Franklin Street, Fifth Floor, 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 #include "tree-pass.h"
43 /* Value of the -G xx switch, and whether it was passed or not. */
44 unsigned HOST_WIDE_INT g_switch_value;
47 /* True if we should exit after parsing options. */
48 bool exit_after_options;
50 /* Print various extra warnings. -W/-Wextra. */
53 /* True to warn about any objects definitions whose size is larger
54 than N bytes. Also want about function definitions whose returned
55 values are larger than N bytes, where N is `larger_than_size'. */
56 bool warn_larger_than;
57 HOST_WIDE_INT larger_than_size;
59 /* Nonzero means warn about constructs which might not be
60 strict-aliasing safe. */
61 int warn_strict_aliasing;
63 /* Hack for cooperation between set_Wunused and set_Wextra. */
64 static bool maybe_warn_unused_parameter;
66 /* Type(s) of debugging information we are producing (if any). See
67 flags.h for the definitions of the different possible types of
68 debugging information. */
69 enum debug_info_type write_symbols = NO_DEBUG;
71 /* Level of debugging information we are producing. See flags.h for
72 the definitions of the different possible levels. */
73 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
75 /* Nonzero means use GNU-only extensions in the generated symbolic
76 debugging information. Currently, this only has an effect when
77 write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
78 bool use_gnu_debug_info_extensions;
80 /* The default visibility for all symbols (unless overridden) */
81 enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;
83 /* Global visibility options. */
84 struct visibility_flags visibility_options;
86 /* Columns of --help display. */
87 static unsigned int columns = 80;
89 /* What to print when a switch has no documentation. */
90 static const char undocumented_msg[] = N_("This switch lacks documentation");
92 /* Used for bookkeeping on whether user set these flags so
93 -fprofile-use/-fprofile-generate does not use them. */
94 static bool profile_arc_flag_set, flag_profile_values_set;
95 static bool flag_unroll_loops_set, flag_tracer_set;
96 static bool flag_value_profile_transformations_set;
97 bool flag_speculative_prefetching_set;
98 static bool flag_peel_loops_set, flag_branch_probabilities_set;
100 /* Input file names. */
101 const char **in_fnames;
102 unsigned num_in_fnames;
104 static size_t find_opt (const char *, int);
105 static int common_handle_option (size_t scode, const char *arg, int value);
106 static void handle_param (const char *);
107 static void set_Wextra (int);
108 static unsigned int handle_option (const char **argv, unsigned int lang_mask);
109 static char *write_langs (unsigned int lang_mask);
110 static void complain_wrong_lang (const char *, const struct cl_option *,
111 unsigned int lang_mask);
112 static void handle_options (unsigned int, const char **, unsigned int);
113 static void wrap_help (const char *help, const char *item, unsigned int);
114 static void print_target_help (void);
115 static void print_help (void);
116 static void print_param_help (void);
117 static void print_filtered_help (unsigned int);
118 static unsigned int print_switch (const char *text, unsigned int indent);
119 static void set_debug_level (enum debug_info_type type, int extended,
122 /* Perform a binary search to find which option the command-line INPUT
123 matches. Returns its index in the option array, and N_OPTS
124 (cl_options_count) on failure.
126 This routine is quite subtle. A normal binary search is not good
127 enough because some options can be suffixed with an argument, and
128 multiple sub-matches can occur, e.g. input of "-pedantic" matching
129 the initial substring of "-pedantic-errors".
131 A more complicated example is -gstabs. It should match "-g" with
132 an argument of "stabs". Suppose, however, that the number and list
133 of switches are such that the binary search tests "-gen-decls"
134 before having tested "-g". This doesn't match, and as "-gen-decls"
135 is less than "-gstabs", it will become the lower bound of the
136 binary search range, and "-g" will never be seen. To resolve this
137 issue, opts.sh makes "-gen-decls" point, via the back_chain member,
138 to "-g" so that failed searches that end between "-gen-decls" and
139 the lexicographically subsequent switch know to go back and see if
140 "-g" causes a match (which it does in this example).
142 This search is done in such a way that the longest match for the
143 front end in question wins. If there is no match for the current
144 front end, the longest match for a different front end is returned
145 (or N_OPTS if none) and the caller emits an error message. */
147 find_opt (const char *input, int lang_mask)
149 size_t mn, mx, md, opt_len;
150 size_t match_wrong_lang;
154 mx = cl_options_count;
156 /* Find mn such this lexicographical inequality holds:
157 cl_options[mn] <= input < cl_options[mn + 1]. */
161 opt_len = cl_options[md].opt_len;
162 comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
170 /* This is the switch that is the best match but for a different
171 front end, or cl_options_count if there is no match at all. */
172 match_wrong_lang = cl_options_count;
174 /* Backtrace the chain of possible matches, returning the longest
175 one, if any, that fits best. With current GCC switches, this
176 loop executes at most twice. */
179 const struct cl_option *opt = &cl_options[mn];
181 /* Is the input either an exact match or a prefix that takes a
183 if (!strncmp (input, opt->opt_text + 1, opt->opt_len)
184 && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
186 /* If language is OK, return it. */
187 if (opt->flags & lang_mask)
190 /* If we haven't remembered a prior match, remember this
191 one. Any prior match is necessarily better. */
192 if (match_wrong_lang == cl_options_count)
193 match_wrong_lang = mn;
196 /* Try the next possibility. This is cl_options_count if there
198 mn = opt->back_chain;
200 while (mn != cl_options_count);
202 /* Return the best wrong match, or cl_options_count if none. */
203 return match_wrong_lang;
206 /* If ARG is a non-negative integer made up solely of digits, return its
207 value, otherwise return -1. */
209 integral_argument (const char *arg)
213 while (*p && ISDIGIT (*p))
222 /* Return a malloced slash-separated list of languages in MASK. */
224 write_langs (unsigned int mask)
226 unsigned int n = 0, len = 0;
227 const char *lang_name;
230 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
231 if (mask & (1U << n))
232 len += strlen (lang_name) + 1;
234 result = xmalloc (len);
236 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
237 if (mask & (1U << n))
241 strcpy (result + len, lang_name);
242 len += strlen (lang_name);
250 /* Complain that switch OPT_INDEX does not apply to this front end. */
252 complain_wrong_lang (const char *text, const struct cl_option *option,
253 unsigned int lang_mask)
255 char *ok_langs, *bad_lang;
257 ok_langs = write_langs (option->flags);
258 bad_lang = write_langs (lang_mask);
260 /* Eventually this should become a hard error IMO. */
261 warning (0, "command line option \"%s\" is valid for %s but not for %s",
262 text, ok_langs, bad_lang);
268 /* Handle the switch beginning at ARGV for the language indicated by
269 LANG_MASK. Returns the number of switches consumed. */
271 handle_option (const char **argv, unsigned int lang_mask)
274 const char *opt, *arg = 0;
277 unsigned int result = 0;
278 const struct cl_option *option;
282 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
283 if (opt_index == cl_options_count
284 && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')
285 && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
287 /* Drop the "no-" from negative switches. */
288 size_t len = strlen (opt) - 3;
290 dup = xmalloc (len + 1);
293 memcpy (dup + 2, opt + 5, len - 2 + 1);
296 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
299 if (opt_index == cl_options_count)
302 option = &cl_options[opt_index];
304 /* Reject negative form of switches that don't take negatives as
306 if (!value && (option->flags & CL_REJECT_NEGATIVE))
309 /* We've recognized this switch. */
312 /* Check to see if the option is disabled for this configuration. */
313 if (option->flags & CL_DISABLED)
315 error ("command line option %qs"
316 " is not supported by this configuration", opt);
320 /* Sort out any argument the switch takes. */
321 if (option->flags & CL_JOINED)
323 /* Have arg point to the original switch. This is because
324 some code, such as disable_builtin_function, expects its
325 argument to be persistent until the program exits. */
326 arg = argv[0] + cl_options[opt_index].opt_len + 1;
328 arg += strlen ("no-");
330 if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
332 if (option->flags & CL_SEPARATE)
338 /* Missing argument. */
342 else if (option->flags & CL_SEPARATE)
348 /* Now we've swallowed any potential argument, complain if this
349 is a switch for a different front end. */
350 if (!(option->flags & (lang_mask | CL_COMMON | CL_TARGET)))
352 complain_wrong_lang (argv[0], option, lang_mask);
356 if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
358 if (!lang_hooks.missing_argument (opt, opt_index))
359 error ("missing argument to \"%s\"", opt);
363 /* If the switch takes an integer, convert it. */
364 if (arg && (option->flags & CL_UINTEGER))
366 value = integral_argument (arg);
369 error ("argument to \"%s\" should be a non-negative integer",
375 if (option->flag_var)
376 switch (option->var_type)
379 *(int *) option->flag_var = value;
383 *(int *) option->flag_var = (value
385 : !option->var_value);
390 if ((value != 0) == (option->var_type == CLVC_BIT_SET))
391 *(int *) option->flag_var |= option->var_value;
393 *(int *) option->flag_var &= ~option->var_value;
394 if (option->flag_var == &target_flags)
395 target_flags_explicit |= option->var_value;
399 *(const char **) option->flag_var = arg;
403 if (option->flags & lang_mask)
404 if (lang_hooks.handle_option (opt_index, arg, value) == 0)
407 if (result && (option->flags & CL_COMMON))
408 if (common_handle_option (opt_index, arg, value) == 0)
411 if (result && (option->flags & CL_TARGET))
412 if (!targetm.handle_option (opt_index, arg, value))
421 /* Handle FILENAME from the command line. */
423 add_input_filename (const char *filename)
426 in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));
427 in_fnames[num_in_fnames - 1] = filename;
430 /* Decode and handle the vector of command line options. LANG_MASK
431 contains has a single bit set representing the current
434 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
438 for (i = 1; i < argc; i += n)
440 const char *opt = argv[i];
442 /* Interpret "-" or a non-switch as a file name. */
443 if (opt[0] != '-' || opt[1] == '\0')
445 if (main_input_filename == NULL)
446 main_input_filename = opt;
447 add_input_filename (opt);
452 n = handle_option (argv + i, lang_mask);
457 error ("unrecognized command line option \"%s\"", opt);
462 /* Parse command line options and set default flag values. Do minimal
463 options processing. */
465 decode_options (unsigned int argc, const char **argv)
467 unsigned int i, lang_mask;
469 /* Perform language-specific options initialization. */
470 lang_mask = lang_hooks.init_options (argc, argv);
472 lang_hooks.initialize_diagnostics (global_dc);
474 /* Scan to see what optimization level has been specified. That will
475 determine the default value of many flags. */
476 for (i = 1; i < argc; i++)
478 if (!strcmp (argv[i], "-O"))
483 else if (argv[i][0] == '-' && argv[i][1] == 'O')
485 /* Handle -Os, -O2, -O3, -O69, ... */
486 const char *p = &argv[i][2];
488 if ((p[0] == 's') && (p[1] == 0))
492 /* Optimizing for size forces optimize to be 2. */
497 const int optimize_val = read_integral_parameter (p, p - 2, -1);
498 if (optimize_val != -1)
500 optimize = optimize_val;
509 flag_merge_constants = 0;
516 flag_delayed_branch = 1;
518 #ifdef CAN_DEBUG_WITHOUT_FP
519 flag_omit_frame_pointer = 1;
521 flag_guess_branch_prob = 1;
522 flag_cprop_registers = 1;
523 flag_loop_optimize = 1;
524 flag_if_conversion = 1;
525 flag_if_conversion2 = 1;
531 flag_tree_live_range_split = 1;
533 flag_tree_copyrename = 1;
535 flag_tree_copy_prop = 1;
537 flag_tree_salias = 1;
538 flag_unit_at_a_time = 1;
542 /* Loop header copying usually increases size of the code. This used
543 not to be true, since quite often it is possible to verify that
544 the condition is satisfied in the first iteration and therefore
545 to eliminate it. Jump threading handles these cases now. */
552 flag_thread_jumps = 1;
553 flag_crossjumping = 1;
554 flag_optimize_sibling_calls = 1;
555 flag_cse_follow_jumps = 1;
556 flag_cse_skip_blocks = 1;
558 flag_expensive_optimizations = 1;
559 flag_strength_reduce = 1;
560 flag_rerun_cse_after_loop = 1;
561 flag_rerun_loop_opt = 1;
562 flag_caller_saves = 1;
564 #ifdef INSN_SCHEDULING
565 flag_schedule_insns = 1;
566 flag_schedule_insns_after_reload = 1;
569 flag_strict_aliasing = 1;
570 flag_delete_null_pointer_checks = 1;
571 flag_reorder_blocks = 1;
572 flag_reorder_functions = 1;
573 flag_tree_store_ccp = 1;
574 flag_tree_store_copy_prop = 1;
579 /* PRE tends to generate bigger code. */
586 flag_inline_functions = 1;
587 flag_unswitch_loops = 1;
588 flag_gcse_after_reload = 1;
591 if (optimize < 2 || optimize_size)
598 /* Don't reorder blocks when optimizing for size because extra
599 jump insns may be created; also barrier may create extra padding.
601 More correctly we should have a block reordering mode that tried
602 to minimize the combined size of all the jumps. This would more
603 or less automatically remove extra jumps, but would also try to
604 use more short jumps instead of long jumps. */
605 flag_reorder_blocks = 0;
606 flag_reorder_blocks_and_partition = 0;
611 /* Inlining of very small functions usually reduces total size. */
612 set_param_value ("max-inline-insns-single", 5);
613 set_param_value ("max-inline-insns-auto", 5);
614 flag_inline_functions = 1;
616 /* We want to crossjump as much as possible. */
617 set_param_value ("min-crossjump-insns", 1);
620 /* Initialize whether `char' is signed. */
621 flag_signed_char = DEFAULT_SIGNED_CHAR;
622 /* Set this to a special "uninitialized" value. The actual default is set
623 after target options have been processed. */
624 flag_short_enums = 2;
626 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
628 target_flags = targetm.default_target_flags;
630 /* Some tagets have ABI-specified unwind tables. */
631 flag_unwind_tables = targetm.unwind_tables_default;
633 #ifdef OPTIMIZATION_OPTIONS
634 /* Allow default optimizations to be specified on a per-machine basis. */
635 OPTIMIZATION_OPTIONS (optimize, optimize_size);
638 handle_options (argc, argv, lang_mask);
642 if (flag_pic && !flag_pie)
645 if (flag_no_inline == 2)
648 flag_really_no_inline = flag_no_inline;
650 /* Set flag_no_inline before the post_options () hook. The C front
651 ends use it to determine tree inlining defaults. FIXME: such
652 code should be lang-independent when all front ends use tree
653 inlining, in which case it, and this condition, should be moved
654 to the top of process_options() instead. */
657 /* Inlining does not work if not optimizing,
658 so force it not to be done. */
662 /* The c_decode_option function and decode_option hook set
663 this to `2' if -Wall is used, so we can avoid giving out
664 lots of errors for people who don't realize what -Wall does. */
665 if (warn_uninitialized == 1)
666 warning (OPT_Wuninitialized,
667 "-Wuninitialized is not supported without -O");
670 if (flag_really_no_inline == 2)
671 flag_really_no_inline = flag_no_inline;
673 /* The optimization to partition hot and cold basic blocks into separate
674 sections of the .o and executable files does not work (currently)
675 with exception handling. If flag_exceptions is turned on we need to
676 turn off the partitioning optimization. */
678 if (flag_exceptions && flag_reorder_blocks_and_partition)
681 ("-freorder-blocks-and-partition does not work with exceptions");
682 flag_reorder_blocks_and_partition = 0;
683 flag_reorder_blocks = 1;
686 if (flag_reorder_blocks_and_partition
687 && !targetm.have_named_sections)
690 ("-freorder-blocks-and-partition does not work on this architecture");
691 flag_reorder_blocks_and_partition = 0;
692 flag_reorder_blocks = 1;
696 /* Handle target- and language-independent options. Return zero to
697 generate an "unknown option" message. Only options that need
698 extra handling need to be listed here; if you simply want
699 VALUE assigned to a variable, it happens automatically. */
702 common_handle_option (size_t scode, const char *arg, int value)
704 enum opt_code code = (enum opt_code) scode;
710 exit_after_options = true;
717 case OPT__target_help:
718 print_target_help ();
719 exit_after_options = true;
723 print_version (stderr, "");
724 exit_after_options = true;
728 g_switch_value = value;
734 /* Currently handled in a prescan. */
738 /* For backward compatibility, -W is the same as -Wextra. */
746 case OPT_Wlarger_than_:
747 larger_than_size = value;
748 warn_larger_than = value != -1;
751 case OPT_Wstrict_aliasing:
752 case OPT_Wstrict_aliasing_:
753 warn_strict_aliasing = value;
762 aux_info_file_name = arg;
763 flag_gen_aux_info = 1;
770 case OPT_auxbase_strip:
772 char *tmp = xstrdup (arg);
773 strip_off_ending (tmp, strlen (tmp));
780 decode_d_option (arg);
784 dump_base_name = arg;
787 case OPT_falign_functions_:
788 align_functions = value;
791 case OPT_falign_jumps_:
795 case OPT_falign_labels_:
796 align_labels = value;
799 case OPT_falign_loops_:
803 case OPT_fbranch_probabilities:
804 flag_branch_probabilities_set = true;
807 case OPT_fcall_used_:
808 fix_register (arg, 0, 1);
811 case OPT_fcall_saved_:
812 fix_register (arg, 0, 0);
815 case OPT_fdiagnostics_show_location_:
816 if (!strcmp (arg, "once"))
817 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
818 else if (!strcmp (arg, "every-line"))
819 diagnostic_prefixing_rule (global_dc)
820 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
825 case OPT_fdiagnostics_show_option:
826 global_dc->show_option_requested = true;
830 if (!dump_switch_p (arg))
835 set_fast_math_flags (value);
839 fix_register (arg, 1, 1);
842 case OPT_finline_limit_:
843 case OPT_finline_limit_eq:
844 set_param_value ("max-inline-insns-single", value / 2);
845 set_param_value ("max-inline-insns-auto", value / 2);
848 case OPT_fmessage_length_:
849 pp_set_line_maximum_length (global_dc->printer, value);
852 case OPT_fpack_struct_:
853 if (value <= 0 || (value & (value - 1)) || value > 16)
854 error("structure alignment must be a small power of two, not %d", value);
857 initial_max_fld_align = value;
858 maximum_field_alignment = value * BITS_PER_UNIT;
862 case OPT_fpeel_loops:
863 flag_peel_loops_set = true;
866 case OPT_fprofile_arcs:
867 profile_arc_flag_set = true;
870 case OPT_fprofile_use:
871 if (!flag_branch_probabilities_set)
872 flag_branch_probabilities = value;
873 if (!flag_profile_values_set)
874 flag_profile_values = value;
875 if (!flag_unroll_loops_set)
876 flag_unroll_loops = value;
877 if (!flag_peel_loops_set)
878 flag_peel_loops = value;
879 if (!flag_tracer_set)
881 if (!flag_value_profile_transformations_set)
882 flag_value_profile_transformations = value;
884 if (0 && !flag_speculative_prefetching_set)
885 flag_speculative_prefetching = value;
889 case OPT_fprofile_generate:
890 if (!profile_arc_flag_set)
891 profile_arc_flag = value;
892 if (!flag_profile_values_set)
893 flag_profile_values = value;
894 if (!flag_value_profile_transformations_set)
895 flag_value_profile_transformations = value;
896 if (!flag_unroll_loops_set)
897 flag_unroll_loops = value;
899 if (0 && !flag_speculative_prefetching_set)
900 flag_speculative_prefetching = value;
904 case OPT_fprofile_values:
905 flag_profile_values_set = true;
908 case OPT_fvisibility_:
910 if (!strcmp(arg, "default"))
911 default_visibility = VISIBILITY_DEFAULT;
912 else if (!strcmp(arg, "internal"))
913 default_visibility = VISIBILITY_INTERNAL;
914 else if (!strcmp(arg, "hidden"))
915 default_visibility = VISIBILITY_HIDDEN;
916 else if (!strcmp(arg, "protected"))
917 default_visibility = VISIBILITY_PROTECTED;
919 error ("unrecognized visibility value \"%s\"", arg);
924 flag_value_profile_transformations_set = true;
927 case OPT_fspeculative_prefetching:
928 flag_speculative_prefetching_set = true;
931 case OPT_frandom_seed:
932 /* The real switch is -fno-random-seed. */
935 flag_random_seed = NULL;
938 case OPT_frandom_seed_:
939 flag_random_seed = arg;
942 case OPT_fsched_verbose_:
943 #ifdef INSN_SCHEDULING
944 fix_sched_param ("verbose", arg);
950 case OPT_fsched_stalled_insns_:
951 flag_sched_stalled_insns = value;
952 if (flag_sched_stalled_insns == 0)
953 flag_sched_stalled_insns = -1;
956 case OPT_fsched_stalled_insns_dep_:
957 flag_sched_stalled_insns_dep = value;
960 case OPT_fstack_limit:
961 /* The real switch is -fno-stack-limit. */
964 stack_limit_rtx = NULL_RTX;
967 case OPT_fstack_limit_register_:
969 int reg = decode_reg_name (arg);
971 error ("unrecognized register name \"%s\"", arg);
973 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
977 case OPT_fstack_limit_symbol_:
978 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
981 case OPT_ftree_vectorizer_verbose_:
982 vect_set_verbosity_level (arg);
985 case OPT_ftls_model_:
986 if (!strcmp (arg, "global-dynamic"))
987 flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
988 else if (!strcmp (arg, "local-dynamic"))
989 flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
990 else if (!strcmp (arg, "initial-exec"))
991 flag_tls_default = TLS_MODEL_INITIAL_EXEC;
992 else if (!strcmp (arg, "local-exec"))
993 flag_tls_default = TLS_MODEL_LOCAL_EXEC;
995 warning (0, "unknown tls-model \"%s\"", arg);
999 flag_tracer_set = true;
1002 case OPT_funroll_loops:
1003 flag_unroll_loops_set = true;
1007 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
1011 set_debug_level (SDB_DEBUG, false, arg);
1015 set_debug_level (DWARF2_DEBUG, false, arg);
1019 set_debug_level (NO_DEBUG, 2, arg);
1024 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
1028 set_debug_level (VMS_DEBUG, false, arg);
1033 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
1037 asm_file_name = arg;
1040 case OPT_pedantic_errors:
1041 flag_pedantic_errors = pedantic = 1;
1044 case OPT_fforce_mem:
1045 warning (0, "-f[no-]force-mem is nop and option will be removed in 4.2");
1049 /* If the flag was handled in a standard way, assume the lack of
1050 processing here is intentional. */
1051 gcc_assert (cl_options[scode].flag_var);
1058 /* Handle --param NAME=VALUE. */
1060 handle_param (const char *carg)
1065 arg = xstrdup (carg);
1066 equal = strchr (arg, '=');
1068 error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1071 value = integral_argument (equal + 1);
1073 error ("invalid --param value %qs", equal + 1);
1077 set_param_value (arg, value);
1084 /* Handle -W and -Wextra. */
1086 set_Wextra (int setting)
1088 extra_warnings = setting;
1089 warn_unused_value = setting;
1090 warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1092 /* We save the value of warn_uninitialized, since if they put
1093 -Wuninitialized on the command line, we need to generate a
1094 warning about not using it without also specifying -O. */
1096 warn_uninitialized = 0;
1097 else if (warn_uninitialized != 1)
1098 warn_uninitialized = 2;
1101 /* Initialize unused warning flags. */
1103 set_Wunused (int setting)
1105 warn_unused_function = setting;
1106 warn_unused_label = setting;
1107 /* Unused function parameter warnings are reported when either
1108 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1109 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1110 otherwise set maybe_warn_extra_parameter, which will be picked up
1112 maybe_warn_unused_parameter = setting;
1113 warn_unused_parameter = (setting && extra_warnings);
1114 warn_unused_variable = setting;
1115 warn_unused_value = setting;
1118 /* The following routines are useful in setting all the flags that
1119 -ffast-math and -fno-fast-math imply. */
1121 set_fast_math_flags (int set)
1123 flag_trapping_math = !set;
1124 flag_unsafe_math_optimizations = set;
1125 flag_finite_math_only = set;
1126 flag_errno_math = !set;
1129 flag_signaling_nans = 0;
1130 flag_rounding_math = 0;
1131 flag_cx_limited_range = 1;
1135 /* Return true iff flags are set as if -ffast-math. */
1137 fast_math_flags_set_p (void)
1139 return (!flag_trapping_math
1140 && flag_unsafe_math_optimizations
1141 && flag_finite_math_only
1142 && !flag_errno_math);
1145 /* Handle a debug output -g switch. EXTENDED is true or false to support
1146 extended output (2 is special and means "-ggdb" was given). */
1148 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1150 static bool type_explicit;
1152 use_gnu_debug_info_extensions = extended;
1154 if (type == NO_DEBUG)
1156 if (write_symbols == NO_DEBUG)
1158 write_symbols = PREFERRED_DEBUGGING_TYPE;
1162 #ifdef DWARF2_DEBUGGING_INFO
1163 write_symbols = DWARF2_DEBUG;
1164 #elif defined DBX_DEBUGGING_INFO
1165 write_symbols = DBX_DEBUG;
1169 if (write_symbols == NO_DEBUG)
1170 warning (0, "target system does not support debug output");
1175 /* Does it conflict with an already selected type? */
1176 if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1177 error ("debug format \"%s\" conflicts with prior selection",
1178 debug_type_names[type]);
1179 write_symbols = type;
1180 type_explicit = true;
1183 /* A debug flag without a level defaults to level 2. */
1186 if (!debug_info_level)
1187 debug_info_level = 2;
1191 debug_info_level = integral_argument (arg);
1192 if (debug_info_level == (unsigned int) -1)
1193 error ("unrecognised debug output level \"%s\"", arg);
1194 else if (debug_info_level > 3)
1195 error ("debug output level %s is too high", arg);
1199 /* Display help for target options. */
1201 print_target_help (void)
1204 static bool displayed = false;
1206 /* Avoid double printing for --help --target-help. */
1211 for (i = 0; i < cl_options_count; i++)
1212 if ((cl_options[i].flags & (CL_TARGET | CL_UNDOCUMENTED)) == CL_TARGET)
1214 printf (_("\nTarget specific options:\n"));
1215 print_filtered_help (CL_TARGET);
1220 /* Output --help text. */
1227 GET_ENVIRONMENT (p, "COLUMNS");
1230 int value = atoi (p);
1235 puts (_("The following options are language-independent:\n"));
1237 print_filtered_help (CL_COMMON);
1238 print_param_help ();
1240 for (i = 0; lang_names[i]; i++)
1242 printf (_("The %s front end recognizes the following options:\n\n"),
1244 print_filtered_help (1U << i);
1246 print_target_help ();
1249 /* Print the help for --param. */
1251 print_param_help (void)
1255 puts (_("The --param option recognizes the following as parameters:\n"));
1257 for (i = 0; i < LAST_PARAM; i++)
1259 const char *help = compiler_params[i].help;
1260 const char *param = compiler_params[i].option;
1262 if (help == NULL || *help == '\0')
1263 help = undocumented_msg;
1265 /* Get the translation. */
1268 wrap_help (help, param, strlen (param));
1274 /* Print help for a specific front-end, etc. */
1276 print_filtered_help (unsigned int flag)
1278 unsigned int i, len, filter, indent = 0;
1279 bool duplicates = false;
1280 const char *help, *opt, *tab;
1281 static char *printed;
1283 if (flag == CL_COMMON || flag == CL_TARGET)
1287 printed = xmalloc (cl_options_count);
1288 memset (printed, 0, cl_options_count);
1292 /* Don't print COMMON options twice. */
1293 filter = flag | CL_COMMON;
1295 for (i = 0; i < cl_options_count; i++)
1297 if ((cl_options[i].flags & filter) != flag)
1300 /* Skip help for internal switches. */
1301 if (cl_options[i].flags & CL_UNDOCUMENTED)
1304 /* Skip switches that have already been printed, mark them to be
1309 indent = print_switch (cl_options[i].opt_text, indent);
1320 for (i = 0; i < cl_options_count; i++)
1322 if ((cl_options[i].flags & filter) != flag)
1325 /* Skip help for internal switches. */
1326 if (cl_options[i].flags & CL_UNDOCUMENTED)
1329 /* Skip switches that have already been printed. */
1335 help = cl_options[i].help;
1337 help = undocumented_msg;
1339 /* Get the translation. */
1342 tab = strchr (help, '\t');
1351 opt = cl_options[i].opt_text;
1355 wrap_help (help, opt, len);
1361 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1362 word-wrapped HELP in a second column. */
1364 print_switch (const char *text, unsigned int indent)
1366 unsigned int len = strlen (text) + 1; /* trailing comma */
1371 if (indent + len > columns)
1382 fputs (text, stdout);
1384 return indent + len + 1;
1387 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1388 word-wrapped HELP in a second column. */
1390 wrap_help (const char *help, const char *item, unsigned int item_width)
1392 unsigned int col_width = 27;
1393 unsigned int remaining, room, len;
1395 remaining = strlen (help);
1399 room = columns - 3 - MAX (col_width, item_width);
1408 for (i = 0; help[i]; i++)
1410 if (i >= room && len != remaining)
1414 else if ((help[i] == '-' || help[i] == '/')
1415 && help[i + 1] != ' '
1416 && i > 0 && ISALPHA (help[i - 1]))
1421 printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
1423 while (help[len] == ' ')
1431 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
1432 a simple on-off switch. */
1435 option_enabled (int opt_idx)
1437 const struct cl_option *option = &(cl_options[opt_idx]);
1438 if (option->flag_var)
1439 switch (option->var_type)
1442 return *(int *) option->flag_var != 0;
1445 return *(int *) option->flag_var == option->var_value;
1447 case CLVC_BIT_CLEAR:
1448 return (*(int *) option->flag_var & option->var_value) == 0;
1451 return (*(int *) option->flag_var & option->var_value) != 0;
1459 /* Fill STATE with the current state of option OPTION. Return true if
1460 there is some state to store. */
1463 get_option_state (int option, struct cl_option_state *state)
1465 if (cl_options[option].flag_var == 0)
1468 switch (cl_options[option].var_type)
1472 state->data = cl_options[option].flag_var;
1473 state->size = sizeof (int);
1476 case CLVC_BIT_CLEAR:
1478 state->ch = option_enabled (option);
1479 state->data = &state->ch;
1484 state->data = *(const char **) cl_options[option].flag_var;
1485 if (state->data == 0)
1487 state->size = strlen (state->data) + 1;