1 /* Command line option handling.
2 Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Neil Booth.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
25 #include "coretypes.h"
31 #include "langhooks.h"
37 #include "diagnostic.h"
38 #include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
39 #include "insn-attr.h" /* For INSN_SCHEDULING. */
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_target_help (void);
114 static void print_help (void);
115 static void print_param_help (void);
116 static void print_filtered_help (unsigned int);
117 static unsigned int print_switch (const char *text
, unsigned int indent
);
118 static void set_debug_level (enum debug_info_type type
, int extended
,
121 /* Perform a binary search to find which option the command-line INPUT
122 matches. Returns its index in the option array, and N_OPTS
123 (cl_options_count) on failure.
125 This routine is quite subtle. A normal binary search is not good
126 enough because some options can be suffixed with an argument, and
127 multiple sub-matches can occur, e.g. input of "-pedantic" matching
128 the initial substring of "-pedantic-errors".
130 A more complicated example is -gstabs. It should match "-g" with
131 an argument of "stabs". Suppose, however, that the number and list
132 of switches are such that the binary search tests "-gen-decls"
133 before having tested "-g". This doesn't match, and as "-gen-decls"
134 is less than "-gstabs", it will become the lower bound of the
135 binary search range, and "-g" will never be seen. To resolve this
136 issue, opts.sh makes "-gen-decls" point, via the back_chain member,
137 to "-g" so that failed searches that end between "-gen-decls" and
138 the lexicographically subsequent switch know to go back and see if
139 "-g" causes a match (which it does in this example).
141 This search is done in such a way that the longest match for the
142 front end in question wins. If there is no match for the current
143 front end, the longest match for a different front end is returned
144 (or N_OPTS if none) and the caller emits an error message. */
146 find_opt (const char *input
, int lang_mask
)
148 size_t mn
, mx
, md
, opt_len
;
149 size_t match_wrong_lang
;
153 mx
= cl_options_count
;
155 /* Find mn such this lexicographical inequality holds:
156 cl_options[mn] <= input < cl_options[mn + 1]. */
160 opt_len
= cl_options
[md
].opt_len
;
161 comp
= strncmp (input
, cl_options
[md
].opt_text
+ 1, opt_len
);
169 /* This is the switch that is the best match but for a different
170 front end, or cl_options_count if there is no match at all. */
171 match_wrong_lang
= cl_options_count
;
173 /* Backtrace the chain of possible matches, returning the longest
174 one, if any, that fits best. With current GCC switches, this
175 loop executes at most twice. */
178 const struct cl_option
*opt
= &cl_options
[mn
];
180 /* Is the input either an exact match or a prefix that takes a
182 if (!strncmp (input
, opt
->opt_text
+ 1, opt
->opt_len
)
183 && (input
[opt
->opt_len
] == '\0' || (opt
->flags
& CL_JOINED
)))
185 /* If language is OK, return it. */
186 if (opt
->flags
& lang_mask
)
189 /* If we haven't remembered a prior match, remember this
190 one. Any prior match is necessarily better. */
191 if (match_wrong_lang
== cl_options_count
)
192 match_wrong_lang
= mn
;
195 /* Try the next possibility. This is cl_options_count if there
197 mn
= opt
->back_chain
;
199 while (mn
!= cl_options_count
);
201 /* Return the best wrong match, or cl_options_count if none. */
202 return match_wrong_lang
;
205 /* If ARG is a non-negative integer made up solely of digits, return its
206 value, otherwise return -1. */
208 integral_argument (const char *arg
)
212 while (*p
&& ISDIGIT (*p
))
221 /* Return a malloced slash-separated list of languages in MASK. */
223 write_langs (unsigned int mask
)
225 unsigned int n
= 0, len
= 0;
226 const char *lang_name
;
229 for (n
= 0; (lang_name
= lang_names
[n
]) != 0; n
++)
230 if (mask
& (1U << n
))
231 len
+= strlen (lang_name
) + 1;
233 result
= xmalloc (len
);
235 for (n
= 0; (lang_name
= lang_names
[n
]) != 0; n
++)
236 if (mask
& (1U << n
))
240 strcpy (result
+ len
, lang_name
);
241 len
+= strlen (lang_name
);
249 /* Complain that switch OPT_INDEX does not apply to this front end. */
251 complain_wrong_lang (const char *text
, const struct cl_option
*option
,
252 unsigned int lang_mask
)
254 char *ok_langs
, *bad_lang
;
256 ok_langs
= write_langs (option
->flags
);
257 bad_lang
= write_langs (lang_mask
);
259 /* Eventually this should become a hard error IMO. */
260 warning (0, "command line option \"%s\" is valid for %s but not for %s",
261 text
, ok_langs
, bad_lang
);
267 /* Handle the switch beginning at ARGV for the language indicated by
268 LANG_MASK. Returns the number of switches consumed. */
270 handle_option (const char **argv
, unsigned int lang_mask
)
273 const char *opt
, *arg
= 0;
276 unsigned int result
= 0;
277 const struct cl_option
*option
;
281 opt_index
= find_opt (opt
+ 1, lang_mask
| CL_COMMON
| CL_TARGET
);
282 if (opt_index
== cl_options_count
283 && (opt
[1] == 'W' || opt
[1] == 'f' || opt
[1] == 'm')
284 && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-')
286 /* Drop the "no-" from negative switches. */
287 size_t len
= strlen (opt
) - 3;
289 dup
= xmalloc (len
+ 1);
292 memcpy (dup
+ 2, opt
+ 5, len
- 2 + 1);
295 opt_index
= find_opt (opt
+ 1, lang_mask
| CL_COMMON
| CL_TARGET
);
298 if (opt_index
== cl_options_count
)
301 option
= &cl_options
[opt_index
];
303 /* Reject negative form of switches that don't take negatives as
305 if (!value
&& (option
->flags
& CL_REJECT_NEGATIVE
))
308 /* We've recognized this switch. */
311 /* Check to see if the option is disabled for this configuration. */
312 if (option
->flags
& CL_DISABLED
)
314 error ("command line option %qs"
315 " is not supported by this configuration", opt
);
319 /* Sort out any argument the switch takes. */
320 if (option
->flags
& CL_JOINED
)
322 /* Have arg point to the original switch. This is because
323 some code, such as disable_builtin_function, expects its
324 argument to be persistent until the program exits. */
325 arg
= argv
[0] + cl_options
[opt_index
].opt_len
+ 1;
327 arg
+= strlen ("no-");
329 if (*arg
== '\0' && !(option
->flags
& CL_MISSING_OK
))
331 if (option
->flags
& CL_SEPARATE
)
337 /* Missing argument. */
341 else if (option
->flags
& CL_SEPARATE
)
347 /* Now we've swallowed any potential argument, complain if this
348 is a switch for a different front end. */
349 if (!(option
->flags
& (lang_mask
| CL_COMMON
| CL_TARGET
)))
351 complain_wrong_lang (argv
[0], option
, lang_mask
);
355 if (arg
== NULL
&& (option
->flags
& (CL_JOINED
| CL_SEPARATE
)))
357 if (!lang_hooks
.missing_argument (opt
, opt_index
))
358 error ("missing argument to \"%s\"", opt
);
362 /* If the switch takes an integer, convert it. */
363 if (arg
&& (option
->flags
& CL_UINTEGER
))
365 value
= integral_argument (arg
);
368 error ("argument to \"%s\" should be a non-negative integer",
374 if (option
->flag_var
)
375 switch (option
->var_type
)
378 *(int *) option
->flag_var
= value
;
382 *(int *) option
->flag_var
= (value
384 : !option
->var_value
);
389 if ((value
!= 0) == (option
->var_type
== CLVC_BIT_SET
))
390 *(int *) option
->flag_var
|= option
->var_value
;
392 *(int *) option
->flag_var
&= ~option
->var_value
;
393 if (option
->flag_var
== &target_flags
)
394 target_flags_explicit
|= option
->var_value
;
398 *(const char **) option
->flag_var
= arg
;
402 if (option
->flags
& lang_mask
)
403 if (lang_hooks
.handle_option (opt_index
, arg
, value
) == 0)
406 if (result
&& (option
->flags
& CL_COMMON
))
407 if (common_handle_option (opt_index
, arg
, value
) == 0)
410 if (result
&& (option
->flags
& CL_TARGET
))
411 if (!targetm
.handle_option (opt_index
, arg
, value
))
420 /* Handle FILENAME from the command line. */
422 add_input_filename (const char *filename
)
425 in_fnames
= xrealloc (in_fnames
, num_in_fnames
* sizeof (in_fnames
[0]));
426 in_fnames
[num_in_fnames
- 1] = filename
;
429 /* Decode and handle the vector of command line options. LANG_MASK
430 contains has a single bit set representing the current
433 handle_options (unsigned int argc
, const char **argv
, unsigned int lang_mask
)
437 for (i
= 1; i
< argc
; i
+= n
)
439 const char *opt
= argv
[i
];
441 /* Interpret "-" or a non-switch as a file name. */
442 if (opt
[0] != '-' || opt
[1] == '\0')
444 if (main_input_filename
== NULL
)
445 main_input_filename
= opt
;
446 add_input_filename (opt
);
451 n
= handle_option (argv
+ i
, lang_mask
);
456 error ("unrecognized command line option \"%s\"", opt
);
461 /* Parse command line options and set default flag values. Do minimal
462 options processing. */
464 decode_options (unsigned int argc
, const char **argv
)
466 unsigned int i
, lang_mask
;
468 /* Perform language-specific options initialization. */
469 lang_mask
= lang_hooks
.init_options (argc
, argv
);
471 lang_hooks
.initialize_diagnostics (global_dc
);
473 /* Scan to see what optimization level has been specified. That will
474 determine the default value of many flags. */
475 for (i
= 1; i
< argc
; i
++)
477 if (!strcmp (argv
[i
], "-O"))
482 else if (argv
[i
][0] == '-' && argv
[i
][1] == 'O')
484 /* Handle -Os, -O2, -O3, -O69, ... */
485 const char *p
= &argv
[i
][2];
487 if ((p
[0] == 's') && (p
[1] == 0))
491 /* Optimizing for size forces optimize to be 2. */
496 const int optimize_val
= read_integral_parameter (p
, p
- 2, -1);
497 if (optimize_val
!= -1)
499 optimize
= optimize_val
;
508 flag_merge_constants
= 0;
515 flag_delayed_branch
= 1;
517 #ifdef CAN_DEBUG_WITHOUT_FP
518 flag_omit_frame_pointer
= 1;
520 flag_guess_branch_prob
= 1;
521 flag_cprop_registers
= 1;
522 flag_loop_optimize
= 1;
523 flag_if_conversion
= 1;
524 flag_if_conversion2
= 1;
530 flag_tree_live_range_split
= 1;
532 flag_tree_copyrename
= 1;
534 flag_tree_copy_prop
= 1;
536 flag_tree_salias
= 1;
537 flag_unit_at_a_time
= 1;
541 /* Loop header copying usually increases size of the code. This used
542 not to be true, since quite often it is possible to verify that
543 the condition is satisfied in the first iteration and therefore
544 to eliminate it. Jump threading handles these cases now. */
551 flag_thread_jumps
= 1;
552 flag_crossjumping
= 1;
553 flag_optimize_sibling_calls
= 1;
554 flag_cse_follow_jumps
= 1;
555 flag_cse_skip_blocks
= 1;
557 flag_expensive_optimizations
= 1;
558 flag_strength_reduce
= 1;
559 flag_rerun_cse_after_loop
= 1;
560 flag_rerun_loop_opt
= 1;
561 flag_caller_saves
= 1;
564 #ifdef INSN_SCHEDULING
565 flag_schedule_insns
= 1;
566 flag_schedule_insns_after_reload
= 1;
569 flag_strict_aliasing
= 1;
570 flag_delete_null_pointer_checks
= 1;
571 flag_reorder_blocks
= 1;
572 flag_reorder_functions
= 1;
573 flag_tree_store_ccp
= 1;
574 flag_tree_store_copy_prop
= 1;
579 /* PRE tends to generate bigger code. */
586 flag_inline_functions
= 1;
587 flag_unswitch_loops
= 1;
588 flag_gcse_after_reload
= 1;
591 if (optimize
< 2 || optimize_size
)
598 /* Don't reorder blocks when optimizing for size because extra
599 jump insns may be created; also barrier may create extra padding.
601 More correctly we should have a block reordering mode that tried
602 to minimize the combined size of all the jumps. This would more
603 or less automatically remove extra jumps, but would also try to
604 use more short jumps instead of long jumps. */
605 flag_reorder_blocks
= 0;
606 flag_reorder_blocks_and_partition
= 0;
611 /* Inlining of very small functions usually reduces total size. */
612 set_param_value ("max-inline-insns-single", 5);
613 set_param_value ("max-inline-insns-auto", 5);
614 flag_inline_functions
= 1;
616 /* We want to crossjump as much as possible. */
617 set_param_value ("min-crossjump-insns", 1);
620 /* Initialize whether `char' is signed. */
621 flag_signed_char
= DEFAULT_SIGNED_CHAR
;
622 /* Set this to a special "uninitialized" value. The actual default is set
623 after target options have been processed. */
624 flag_short_enums
= 2;
626 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
628 target_flags
= targetm
.default_target_flags
;
630 /* Some tagets have ABI-specified unwind tables. */
631 flag_unwind_tables
= targetm
.unwind_tables_default
;
633 #ifdef OPTIMIZATION_OPTIONS
634 /* Allow default optimizations to be specified on a per-machine basis. */
635 OPTIMIZATION_OPTIONS (optimize
, optimize_size
);
638 handle_options (argc
, argv
, lang_mask
);
642 if (flag_pic
&& !flag_pie
)
645 if (flag_no_inline
== 2)
648 flag_really_no_inline
= flag_no_inline
;
650 /* Set flag_no_inline before the post_options () hook. The C front
651 ends use it to determine tree inlining defaults. FIXME: such
652 code should be lang-independent when all front ends use tree
653 inlining, in which case it, and this condition, should be moved
654 to the top of process_options() instead. */
657 /* Inlining does not work if not optimizing,
658 so force it not to be done. */
662 /* The c_decode_option function and decode_option hook set
663 this to `2' if -Wall is used, so we can avoid giving out
664 lots of errors for people who don't realize what -Wall does. */
665 if (warn_uninitialized
== 1)
666 warning (OPT_Wuninitialized
,
667 "-Wuninitialized is not supported without -O");
670 if (flag_really_no_inline
== 2)
671 flag_really_no_inline
= flag_no_inline
;
673 /* The optimization to partition hot and cold basic blocks into separate
674 sections of the .o and executable files does not work (currently)
675 with exception handling. If flag_exceptions is turned on we need to
676 turn off the partitioning optimization. */
678 if (flag_exceptions
&& flag_reorder_blocks_and_partition
)
681 ("-freorder-blocks-and-partition does not work with exceptions");
682 flag_reorder_blocks_and_partition
= 0;
683 flag_reorder_blocks
= 1;
686 if (flag_reorder_blocks_and_partition
687 && !targetm
.have_named_sections
)
690 ("-freorder-blocks-and-partition does not work on this architecture.");
691 flag_reorder_blocks_and_partition
= 0;
692 flag_reorder_blocks
= 1;
696 /* Handle target- and language-independent options. Return zero to
697 generate an "unknown option" message. Only options that need
698 extra handling need to be listed here; if you simply want
699 VALUE assigned to a variable, it happens automatically. */
702 common_handle_option (size_t scode
, const char *arg
, int value
)
704 enum opt_code code
= (enum opt_code
) scode
;
710 exit_after_options
= true;
717 case OPT__target_help
:
718 print_target_help ();
719 exit_after_options
= true;
723 print_version (stderr
, "");
724 exit_after_options
= true;
728 g_switch_value
= value
;
734 /* Currently handled in a prescan. */
738 /* For backward compatibility, -W is the same as -Wextra. */
746 case OPT_Wlarger_than_
:
747 larger_than_size
= value
;
748 warn_larger_than
= value
!= -1;
751 case OPT_Wstrict_aliasing
:
752 case OPT_Wstrict_aliasing_
:
753 warn_strict_aliasing
= value
;
762 aux_info_file_name
= arg
;
763 flag_gen_aux_info
= 1;
770 case OPT_auxbase_strip
:
772 char *tmp
= xstrdup (arg
);
773 strip_off_ending (tmp
, strlen (tmp
));
780 decode_d_option (arg
);
784 dump_base_name
= arg
;
787 case OPT_falign_functions_
:
788 align_functions
= value
;
791 case OPT_falign_jumps_
:
795 case OPT_falign_labels_
:
796 align_labels
= value
;
799 case OPT_falign_loops_
:
803 case OPT_fbranch_probabilities
:
804 flag_branch_probabilities_set
= true;
807 case OPT_fcall_used_
:
808 fix_register (arg
, 0, 1);
811 case OPT_fcall_saved_
:
812 fix_register (arg
, 0, 0);
815 case OPT_fdiagnostics_show_location_
:
816 if (!strcmp (arg
, "once"))
817 diagnostic_prefixing_rule (global_dc
) = DIAGNOSTICS_SHOW_PREFIX_ONCE
;
818 else if (!strcmp (arg
, "every-line"))
819 diagnostic_prefixing_rule (global_dc
)
820 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE
;
825 case OPT_fdiagnostics_show_option
:
826 global_dc
->show_option_requested
= true;
830 if (!dump_switch_p (arg
))
835 set_fast_math_flags (value
);
839 fix_register (arg
, 1, 1);
842 case OPT_finline_limit_
:
843 case OPT_finline_limit_eq
:
844 set_param_value ("max-inline-insns-single", value
/ 2);
845 set_param_value ("max-inline-insns-auto", value
/ 2);
848 case OPT_fmessage_length_
:
849 pp_set_line_maximum_length (global_dc
->printer
, value
);
852 case OPT_fpack_struct_
:
853 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
854 error("structure alignment must be a small power of two, not %d", value
);
857 initial_max_fld_align
= value
;
858 maximum_field_alignment
= value
* BITS_PER_UNIT
;
862 case OPT_fpeel_loops
:
863 flag_peel_loops_set
= true;
866 case OPT_fprofile_arcs
:
867 profile_arc_flag_set
= true;
870 case OPT_fprofile_use
:
871 if (!flag_branch_probabilities_set
)
872 flag_branch_probabilities
= value
;
873 if (!flag_profile_values_set
)
874 flag_profile_values
= value
;
875 if (!flag_unroll_loops_set
)
876 flag_unroll_loops
= value
;
877 if (!flag_peel_loops_set
)
878 flag_peel_loops
= value
;
879 if (!flag_tracer_set
)
881 if (!flag_value_profile_transformations_set
)
882 flag_value_profile_transformations
= value
;
884 if (0 && !flag_speculative_prefetching_set
)
885 flag_speculative_prefetching
= value
;
889 case OPT_fprofile_generate
:
890 if (!profile_arc_flag_set
)
891 profile_arc_flag
= value
;
892 if (!flag_profile_values_set
)
893 flag_profile_values
= value
;
894 if (!flag_value_profile_transformations_set
)
895 flag_value_profile_transformations
= value
;
896 if (!flag_unroll_loops_set
)
897 flag_unroll_loops
= value
;
899 if (0 && !flag_speculative_prefetching_set
)
900 flag_speculative_prefetching
= value
;
904 case OPT_fprofile_values
:
905 flag_profile_values_set
= true;
908 case OPT_fvisibility_
:
910 if (!strcmp(arg
, "default"))
911 default_visibility
= VISIBILITY_DEFAULT
;
912 else if (!strcmp(arg
, "internal"))
913 default_visibility
= VISIBILITY_INTERNAL
;
914 else if (!strcmp(arg
, "hidden"))
915 default_visibility
= VISIBILITY_HIDDEN
;
916 else if (!strcmp(arg
, "protected"))
917 default_visibility
= VISIBILITY_PROTECTED
;
919 error ("unrecognized visibility value \"%s\"", arg
);
924 flag_value_profile_transformations_set
= true;
927 case OPT_fspeculative_prefetching
:
928 flag_speculative_prefetching_set
= true;
931 case OPT_frandom_seed
:
932 /* The real switch is -fno-random-seed. */
935 flag_random_seed
= NULL
;
938 case OPT_frandom_seed_
:
939 flag_random_seed
= arg
;
942 case OPT_fsched_verbose_
:
943 #ifdef INSN_SCHEDULING
944 fix_sched_param ("verbose", arg
);
950 case OPT_fsched_stalled_insns_
:
951 flag_sched_stalled_insns
= value
;
952 if (flag_sched_stalled_insns
== 0)
953 flag_sched_stalled_insns
= -1;
956 case OPT_fsched_stalled_insns_dep_
:
957 flag_sched_stalled_insns_dep
= value
;
960 case OPT_fstack_limit
:
961 /* The real switch is -fno-stack-limit. */
964 stack_limit_rtx
= NULL_RTX
;
967 case OPT_fstack_limit_register_
:
969 int reg
= decode_reg_name (arg
);
971 error ("unrecognized register name \"%s\"", arg
);
973 stack_limit_rtx
= gen_rtx_REG (Pmode
, reg
);
977 case OPT_fstack_limit_symbol_
:
978 stack_limit_rtx
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (arg
));
981 case OPT_ftree_vectorizer_verbose_
:
982 vect_set_verbosity_level (arg
);
985 case OPT_ftls_model_
:
986 if (!strcmp (arg
, "global-dynamic"))
987 flag_tls_default
= TLS_MODEL_GLOBAL_DYNAMIC
;
988 else if (!strcmp (arg
, "local-dynamic"))
989 flag_tls_default
= TLS_MODEL_LOCAL_DYNAMIC
;
990 else if (!strcmp (arg
, "initial-exec"))
991 flag_tls_default
= TLS_MODEL_INITIAL_EXEC
;
992 else if (!strcmp (arg
, "local-exec"))
993 flag_tls_default
= TLS_MODEL_LOCAL_EXEC
;
995 warning (0, "unknown tls-model \"%s\"", arg
);
999 flag_tracer_set
= true;
1002 case OPT_funroll_loops
:
1003 flag_unroll_loops_set
= true;
1007 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
);
1011 set_debug_level (SDB_DEBUG
, false, arg
);
1015 set_debug_level (DWARF2_DEBUG
, false, arg
);
1019 set_debug_level (NO_DEBUG
, 2, arg
);
1024 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
);
1028 set_debug_level (VMS_DEBUG
, false, arg
);
1033 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
);
1037 asm_file_name
= arg
;
1040 case OPT_pedantic_errors
:
1041 flag_pedantic_errors
= pedantic
= 1;
1045 /* If the flag was handled in a standard way, assume the lack of
1046 processing here is intentional. */
1047 gcc_assert (cl_options
[scode
].flag_var
);
1054 /* Handle --param NAME=VALUE. */
1056 handle_param (const char *carg
)
1061 arg
= xstrdup (carg
);
1062 equal
= strchr (arg
, '=');
1064 error ("%s: --param arguments should be of the form NAME=VALUE", arg
);
1067 value
= integral_argument (equal
+ 1);
1069 error ("invalid --param value %qs", equal
+ 1);
1073 set_param_value (arg
, value
);
1080 /* Handle -W and -Wextra. */
1082 set_Wextra (int setting
)
1084 extra_warnings
= setting
;
1085 warn_unused_value
= setting
;
1086 warn_unused_parameter
= (setting
&& maybe_warn_unused_parameter
);
1088 /* We save the value of warn_uninitialized, since if they put
1089 -Wuninitialized on the command line, we need to generate a
1090 warning about not using it without also specifying -O. */
1092 warn_uninitialized
= 0;
1093 else if (warn_uninitialized
!= 1)
1094 warn_uninitialized
= 2;
1097 /* Initialize unused warning flags. */
1099 set_Wunused (int setting
)
1101 warn_unused_function
= setting
;
1102 warn_unused_label
= setting
;
1103 /* Unused function parameter warnings are reported when either
1104 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1105 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1106 otherwise set maybe_warn_extra_parameter, which will be picked up
1108 maybe_warn_unused_parameter
= setting
;
1109 warn_unused_parameter
= (setting
&& extra_warnings
);
1110 warn_unused_variable
= setting
;
1111 warn_unused_value
= setting
;
1114 /* The following routines are useful in setting all the flags that
1115 -ffast-math and -fno-fast-math imply. */
1117 set_fast_math_flags (int set
)
1119 flag_trapping_math
= !set
;
1120 flag_unsafe_math_optimizations
= set
;
1121 flag_finite_math_only
= set
;
1122 flag_errno_math
= !set
;
1125 flag_signaling_nans
= 0;
1126 flag_rounding_math
= 0;
1127 flag_cx_limited_range
= 1;
1131 /* Return true iff flags are set as if -ffast-math. */
1133 fast_math_flags_set_p (void)
1135 return (!flag_trapping_math
1136 && flag_unsafe_math_optimizations
1137 && flag_finite_math_only
1138 && !flag_errno_math
);
1141 /* Handle a debug output -g switch. EXTENDED is true or false to support
1142 extended output (2 is special and means "-ggdb" was given). */
1144 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
)
1146 static bool type_explicit
;
1148 use_gnu_debug_info_extensions
= extended
;
1150 if (type
== NO_DEBUG
)
1152 if (write_symbols
== NO_DEBUG
)
1154 write_symbols
= PREFERRED_DEBUGGING_TYPE
;
1158 #ifdef DWARF2_DEBUGGING_INFO
1159 write_symbols
= DWARF2_DEBUG
;
1160 #elif defined DBX_DEBUGGING_INFO
1161 write_symbols
= DBX_DEBUG
;
1165 if (write_symbols
== NO_DEBUG
)
1166 warning (0, "target system does not support debug output");
1171 /* Does it conflict with an already selected type? */
1172 if (type_explicit
&& write_symbols
!= NO_DEBUG
&& type
!= write_symbols
)
1173 error ("debug format \"%s\" conflicts with prior selection",
1174 debug_type_names
[type
]);
1175 write_symbols
= type
;
1176 type_explicit
= true;
1179 /* A debug flag without a level defaults to level 2. */
1182 if (!debug_info_level
)
1183 debug_info_level
= 2;
1187 debug_info_level
= integral_argument (arg
);
1188 if (debug_info_level
== (unsigned int) -1)
1189 error ("unrecognised debug output level \"%s\"", arg
);
1190 else if (debug_info_level
> 3)
1191 error ("debug output level %s is too high", arg
);
1195 /* Display help for target options. */
1197 print_target_help (void)
1200 static bool displayed
= false;
1202 /* Avoid double printing for --help --target-help. */
1207 for (i
= 0; i
< cl_options_count
; i
++)
1208 if ((cl_options
[i
].flags
& (CL_TARGET
| CL_UNDOCUMENTED
)) == CL_TARGET
)
1210 printf (_("\nTarget specific options:\n"));
1211 print_filtered_help (CL_TARGET
);
1216 /* Output --help text. */
1223 GET_ENVIRONMENT (p
, "COLUMNS");
1226 int value
= atoi (p
);
1231 puts (_("The following options are language-independent:\n"));
1233 print_filtered_help (CL_COMMON
);
1234 print_param_help ();
1236 for (i
= 0; lang_names
[i
]; i
++)
1238 printf (_("The %s front end recognizes the following options:\n\n"),
1240 print_filtered_help (1U << i
);
1242 print_target_help ();
1245 /* Print the help for --param. */
1247 print_param_help (void)
1251 puts (_("The --param option recognizes the following as parameters:\n"));
1253 for (i
= 0; i
< LAST_PARAM
; i
++)
1255 const char *help
= compiler_params
[i
].help
;
1256 const char *param
= compiler_params
[i
].option
;
1258 if (help
== NULL
|| *help
== '\0')
1259 help
= undocumented_msg
;
1261 /* Get the translation. */
1264 wrap_help (help
, param
, strlen (param
));
1270 /* Print help for a specific front-end, etc. */
1272 print_filtered_help (unsigned int flag
)
1274 unsigned int i
, len
, filter
, indent
= 0;
1275 bool duplicates
= false;
1276 const char *help
, *opt
, *tab
;
1277 static char *printed
;
1279 if (flag
== CL_COMMON
|| flag
== CL_TARGET
)
1283 printed
= xmalloc (cl_options_count
);
1284 memset (printed
, 0, cl_options_count
);
1288 /* Don't print COMMON options twice. */
1289 filter
= flag
| CL_COMMON
;
1291 for (i
= 0; i
< cl_options_count
; i
++)
1293 if ((cl_options
[i
].flags
& filter
) != flag
)
1296 /* Skip help for internal switches. */
1297 if (cl_options
[i
].flags
& CL_UNDOCUMENTED
)
1300 /* Skip switches that have already been printed, mark them to be
1305 indent
= print_switch (cl_options
[i
].opt_text
, indent
);
1316 for (i
= 0; i
< cl_options_count
; i
++)
1318 if ((cl_options
[i
].flags
& filter
) != flag
)
1321 /* Skip help for internal switches. */
1322 if (cl_options
[i
].flags
& CL_UNDOCUMENTED
)
1325 /* Skip switches that have already been printed. */
1331 help
= cl_options
[i
].help
;
1333 help
= undocumented_msg
;
1335 /* Get the translation. */
1338 tab
= strchr (help
, '\t');
1347 opt
= cl_options
[i
].opt_text
;
1351 wrap_help (help
, opt
, len
);
1357 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1358 word-wrapped HELP in a second column. */
1360 print_switch (const char *text
, unsigned int indent
)
1362 unsigned int len
= strlen (text
) + 1; /* trailing comma */
1367 if (indent
+ len
> columns
)
1378 fputs (text
, stdout
);
1380 return indent
+ len
+ 1;
1383 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1384 word-wrapped HELP in a second column. */
1386 wrap_help (const char *help
, const char *item
, unsigned int item_width
)
1388 unsigned int col_width
= 27;
1389 unsigned int remaining
, room
, len
;
1391 remaining
= strlen (help
);
1395 room
= columns
- 3 - MAX (col_width
, item_width
);
1404 for (i
= 0; help
[i
]; i
++)
1406 if (i
>= room
&& len
!= remaining
)
1410 else if ((help
[i
] == '-' || help
[i
] == '/')
1411 && help
[i
+ 1] != ' '
1412 && i
> 0 && ISALPHA (help
[i
- 1]))
1417 printf( " %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1419 while (help
[len
] == ' ')
1427 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
1428 a simple on-off switch. */
1431 option_enabled (int opt_idx
)
1433 const struct cl_option
*option
= &(cl_options
[opt_idx
]);
1434 if (option
->flag_var
)
1435 switch (option
->var_type
)
1438 return *(int *) option
->flag_var
!= 0;
1441 return *(int *) option
->flag_var
== option
->var_value
;
1443 case CLVC_BIT_CLEAR
:
1444 return (*(int *) option
->flag_var
& option
->var_value
) == 0;
1447 return (*(int *) option
->flag_var
& option
->var_value
) != 0;
1455 /* Fill STATE with the current state of option OPTION. Return true if
1456 there is some state to store. */
1459 get_option_state (int option
, struct cl_option_state
*state
)
1461 if (cl_options
[option
].flag_var
== 0)
1464 switch (cl_options
[option
].var_type
)
1468 state
->data
= cl_options
[option
].flag_var
;
1469 state
->size
= sizeof (int);
1472 case CLVC_BIT_CLEAR
:
1474 state
->ch
= option_enabled (option
);
1475 state
->data
= &state
->ch
;
1480 state
->data
= *(const char **) cl_options
[option
].flag_var
;
1481 if (state
->data
== 0)
1483 state
->size
= strlen (state
->data
) + 1;