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, 59 Temple Place - Suite 330, Boston, MA
25 #include "coretypes.h"
31 #include "langhooks.h"
37 #include "diagnostic.h"
38 #include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
39 #include "insn-attr.h" /* For INSN_SCHEDULING. */
42 /* Value of the -G xx switch, and whether it was passed or not. */
43 unsigned HOST_WIDE_INT g_switch_value;
46 /* True if we should exit after parsing options. */
47 bool exit_after_options;
49 /* Print various extra warnings. -W/-Wextra. */
52 /* True to warn about any objects definitions whose size is larger
53 than N bytes. Also want about function definitions whose returned
54 values are larger than N bytes, where N is `larger_than_size'. */
55 bool warn_larger_than;
56 HOST_WIDE_INT larger_than_size;
58 /* Nonzero means warn about constructs which might not be
59 strict-aliasing safe. */
60 int warn_strict_aliasing;
62 /* Hack for cooperation between set_Wunused and set_Wextra. */
63 static bool maybe_warn_unused_parameter;
65 /* Type(s) of debugging information we are producing (if any). See
66 flags.h for the definitions of the different possible types of
67 debugging information. */
68 enum debug_info_type write_symbols = NO_DEBUG;
70 /* Level of debugging information we are producing. See flags.h for
71 the definitions of the different possible levels. */
72 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
74 /* Nonzero means use GNU-only extensions in the generated symbolic
75 debugging information. Currently, this only has an effect when
76 write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
77 bool use_gnu_debug_info_extensions;
79 /* The default visibility for all symbols (unless overridden) */
80 enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;
82 /* Global visibility options. */
83 struct visibility_flags visibility_options;
85 /* Columns of --help display. */
86 static unsigned int columns = 80;
88 /* What to print when a switch has no documentation. */
89 static const char undocumented_msg[] = N_("This switch lacks documentation");
91 /* Used for bookkeeping on whether user set these flags so
92 -fprofile-use/-fprofile-generate does not use them. */
93 static bool profile_arc_flag_set, flag_profile_values_set;
94 static bool flag_unroll_loops_set, flag_tracer_set;
95 static bool flag_value_profile_transformations_set;
96 bool flag_speculative_prefetching_set;
97 static bool flag_peel_loops_set, flag_branch_probabilities_set;
99 /* Input file names. */
100 const char **in_fnames;
101 unsigned num_in_fnames;
103 static size_t find_opt (const char *, int);
104 static int common_handle_option (size_t scode, const char *arg, int value);
105 static void handle_param (const char *);
106 static void set_Wextra (int);
107 static unsigned int handle_option (const char **argv, unsigned int lang_mask);
108 static char *write_langs (unsigned int lang_mask);
109 static void complain_wrong_lang (const char *, const struct cl_option *,
110 unsigned int lang_mask);
111 static void handle_options (unsigned int, const char **, unsigned int);
112 static void wrap_help (const char *help, const char *item, unsigned int);
113 static void print_help (void);
114 static void print_param_help (void);
115 static unsigned int print_switch (const char *text, unsigned int indent);
116 static void set_debug_level (enum debug_info_type type, int extended,
119 /* Perform a binary search to find which option the command-line INPUT
120 matches. Returns its index in the option array, and N_OPTS
121 (cl_options_count) on failure.
123 This routine is quite subtle. A normal binary search is not good
124 enough because some options can be suffixed with an argument, and
125 multiple sub-matches can occur, e.g. input of "-pedantic" matching
126 the initial substring of "-pedantic-errors".
128 A more complicated example is -gstabs. It should match "-g" with
129 an argument of "stabs". Suppose, however, that the number and list
130 of switches are such that the binary search tests "-gen-decls"
131 before having tested "-g". This doesn't match, and as "-gen-decls"
132 is less than "-gstabs", it will become the lower bound of the
133 binary search range, and "-g" will never be seen. To resolve this
134 issue, opts.sh makes "-gen-decls" point, via the back_chain member,
135 to "-g" so that failed searches that end between "-gen-decls" and
136 the lexicographically subsequent switch know to go back and see if
137 "-g" causes a match (which it does in this example).
139 This search is done in such a way that the longest match for the
140 front end in question wins. If there is no match for the current
141 front end, the longest match for a different front end is returned
142 (or N_OPTS if none) and the caller emits an error message. */
144 find_opt (const char *input, int lang_mask)
146 size_t mn, mx, md, opt_len;
147 size_t match_wrong_lang;
151 mx = cl_options_count;
153 /* Find mn such this lexicographical inequality holds:
154 cl_options[mn] <= input < cl_options[mn + 1]. */
158 opt_len = cl_options[md].opt_len;
159 comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
167 /* This is the switch that is the best match but for a different
168 front end, or cl_options_count if there is no match at all. */
169 match_wrong_lang = cl_options_count;
171 /* Backtrace the chain of possible matches, returning the longest
172 one, if any, that fits best. With current GCC switches, this
173 loop executes at most twice. */
176 const struct cl_option *opt = &cl_options[mn];
178 /* Is the input either an exact match or a prefix that takes a
180 if (!strncmp (input, opt->opt_text + 1, opt->opt_len)
181 && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
183 /* If language is OK, return it. */
184 if (opt->flags & lang_mask)
187 /* If we haven't remembered a prior match, remember this
188 one. Any prior match is necessarily better. */
189 if (match_wrong_lang == cl_options_count)
190 match_wrong_lang = mn;
193 /* Try the next possibility. This is cl_options_count if there
195 mn = opt->back_chain;
197 while (mn != cl_options_count);
199 /* Return the best wrong match, or cl_options_count if none. */
200 return match_wrong_lang;
203 /* If ARG is a non-negative integer made up solely of digits, return its
204 value, otherwise return -1. */
206 integral_argument (const char *arg)
210 while (*p && ISDIGIT (*p))
219 /* Return a malloced slash-separated list of languages in MASK. */
221 write_langs (unsigned int mask)
223 unsigned int n = 0, len = 0;
224 const char *lang_name;
227 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
228 if (mask & (1U << n))
229 len += strlen (lang_name) + 1;
231 result = xmalloc (len);
233 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
234 if (mask & (1U << n))
238 strcpy (result + len, lang_name);
239 len += strlen (lang_name);
247 /* Complain that switch OPT_INDEX does not apply to this front end. */
249 complain_wrong_lang (const char *text, const struct cl_option *option,
250 unsigned int lang_mask)
252 char *ok_langs, *bad_lang;
254 ok_langs = write_langs (option->flags);
255 bad_lang = write_langs (lang_mask);
257 /* Eventually this should become a hard error IMO. */
258 warning ("command line option \"%s\" is valid for %s but not for %s",
259 text, ok_langs, bad_lang);
265 /* Handle the switch beginning at ARGV for the language indicated by
266 LANG_MASK. Returns the number of switches consumed. */
268 handle_option (const char **argv, unsigned int lang_mask)
271 const char *opt, *arg = 0;
274 unsigned int result = 0;
275 const struct cl_option *option;
279 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
280 if (opt_index == cl_options_count
281 && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')
282 && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
284 /* Drop the "no-" from negative switches. */
285 size_t len = strlen (opt) - 3;
287 dup = xmalloc (len + 1);
290 memcpy (dup + 2, opt + 5, len - 2 + 1);
293 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
296 if (opt_index == cl_options_count)
299 option = &cl_options[opt_index];
301 /* Reject negative form of switches that don't take negatives as
303 if (!value && (option->flags & CL_REJECT_NEGATIVE))
306 /* We've recognized this switch. */
309 /* Sort out any argument the switch takes. */
310 if (option->flags & CL_JOINED)
312 /* Have arg point to the original switch. This is because
313 some code, such as disable_builtin_function, expects its
314 argument to be persistent until the program exits. */
315 arg = argv[0] + cl_options[opt_index].opt_len + 1;
317 arg += strlen ("no-");
319 if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
321 if (option->flags & CL_SEPARATE)
327 /* Missing argument. */
331 else if (option->flags & CL_SEPARATE)
337 /* Now we've swallowed any potential argument, complain if this
338 is a switch for a different front end. */
339 if (!(option->flags & (lang_mask | CL_COMMON | CL_TARGET)))
341 complain_wrong_lang (argv[0], option, lang_mask);
345 if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
347 if (!lang_hooks.missing_argument (opt, opt_index))
348 error ("missing argument to \"%s\"", opt);
352 /* If the switch takes an integer, convert it. */
353 if (arg && (option->flags & CL_UINTEGER))
355 value = integral_argument (arg);
358 error ("argument to \"%s\" should be a non-negative integer",
364 if (option->flag_var)
365 switch (option->var_cond)
368 *option->flag_var = value;
372 *option->flag_var = value ? option->var_value : !option->var_value;
377 if ((value != 0) == (option->var_cond == CLVC_BIT_SET))
378 *option->flag_var |= option->var_value;
380 *option->flag_var &= ~option->var_value;
381 if (option->flag_var == &target_flags)
382 target_flags_explicit |= option->var_value;
386 if (option->flags & lang_mask)
387 if (lang_hooks.handle_option (opt_index, arg, value) == 0)
390 if (result && (option->flags & CL_COMMON))
391 if (common_handle_option (opt_index, arg, value) == 0)
394 if (result && (option->flags & CL_TARGET))
395 if (!targetm.handle_option (opt_index, arg, value))
404 /* Handle FILENAME from the command line. */
406 add_input_filename (const char *filename)
409 in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));
410 in_fnames[num_in_fnames - 1] = filename;
413 /* Decode and handle the vector of command line options. LANG_MASK
414 contains has a single bit set representing the current
417 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
421 for (i = 1; i < argc; i += n)
423 const char *opt = argv[i];
425 /* Interpret "-" or a non-switch as a file name. */
426 if (opt[0] != '-' || opt[1] == '\0')
428 if (main_input_filename == NULL)
429 main_input_filename = opt;
430 add_input_filename (opt);
435 n = handle_option (argv + i, lang_mask);
440 error ("unrecognized command line option \"%s\"", opt);
445 /* Parse command line options and set default flag values. Do minimal
446 options processing. */
448 decode_options (unsigned int argc, const char **argv)
450 unsigned int i, lang_mask;
452 /* Perform language-specific options initialization. */
453 lang_mask = lang_hooks.init_options (argc, argv);
455 lang_hooks.initialize_diagnostics (global_dc);
457 /* Scan to see what optimization level has been specified. That will
458 determine the default value of many flags. */
459 for (i = 1; i < argc; i++)
461 if (!strcmp (argv[i], "-O"))
466 else if (argv[i][0] == '-' && argv[i][1] == 'O')
468 /* Handle -Os, -O2, -O3, -O69, ... */
469 const char *p = &argv[i][2];
471 if ((p[0] == 's') && (p[1] == 0))
475 /* Optimizing for size forces optimize to be 2. */
480 const int optimize_val = read_integral_parameter (p, p - 2, -1);
481 if (optimize_val != -1)
483 optimize = optimize_val;
492 flag_merge_constants = 0;
499 flag_delayed_branch = 1;
501 #ifdef CAN_DEBUG_WITHOUT_FP
502 flag_omit_frame_pointer = 1;
504 flag_guess_branch_prob = 1;
505 flag_cprop_registers = 1;
506 flag_loop_optimize = 1;
507 flag_if_conversion = 1;
508 flag_if_conversion2 = 1;
514 flag_tree_live_range_split = 1;
516 flag_tree_copyrename = 1;
519 flag_tree_salias = 1;
523 /* Loop header copying usually increases size of the code. This used
524 not to be true, since quite often it is possible to verify that
525 the condition is satisfied in the first iteration and therefore
526 to eliminate it. Jump threading handles these cases now. */
533 flag_thread_jumps = 1;
534 flag_crossjumping = 1;
535 flag_optimize_sibling_calls = 1;
536 flag_cse_follow_jumps = 1;
537 flag_cse_skip_blocks = 1;
539 flag_expensive_optimizations = 1;
540 flag_strength_reduce = 1;
541 flag_rerun_cse_after_loop = 1;
542 flag_rerun_loop_opt = 1;
543 flag_caller_saves = 1;
546 #ifdef INSN_SCHEDULING
547 flag_schedule_insns = 1;
548 flag_schedule_insns_after_reload = 1;
551 flag_strict_aliasing = 1;
552 flag_delete_null_pointer_checks = 1;
553 flag_reorder_blocks = 1;
554 flag_reorder_functions = 1;
555 flag_unit_at_a_time = 1;
559 /* PRE tends to generate bigger code. */
566 flag_inline_functions = 1;
567 flag_unswitch_loops = 1;
568 flag_gcse_after_reload = 1;
571 if (optimize < 2 || optimize_size)
578 /* Don't reorder blocks when optimizing for size because extra
579 jump insns may be created; also barrier may create extra padding.
581 More correctly we should have a block reordering mode that tried
582 to minimize the combined size of all the jumps. This would more
583 or less automatically remove extra jumps, but would also try to
584 use more short jumps instead of long jumps. */
585 flag_reorder_blocks = 0;
586 flag_reorder_blocks_and_partition = 0;
591 /* Inlining of very small functions usually reduces total size. */
592 set_param_value ("max-inline-insns-single", 5);
593 set_param_value ("max-inline-insns-auto", 5);
594 flag_inline_functions = 1;
596 /* We want to crossjump as much as possible. */
597 set_param_value ("min-crossjump-insns", 1);
600 /* Initialize whether `char' is signed. */
601 flag_signed_char = DEFAULT_SIGNED_CHAR;
602 /* Set this to a special "uninitialized" value. The actual default is set
603 after target options have been processed. */
604 flag_short_enums = 2;
606 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
608 target_flags = targetm.default_target_flags;
609 set_target_switch ("");
611 /* Unwind tables are always present when a target has ABI-specified unwind
612 tables, so the default should be ON. */
613 #ifdef TARGET_UNWIND_INFO
614 flag_unwind_tables = TARGET_UNWIND_INFO;
617 #ifdef OPTIMIZATION_OPTIONS
618 /* Allow default optimizations to be specified on a per-machine basis. */
619 OPTIMIZATION_OPTIONS (optimize, optimize_size);
622 handle_options (argc, argv, lang_mask);
626 if (flag_pic && !flag_pie)
629 if (flag_no_inline == 2)
632 flag_really_no_inline = flag_no_inline;
634 /* Set flag_no_inline before the post_options () hook. The C front
635 ends use it to determine tree inlining defaults. FIXME: such
636 code should be lang-independent when all front ends use tree
637 inlining, in which case it, and this condition, should be moved
638 to the top of process_options() instead. */
641 /* Inlining does not work if not optimizing,
642 so force it not to be done. */
646 /* The c_decode_option function and decode_option hook set
647 this to `2' if -Wall is used, so we can avoid giving out
648 lots of errors for people who don't realize what -Wall does. */
649 if (warn_uninitialized == 1)
650 warning ("-Wuninitialized is not supported without -O");
653 if (flag_really_no_inline == 2)
654 flag_really_no_inline = flag_no_inline;
656 /* The optimization to partition hot and cold basic blocks into separate
657 sections of the .o and executable files does not work (currently)
658 with exception handling. If flag_exceptions is turned on we need to
659 turn off the partitioning optimization. */
661 if (flag_exceptions && flag_reorder_blocks_and_partition)
664 ("-freorder-blocks-and-partition does not work with exceptions");
665 flag_reorder_blocks_and_partition = 0;
666 flag_reorder_blocks = 1;
669 /* The optimization to partition hot and cold basic blocks into
670 separate sections of the .o and executable files does not currently
671 work correctly with DWARF debugging turned on. Until this is fixed
672 we will disable the optimization when DWARF debugging is set. */
674 if (flag_reorder_blocks_and_partition && write_symbols == DWARF2_DEBUG)
677 ("-freorder-blocks-and-partition does not work with -g (currently)");
678 flag_reorder_blocks_and_partition = 0;
679 flag_reorder_blocks = 1;
683 /* Handle target- and language-independent options. Return zero to
684 generate an "unknown option" message. Only options that need
685 extra handling need to be listed here; if you simply want
686 VALUE assigned to a variable, it happens automatically. */
689 common_handle_option (size_t scode, const char *arg, int value)
691 enum opt_code code = (enum opt_code) scode;
697 exit_after_options = true;
704 case OPT__target_help:
705 display_target_options ();
706 exit_after_options = true;
710 print_version (stderr, "");
711 exit_after_options = true;
715 g_switch_value = value;
721 /* Currently handled in a prescan. */
725 /* For backward compatibility, -W is the same as -Wextra. */
733 case OPT_Wlarger_than_:
734 larger_than_size = value;
735 warn_larger_than = value != -1;
738 case OPT_Wstrict_aliasing:
739 case OPT_Wstrict_aliasing_:
740 warn_strict_aliasing = value;
749 aux_info_file_name = arg;
750 flag_gen_aux_info = 1;
757 case OPT_auxbase_strip:
759 char *tmp = xstrdup (arg);
760 strip_off_ending (tmp, strlen (tmp));
767 decode_d_option (arg);
771 dump_base_name = arg;
774 case OPT_falign_functions_:
775 align_functions = value;
778 case OPT_falign_jumps_:
782 case OPT_falign_labels_:
783 align_labels = value;
786 case OPT_falign_loops_:
790 case OPT_fbranch_probabilities:
791 flag_branch_probabilities_set = true;
794 case OPT_fcall_used_:
795 fix_register (arg, 0, 1);
798 case OPT_fcall_saved_:
799 fix_register (arg, 0, 0);
802 case OPT_fdiagnostics_show_location_:
803 if (!strcmp (arg, "once"))
804 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
805 else if (!strcmp (arg, "every-line"))
806 diagnostic_prefixing_rule (global_dc)
807 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
813 if (!dump_switch_p (arg))
818 set_fast_math_flags (value);
822 fix_register (arg, 1, 1);
825 case OPT_finline_limit_:
826 case OPT_finline_limit_eq:
827 set_param_value ("max-inline-insns-single", value / 2);
828 set_param_value ("max-inline-insns-auto", value / 2);
831 case OPT_fmessage_length_:
832 pp_set_line_maximum_length (global_dc->printer, value);
835 case OPT_fpack_struct_:
836 if (value <= 0 || (value & (value - 1)) || value > 16)
837 error("structure alignment must be a small power of two, not %d", value);
840 initial_max_fld_align = value;
841 maximum_field_alignment = value * BITS_PER_UNIT;
845 case OPT_fpeel_loops:
846 flag_peel_loops_set = true;
849 case OPT_fprofile_arcs:
850 profile_arc_flag_set = true;
853 case OPT_fprofile_use:
854 if (!flag_branch_probabilities_set)
855 flag_branch_probabilities = value;
856 if (!flag_profile_values_set)
857 flag_profile_values = value;
858 if (!flag_unroll_loops_set)
859 flag_unroll_loops = value;
860 if (!flag_peel_loops_set)
861 flag_peel_loops = value;
862 if (!flag_tracer_set)
864 if (!flag_value_profile_transformations_set)
865 flag_value_profile_transformations = value;
867 if (0 && !flag_speculative_prefetching_set)
868 flag_speculative_prefetching = value;
872 case OPT_fprofile_generate:
873 if (!profile_arc_flag_set)
874 profile_arc_flag = value;
875 if (!flag_profile_values_set)
876 flag_profile_values = value;
877 if (!flag_value_profile_transformations_set)
878 flag_value_profile_transformations = value;
879 if (!flag_unroll_loops_set)
880 flag_unroll_loops = value;
882 if (0 && !flag_speculative_prefetching_set)
883 flag_speculative_prefetching = value;
887 case OPT_fprofile_values:
888 flag_profile_values_set = true;
891 case OPT_fvisibility_:
893 if (!strcmp(arg, "default"))
894 default_visibility = VISIBILITY_DEFAULT;
895 else if (!strcmp(arg, "internal"))
896 default_visibility = VISIBILITY_INTERNAL;
897 else if (!strcmp(arg, "hidden"))
898 default_visibility = VISIBILITY_HIDDEN;
899 else if (!strcmp(arg, "protected"))
900 default_visibility = VISIBILITY_PROTECTED;
902 error ("unrecognised visibility value \"%s\"", arg);
907 flag_value_profile_transformations_set = true;
910 case OPT_fspeculative_prefetching:
911 flag_speculative_prefetching_set = true;
914 case OPT_frandom_seed:
915 /* The real switch is -fno-random-seed. */
918 flag_random_seed = NULL;
921 case OPT_frandom_seed_:
922 flag_random_seed = arg;
925 case OPT_fsched_verbose_:
926 #ifdef INSN_SCHEDULING
927 fix_sched_param ("verbose", arg);
933 case OPT_fsched_stalled_insns_:
934 flag_sched_stalled_insns = value;
935 if (flag_sched_stalled_insns == 0)
936 flag_sched_stalled_insns = -1;
939 case OPT_fsched_stalled_insns_dep_:
940 flag_sched_stalled_insns_dep = value;
943 case OPT_fstack_limit:
944 /* The real switch is -fno-stack-limit. */
947 stack_limit_rtx = NULL_RTX;
950 case OPT_fstack_limit_register_:
952 int reg = decode_reg_name (arg);
954 error ("unrecognized register name \"%s\"", arg);
956 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
960 case OPT_fstack_limit_symbol_:
961 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
964 case OPT_ftree_vectorizer_verbose_:
965 vect_set_verbosity_level (arg);
968 case OPT_ftls_model_:
969 if (!strcmp (arg, "global-dynamic"))
970 flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
971 else if (!strcmp (arg, "local-dynamic"))
972 flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
973 else if (!strcmp (arg, "initial-exec"))
974 flag_tls_default = TLS_MODEL_INITIAL_EXEC;
975 else if (!strcmp (arg, "local-exec"))
976 flag_tls_default = TLS_MODEL_LOCAL_EXEC;
978 warning ("unknown tls-model \"%s\"", arg);
982 flag_tracer_set = true;
985 case OPT_funroll_loops:
986 flag_unroll_loops_set = true;
990 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
994 set_debug_level (SDB_DEBUG, false, arg);
998 set_debug_level (DWARF2_DEBUG, false, arg);
1002 set_debug_level (NO_DEBUG, 2, arg);
1007 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
1011 set_debug_level (VMS_DEBUG, false, arg);
1016 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
1020 set_target_switch (arg);
1024 asm_file_name = arg;
1027 case OPT_pedantic_errors:
1028 flag_pedantic_errors = pedantic = 1;
1032 /* If the flag was handled in a standard way, assume the lack of
1033 processing here is intentional. */
1034 if (cl_options[scode].flag_var)
1043 /* Handle --param NAME=VALUE. */
1045 handle_param (const char *carg)
1050 arg = xstrdup (carg);
1051 equal = strchr (arg, '=');
1053 error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1056 value = integral_argument (equal + 1);
1058 error ("invalid --param value %qs", equal + 1);
1062 set_param_value (arg, value);
1069 /* Handle -W and -Wextra. */
1071 set_Wextra (int setting)
1073 extra_warnings = setting;
1074 warn_unused_value = setting;
1075 warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1077 /* We save the value of warn_uninitialized, since if they put
1078 -Wuninitialized on the command line, we need to generate a
1079 warning about not using it without also specifying -O. */
1081 warn_uninitialized = 0;
1082 else if (warn_uninitialized != 1)
1083 warn_uninitialized = 2;
1086 /* Initialize unused warning flags. */
1088 set_Wunused (int setting)
1090 warn_unused_function = setting;
1091 warn_unused_label = setting;
1092 /* Unused function parameter warnings are reported when either
1093 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1094 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1095 otherwise set maybe_warn_extra_parameter, which will be picked up
1097 maybe_warn_unused_parameter = setting;
1098 warn_unused_parameter = (setting && extra_warnings);
1099 warn_unused_variable = setting;
1100 warn_unused_value = setting;
1103 /* The following routines are useful in setting all the flags that
1104 -ffast-math and -fno-fast-math imply. */
1106 set_fast_math_flags (int set)
1108 flag_trapping_math = !set;
1109 flag_unsafe_math_optimizations = set;
1110 flag_finite_math_only = set;
1111 flag_errno_math = !set;
1114 flag_signaling_nans = 0;
1115 flag_rounding_math = 0;
1116 flag_cx_limited_range = 1;
1120 /* Return true iff flags are set as if -ffast-math. */
1122 fast_math_flags_set_p (void)
1124 return (!flag_trapping_math
1125 && flag_unsafe_math_optimizations
1126 && flag_finite_math_only
1127 && !flag_errno_math);
1130 /* Handle a debug output -g switch. EXTENDED is true or false to support
1131 extended output (2 is special and means "-ggdb" was given). */
1133 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1135 static bool type_explicit;
1137 use_gnu_debug_info_extensions = extended;
1139 if (type == NO_DEBUG)
1141 if (write_symbols == NO_DEBUG)
1143 write_symbols = PREFERRED_DEBUGGING_TYPE;
1147 #ifdef DWARF2_DEBUGGING_INFO
1148 write_symbols = DWARF2_DEBUG;
1149 #elif defined DBX_DEBUGGING_INFO
1150 write_symbols = DBX_DEBUG;
1154 if (write_symbols == NO_DEBUG)
1155 warning ("target system does not support debug output");
1160 /* Does it conflict with an already selected type? */
1161 if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1162 error ("debug format \"%s\" conflicts with prior selection",
1163 debug_type_names[type]);
1164 write_symbols = type;
1165 type_explicit = true;
1168 /* A debug flag without a level defaults to level 2. */
1171 if (!debug_info_level)
1172 debug_info_level = 2;
1176 debug_info_level = integral_argument (arg);
1177 if (debug_info_level == (unsigned int) -1)
1178 error ("unrecognised debug output level \"%s\"", arg);
1179 else if (debug_info_level > 3)
1180 error ("debug output level %s is too high", arg);
1184 /* Output --help text. */
1191 GET_ENVIRONMENT (p, "COLUMNS");
1194 int value = atoi (p);
1199 puts (_("The following options are language-independent:\n"));
1201 print_filtered_help (CL_COMMON);
1202 print_param_help ();
1204 for (i = 0; lang_names[i]; i++)
1206 printf (_("The %s front end recognizes the following options:\n\n"),
1208 print_filtered_help (1U << i);
1211 display_target_options ();
1214 /* Print the help for --param. */
1216 print_param_help (void)
1220 puts (_("The --param option recognizes the following as parameters:\n"));
1222 for (i = 0; i < LAST_PARAM; i++)
1224 const char *help = compiler_params[i].help;
1225 const char *param = compiler_params[i].option;
1227 if (help == NULL || *help == '\0')
1228 help = undocumented_msg;
1230 /* Get the translation. */
1233 wrap_help (help, param, strlen (param));
1239 /* Print help for a specific front-end, etc. */
1241 print_filtered_help (unsigned int flag)
1243 unsigned int i, len, filter, indent = 0;
1244 bool duplicates = false;
1245 const char *help, *opt, *tab;
1246 static char *printed;
1248 if (flag == CL_COMMON || flag == CL_TARGET)
1252 printed = xmalloc (cl_options_count);
1253 memset (printed, 0, cl_options_count);
1257 /* Don't print COMMON options twice. */
1258 filter = flag | CL_COMMON;
1260 for (i = 0; i < cl_options_count; i++)
1262 if ((cl_options[i].flags & filter) != flag)
1265 /* Skip help for internal switches. */
1266 if (cl_options[i].flags & CL_UNDOCUMENTED)
1269 /* Skip switches that have already been printed, mark them to be
1274 indent = print_switch (cl_options[i].opt_text, indent);
1285 for (i = 0; i < cl_options_count; i++)
1287 if ((cl_options[i].flags & filter) != flag)
1290 /* Skip help for internal switches. */
1291 if (cl_options[i].flags & CL_UNDOCUMENTED)
1294 /* Skip switches that have already been printed. */
1300 help = cl_options[i].help;
1302 help = undocumented_msg;
1304 /* Get the translation. */
1307 tab = strchr (help, '\t');
1316 opt = cl_options[i].opt_text;
1320 wrap_help (help, opt, len);
1326 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1327 word-wrapped HELP in a second column. */
1329 print_switch (const char *text, unsigned int indent)
1331 unsigned int len = strlen (text) + 1; /* trailing comma */
1336 if (indent + len > columns)
1347 fputs (text, stdout);
1349 return indent + len + 1;
1352 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1353 word-wrapped HELP in a second column. */
1355 wrap_help (const char *help, const char *item, unsigned int item_width)
1357 unsigned int col_width = 27;
1358 unsigned int remaining, room, len;
1360 remaining = strlen (help);
1364 room = columns - 3 - MAX (col_width, item_width);
1373 for (i = 0; help[i]; i++)
1375 if (i >= room && len != remaining)
1379 else if ((help[i] == '-' || help[i] == '/')
1380 && help[i + 1] != ' '
1381 && i > 0 && ISALPHA (help[i - 1]))
1386 printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
1388 while (help[len] == ' ')
1396 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
1397 a simple on-off switch. */
1400 option_enabled (const struct cl_option *option)
1402 if (option->flag_var)
1403 switch (option->var_cond)
1406 return *option->flag_var != 0;
1409 return *option->flag_var == option->var_value;
1411 case CLVC_BIT_CLEAR:
1412 return (*option->flag_var & option->var_value) == 0;
1415 return (*option->flag_var & option->var_value) != 0;