1 /* Command line option handling.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006 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 /* Disable unit-at-a-time for frontends that might be still broken in this
86 bool no_unit_at_a_time_default
;
88 /* Global visibility options. */
89 struct visibility_flags visibility_options
;
91 /* Columns of --help display. */
92 static unsigned int columns
= 80;
94 /* What to print when a switch has no documentation. */
95 static const char undocumented_msg
[] = N_("This switch lacks documentation");
97 /* Used for bookkeeping on whether user set these flags so
98 -fprofile-use/-fprofile-generate does not use them. */
99 static bool profile_arc_flag_set
, flag_profile_values_set
;
100 static bool flag_unroll_loops_set
, flag_tracer_set
;
101 static bool flag_value_profile_transformations_set
;
102 static bool flag_peel_loops_set
, flag_branch_probabilities_set
;
103 static bool flag_loop_optimize_set
;
105 /* Input file names. */
106 const char **in_fnames
;
107 unsigned num_in_fnames
;
109 static size_t find_opt (const char *, int);
110 static int common_handle_option (size_t scode
, const char *arg
, int value
,
111 unsigned int lang_mask
);
112 static void handle_param (const char *);
113 static void set_Wextra (int);
114 static unsigned int handle_option (const char **argv
, unsigned int lang_mask
);
115 static char *write_langs (unsigned int lang_mask
);
116 static void complain_wrong_lang (const char *, const struct cl_option
*,
117 unsigned int lang_mask
);
118 static void handle_options (unsigned int, const char **, unsigned int);
119 static void wrap_help (const char *help
, const char *item
, unsigned int);
120 static void print_target_help (void);
121 static void print_help (void);
122 static void print_param_help (void);
123 static void print_filtered_help (unsigned int);
124 static unsigned int print_switch (const char *text
, unsigned int indent
);
125 static void set_debug_level (enum debug_info_type type
, int extended
,
128 /* Perform a binary search to find which option the command-line INPUT
129 matches. Returns its index in the option array, and N_OPTS
130 (cl_options_count) on failure.
132 This routine is quite subtle. A normal binary search is not good
133 enough because some options can be suffixed with an argument, and
134 multiple sub-matches can occur, e.g. input of "-pedantic" matching
135 the initial substring of "-pedantic-errors".
137 A more complicated example is -gstabs. It should match "-g" with
138 an argument of "stabs". Suppose, however, that the number and list
139 of switches are such that the binary search tests "-gen-decls"
140 before having tested "-g". This doesn't match, and as "-gen-decls"
141 is less than "-gstabs", it will become the lower bound of the
142 binary search range, and "-g" will never be seen. To resolve this
143 issue, opts.sh makes "-gen-decls" point, via the back_chain member,
144 to "-g" so that failed searches that end between "-gen-decls" and
145 the lexicographically subsequent switch know to go back and see if
146 "-g" causes a match (which it does in this example).
148 This search is done in such a way that the longest match for the
149 front end in question wins. If there is no match for the current
150 front end, the longest match for a different front end is returned
151 (or N_OPTS if none) and the caller emits an error message. */
153 find_opt (const char *input
, int lang_mask
)
155 size_t mn
, mx
, md
, opt_len
;
156 size_t match_wrong_lang
;
160 mx
= cl_options_count
;
162 /* Find mn such this lexicographical inequality holds:
163 cl_options[mn] <= input < cl_options[mn + 1]. */
167 opt_len
= cl_options
[md
].opt_len
;
168 comp
= strncmp (input
, cl_options
[md
].opt_text
+ 1, opt_len
);
176 /* This is the switch that is the best match but for a different
177 front end, or cl_options_count if there is no match at all. */
178 match_wrong_lang
= cl_options_count
;
180 /* Backtrace the chain of possible matches, returning the longest
181 one, if any, that fits best. With current GCC switches, this
182 loop executes at most twice. */
185 const struct cl_option
*opt
= &cl_options
[mn
];
187 /* Is the input either an exact match or a prefix that takes a
189 if (!strncmp (input
, opt
->opt_text
+ 1, opt
->opt_len
)
190 && (input
[opt
->opt_len
] == '\0' || (opt
->flags
& CL_JOINED
)))
192 /* If language is OK, return it. */
193 if (opt
->flags
& lang_mask
)
196 /* If we haven't remembered a prior match, remember this
197 one. Any prior match is necessarily better. */
198 if (match_wrong_lang
== cl_options_count
)
199 match_wrong_lang
= mn
;
202 /* Try the next possibility. This is cl_options_count if there
204 mn
= opt
->back_chain
;
206 while (mn
!= cl_options_count
);
208 /* Return the best wrong match, or cl_options_count if none. */
209 return match_wrong_lang
;
212 /* If ARG is a non-negative integer made up solely of digits, return its
213 value, otherwise return -1. */
215 integral_argument (const char *arg
)
219 while (*p
&& ISDIGIT (*p
))
228 /* Return a malloced slash-separated list of languages in MASK. */
230 write_langs (unsigned int mask
)
232 unsigned int n
= 0, len
= 0;
233 const char *lang_name
;
236 for (n
= 0; (lang_name
= lang_names
[n
]) != 0; n
++)
237 if (mask
& (1U << n
))
238 len
+= strlen (lang_name
) + 1;
240 result
= XNEWVEC (char, len
);
242 for (n
= 0; (lang_name
= lang_names
[n
]) != 0; n
++)
243 if (mask
& (1U << n
))
247 strcpy (result
+ len
, lang_name
);
248 len
+= strlen (lang_name
);
256 /* Complain that switch OPT_INDEX does not apply to this front end. */
258 complain_wrong_lang (const char *text
, const struct cl_option
*option
,
259 unsigned int lang_mask
)
261 char *ok_langs
, *bad_lang
;
263 ok_langs
= write_langs (option
->flags
);
264 bad_lang
= write_langs (lang_mask
);
266 /* Eventually this should become a hard error IMO. */
267 warning (0, "command line option \"%s\" is valid for %s but not for %s",
268 text
, ok_langs
, bad_lang
);
274 /* Handle the switch beginning at ARGV for the language indicated by
275 LANG_MASK. Returns the number of switches consumed. */
277 handle_option (const char **argv
, unsigned int lang_mask
)
280 const char *opt
, *arg
= 0;
283 unsigned int result
= 0;
284 const struct cl_option
*option
;
288 opt_index
= find_opt (opt
+ 1, lang_mask
| CL_COMMON
| CL_TARGET
);
289 if (opt_index
== cl_options_count
290 && (opt
[1] == 'W' || opt
[1] == 'f' || opt
[1] == 'm')
291 && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-')
293 /* Drop the "no-" from negative switches. */
294 size_t len
= strlen (opt
) - 3;
296 dup
= XNEWVEC (char, len
+ 1);
299 memcpy (dup
+ 2, opt
+ 5, len
- 2 + 1);
302 opt_index
= find_opt (opt
+ 1, lang_mask
| CL_COMMON
| CL_TARGET
);
305 if (opt_index
== cl_options_count
)
308 option
= &cl_options
[opt_index
];
310 /* Reject negative form of switches that don't take negatives as
312 if (!value
&& (option
->flags
& CL_REJECT_NEGATIVE
))
315 /* We've recognized this switch. */
318 /* Check to see if the option is disabled for this configuration. */
319 if (option
->flags
& CL_DISABLED
)
321 error ("command line option %qs"
322 " is not supported by this configuration", opt
);
326 /* Sort out any argument the switch takes. */
327 if (option
->flags
& CL_JOINED
)
329 /* Have arg point to the original switch. This is because
330 some code, such as disable_builtin_function, expects its
331 argument to be persistent until the program exits. */
332 arg
= argv
[0] + cl_options
[opt_index
].opt_len
+ 1;
334 arg
+= strlen ("no-");
336 if (*arg
== '\0' && !(option
->flags
& CL_MISSING_OK
))
338 if (option
->flags
& CL_SEPARATE
)
344 /* Missing argument. */
348 else if (option
->flags
& CL_SEPARATE
)
354 /* Now we've swallowed any potential argument, complain if this
355 is a switch for a different front end. */
356 if (!(option
->flags
& (lang_mask
| CL_COMMON
| CL_TARGET
)))
358 complain_wrong_lang (argv
[0], option
, lang_mask
);
362 if (arg
== NULL
&& (option
->flags
& (CL_JOINED
| CL_SEPARATE
)))
364 if (!lang_hooks
.missing_argument (opt
, opt_index
))
365 error ("missing argument to \"%s\"", opt
);
369 /* If the switch takes an integer, convert it. */
370 if (arg
&& (option
->flags
& CL_UINTEGER
))
372 value
= integral_argument (arg
);
375 error ("argument to \"%s\" should be a non-negative integer",
381 if (option
->flag_var
)
382 switch (option
->var_type
)
385 *(int *) option
->flag_var
= value
;
389 *(int *) option
->flag_var
= (value
391 : !option
->var_value
);
396 if ((value
!= 0) == (option
->var_type
== CLVC_BIT_SET
))
397 *(int *) option
->flag_var
|= option
->var_value
;
399 *(int *) option
->flag_var
&= ~option
->var_value
;
400 if (option
->flag_var
== &target_flags
)
401 target_flags_explicit
|= option
->var_value
;
405 *(const char **) option
->flag_var
= arg
;
409 if (option
->flags
& lang_mask
)
410 if (lang_hooks
.handle_option (opt_index
, arg
, value
) == 0)
413 if (result
&& (option
->flags
& CL_COMMON
))
414 if (common_handle_option (opt_index
, arg
, value
, lang_mask
) == 0)
417 if (result
&& (option
->flags
& CL_TARGET
))
418 if (!targetm
.handle_option (opt_index
, arg
, value
))
427 /* Handle FILENAME from the command line. */
429 add_input_filename (const char *filename
)
432 in_fnames
= xrealloc (in_fnames
, num_in_fnames
* sizeof (in_fnames
[0]));
433 in_fnames
[num_in_fnames
- 1] = filename
;
436 /* Decode and handle the vector of command line options. LANG_MASK
437 contains has a single bit set representing the current
440 handle_options (unsigned int argc
, const char **argv
, unsigned int lang_mask
)
444 for (i
= 1; i
< argc
; i
+= n
)
446 const char *opt
= argv
[i
];
448 /* Interpret "-" or a non-switch as a file name. */
449 if (opt
[0] != '-' || opt
[1] == '\0')
451 if (main_input_filename
== NULL
)
452 main_input_filename
= opt
;
453 add_input_filename (opt
);
458 n
= handle_option (argv
+ i
, lang_mask
);
463 error ("unrecognized command line option \"%s\"", opt
);
468 /* Parse command line options and set default flag values. Do minimal
469 options processing. */
471 decode_options (unsigned int argc
, const char **argv
)
473 unsigned int i
, lang_mask
;
475 /* Perform language-specific options initialization. */
476 lang_mask
= lang_hooks
.init_options (argc
, argv
);
478 lang_hooks
.initialize_diagnostics (global_dc
);
480 /* Scan to see what optimization level has been specified. That will
481 determine the default value of many flags. */
482 for (i
= 1; i
< argc
; i
++)
484 if (!strcmp (argv
[i
], "-O"))
489 else if (argv
[i
][0] == '-' && argv
[i
][1] == 'O')
491 /* Handle -Os, -O2, -O3, -O69, ... */
492 const char *p
= &argv
[i
][2];
494 if ((p
[0] == 's') && (p
[1] == 0))
498 /* Optimizing for size forces optimize to be 2. */
503 const int optimize_val
= read_integral_parameter (p
, p
- 2, -1);
504 if (optimize_val
!= -1)
506 optimize
= optimize_val
;
515 flag_merge_constants
= 0;
522 flag_delayed_branch
= 1;
524 #ifdef CAN_DEBUG_WITHOUT_FP
525 flag_omit_frame_pointer
= 1;
527 flag_guess_branch_prob
= 1;
528 flag_cprop_registers
= 1;
529 flag_loop_optimize
= 1;
530 flag_if_conversion
= 1;
531 flag_if_conversion2
= 1;
532 flag_ipa_pure_const
= 1;
533 flag_ipa_reference
= 1;
539 flag_tree_live_range_split
= 1;
541 flag_tree_copyrename
= 1;
543 flag_tree_copy_prop
= 1;
545 flag_tree_salias
= 1;
546 if (!no_unit_at_a_time_default
)
547 flag_unit_at_a_time
= 1;
551 /* Loop header copying usually increases size of the code. This used
552 not to be true, since quite often it is possible to verify that
553 the condition is satisfied in the first iteration and therefore
554 to eliminate it. Jump threading handles these cases now. */
561 flag_thread_jumps
= 1;
562 flag_crossjumping
= 1;
563 flag_optimize_sibling_calls
= 1;
564 flag_cse_follow_jumps
= 1;
565 flag_cse_skip_blocks
= 1;
567 flag_expensive_optimizations
= 1;
568 flag_ipa_type_escape
= 1;
569 flag_strength_reduce
= 1;
570 flag_rerun_cse_after_loop
= 1;
571 flag_rerun_loop_opt
= 1;
572 flag_caller_saves
= 1;
574 #ifdef INSN_SCHEDULING
575 flag_schedule_insns
= 1;
576 flag_schedule_insns_after_reload
= 1;
579 flag_strict_aliasing
= 1;
580 flag_delete_null_pointer_checks
= 1;
581 flag_reorder_blocks
= 1;
582 flag_reorder_functions
= 1;
583 flag_tree_store_ccp
= 1;
584 flag_tree_store_copy_prop
= 1;
589 /* PRE tends to generate bigger code. */
596 flag_inline_functions
= 1;
597 flag_unswitch_loops
= 1;
598 flag_gcse_after_reload
= 1;
601 if (optimize
< 2 || optimize_size
)
608 /* Don't reorder blocks when optimizing for size because extra
609 jump insns may be created; also barrier may create extra padding.
611 More correctly we should have a block reordering mode that tried
612 to minimize the combined size of all the jumps. This would more
613 or less automatically remove extra jumps, but would also try to
614 use more short jumps instead of long jumps. */
615 flag_reorder_blocks
= 0;
616 flag_reorder_blocks_and_partition
= 0;
621 /* Inlining of very small functions usually reduces total size. */
622 set_param_value ("max-inline-insns-single", 5);
623 set_param_value ("max-inline-insns-auto", 5);
624 flag_inline_functions
= 1;
626 /* We want to crossjump as much as possible. */
627 set_param_value ("min-crossjump-insns", 1);
630 /* Initialize whether `char' is signed. */
631 flag_signed_char
= DEFAULT_SIGNED_CHAR
;
632 /* Set this to a special "uninitialized" value. The actual default is set
633 after target options have been processed. */
634 flag_short_enums
= 2;
636 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
638 target_flags
= targetm
.default_target_flags
;
640 /* Some tagets have ABI-specified unwind tables. */
641 flag_unwind_tables
= targetm
.unwind_tables_default
;
643 #ifdef OPTIMIZATION_OPTIONS
644 /* Allow default optimizations to be specified on a per-machine basis. */
645 OPTIMIZATION_OPTIONS (optimize
, optimize_size
);
648 handle_options (argc
, argv
, lang_mask
);
652 if (flag_pic
&& !flag_pie
)
655 if (flag_no_inline
== 2)
658 flag_really_no_inline
= flag_no_inline
;
660 /* Set flag_no_inline before the post_options () hook. The C front
661 ends use it to determine tree inlining defaults. FIXME: such
662 code should be lang-independent when all front ends use tree
663 inlining, in which case it, and this condition, should be moved
664 to the top of process_options() instead. */
667 /* Inlining does not work if not optimizing,
668 so force it not to be done. */
672 /* The c_decode_option function and decode_option hook set
673 this to `2' if -Wall is used, so we can avoid giving out
674 lots of errors for people who don't realize what -Wall does. */
675 if (warn_uninitialized
== 1)
676 warning (OPT_Wuninitialized
,
677 "-Wuninitialized is not supported without -O");
680 if (flag_really_no_inline
== 2)
681 flag_really_no_inline
= flag_no_inline
;
683 /* The optimization to partition hot and cold basic blocks into separate
684 sections of the .o and executable files does not work (currently)
685 with exception handling. This is because there is no support for
686 generating unwind info. If flag_exceptions is turned on we need to
687 turn off the partitioning optimization. */
689 if (flag_exceptions
&& flag_reorder_blocks_and_partition
)
692 ("-freorder-blocks-and-partition does not work with exceptions");
693 flag_reorder_blocks_and_partition
= 0;
694 flag_reorder_blocks
= 1;
697 /* If user requested unwind info, then turn off the partitioning
700 if (flag_unwind_tables
&& ! targetm
.unwind_tables_default
701 && flag_reorder_blocks_and_partition
)
703 inform ("-freorder-blocks-and-partition does not support unwind info");
704 flag_reorder_blocks_and_partition
= 0;
705 flag_reorder_blocks
= 1;
708 /* If the target requested unwind info, then turn off the partitioning
709 optimization with a different message. Likewise, if the target does not
710 support named sections. */
712 if (flag_reorder_blocks_and_partition
713 && (!targetm
.have_named_sections
714 || (flag_unwind_tables
&& targetm
.unwind_tables_default
)))
717 ("-freorder-blocks-and-partition does not work on this architecture");
718 flag_reorder_blocks_and_partition
= 0;
719 flag_reorder_blocks
= 1;
723 /* Handle target- and language-independent options. Return zero to
724 generate an "unknown option" message. Only options that need
725 extra handling need to be listed here; if you simply want
726 VALUE assigned to a variable, it happens automatically. */
729 common_handle_option (size_t scode
, const char *arg
, int value
,
730 unsigned int lang_mask
)
732 enum opt_code code
= (enum opt_code
) scode
;
738 exit_after_options
= true;
745 case OPT__target_help
:
746 print_target_help ();
747 exit_after_options
= true;
751 print_version (stderr
, "");
752 exit_after_options
= true;
756 g_switch_value
= value
;
762 /* Currently handled in a prescan. */
766 /* For backward compatibility, -W is the same as -Wextra. */
774 new_option
= XNEWVEC (char, strlen (arg
) + 2);
776 strcpy (new_option
+1, arg
);
777 option_index
= find_opt (new_option
, lang_mask
);
778 if (option_index
== N_OPTS
)
780 error ("-Werror-%s: No option -%s", arg
, new_option
);
784 int kind
= value
? DK_ERROR
: DK_WARNING
;
785 diagnostic_classify_diagnostic (global_dc
, option_index
, kind
);
787 /* -Werror=foo implies -Wfoo. */
788 if (cl_options
[option_index
].var_type
== CLVC_BOOLEAN
789 && cl_options
[option_index
].flag_var
791 *(int *) cl_options
[option_index
].flag_var
= 1;
801 case OPT_Wlarger_than_
:
802 larger_than_size
= value
;
803 warn_larger_than
= value
!= -1;
806 case OPT_Wstrict_aliasing
:
807 case OPT_Wstrict_aliasing_
:
808 warn_strict_aliasing
= value
;
817 aux_info_file_name
= arg
;
818 flag_gen_aux_info
= 1;
825 case OPT_auxbase_strip
:
827 char *tmp
= xstrdup (arg
);
828 strip_off_ending (tmp
, strlen (tmp
));
835 decode_d_option (arg
);
839 dump_base_name
= arg
;
842 case OPT_falign_functions_
:
843 align_functions
= value
;
846 case OPT_falign_jumps_
:
850 case OPT_falign_labels_
:
851 align_labels
= value
;
854 case OPT_falign_loops_
:
858 case OPT_fbranch_probabilities
:
859 flag_branch_probabilities_set
= true;
862 case OPT_floop_optimize
:
863 flag_loop_optimize_set
= true;
866 case OPT_fcall_used_
:
867 fix_register (arg
, 0, 1);
870 case OPT_fcall_saved_
:
871 fix_register (arg
, 0, 0);
874 case OPT_fdiagnostics_show_location_
:
875 if (!strcmp (arg
, "once"))
876 diagnostic_prefixing_rule (global_dc
) = DIAGNOSTICS_SHOW_PREFIX_ONCE
;
877 else if (!strcmp (arg
, "every-line"))
878 diagnostic_prefixing_rule (global_dc
)
879 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE
;
884 case OPT_fdiagnostics_show_option
:
885 global_dc
->show_option_requested
= true;
889 if (!dump_switch_p (arg
))
894 set_fast_math_flags (value
);
898 fix_register (arg
, 1, 1);
901 case OPT_finline_limit_
:
902 case OPT_finline_limit_eq
:
903 set_param_value ("max-inline-insns-single", value
/ 2);
904 set_param_value ("max-inline-insns-auto", value
/ 2);
907 case OPT_fmessage_length_
:
908 pp_set_line_maximum_length (global_dc
->printer
, value
);
911 case OPT_fpack_struct_
:
912 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
913 error("structure alignment must be a small power of two, not %d", value
);
916 initial_max_fld_align
= value
;
917 maximum_field_alignment
= value
* BITS_PER_UNIT
;
921 case OPT_fpeel_loops
:
922 flag_peel_loops_set
= true;
925 case OPT_fprofile_arcs
:
926 profile_arc_flag_set
= true;
929 case OPT_fprofile_use
:
930 if (!flag_branch_probabilities_set
)
931 flag_branch_probabilities
= value
;
932 if (!flag_profile_values_set
)
933 flag_profile_values
= value
;
934 if (!flag_unroll_loops_set
)
935 flag_unroll_loops
= value
;
936 if (!flag_peel_loops_set
)
937 flag_peel_loops
= value
;
938 if (!flag_tracer_set
)
940 if (!flag_value_profile_transformations_set
)
941 flag_value_profile_transformations
= value
;
942 /* Old loop optimizer is incompatible with tree profiling. */
943 if (!flag_loop_optimize_set
)
944 flag_loop_optimize
= 0;
947 case OPT_fprofile_generate
:
948 if (!profile_arc_flag_set
)
949 profile_arc_flag
= value
;
950 if (!flag_profile_values_set
)
951 flag_profile_values
= value
;
952 if (!flag_value_profile_transformations_set
)
953 flag_value_profile_transformations
= value
;
956 case OPT_fprofile_values
:
957 flag_profile_values_set
= true;
960 case OPT_fvisibility_
:
962 if (!strcmp(arg
, "default"))
963 default_visibility
= VISIBILITY_DEFAULT
;
964 else if (!strcmp(arg
, "internal"))
965 default_visibility
= VISIBILITY_INTERNAL
;
966 else if (!strcmp(arg
, "hidden"))
967 default_visibility
= VISIBILITY_HIDDEN
;
968 else if (!strcmp(arg
, "protected"))
969 default_visibility
= VISIBILITY_PROTECTED
;
971 error ("unrecognized visibility value \"%s\"", arg
);
976 flag_value_profile_transformations_set
= true;
979 case OPT_frandom_seed
:
980 /* The real switch is -fno-random-seed. */
983 flag_random_seed
= NULL
;
986 case OPT_frandom_seed_
:
987 flag_random_seed
= arg
;
990 case OPT_fsched_verbose_
:
991 #ifdef INSN_SCHEDULING
992 fix_sched_param ("verbose", arg
);
998 case OPT_fsched_stalled_insns_
:
999 flag_sched_stalled_insns
= value
;
1000 if (flag_sched_stalled_insns
== 0)
1001 flag_sched_stalled_insns
= -1;
1004 case OPT_fsched_stalled_insns_dep_
:
1005 flag_sched_stalled_insns_dep
= value
;
1008 case OPT_fstack_limit
:
1009 /* The real switch is -fno-stack-limit. */
1012 stack_limit_rtx
= NULL_RTX
;
1015 case OPT_fstack_limit_register_
:
1017 int reg
= decode_reg_name (arg
);
1019 error ("unrecognized register name \"%s\"", arg
);
1021 stack_limit_rtx
= gen_rtx_REG (Pmode
, reg
);
1025 case OPT_fstack_limit_symbol_
:
1026 stack_limit_rtx
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (arg
));
1029 case OPT_ftree_vectorizer_verbose_
:
1030 vect_set_verbosity_level (arg
);
1033 case OPT_ftls_model_
:
1034 if (!strcmp (arg
, "global-dynamic"))
1035 flag_tls_default
= TLS_MODEL_GLOBAL_DYNAMIC
;
1036 else if (!strcmp (arg
, "local-dynamic"))
1037 flag_tls_default
= TLS_MODEL_LOCAL_DYNAMIC
;
1038 else if (!strcmp (arg
, "initial-exec"))
1039 flag_tls_default
= TLS_MODEL_INITIAL_EXEC
;
1040 else if (!strcmp (arg
, "local-exec"))
1041 flag_tls_default
= TLS_MODEL_LOCAL_EXEC
;
1043 warning (0, "unknown tls-model \"%s\"", arg
);
1047 flag_tracer_set
= true;
1050 case OPT_funroll_loops
:
1051 flag_unroll_loops_set
= true;
1055 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
);
1059 set_debug_level (SDB_DEBUG
, false, arg
);
1063 set_debug_level (DWARF2_DEBUG
, false, arg
);
1067 set_debug_level (NO_DEBUG
, 2, arg
);
1072 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
);
1076 set_debug_level (VMS_DEBUG
, false, arg
);
1081 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
);
1085 asm_file_name
= arg
;
1088 case OPT_pedantic_errors
:
1089 flag_pedantic_errors
= pedantic
= 1;
1092 case OPT_fforce_mem
:
1093 warning (0, "-f[no-]force-mem is nop and option will be removed in 4.2");
1097 /* If the flag was handled in a standard way, assume the lack of
1098 processing here is intentional. */
1099 gcc_assert (cl_options
[scode
].flag_var
);
1106 /* Handle --param NAME=VALUE. */
1108 handle_param (const char *carg
)
1113 arg
= xstrdup (carg
);
1114 equal
= strchr (arg
, '=');
1116 error ("%s: --param arguments should be of the form NAME=VALUE", arg
);
1119 value
= integral_argument (equal
+ 1);
1121 error ("invalid --param value %qs", equal
+ 1);
1125 set_param_value (arg
, value
);
1132 /* Handle -W and -Wextra. */
1134 set_Wextra (int setting
)
1136 extra_warnings
= setting
;
1137 warn_unused_value
= setting
;
1138 warn_unused_parameter
= (setting
&& maybe_warn_unused_parameter
);
1140 /* We save the value of warn_uninitialized, since if they put
1141 -Wuninitialized on the command line, we need to generate a
1142 warning about not using it without also specifying -O. */
1144 warn_uninitialized
= 0;
1145 else if (warn_uninitialized
!= 1)
1146 warn_uninitialized
= 2;
1149 /* Initialize unused warning flags. */
1151 set_Wunused (int setting
)
1153 warn_unused_function
= setting
;
1154 warn_unused_label
= setting
;
1155 /* Unused function parameter warnings are reported when either
1156 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1157 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1158 otherwise set maybe_warn_extra_parameter, which will be picked up
1160 maybe_warn_unused_parameter
= setting
;
1161 warn_unused_parameter
= (setting
&& extra_warnings
);
1162 warn_unused_variable
= setting
;
1163 warn_unused_value
= setting
;
1166 /* The following routines are useful in setting all the flags that
1167 -ffast-math and -fno-fast-math imply. */
1169 set_fast_math_flags (int set
)
1171 flag_trapping_math
= !set
;
1172 flag_unsafe_math_optimizations
= set
;
1173 flag_finite_math_only
= set
;
1174 flag_errno_math
= !set
;
1177 flag_signaling_nans
= 0;
1178 flag_rounding_math
= 0;
1179 flag_cx_limited_range
= 1;
1183 /* Return true iff flags are set as if -ffast-math. */
1185 fast_math_flags_set_p (void)
1187 return (!flag_trapping_math
1188 && flag_unsafe_math_optimizations
1189 && flag_finite_math_only
1190 && !flag_errno_math
);
1193 /* Handle a debug output -g switch. EXTENDED is true or false to support
1194 extended output (2 is special and means "-ggdb" was given). */
1196 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
)
1198 static bool type_explicit
;
1200 use_gnu_debug_info_extensions
= extended
;
1202 if (type
== NO_DEBUG
)
1204 if (write_symbols
== NO_DEBUG
)
1206 write_symbols
= PREFERRED_DEBUGGING_TYPE
;
1210 #ifdef DWARF2_DEBUGGING_INFO
1211 write_symbols
= DWARF2_DEBUG
;
1212 #elif defined DBX_DEBUGGING_INFO
1213 write_symbols
= DBX_DEBUG
;
1217 if (write_symbols
== NO_DEBUG
)
1218 warning (0, "target system does not support debug output");
1223 /* Does it conflict with an already selected type? */
1224 if (type_explicit
&& write_symbols
!= NO_DEBUG
&& type
!= write_symbols
)
1225 error ("debug format \"%s\" conflicts with prior selection",
1226 debug_type_names
[type
]);
1227 write_symbols
= type
;
1228 type_explicit
= true;
1231 /* A debug flag without a level defaults to level 2. */
1234 if (!debug_info_level
)
1235 debug_info_level
= 2;
1239 debug_info_level
= integral_argument (arg
);
1240 if (debug_info_level
== (unsigned int) -1)
1241 error ("unrecognised debug output level \"%s\"", arg
);
1242 else if (debug_info_level
> 3)
1243 error ("debug output level %s is too high", arg
);
1247 /* Display help for target options. */
1249 print_target_help (void)
1252 static bool displayed
= false;
1254 /* Avoid double printing for --help --target-help. */
1259 for (i
= 0; i
< cl_options_count
; i
++)
1260 if ((cl_options
[i
].flags
& (CL_TARGET
| CL_UNDOCUMENTED
)) == CL_TARGET
)
1262 printf (_("\nTarget specific options:\n"));
1263 print_filtered_help (CL_TARGET
);
1268 /* Output --help text. */
1275 GET_ENVIRONMENT (p
, "COLUMNS");
1278 int value
= atoi (p
);
1283 puts (_("The following options are language-independent:\n"));
1285 print_filtered_help (CL_COMMON
);
1286 print_param_help ();
1288 for (i
= 0; lang_names
[i
]; i
++)
1290 printf (_("The %s front end recognizes the following options:\n\n"),
1292 print_filtered_help (1U << i
);
1294 print_target_help ();
1297 /* Print the help for --param. */
1299 print_param_help (void)
1303 puts (_("The --param option recognizes the following as parameters:\n"));
1305 for (i
= 0; i
< LAST_PARAM
; i
++)
1307 const char *help
= compiler_params
[i
].help
;
1308 const char *param
= compiler_params
[i
].option
;
1310 if (help
== NULL
|| *help
== '\0')
1311 help
= undocumented_msg
;
1313 /* Get the translation. */
1316 wrap_help (help
, param
, strlen (param
));
1322 /* Print help for a specific front-end, etc. */
1324 print_filtered_help (unsigned int flag
)
1326 unsigned int i
, len
, filter
, indent
= 0;
1327 bool duplicates
= false;
1328 const char *help
, *opt
, *tab
;
1329 static char *printed
;
1331 if (flag
== CL_COMMON
|| flag
== CL_TARGET
)
1335 printed
= xmalloc (cl_options_count
);
1336 memset (printed
, 0, cl_options_count
);
1340 /* Don't print COMMON options twice. */
1341 filter
= flag
| CL_COMMON
;
1343 for (i
= 0; i
< cl_options_count
; i
++)
1345 if ((cl_options
[i
].flags
& filter
) != flag
)
1348 /* Skip help for internal switches. */
1349 if (cl_options
[i
].flags
& CL_UNDOCUMENTED
)
1352 /* Skip switches that have already been printed, mark them to be
1357 indent
= print_switch (cl_options
[i
].opt_text
, indent
);
1368 for (i
= 0; i
< cl_options_count
; i
++)
1370 if ((cl_options
[i
].flags
& filter
) != flag
)
1373 /* Skip help for internal switches. */
1374 if (cl_options
[i
].flags
& CL_UNDOCUMENTED
)
1377 /* Skip switches that have already been printed. */
1383 help
= cl_options
[i
].help
;
1385 help
= undocumented_msg
;
1387 /* Get the translation. */
1390 tab
= strchr (help
, '\t');
1399 opt
= cl_options
[i
].opt_text
;
1403 wrap_help (help
, opt
, len
);
1409 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1410 word-wrapped HELP in a second column. */
1412 print_switch (const char *text
, unsigned int indent
)
1414 unsigned int len
= strlen (text
) + 1; /* trailing comma */
1419 if (indent
+ len
> columns
)
1430 fputs (text
, stdout
);
1432 return indent
+ len
+ 1;
1435 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1436 word-wrapped HELP in a second column. */
1438 wrap_help (const char *help
, const char *item
, unsigned int item_width
)
1440 unsigned int col_width
= 27;
1441 unsigned int remaining
, room
, len
;
1443 remaining
= strlen (help
);
1447 room
= columns
- 3 - MAX (col_width
, item_width
);
1456 for (i
= 0; help
[i
]; i
++)
1458 if (i
>= room
&& len
!= remaining
)
1462 else if ((help
[i
] == '-' || help
[i
] == '/')
1463 && help
[i
+ 1] != ' '
1464 && i
> 0 && ISALPHA (help
[i
- 1]))
1469 printf( " %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1471 while (help
[len
] == ' ')
1479 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
1480 a simple on-off switch. */
1483 option_enabled (int opt_idx
)
1485 const struct cl_option
*option
= &(cl_options
[opt_idx
]);
1486 if (option
->flag_var
)
1487 switch (option
->var_type
)
1490 return *(int *) option
->flag_var
!= 0;
1493 return *(int *) option
->flag_var
== option
->var_value
;
1495 case CLVC_BIT_CLEAR
:
1496 return (*(int *) option
->flag_var
& option
->var_value
) == 0;
1499 return (*(int *) option
->flag_var
& option
->var_value
) != 0;
1507 /* Fill STATE with the current state of option OPTION. Return true if
1508 there is some state to store. */
1511 get_option_state (int option
, struct cl_option_state
*state
)
1513 if (cl_options
[option
].flag_var
== 0)
1516 switch (cl_options
[option
].var_type
)
1520 state
->data
= cl_options
[option
].flag_var
;
1521 state
->size
= sizeof (int);
1524 case CLVC_BIT_CLEAR
:
1526 state
->ch
= option_enabled (option
);
1527 state
->data
= &state
->ch
;
1532 state
->data
= *(const char **) cl_options
[option
].flag_var
;
1533 if (state
->data
== 0)
1535 state
->size
= strlen (state
->data
) + 1;