1 /* Command line option handling.
2 Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
3 Contributed by Neil Booth.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "coretypes.h"
31 #include "langhooks.h"
37 #include "diagnostic.h"
38 #include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
39 #include "insn-attr.h" /* For INSN_SCHEDULING. */
42 /* Value of the -G xx switch, and whether it was passed or not. */
43 unsigned HOST_WIDE_INT g_switch_value
;
46 /* True if we should exit after parsing options. */
47 bool exit_after_options
;
49 /* Print various extra warnings. -W/-Wextra. */
52 /* True to warn about any objects definitions whose size is larger
53 than N bytes. Also want about function definitions whose returned
54 values are larger than N bytes, where N is `larger_than_size'. */
55 bool warn_larger_than
;
56 HOST_WIDE_INT larger_than_size
;
58 /* Nonzero means warn about constructs which might not be
59 strict-aliasing safe. */
60 int warn_strict_aliasing
;
62 /* Hack for cooperation between set_Wunused and set_Wextra. */
63 static bool maybe_warn_unused_parameter
;
65 /* Type(s) of debugging information we are producing (if any). See
66 flags.h for the definitions of the different possible types of
67 debugging information. */
68 enum debug_info_type write_symbols
= NO_DEBUG
;
70 /* Level of debugging information we are producing. See flags.h for
71 the definitions of the different possible levels. */
72 enum debug_info_level debug_info_level
= DINFO_LEVEL_NONE
;
74 /* Nonzero means use GNU-only extensions in the generated symbolic
75 debugging information. Currently, this only has an effect when
76 write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
77 bool use_gnu_debug_info_extensions
;
79 /* The default visibility for all symbols (unless overridden) */
80 enum symbol_visibility default_visibility
= VISIBILITY_DEFAULT
;
82 /* Global visibility options. */
83 struct visibility_flags visibility_options
;
85 /* Columns of --help display. */
86 static unsigned int columns
= 80;
88 /* What to print when a switch has no documentation. */
89 static const char undocumented_msg
[] = N_("This switch lacks documentation");
91 /* Used for bookkeeping on whether user set these flags so
92 -fprofile-use/-fprofile-generate does not use them. */
93 static bool profile_arc_flag_set
, flag_profile_values_set
;
94 static bool flag_unroll_loops_set
, flag_tracer_set
;
95 static bool flag_value_profile_transformations_set
;
96 static bool flag_peel_loops_set
, flag_branch_probabilities_set
;
98 /* Input file names. */
99 const char **in_fnames
;
100 unsigned num_in_fnames
;
102 static size_t find_opt (const char *, int);
103 static int common_handle_option (size_t scode
, const char *arg
, int value
);
104 static void handle_param (const char *);
105 static void set_Wextra (int);
106 static unsigned int handle_option (const char **argv
, unsigned int lang_mask
);
107 static char *write_langs (unsigned int lang_mask
);
108 static void complain_wrong_lang (const char *, const struct cl_option
*,
109 unsigned int lang_mask
);
110 static void handle_options (unsigned int, const char **, unsigned int);
111 static void wrap_help (const char *help
, const char *item
, unsigned int);
112 static void print_help (void);
113 static void print_param_help (void);
114 static void print_filtered_help (unsigned int flag
);
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 this switch a prefix of the input? */
179 if (!strncmp (input
, opt
->opt_text
+ 1, opt
->opt_len
))
181 /* If language is OK, and the match is exact or the switch
182 takes a joined argument, return it. */
183 if ((opt
->flags
& lang_mask
)
184 && (input
[opt
->opt_len
] == '\0' || (opt
->flags
& CL_JOINED
)))
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 /* Drop the "no-" from negative switches. */
280 if ((opt
[1] == 'W' || opt
[1] == 'f')
281 && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-')
283 size_t len
= strlen (opt
) - 3;
285 dup
= xmalloc (len
+ 1);
288 memcpy (dup
+ 2, opt
+ 5, len
- 2 + 1);
293 opt_index
= find_opt (opt
+ 1, lang_mask
| CL_COMMON
);
294 if (opt_index
== cl_options_count
)
297 option
= &cl_options
[opt_index
];
299 /* Reject negative form of switches that don't take negatives as
301 if (!value
&& (option
->flags
& CL_REJECT_NEGATIVE
))
304 /* We've recognized this switch. */
307 /* Sort out any argument the switch takes. */
308 if (option
->flags
& CL_JOINED
)
310 /* Have arg point to the original switch. This is because
311 some code, such as disable_builtin_function, expects its
312 argument to be persistent until the program exits. */
313 arg
= argv
[0] + cl_options
[opt_index
].opt_len
+ 1;
315 arg
+= strlen ("no-");
317 if (*arg
== '\0' && !(option
->flags
& CL_MISSING_OK
))
319 if (option
->flags
& CL_SEPARATE
)
325 /* Missing argument. */
329 else if (option
->flags
& CL_SEPARATE
)
335 /* Now we've swallowed any potential argument, complain if this
336 is a switch for a different front end. */
337 if (!(option
->flags
& (lang_mask
| CL_COMMON
)))
339 complain_wrong_lang (argv
[0], option
, lang_mask
);
343 if (arg
== NULL
&& (option
->flags
& (CL_JOINED
| CL_SEPARATE
)))
345 if (!lang_hooks
.missing_argument (opt
, opt_index
))
346 error ("missing argument to \"%s\"", opt
);
350 /* If the switch takes an integer, convert it. */
351 if (arg
&& (option
->flags
& CL_UINTEGER
))
353 value
= integral_argument (arg
);
356 error ("argument to \"%s\" should be a non-negative integer",
362 if (option
->flag_var
)
364 if (option
->has_set_value
)
367 *option
->flag_var
= option
->set_value
;
369 *option
->flag_var
= !option
->set_value
;
372 *option
->flag_var
= value
;
375 if (option
->flags
& lang_mask
)
376 if (lang_hooks
.handle_option (opt_index
, arg
, value
) == 0)
379 if (result
&& (option
->flags
& CL_COMMON
))
380 if (common_handle_option (opt_index
, arg
, value
) == 0)
389 /* Decode and handle the vector of command line options. LANG_MASK
390 contains has a single bit set representing the current
393 handle_options (unsigned int argc
, const char **argv
, unsigned int lang_mask
)
397 for (i
= 1; i
< argc
; i
+= n
)
399 const char *opt
= argv
[i
];
401 /* Interpret "-" or a non-switch as a file name. */
402 if (opt
[0] != '-' || opt
[1] == '\0')
404 if (main_input_filename
== NULL
)
405 main_input_filename
= opt
;
406 add_input_filename (opt
);
411 n
= handle_option (argv
+ i
, lang_mask
);
416 error ("unrecognized command line option \"%s\"", opt
);
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 /* Parse command line options and set default flag values. Do minimal
431 options processing. */
433 decode_options (unsigned int argc
, const char **argv
)
435 unsigned int i
, lang_mask
;
437 /* Perform language-specific options initialization. */
438 lang_mask
= lang_hooks
.init_options (argc
, argv
);
440 lang_hooks
.initialize_diagnostics (global_dc
);
442 /* Scan to see what optimization level has been specified. That will
443 determine the default value of many flags. */
444 for (i
= 1; i
< argc
; i
++)
446 if (!strcmp (argv
[i
], "-O"))
451 else if (argv
[i
][0] == '-' && argv
[i
][1] == 'O')
453 /* Handle -Os, -O2, -O3, -O69, ... */
454 const char *p
= &argv
[i
][2];
456 if ((p
[0] == 's') && (p
[1] == 0))
460 /* Optimizing for size forces optimize to be 2. */
465 const int optimize_val
= read_integral_parameter (p
, p
- 2, -1);
466 if (optimize_val
!= -1)
468 optimize
= optimize_val
;
477 flag_merge_constants
= 0;
483 flag_thread_jumps
= 1;
485 flag_delayed_branch
= 1;
487 #ifdef CAN_DEBUG_WITHOUT_FP
488 flag_omit_frame_pointer
= 1;
490 flag_guess_branch_prob
= 1;
491 flag_cprop_registers
= 1;
492 flag_loop_optimize
= 1;
493 flag_if_conversion
= 1;
494 flag_if_conversion2
= 1;
501 flag_tree_live_range_split
= 1;
503 flag_tree_copyrename
= 1;
508 /* Loop header copying usually increases size of the code. This used
509 not to be true, since quite often it is possible to verify that
510 the condition is satisfied in the first iteration and therefore
511 to eliminate it. Jump threading handles these cases now. */
518 flag_crossjumping
= 1;
519 flag_optimize_sibling_calls
= 1;
520 flag_cse_follow_jumps
= 1;
521 flag_cse_skip_blocks
= 1;
523 flag_expensive_optimizations
= 1;
524 flag_strength_reduce
= 1;
525 flag_rerun_cse_after_loop
= 1;
526 flag_rerun_loop_opt
= 1;
527 flag_caller_saves
= 1;
530 #ifdef INSN_SCHEDULING
531 flag_schedule_insns
= 1;
532 flag_schedule_insns_after_reload
= 1;
535 flag_strict_aliasing
= 1;
536 flag_delete_null_pointer_checks
= 1;
537 flag_reorder_blocks
= 1;
538 flag_reorder_functions
= 1;
539 flag_unit_at_a_time
= 1;
544 flag_inline_functions
= 1;
545 flag_unswitch_loops
= 1;
546 flag_gcse_after_reload
= 1;
549 if (optimize
< 2 || optimize_size
)
556 /* Don't reorder blocks when optimizing for size because extra
557 jump insns may be created; also barrier may create extra padding.
559 More correctly we should have a block reordering mode that tried
560 to minimize the combined size of all the jumps. This would more
561 or less automatically remove extra jumps, but would also try to
562 use more short jumps instead of long jumps. */
563 flag_reorder_blocks
= 0;
564 flag_reorder_blocks_and_partition
= 0;
569 /* Inlining of very small functions usually reduces total size. */
570 set_param_value ("max-inline-insns-single", 5);
571 set_param_value ("max-inline-insns-auto", 5);
572 set_param_value ("max-inline-insns-rtl", 10);
573 flag_inline_functions
= 1;
576 /* Initialize whether `char' is signed. */
577 flag_signed_char
= DEFAULT_SIGNED_CHAR
;
578 /* Set this to a special "uninitialized" value. The actual default is set
579 after target options have been processed. */
580 flag_short_enums
= 2;
582 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
585 set_target_switch ("");
587 /* Unwind tables are always present when a target has ABI-specified unwind
588 tables, so the default should be ON. */
589 #ifdef TARGET_UNWIND_INFO
590 flag_unwind_tables
= TARGET_UNWIND_INFO
;
593 #ifdef OPTIMIZATION_OPTIONS
594 /* Allow default optimizations to be specified on a per-machine basis. */
595 OPTIMIZATION_OPTIONS (optimize
, optimize_size
);
598 handle_options (argc
, argv
, lang_mask
);
602 if (flag_pic
&& !flag_pie
)
605 if (flag_no_inline
== 2)
608 flag_really_no_inline
= flag_no_inline
;
610 /* Set flag_no_inline before the post_options () hook. The C front
611 ends use it to determine tree inlining defaults. FIXME: such
612 code should be lang-independent when all front ends use tree
613 inlining, in which case it, and this condition, should be moved
614 to the top of process_options() instead. */
617 /* Inlining does not work if not optimizing,
618 so force it not to be done. */
622 /* The c_decode_option function and decode_option hook set
623 this to `2' if -Wall is used, so we can avoid giving out
624 lots of errors for people who don't realize what -Wall does. */
625 if (warn_uninitialized
== 1)
626 warning ("-Wuninitialized is not supported without -O");
629 if (flag_really_no_inline
== 2)
630 flag_really_no_inline
= flag_no_inline
;
632 /* The optimization to partition hot and cold basic blocks into separate
633 sections of the .o and executable files does not work (currently)
634 with exception handling. If flag_exceptions is turned on we need to
635 turn off the partitioning optimization. */
637 if (flag_exceptions
&& flag_reorder_blocks_and_partition
)
640 ("-freorder-blocks-and-partition does not work with exceptions");
641 flag_reorder_blocks_and_partition
= 0;
642 flag_reorder_blocks
= 1;
645 /* The optimization to partition hot and cold basic blocks into
646 separate sections of the .o and executable files does not currently
647 work correctly with DWARF debugging turned on. Until this is fixed
648 we will disable the optimization when DWARF debugging is set. */
650 if (flag_reorder_blocks_and_partition
651 && (write_symbols
== DWARF_DEBUG
652 || write_symbols
== DWARF2_DEBUG
))
655 ("-freorder-blocks-and-partition does not work with -g (currently)");
656 flag_reorder_blocks_and_partition
= 0;
657 flag_reorder_blocks
= 1;
661 /* Handle target- and language-independent options. Return zero to
662 generate an "unknown option" message. Only options that need
663 extra handling need to be listed here; if you simply want
664 VALUE assigned to a variable, it happens automatically. */
667 common_handle_option (size_t scode
, const char *arg
, int value
)
669 enum opt_code code
= (enum opt_code
) scode
;
675 exit_after_options
= true;
682 case OPT__target_help
:
683 display_target_options ();
684 exit_after_options
= true;
688 print_version (stderr
, "");
689 exit_after_options
= true;
693 g_switch_value
= value
;
699 /* Currently handled in a prescan. */
703 /* For backward compatibility, -W is the same as -Wextra. */
711 case OPT_Wlarger_than_
:
712 larger_than_size
= value
;
713 warn_larger_than
= value
!= -1;
716 case OPT_Wstrict_aliasing
:
717 case OPT_Wstrict_aliasing_
:
718 warn_strict_aliasing
= value
;
727 aux_info_file_name
= arg
;
728 flag_gen_aux_info
= 1;
735 case OPT_auxbase_strip
:
737 char *tmp
= xstrdup (arg
);
738 strip_off_ending (tmp
, strlen (tmp
));
745 decode_d_option (arg
);
749 dump_base_name
= arg
;
752 case OPT_falign_functions_
:
753 align_functions
= value
;
756 case OPT_falign_jumps_
:
760 case OPT_falign_labels_
:
761 align_labels
= value
;
764 case OPT_falign_loops_
:
768 case OPT_fbranch_probabilities
:
769 flag_branch_probabilities_set
= true;
772 case OPT_fcall_used_
:
773 fix_register (arg
, 0, 1);
776 case OPT_fcall_saved_
:
777 fix_register (arg
, 0, 0);
780 case OPT_fdiagnostics_show_location_
:
781 if (!strcmp (arg
, "once"))
782 diagnostic_prefixing_rule (global_dc
) = DIAGNOSTICS_SHOW_PREFIX_ONCE
;
783 else if (!strcmp (arg
, "every-line"))
784 diagnostic_prefixing_rule (global_dc
)
785 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE
;
791 if (!dump_switch_p (arg
))
796 set_fast_math_flags (value
);
800 fix_register (arg
, 1, 1);
803 case OPT_finline_limit_
:
804 case OPT_finline_limit_eq
:
805 set_param_value ("max-inline-insns-single", value
/ 2);
806 set_param_value ("max-inline-insns-auto", value
/ 2);
807 set_param_value ("max-inline-insns-rtl", value
);
810 case OPT_fmessage_length_
:
811 pp_set_line_maximum_length (global_dc
->printer
, value
);
814 case OPT_fpeel_loops
:
815 flag_peel_loops_set
= true;
818 case OPT_fprofile_arcs
:
819 profile_arc_flag_set
= true;
822 case OPT_fprofile_use
:
823 if (!flag_branch_probabilities_set
)
824 flag_branch_probabilities
= value
;
825 if (!flag_profile_values_set
)
826 flag_profile_values
= value
;
827 if (!flag_unroll_loops_set
)
828 flag_unroll_loops
= value
;
829 if (!flag_peel_loops_set
)
830 flag_peel_loops
= value
;
831 if (!flag_tracer_set
)
833 if (!flag_value_profile_transformations_set
)
834 flag_value_profile_transformations
= value
;
837 case OPT_fprofile_generate
:
838 if (!profile_arc_flag_set
)
839 profile_arc_flag
= value
;
840 if (!flag_profile_values_set
)
841 flag_profile_values
= value
;
842 if (!flag_value_profile_transformations_set
)
843 flag_value_profile_transformations
= value
;
846 case OPT_fprofile_values
:
847 flag_profile_values_set
= true;
850 case OPT_fvisibility_
:
852 if (!strcmp(arg
, "default"))
853 default_visibility
= VISIBILITY_DEFAULT
;
854 else if (!strcmp(arg
, "internal"))
855 default_visibility
= VISIBILITY_INTERNAL
;
856 else if (!strcmp(arg
, "hidden"))
857 default_visibility
= VISIBILITY_HIDDEN
;
858 else if (!strcmp(arg
, "protected"))
859 default_visibility
= VISIBILITY_PROTECTED
;
861 error ("unrecognised visibility value \"%s\"", arg
);
866 flag_value_profile_transformations_set
= value
;
869 case OPT_frandom_seed
:
870 /* The real switch is -fno-random-seed. */
873 flag_random_seed
= NULL
;
876 case OPT_frandom_seed_
:
877 flag_random_seed
= arg
;
880 case OPT_fsched_verbose_
:
881 #ifdef INSN_SCHEDULING
882 fix_sched_param ("verbose", arg
);
888 case OPT_fsched_stalled_insns_
:
889 flag_sched_stalled_insns
= value
;
890 if (flag_sched_stalled_insns
== 0)
891 flag_sched_stalled_insns
= -1;
894 case OPT_fsched_stalled_insns_dep_
:
895 flag_sched_stalled_insns_dep
= value
;
898 case OPT_fstack_limit
:
899 /* The real switch is -fno-stack-limit. */
902 stack_limit_rtx
= NULL_RTX
;
905 case OPT_fstack_limit_register_
:
907 int reg
= decode_reg_name (arg
);
909 error ("unrecognized register name \"%s\"", arg
);
911 stack_limit_rtx
= gen_rtx_REG (Pmode
, reg
);
915 case OPT_fstack_limit_symbol_
:
916 stack_limit_rtx
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (arg
));
919 case OPT_ftls_model_
:
920 if (!strcmp (arg
, "global-dynamic"))
921 flag_tls_default
= TLS_MODEL_GLOBAL_DYNAMIC
;
922 else if (!strcmp (arg
, "local-dynamic"))
923 flag_tls_default
= TLS_MODEL_LOCAL_DYNAMIC
;
924 else if (!strcmp (arg
, "initial-exec"))
925 flag_tls_default
= TLS_MODEL_INITIAL_EXEC
;
926 else if (!strcmp (arg
, "local-exec"))
927 flag_tls_default
= TLS_MODEL_LOCAL_EXEC
;
929 warning ("unknown tls-model \"%s\"", arg
);
933 flag_tracer_set
= true;
936 case OPT_ftree_points_to_
:
937 if (!strcmp (arg
, "andersen"))
939 flag_tree_points_to
= PTA_ANDERSEN
;
941 warning ("Andersen's PTA not available - libbanshee not compiled.");
943 else if (!strcmp (arg
, "none"))
944 flag_tree_points_to
= PTA_NONE
;
947 warning ("`%s`: unknown points-to analysis algorithm", arg
);
952 case OPT_funroll_loops
:
953 flag_unroll_loops_set
= true;
957 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
);
961 set_debug_level (SDB_DEBUG
, false, arg
);
965 set_debug_level (DWARF2_DEBUG
, false, arg
);
969 set_debug_level (NO_DEBUG
, 2, arg
);
974 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
);
978 set_debug_level (VMS_DEBUG
, false, arg
);
983 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
);
987 set_target_switch (arg
);
994 case OPT_pedantic_errors
:
995 flag_pedantic_errors
= pedantic
= 1;
999 /* If the flag was handled in a standard way, assume the lack of
1000 processing here is intentional. */
1001 if (cl_options
[scode
].flag_var
)
1010 /* Handle --param NAME=VALUE. */
1012 handle_param (const char *carg
)
1017 arg
= xstrdup (carg
);
1018 equal
= strchr (arg
, '=');
1020 error ("%s: --param arguments should be of the form NAME=VALUE", arg
);
1023 value
= integral_argument (equal
+ 1);
1025 error ("invalid --param value `%s'", equal
+ 1);
1029 set_param_value (arg
, value
);
1036 /* Handle -W and -Wextra. */
1038 set_Wextra (int setting
)
1040 extra_warnings
= setting
;
1041 warn_unused_value
= setting
;
1042 warn_unused_parameter
= (setting
&& maybe_warn_unused_parameter
);
1044 /* We save the value of warn_uninitialized, since if they put
1045 -Wuninitialized on the command line, we need to generate a
1046 warning about not using it without also specifying -O. */
1048 warn_uninitialized
= 0;
1049 else if (warn_uninitialized
!= 1)
1050 warn_uninitialized
= 2;
1053 /* Initialize unused warning flags. */
1055 set_Wunused (int setting
)
1057 warn_unused_function
= setting
;
1058 warn_unused_label
= setting
;
1059 /* Unused function parameter warnings are reported when either
1060 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1061 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1062 otherwise set maybe_warn_extra_parameter, which will be picked up
1064 maybe_warn_unused_parameter
= setting
;
1065 warn_unused_parameter
= (setting
&& extra_warnings
);
1066 warn_unused_variable
= setting
;
1067 warn_unused_value
= setting
;
1070 /* The following routines are useful in setting all the flags that
1071 -ffast-math and -fno-fast-math imply. */
1073 set_fast_math_flags (int set
)
1075 flag_trapping_math
= !set
;
1076 flag_unsafe_math_optimizations
= set
;
1077 flag_finite_math_only
= set
;
1078 flag_errno_math
= !set
;
1081 flag_signaling_nans
= 0;
1082 flag_rounding_math
= 0;
1086 /* Return true iff flags are set as if -ffast-math. */
1088 fast_math_flags_set_p (void)
1090 return (!flag_trapping_math
1091 && flag_unsafe_math_optimizations
1092 && flag_finite_math_only
1093 && !flag_errno_math
);
1096 /* Handle a debug output -g switch. EXTENDED is true or false to support
1097 extended output (2 is special and means "-ggdb" was given). */
1099 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
)
1101 static bool type_explicit
;
1103 use_gnu_debug_info_extensions
= extended
;
1105 if (type
== NO_DEBUG
)
1107 if (write_symbols
== NO_DEBUG
)
1109 write_symbols
= PREFERRED_DEBUGGING_TYPE
;
1113 #ifdef DWARF2_DEBUGGING_INFO
1114 write_symbols
= DWARF2_DEBUG
;
1115 #elif defined DBX_DEBUGGING_INFO
1116 write_symbols
= DBX_DEBUG
;
1120 if (write_symbols
== NO_DEBUG
)
1121 warning ("target system does not support debug output");
1126 /* Does it conflict with an already selected type? */
1127 if (type_explicit
&& write_symbols
!= NO_DEBUG
&& type
!= write_symbols
)
1128 error ("debug format \"%s\" conflicts with prior selection",
1129 debug_type_names
[type
]);
1130 write_symbols
= type
;
1131 type_explicit
= true;
1134 /* A debug flag without a level defaults to level 2. */
1137 if (!debug_info_level
)
1138 debug_info_level
= 2;
1142 debug_info_level
= integral_argument (arg
);
1143 if (debug_info_level
== (unsigned int) -1)
1144 error ("unrecognised debug output level \"%s\"", arg
);
1145 else if (debug_info_level
> 3)
1146 error ("debug output level %s is too high", arg
);
1150 /* Output --help text. */
1157 GET_ENVIRONMENT (p
, "COLUMNS");
1160 int value
= atoi (p
);
1165 puts (_("The following options are language-independent:\n"));
1167 print_filtered_help (CL_COMMON
);
1168 print_param_help ();
1170 for (i
= 0; lang_names
[i
]; i
++)
1172 printf (_("The %s front end recognizes the following options:\n\n"),
1174 print_filtered_help (1U << i
);
1177 display_target_options ();
1180 /* Print the help for --param. */
1182 print_param_help (void)
1186 puts (_("The --param option recognizes the following as parameters:\n"));
1188 for (i
= 0; i
< LAST_PARAM
; i
++)
1190 const char *help
= compiler_params
[i
].help
;
1191 const char *param
= compiler_params
[i
].option
;
1193 if (help
== NULL
|| *help
== '\0')
1194 help
= undocumented_msg
;
1196 /* Get the translation. */
1199 wrap_help (help
, param
, strlen (param
));
1205 /* Print help for a specific front-end, etc. */
1207 print_filtered_help (unsigned int flag
)
1209 unsigned int i
, len
, filter
, indent
= 0;
1210 bool duplicates
= false;
1211 const char *help
, *opt
, *tab
;
1212 static char *printed
;
1214 if (flag
== CL_COMMON
)
1218 printed
= xmalloc (cl_options_count
);
1219 memset (printed
, 0, cl_options_count
);
1223 /* Don't print COMMON options twice. */
1224 filter
= flag
| CL_COMMON
;
1226 for (i
= 0; i
< cl_options_count
; i
++)
1228 if ((cl_options
[i
].flags
& filter
) != flag
)
1231 /* Skip help for internal switches. */
1232 if (cl_options
[i
].flags
& CL_UNDOCUMENTED
)
1235 /* Skip switches that have already been printed, mark them to be
1240 indent
= print_switch (cl_options
[i
].opt_text
, indent
);
1251 for (i
= 0; i
< cl_options_count
; i
++)
1253 if ((cl_options
[i
].flags
& filter
) != flag
)
1256 /* Skip help for internal switches. */
1257 if (cl_options
[i
].flags
& CL_UNDOCUMENTED
)
1260 /* Skip switches that have already been printed. */
1266 help
= cl_options
[i
].help
;
1268 help
= undocumented_msg
;
1270 /* Get the translation. */
1273 tab
= strchr (help
, '\t');
1282 opt
= cl_options
[i
].opt_text
;
1286 wrap_help (help
, opt
, len
);
1292 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1293 word-wrapped HELP in a second column. */
1295 print_switch (const char *text
, unsigned int indent
)
1297 unsigned int len
= strlen (text
) + 1; /* trailing comma */
1302 if (indent
+ len
> columns
)
1313 fputs (text
, stdout
);
1315 return indent
+ len
+ 1;
1318 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1319 word-wrapped HELP in a second column. */
1321 wrap_help (const char *help
, const char *item
, unsigned int item_width
)
1323 unsigned int col_width
= 27;
1324 unsigned int remaining
, room
, len
;
1326 remaining
= strlen (help
);
1330 room
= columns
- 3 - MAX (col_width
, item_width
);
1339 for (i
= 0; help
[i
]; i
++)
1341 if (i
>= room
&& len
!= remaining
)
1345 else if ((help
[i
] == '-' || help
[i
] == '/')
1346 && help
[i
+ 1] != ' '
1347 && i
> 0 && ISALPHA (help
[i
- 1]))
1352 printf( " %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1354 while (help
[len
] == ' ')