1 /* Command line option handling.
2 Copyright (C) 2002, 2003 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. */
41 /* Value of the -G xx switch, and whether it was passed or not. */
42 unsigned HOST_WIDE_INT g_switch_value
;
45 /* True if we should exit after parsing options. */
46 bool exit_after_options
;
51 /* Print various extra warnings. -W/-Wextra. */
54 /* Don't print warning messages. -w. */
55 bool inhibit_warnings
;
57 /* Treat warnings as errors. -Werror. */
58 bool warnings_are_errors
;
60 /* Warn if a function returns an aggregate, since there are often
61 incompatible calling conventions for doing this. */
62 bool warn_aggregate_return
;
64 /* Nonzero means warn about pointer casts that increase the required
65 alignment of the target type (and might therefore lead to a crash
66 due to a misaligned access). */
69 /* Nonzero means warn about uses of __attribute__((deprecated))
71 bool warn_deprecated_decl
= true;
73 /* Warn when an optimization pass is disabled. */
74 bool warn_disabled_optimization
;
76 /* Nonzero means warn if inline function is too large. */
79 /* True to warn about any objects definitions whose size is larger
80 than N bytes. Also want about function definitions whose returned
81 values are larger than N bytes, where N is `larger_than_size'. */
82 bool warn_larger_than
;
83 HOST_WIDE_INT larger_than_size
;
85 /* Warn about functions which might be candidates for attribute noreturn. */
86 bool warn_missing_noreturn
;
88 /* True to warn about code which is never reached. */
91 /* Warn if packed attribute on struct is unnecessary and inefficient. */
94 /* Warn when gcc pads a structure to an alignment boundary. */
97 /* True means warn about all declarations which shadow others. */
100 /* Nonzero means warn about constructs which might not be
101 strict-aliasing safe. */
102 bool warn_strict_aliasing
;
104 /* True to warn if a switch on an enum, that does not have a default
105 case, fails to have a case for every enum value. */
108 /* Warn if a switch does not have a default case. */
109 bool warn_switch_default
;
111 /* Warn if a switch on an enum fails to have a case for every enum
112 value (regardless of the presence or otherwise of a default case). */
113 bool warn_switch_enum
;
115 /* Don't suppress warnings from system headers. -Wsystem-headers. */
116 bool warn_system_headers
;
118 /* True to warn about variables used before they are initialized. */
119 int warn_uninitialized
;
121 /* True to warn about unused variables, functions et.al. */
122 bool warn_unused_function
;
123 bool warn_unused_label
;
124 bool warn_unused_parameter
;
125 bool warn_unused_variable
;
126 bool warn_unused_value
;
128 /* Hack for cooperation between set_Wunused and set_Wextra. */
129 static bool maybe_warn_unused_parameter
;
131 /* Columns of --help display. */
132 static unsigned int columns
= 80;
134 /* What to print when a switch has no documentation. */
135 static const char undocumented_msg
[] = N_("This switch lacks documentation");
137 static size_t find_opt (const char *, int);
138 static int common_handle_option (size_t scode
, const char *arg
, int value
);
139 static void handle_param (const char *);
140 static void set_Wextra (int);
141 static unsigned int handle_option (const char **argv
, unsigned int lang_mask
);
142 static char *write_langs (unsigned int lang_mask
);
143 static void complain_wrong_lang (const char *, const struct cl_option
*,
144 unsigned int lang_mask
);
145 static void handle_options (unsigned int, const char **, unsigned int);
146 static void wrap_help (const char *help
, const char *item
, unsigned int);
147 static void print_help (void);
148 static void print_param_help (void);
149 static void print_filtered_help (unsigned int flag
);
150 static unsigned int print_switch (const char *text
, unsigned int indent
);
152 /* Perform a binary search to find which option the command-line INPUT
153 matches. Returns its index in the option array, and N_OPTS
154 (cl_options_count) on failure.
156 This routine is quite subtle. A normal binary search is not good
157 enough because some options can be suffixed with an argument, and
158 multiple sub-matches can occur, e.g. input of "-pedantic" matching
159 the initial substring of "-pedantic-errors".
161 A more complicated example is -gstabs. It should match "-g" with
162 an argument of "stabs". Suppose, however, that the number and list
163 of switches are such that the binary search tests "-gen-decls"
164 before having tested "-g". This doesn't match, and as "-gen-decls"
165 is less than "-gstabs", it will become the lower bound of the
166 binary search range, and "-g" will never be seen. To resolve this
167 issue, opts.sh makes "-gen-decls" point, via the back_chain member,
168 to "-g" so that failed searches that end between "-gen-decls" and
169 the lexicographically subsequent switch know to go back and see if
170 "-g" causes a match (which it does in this example).
172 This search is done in such a way that the longest match for the
173 front end in question wins. If there is no match for the current
174 front end, the longest match for a different front end is returned
175 (or N_OPTS if none) and the caller emits an error message. */
177 find_opt (const char *input
, int lang_mask
)
179 size_t mn
, mx
, md
, opt_len
;
180 size_t match_wrong_lang
;
184 mx
= cl_options_count
;
186 /* Find mn such this lexicographical inequality holds:
187 cl_options[mn] <= input < cl_options[mn + 1]. */
191 opt_len
= cl_options
[md
].opt_len
;
192 comp
= strncmp (input
, cl_options
[md
].opt_text
+ 1, opt_len
);
200 /* This is the switch that is the best match but for a different
201 front end, or cl_options_count if there is no match at all. */
202 match_wrong_lang
= cl_options_count
;
204 /* Backtrace the chain of possible matches, returning the longest
205 one, if any, that fits best. With current GCC switches, this
206 loop executes at most twice. */
209 const struct cl_option
*opt
= &cl_options
[mn
];
211 /* Is this switch a prefix of the input? */
212 if (!strncmp (input
, opt
->opt_text
+ 1, opt
->opt_len
))
214 /* If language is OK, and the match is exact or the switch
215 takes a joined argument, return it. */
216 if ((opt
->flags
& lang_mask
)
217 && (input
[opt
->opt_len
] == '\0' || (opt
->flags
& CL_JOINED
)))
220 /* If we haven't remembered a prior match, remember this
221 one. Any prior match is necessarily better. */
222 if (match_wrong_lang
== cl_options_count
)
223 match_wrong_lang
= mn
;
226 /* Try the next possibility. This is cl_options_count if there
228 mn
= opt
->back_chain
;
230 while (mn
!= cl_options_count
);
232 /* Return the best wrong match, or cl_options_count if none. */
233 return match_wrong_lang
;
236 /* If ARG is a non-negative integer made up solely of digits, return its
237 value, otherwise return -1. */
239 integral_argument (const char *arg
)
243 while (*p
&& ISDIGIT (*p
))
252 /* Return a malloced slash-separated list of languages in MASK. */
254 write_langs (unsigned int mask
)
256 unsigned int n
= 0, len
= 0;
257 const char *lang_name
;
260 for (n
= 0; (lang_name
= lang_names
[n
]) != 0; n
++)
261 if (mask
& (1U << n
))
262 len
+= strlen (lang_name
) + 1;
264 result
= xmalloc (len
);
266 for (n
= 0; (lang_name
= lang_names
[n
]) != 0; n
++)
267 if (mask
& (1U << n
))
271 strcpy (result
+ len
, lang_name
);
272 len
+= strlen (lang_name
);
280 /* Complain that switch OPT_INDEX does not apply to this front end. */
282 complain_wrong_lang (const char *text
, const struct cl_option
*option
,
283 unsigned int lang_mask
)
285 char *ok_langs
, *bad_lang
;
287 ok_langs
= write_langs (option
->flags
);
288 bad_lang
= write_langs (lang_mask
);
290 /* Eventually this should become a hard error IMO. */
291 warning ("command line option \"%s\" is valid for %s but not for %s",
292 text
, ok_langs
, bad_lang
);
298 /* Handle the switch beginning at ARGV for the language indicated by
299 LANG_MASK. Returns the number of switches consumed. */
301 handle_option (const char **argv
, unsigned int lang_mask
)
304 const char *opt
, *arg
= 0;
307 unsigned int result
= 0;
308 const struct cl_option
*option
;
312 /* Drop the "no-" from negative switches. */
313 if ((opt
[1] == 'W' || opt
[1] == 'f')
314 && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-')
316 size_t len
= strlen (opt
) - 3;
318 dup
= xmalloc (len
+ 1);
321 memcpy (dup
+ 2, opt
+ 5, len
- 2 + 1);
326 opt_index
= find_opt (opt
+ 1, lang_mask
| CL_COMMON
);
327 if (opt_index
== cl_options_count
)
330 option
= &cl_options
[opt_index
];
332 /* Reject negative form of switches that don't take negatives as
334 if (!value
&& (option
->flags
& CL_REJECT_NEGATIVE
))
337 /* We've recognized this switch. */
340 /* Sort out any argument the switch takes. */
341 if (option
->flags
& CL_JOINED
)
343 /* Have arg point to the original switch. This is because
344 some code, such as disable_builtin_function, expects its
345 argument to be persistent until the program exits. */
346 arg
= argv
[0] + cl_options
[opt_index
].opt_len
+ 1;
348 arg
+= strlen ("no-");
350 if (*arg
== '\0' && !(option
->flags
& CL_MISSING_OK
))
352 if (option
->flags
& CL_SEPARATE
)
358 /* Missing argument. */
362 else if (option
->flags
& CL_SEPARATE
)
368 /* Now we've swallowed any potential argument, complain if this
369 is a switch for a different front end. */
370 if (!(option
->flags
& (lang_mask
| CL_COMMON
)))
372 complain_wrong_lang (argv
[0], option
, lang_mask
);
376 if (arg
== NULL
&& (option
->flags
& (CL_JOINED
| CL_SEPARATE
)))
378 if (!(*lang_hooks
.missing_argument
) (opt
, opt_index
))
379 error ("missing argument to \"%s\"", opt
);
383 /* If the switch takes an integer, convert it. */
384 if (arg
&& (option
->flags
& CL_UINTEGER
))
386 value
= integral_argument (arg
);
389 error ("argument to \"%s\" should be a non-negative integer",
395 if (option
->flags
& lang_mask
)
396 if ((*lang_hooks
.handle_option
) (opt_index
, arg
, value
) == 0)
399 if (result
&& (option
->flags
& CL_COMMON
))
400 if (common_handle_option (opt_index
, arg
, value
) == 0)
409 /* Decode and handle the vector of command line options. LANG_MASK
410 contains has a single bit set representing the current
413 handle_options (unsigned int argc
, const char **argv
, unsigned int lang_mask
)
417 for (i
= 1; i
< argc
; i
+= n
)
419 const char *opt
= argv
[i
];
421 /* Interpret "-" or a non-switch as a file name. */
422 if (opt
[0] != '-' || opt
[1] == '\0')
424 main_input_filename
= opt
;
425 (*lang_hooks
.handle_filename
) (opt
);
430 n
= handle_option (argv
+ i
, lang_mask
);
435 error ("unrecognized command line option \"%s\"", opt
);
440 /* Parse command line options and set default flag values. Do minimal
441 options processing. */
443 decode_options (unsigned int argc
, const char **argv
)
445 unsigned int i
, lang_mask
;
447 /* Perform language-specific options initialization. */
448 lang_mask
= (*lang_hooks
.init_options
) (argc
, argv
);
450 /* Scan to see what optimization level has been specified. That will
451 determine the default value of many flags. */
452 for (i
= 1; i
< argc
; i
++)
454 if (!strcmp (argv
[i
], "-O"))
459 else if (argv
[i
][0] == '-' && argv
[i
][1] == 'O')
461 /* Handle -Os, -O2, -O3, -O69, ... */
462 const char *p
= &argv
[i
][2];
464 if ((p
[0] == 's') && (p
[1] == 0))
468 /* Optimizing for size forces optimize to be 2. */
473 const int optimize_val
= read_integral_parameter (p
, p
- 2, -1);
474 if (optimize_val
!= -1)
476 optimize
= optimize_val
;
485 flag_merge_constants
= 0;
491 flag_thread_jumps
= 1;
493 flag_delayed_branch
= 1;
495 #ifdef CAN_DEBUG_WITHOUT_FP
496 flag_omit_frame_pointer
= 1;
498 flag_guess_branch_prob
= 1;
499 flag_cprop_registers
= 1;
500 flag_loop_optimize
= 1;
501 flag_crossjumping
= 1;
502 flag_if_conversion
= 1;
503 flag_if_conversion2
= 1;
508 flag_optimize_sibling_calls
= 1;
509 flag_cse_follow_jumps
= 1;
510 flag_cse_skip_blocks
= 1;
512 flag_expensive_optimizations
= 1;
513 flag_strength_reduce
= 1;
514 flag_rerun_cse_after_loop
= 1;
515 flag_rerun_loop_opt
= 1;
516 flag_caller_saves
= 1;
519 #ifdef INSN_SCHEDULING
520 flag_schedule_insns
= 1;
521 flag_schedule_insns_after_reload
= 1;
524 flag_strict_aliasing
= 1;
525 flag_delete_null_pointer_checks
= 1;
526 flag_reorder_blocks
= 1;
527 flag_reorder_functions
= 1;
532 flag_inline_functions
= 1;
533 flag_rename_registers
= 1;
534 flag_unswitch_loops
= 1;
535 flag_unit_at_a_time
= 1;
538 if (optimize
< 2 || optimize_size
)
545 /* Don't reorder blocks when optimizing for size because extra
546 jump insns may be created; also barrier may create extra padding.
548 More correctly we should have a block reordering mode that tried
549 to minimize the combined size of all the jumps. This would more
550 or less automatically remove extra jumps, but would also try to
551 use more short jumps instead of long jumps. */
552 flag_reorder_blocks
= 0;
555 /* Initialize whether `char' is signed. */
556 flag_signed_char
= DEFAULT_SIGNED_CHAR
;
557 #ifdef DEFAULT_SHORT_ENUMS
558 /* Initialize how much space enums occupy, by default. */
559 flag_short_enums
= DEFAULT_SHORT_ENUMS
;
562 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
565 set_target_switch ("");
567 /* Unwind tables are always present in an ABI-conformant IA-64
568 object file, so the default should be ON. */
569 #ifdef IA64_UNWIND_INFO
570 flag_unwind_tables
= IA64_UNWIND_INFO
;
573 #ifdef OPTIMIZATION_OPTIONS
574 /* Allow default optimizations to be specified on a per-machine basis. */
575 OPTIMIZATION_OPTIONS (optimize
, optimize_size
);
578 handle_options (argc
, argv
, lang_mask
);
582 if (flag_pic
&& !flag_pie
)
585 if (flag_no_inline
== 2)
588 flag_really_no_inline
= flag_no_inline
;
590 /* Set flag_no_inline before the post_options () hook. The C front
591 ends use it to determine tree inlining defaults. FIXME: such
592 code should be lang-independent when all front ends use tree
593 inlining, in which case it, and this condition, should be moved
594 to the top of process_options() instead. */
597 /* Inlining does not work if not optimizing,
598 so force it not to be done. */
602 /* The c_decode_option function and decode_option hook set
603 this to `2' if -Wall is used, so we can avoid giving out
604 lots of errors for people who don't realize what -Wall does. */
605 if (warn_uninitialized
== 1)
606 warning ("-Wuninitialized is not supported without -O");
609 if (flag_really_no_inline
== 2)
610 flag_really_no_inline
= flag_no_inline
;
613 /* Handle target- and language-independent options. Return zero to
614 generate an "unknown option" message. */
616 common_handle_option (size_t scode
, const char *arg
,
617 int value ATTRIBUTE_UNUSED
)
619 enum opt_code code
= (enum opt_code
) scode
;
628 exit_after_options
= true;
635 case OPT__target_help
:
636 display_target_options ();
637 exit_after_options
= true;
641 print_version (stderr
, "");
642 exit_after_options
= true;
646 g_switch_value
= value
;
652 /* Currently handled in a prescan. */
656 /* For backward compatibility, -W is the same as -Wextra. */
660 case OPT_Waggregate_return
:
661 warn_aggregate_return
= value
;
664 case OPT_Wcast_align
:
665 warn_cast_align
= value
;
668 case OPT_Wdeprecated_declarations
:
669 warn_deprecated_decl
= value
;
672 case OPT_Wdisabled_optimization
:
673 warn_disabled_optimization
= value
;
677 warnings_are_errors
= value
;
688 case OPT_Wlarger_than_
:
689 larger_than_size
= value
;
690 warn_larger_than
= value
!= -1;
693 case OPT_Wmissing_noreturn
:
694 warn_missing_noreturn
= value
;
709 case OPT_Wstrict_aliasing
:
710 warn_strict_aliasing
= value
;
717 case OPT_Wswitch_default
:
718 warn_switch_default
= value
;
721 case OPT_Wswitch_enum
:
722 warn_switch_enum
= value
;
725 case OPT_Wsystem_headers
:
726 warn_system_headers
= value
;
729 case OPT_Wuninitialized
:
730 warn_uninitialized
= value
;
733 case OPT_Wunreachable_code
:
734 warn_notreached
= value
;
741 case OPT_Wunused_function
:
742 warn_unused_function
= value
;
745 case OPT_Wunused_label
:
746 warn_unused_label
= value
;
749 case OPT_Wunused_parameter
:
750 warn_unused_parameter
= value
;
753 case OPT_Wunused_value
:
754 warn_unused_value
= value
;
757 case OPT_Wunused_variable
:
758 warn_unused_variable
= value
;
763 aux_info_file_name
= arg
;
764 flag_gen_aux_info
= 1;
771 case OPT_auxbase_strip
:
773 char *tmp
= xstrdup (arg
);
774 strip_off_ending (tmp
, strlen (tmp
));
781 decode_d_option (arg
);
785 dump_base_name
= arg
;
789 flag_pic
= value
+ value
;
793 flag_pie
= value
+ value
;
796 case OPT_falign_functions
:
797 align_functions
= !value
;
800 case OPT_falign_functions_
:
801 align_functions
= value
;
804 case OPT_falign_jumps
:
805 align_jumps
= !value
;
808 case OPT_falign_jumps_
:
812 case OPT_falign_labels
:
813 align_labels
= !value
;
816 case OPT_falign_labels_
:
817 align_labels
= value
;
820 case OPT_falign_loops
:
821 align_loops
= !value
;
824 case OPT_falign_loops_
:
828 case OPT_fargument_alias
:
829 flag_argument_noalias
= !value
;
832 case OPT_fargument_noalias
:
833 flag_argument_noalias
= value
;
836 case OPT_fargument_noalias_global
:
837 flag_argument_noalias
= value
+ value
;
840 case OPT_fasynchronous_unwind_tables
:
841 flag_asynchronous_unwind_tables
= value
;
844 case OPT_fbounds_check
:
845 flag_bounds_check
= value
;
848 case OPT_fbranch_count_reg
:
849 flag_branch_on_count_reg
= value
;
852 case OPT_fbranch_probabilities
:
853 flag_branch_probabilities
= value
;
856 case OPT_fbranch_target_load_optimize
:
857 flag_branch_target_load_optimize
= value
;
860 case OPT_fbranch_target_load_optimize2
:
861 flag_branch_target_load_optimize2
= value
;
864 case OPT_fcall_used_
:
865 fix_register (arg
, 0, 1);
868 case OPT_fcall_saved_
:
869 fix_register (arg
, 0, 0);
872 case OPT_fcaller_saves
:
873 flag_caller_saves
= value
;
877 flag_no_common
= !value
;
880 case OPT_fcprop_registers
:
881 flag_cprop_registers
= value
;
884 case OPT_fcrossjumping
:
885 flag_crossjumping
= value
;
888 case OPT_fcse_follow_jumps
:
889 flag_cse_follow_jumps
= value
;
892 case OPT_fcse_skip_blocks
:
893 flag_cse_skip_blocks
= value
;
896 case OPT_fdata_sections
:
897 flag_data_sections
= value
;
901 flag_defer_pop
= value
;
904 case OPT_fdelayed_branch
:
905 flag_delayed_branch
= value
;
908 case OPT_fdelete_null_pointer_checks
:
909 flag_delete_null_pointer_checks
= value
;
912 case OPT_fdiagnostics_show_location_
:
913 if (!strcmp (arg
, "once"))
914 diagnostic_prefixing_rule (global_dc
) = DIAGNOSTICS_SHOW_PREFIX_ONCE
;
915 else if (!strcmp (arg
, "every-line"))
916 diagnostic_prefixing_rule (global_dc
)
917 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE
;
922 case OPT_fdump_unnumbered
:
923 flag_dump_unnumbered
= value
;
926 case OPT_feliminate_dwarf2_dups
:
927 flag_eliminate_dwarf2_dups
= value
;
930 case OPT_feliminate_unused_debug_types
:
931 flag_eliminate_unused_debug_types
= value
;
934 case OPT_feliminate_unused_debug_symbols
:
935 flag_debug_only_used_symbols
= value
;
938 case OPT_fexceptions
:
939 flag_exceptions
= value
;
942 case OPT_fexpensive_optimizations
:
943 flag_expensive_optimizations
= value
;
947 set_fast_math_flags (value
);
950 case OPT_ffinite_math_only
:
951 flag_finite_math_only
= value
;
955 fix_register (arg
, 1, 1);
958 case OPT_ffunction_cse
:
959 flag_no_function_cse
= !value
;
962 case OPT_ffloat_store
:
963 flag_float_store
= value
;
966 case OPT_fforce_addr
:
967 flag_force_addr
= value
;
971 flag_force_mem
= value
;
974 case OPT_ffunction_sections
:
975 flag_function_sections
= value
;
983 flag_gcse_lm
= value
;
987 flag_gcse_sm
= value
;
990 case OPT_fgnu_linker
:
991 flag_gnu_linker
= value
;
994 case OPT_fguess_branch_probability
:
995 flag_guess_branch_prob
= value
;
999 flag_no_ident
= !value
;
1002 case OPT_fif_conversion
:
1003 flag_if_conversion
= value
;
1006 case OPT_fif_conversion2
:
1007 flag_if_conversion2
= value
;
1010 case OPT_finhibit_size_directive
:
1011 flag_inhibit_size_directive
= value
;
1015 flag_no_inline
= !value
;
1018 case OPT_finline_functions
:
1019 flag_inline_functions
= value
;
1022 case OPT_finline_limit_
:
1023 case OPT_finline_limit_eq
:
1024 set_param_value ("max-inline-insns", value
);
1025 set_param_value ("max-inline-insns-single", value
/ 2);
1026 set_param_value ("max-inline-insns-auto", value
/ 2);
1027 set_param_value ("max-inline-insns-rtl", value
);
1028 if (value
/ 4 < MIN_INLINE_INSNS
)
1031 set_param_value ("min-inline-insns", value
/ 4);
1033 set_param_value ("min-inline-insns", 10);
1037 case OPT_finstrument_functions
:
1038 flag_instrument_function_entry_exit
= value
;
1041 case OPT_fkeep_inline_functions
:
1042 flag_keep_inline_functions
=value
;
1045 case OPT_fkeep_static_consts
:
1046 flag_keep_static_consts
= value
;
1049 case OPT_fleading_underscore
:
1050 flag_leading_underscore
= value
;
1053 case OPT_floop_optimize
:
1054 flag_loop_optimize
= value
;
1057 case OPT_fmath_errno
:
1058 flag_errno_math
= value
;
1061 case OPT_fmem_report
:
1065 case OPT_fmerge_all_constants
:
1066 flag_merge_constants
= value
+ value
;
1069 case OPT_fmerge_constants
:
1070 flag_merge_constants
= value
;
1073 case OPT_fmessage_length_
:
1074 output_set_maximum_length (&global_dc
->buffer
, value
);
1077 case OPT_fmove_all_movables
:
1078 flag_move_all_movables
= value
;
1082 flag_new_regalloc
= value
;
1085 case OPT_fnon_call_exceptions
:
1086 flag_non_call_exceptions
= value
;
1089 case OPT_fold_unroll_all_loops
:
1090 flag_old_unroll_all_loops
= value
;
1093 case OPT_fold_unroll_loops
:
1094 flag_old_unroll_loops
= value
;
1097 case OPT_fomit_frame_pointer
:
1098 flag_omit_frame_pointer
= value
;
1101 case OPT_foptimize_register_move
:
1102 flag_regmove
= value
;
1105 case OPT_foptimize_sibling_calls
:
1106 flag_optimize_sibling_calls
= value
;
1109 case OPT_fpack_struct
:
1110 flag_pack_struct
= value
;
1113 case OPT_fpeel_loops
:
1114 flag_peel_loops
= value
;
1117 case OPT_fpcc_struct_return
:
1118 flag_pcc_struct_return
= value
;
1122 flag_no_peephole
= !value
;
1125 case OPT_fpeephole2
:
1126 flag_peephole2
= value
;
1137 case OPT_fprefetch_loop_arrays
:
1138 flag_prefetch_loop_arrays
= value
;
1142 profile_flag
= value
;
1145 case OPT_fprofile_arcs
:
1146 profile_arc_flag
= value
;
1149 case OPT_frandom_seed
:
1150 /* The real switch is -fno-random-seed. */
1153 flag_random_seed
= NULL
;
1156 case OPT_frandom_seed_
:
1157 flag_random_seed
= arg
;
1160 case OPT_freduce_all_givs
:
1161 flag_reduce_all_givs
= value
;
1164 case OPT_freg_struct_return
:
1165 flag_pcc_struct_return
= !value
;
1169 flag_regmove
= value
;
1172 case OPT_frename_registers
:
1173 flag_rename_registers
= value
;
1176 case OPT_freorder_blocks
:
1177 flag_reorder_blocks
= value
;
1180 case OPT_freorder_functions
:
1181 flag_reorder_functions
= value
;
1184 case OPT_frerun_cse_after_loop
:
1185 flag_rerun_cse_after_loop
= value
;
1188 case OPT_frerun_loop_opt
:
1189 flag_rerun_loop_opt
= value
;
1192 case OPT_fsched_interblock
:
1193 flag_schedule_interblock
= value
;
1196 case OPT_fsched_spec
:
1197 flag_schedule_speculative
= value
;
1200 case OPT_fsched_spec_load
:
1201 flag_schedule_speculative_load
= value
;
1204 case OPT_fsched_spec_load_dangerous
:
1205 flag_schedule_speculative_load_dangerous
= value
;
1208 case OPT_fsched_verbose_
:
1209 #ifdef INSN_SCHEDULING
1210 fix_sched_param ("verbose", arg
);
1216 case OPT_fsched2_use_superblocks
:
1217 flag_sched2_use_superblocks
= value
;
1220 case OPT_fsched2_use_traces
:
1221 flag_sched2_use_traces
= value
;
1224 case OPT_fschedule_insns
:
1225 flag_schedule_insns
= value
;
1228 case OPT_fschedule_insns2
:
1229 flag_schedule_insns_after_reload
= value
;
1232 case OPT_fshared_data
:
1233 flag_shared_data
= value
;
1236 case OPT_fsignaling_nans
:
1237 flag_signaling_nans
= value
;
1240 case OPT_fsingle_precision_constant
:
1241 flag_single_precision_constant
= value
;
1249 flag_ssa_ccp
= value
;
1253 flag_ssa_dce
= value
;
1256 case OPT_fstack_check
:
1257 flag_stack_check
= value
;
1260 case OPT_fstack_limit
:
1261 /* The real switch is -fno-stack-limit. */
1264 stack_limit_rtx
= NULL_RTX
;
1267 case OPT_fstack_limit_register_
:
1269 int reg
= decode_reg_name (arg
);
1271 error ("unrecognized register name \"%s\"", arg
);
1273 stack_limit_rtx
= gen_rtx_REG (Pmode
, reg
);
1277 case OPT_fstack_limit_symbol_
:
1278 stack_limit_rtx
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (arg
));
1281 case OPT_fstrength_reduce
:
1282 flag_strength_reduce
= value
;
1285 case OPT_fstrict_aliasing
:
1286 flag_strict_aliasing
= value
;
1289 case OPT_fsyntax_only
:
1290 flag_syntax_only
= value
;
1293 case OPT_ftest_coverage
:
1294 flag_test_coverage
= value
;
1297 case OPT_fthread_jumps
:
1298 flag_thread_jumps
= value
;
1301 case OPT_ftime_report
:
1302 time_report
= value
;
1305 case OPT_ftls_model_
:
1306 if (!strcmp (arg
, "global-dynamic"))
1307 flag_tls_default
= TLS_MODEL_GLOBAL_DYNAMIC
;
1308 else if (!strcmp (arg
, "local-dynamic"))
1309 flag_tls_default
= TLS_MODEL_LOCAL_DYNAMIC
;
1310 else if (!strcmp (arg
, "initial-exec"))
1311 flag_tls_default
= TLS_MODEL_INITIAL_EXEC
;
1312 else if (!strcmp (arg
, "local-exec"))
1313 flag_tls_default
= TLS_MODEL_LOCAL_EXEC
;
1315 warning ("unknown tls-model \"%s\"", arg
);
1319 flag_tracer
= value
;
1322 case OPT_ftrapping_math
:
1323 flag_trapping_math
= value
;
1330 case OPT_funit_at_a_time
:
1331 flag_unit_at_a_time
= value
;
1334 case OPT_funroll_all_loops
:
1335 flag_unroll_all_loops
= value
;
1338 case OPT_funroll_loops
:
1339 flag_unroll_loops
= value
;
1342 case OPT_funsafe_math_optimizations
:
1343 flag_unsafe_math_optimizations
= value
;
1346 case OPT_funswitch_loops
:
1347 flag_unswitch_loops
= value
;
1350 case OPT_funwind_tables
:
1351 flag_unwind_tables
= value
;
1354 case OPT_fverbose_asm
:
1355 flag_verbose_asm
= value
;
1362 case OPT_fwritable_strings
:
1363 flag_writable_strings
= value
;
1366 case OPT_fzero_initialized_in_bss
:
1367 flag_zero_initialized_in_bss
= value
;
1371 decode_g_option (arg
);
1375 set_target_switch (arg
);
1379 asm_file_name
= arg
;
1390 case OPT_pedantic_errors
:
1391 flag_pedantic_errors
= pedantic
= 1;
1403 inhibit_warnings
= true;
1410 /* Handle --param NAME=VALUE. */
1412 handle_param (const char *carg
)
1417 arg
= xstrdup (carg
);
1418 equal
= strchr (arg
, '=');
1420 error ("%s: --param arguments should be of the form NAME=VALUE", arg
);
1423 value
= integral_argument (equal
+ 1);
1425 error ("invalid --param value `%s'", equal
+ 1);
1429 set_param_value (arg
, value
);
1436 /* Handle -W and -Wextra. */
1438 set_Wextra (int setting
)
1440 extra_warnings
= setting
;
1441 warn_unused_value
= setting
;
1442 warn_unused_parameter
= (setting
&& maybe_warn_unused_parameter
);
1444 /* We save the value of warn_uninitialized, since if they put
1445 -Wuninitialized on the command line, we need to generate a
1446 warning about not using it without also specifying -O. */
1448 warn_uninitialized
= 0;
1449 else if (warn_uninitialized
!= 1)
1450 warn_uninitialized
= 2;
1453 /* Initialize unused warning flags. */
1455 set_Wunused (int setting
)
1457 warn_unused_function
= setting
;
1458 warn_unused_label
= setting
;
1459 /* Unused function parameter warnings are reported when either
1460 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1461 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1462 otherwise set maybe_warn_extra_parameter, which will be picked up
1464 maybe_warn_unused_parameter
= setting
;
1465 warn_unused_parameter
= (setting
&& extra_warnings
);
1466 warn_unused_variable
= setting
;
1467 warn_unused_value
= setting
;
1470 /* The following routines are useful in setting all the flags that
1471 -ffast-math and -fno-fast-math imply. */
1473 set_fast_math_flags (int set
)
1475 flag_trapping_math
= !set
;
1476 flag_unsafe_math_optimizations
= set
;
1477 flag_finite_math_only
= set
;
1478 flag_errno_math
= !set
;
1480 flag_signaling_nans
= 0;
1483 /* Return true iff flags are set as if -ffast-math. */
1485 fast_math_flags_set_p (void)
1487 return (!flag_trapping_math
1488 && flag_unsafe_math_optimizations
1489 && flag_finite_math_only
1490 && !flag_errno_math
);
1493 /* Output --help text. */
1500 GET_ENVIRONMENT (p
, "COLUMNS");
1503 int value
= atoi (p
);
1508 puts (_("The following options are language-independent:\n"));
1510 print_filtered_help (CL_COMMON
);
1511 print_param_help ();
1513 for (i
= 0; lang_names
[i
]; i
++)
1515 printf (_("The %s front end recognizes the following options:\n\n"),
1517 print_filtered_help (1U << i
);
1523 /* Print the help for --param. */
1525 print_param_help (void)
1529 puts (_("The --param option recognizes the following as parameters:\n"));
1531 for (i
= 0; i
< LAST_PARAM
; i
++)
1533 const char *help
= compiler_params
[i
].help
;
1534 const char *param
= compiler_params
[i
].option
;
1536 if (help
== NULL
|| *help
== '\0')
1537 help
= undocumented_msg
;
1539 /* Get the translation. */
1542 wrap_help (help
, param
, strlen (param
));
1548 /* Print help for a specific front-end, etc. */
1550 print_filtered_help (unsigned int flag
)
1552 unsigned int i
, len
, filter
, indent
= 0;
1553 bool duplicates
= false;
1554 const char *help
, *opt
, *tab
;
1555 static char *printed
;
1557 if (flag
== CL_COMMON
)
1561 printed
= xmalloc (cl_options_count
);
1562 memset (printed
, 0, cl_options_count
);
1566 /* Don't print COMMON options twice. */
1567 filter
= flag
| CL_COMMON
;
1569 for (i
= 0; i
< cl_options_count
; i
++)
1571 if ((cl_options
[i
].flags
& filter
) != flag
)
1574 /* Skip help for internal switches. */
1575 if (cl_options
[i
].flags
& CL_UNDOCUMENTED
)
1578 /* Skip switches that have already been printed, mark them to be
1583 indent
= print_switch (cl_options
[i
].opt_text
, indent
);
1594 for (i
= 0; i
< cl_options_count
; i
++)
1596 if ((cl_options
[i
].flags
& filter
) != flag
)
1599 /* Skip help for internal switches. */
1600 if (cl_options
[i
].flags
& CL_UNDOCUMENTED
)
1603 /* Skip switches that have already been printed. */
1609 help
= cl_options
[i
].help
;
1611 help
= undocumented_msg
;
1613 /* Get the translation. */
1616 tab
= strchr (help
, '\t');
1625 opt
= cl_options
[i
].opt_text
;
1629 wrap_help (help
, opt
, len
);
1635 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1636 word-wrapped HELP in a second column. */
1638 print_switch (const char *text
, unsigned int indent
)
1640 unsigned int len
= strlen (text
) + 1; /* trailing comma */
1645 if (indent
+ len
> columns
)
1656 fputs (text
, stdout
);
1658 return indent
+ len
+ 1;
1661 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1662 word-wrapped HELP in a second column. */
1664 wrap_help (const char *help
, const char *item
, unsigned int item_width
)
1666 unsigned int col_width
= 27;
1667 unsigned int remaining
, room
, len
;
1669 remaining
= strlen (help
);
1673 room
= columns
- 3 - MAX (col_width
, item_width
);
1682 for (i
= 0; help
[i
]; i
++)
1684 if (i
>= room
&& len
!= remaining
)
1688 else if ((help
[i
] == '-' || help
[i
] == '/')
1689 && help
[i
+ 1] != ' '
1690 && ISALPHA (help
[i
- 1]))
1695 printf( " %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1697 while (help
[len
] == ' ')