1 /* Command line option handling.
2 Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
3 Contributed by Neil Booth.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "coretypes.h"
31 #include "langhooks.h"
37 #include "diagnostic.h"
38 #include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
39 #include "insn-attr.h" /* For INSN_SCHEDULING. */
42 /* Value of the -G xx switch, and whether it was passed or not. */
43 unsigned HOST_WIDE_INT g_switch_value
;
46 /* True if we should exit after parsing options. */
47 bool exit_after_options
;
49 /* Print various extra warnings. -W/-Wextra. */
52 /* True to warn about any objects definitions whose size is larger
53 than N bytes. Also want about function definitions whose returned
54 values are larger than N bytes, where N is `larger_than_size'. */
55 bool warn_larger_than
;
56 HOST_WIDE_INT larger_than_size
;
58 /* Nonzero means warn about constructs which might not be
59 strict-aliasing safe. */
60 int warn_strict_aliasing
;
62 /* Hack for cooperation between set_Wunused and set_Wextra. */
63 static bool maybe_warn_unused_parameter
;
65 /* Type(s) of debugging information we are producing (if any). See
66 flags.h for the definitions of the different possible types of
67 debugging information. */
68 enum debug_info_type write_symbols
= NO_DEBUG
;
70 /* Level of debugging information we are producing. See flags.h for
71 the definitions of the different possible levels. */
72 enum debug_info_level debug_info_level
= DINFO_LEVEL_NONE
;
74 /* Nonzero means use GNU-only extensions in the generated symbolic
75 debugging information. Currently, this only has an effect when
76 write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
77 bool use_gnu_debug_info_extensions
;
79 /* Columns of --help display. */
80 static unsigned int columns
= 80;
82 /* What to print when a switch has no documentation. */
83 static const char undocumented_msg
[] = N_("This switch lacks documentation");
85 /* Used for bookkeeping on whether user set these flags so
86 -fprofile-use/-fprofile-generate does not use them. */
87 static bool profile_arc_flag_set
, flag_profile_values_set
;
88 static bool flag_unroll_loops_set
, flag_tracer_set
;
89 static bool flag_value_profile_transformations_set
;
90 static bool flag_peel_loops_set
, flag_branch_probabilities_set
;
92 /* Input file names. */
93 const char **in_fnames
;
94 unsigned num_in_fnames
;
96 static size_t find_opt (const char *, int);
97 static int common_handle_option (size_t scode
, const char *arg
, int value
);
98 static void handle_param (const char *);
99 static void set_Wextra (int);
100 static unsigned int handle_option (const char **argv
, unsigned int lang_mask
);
101 static char *write_langs (unsigned int lang_mask
);
102 static void complain_wrong_lang (const char *, const struct cl_option
*,
103 unsigned int lang_mask
);
104 static void handle_options (unsigned int, const char **, unsigned int);
105 static void wrap_help (const char *help
, const char *item
, unsigned int);
106 static void print_help (void);
107 static void print_param_help (void);
108 static void print_filtered_help (unsigned int flag
);
109 static unsigned int print_switch (const char *text
, unsigned int indent
);
110 static void set_debug_level (enum debug_info_type type
, int extended
,
113 /* Perform a binary search to find which option the command-line INPUT
114 matches. Returns its index in the option array, and N_OPTS
115 (cl_options_count) on failure.
117 This routine is quite subtle. A normal binary search is not good
118 enough because some options can be suffixed with an argument, and
119 multiple sub-matches can occur, e.g. input of "-pedantic" matching
120 the initial substring of "-pedantic-errors".
122 A more complicated example is -gstabs. It should match "-g" with
123 an argument of "stabs". Suppose, however, that the number and list
124 of switches are such that the binary search tests "-gen-decls"
125 before having tested "-g". This doesn't match, and as "-gen-decls"
126 is less than "-gstabs", it will become the lower bound of the
127 binary search range, and "-g" will never be seen. To resolve this
128 issue, opts.sh makes "-gen-decls" point, via the back_chain member,
129 to "-g" so that failed searches that end between "-gen-decls" and
130 the lexicographically subsequent switch know to go back and see if
131 "-g" causes a match (which it does in this example).
133 This search is done in such a way that the longest match for the
134 front end in question wins. If there is no match for the current
135 front end, the longest match for a different front end is returned
136 (or N_OPTS if none) and the caller emits an error message. */
138 find_opt (const char *input
, int lang_mask
)
140 size_t mn
, mx
, md
, opt_len
;
141 size_t match_wrong_lang
;
145 mx
= cl_options_count
;
147 /* Find mn such this lexicographical inequality holds:
148 cl_options[mn] <= input < cl_options[mn + 1]. */
152 opt_len
= cl_options
[md
].opt_len
;
153 comp
= strncmp (input
, cl_options
[md
].opt_text
+ 1, opt_len
);
161 /* This is the switch that is the best match but for a different
162 front end, or cl_options_count if there is no match at all. */
163 match_wrong_lang
= cl_options_count
;
165 /* Backtrace the chain of possible matches, returning the longest
166 one, if any, that fits best. With current GCC switches, this
167 loop executes at most twice. */
170 const struct cl_option
*opt
= &cl_options
[mn
];
172 /* Is this switch a prefix of the input? */
173 if (!strncmp (input
, opt
->opt_text
+ 1, opt
->opt_len
))
175 /* If language is OK, and the match is exact or the switch
176 takes a joined argument, return it. */
177 if ((opt
->flags
& lang_mask
)
178 && (input
[opt
->opt_len
] == '\0' || (opt
->flags
& CL_JOINED
)))
181 /* If we haven't remembered a prior match, remember this
182 one. Any prior match is necessarily better. */
183 if (match_wrong_lang
== cl_options_count
)
184 match_wrong_lang
= mn
;
187 /* Try the next possibility. This is cl_options_count if there
189 mn
= opt
->back_chain
;
191 while (mn
!= cl_options_count
);
193 /* Return the best wrong match, or cl_options_count if none. */
194 return match_wrong_lang
;
197 /* If ARG is a non-negative integer made up solely of digits, return its
198 value, otherwise return -1. */
200 integral_argument (const char *arg
)
204 while (*p
&& ISDIGIT (*p
))
213 /* Return a malloced slash-separated list of languages in MASK. */
215 write_langs (unsigned int mask
)
217 unsigned int n
= 0, len
= 0;
218 const char *lang_name
;
221 for (n
= 0; (lang_name
= lang_names
[n
]) != 0; n
++)
222 if (mask
& (1U << n
))
223 len
+= strlen (lang_name
) + 1;
225 result
= xmalloc (len
);
227 for (n
= 0; (lang_name
= lang_names
[n
]) != 0; n
++)
228 if (mask
& (1U << n
))
232 strcpy (result
+ len
, lang_name
);
233 len
+= strlen (lang_name
);
241 /* Complain that switch OPT_INDEX does not apply to this front end. */
243 complain_wrong_lang (const char *text
, const struct cl_option
*option
,
244 unsigned int lang_mask
)
246 char *ok_langs
, *bad_lang
;
248 ok_langs
= write_langs (option
->flags
);
249 bad_lang
= write_langs (lang_mask
);
251 /* Eventually this should become a hard error IMO. */
252 warning ("command line option \"%s\" is valid for %s but not for %s",
253 text
, ok_langs
, bad_lang
);
259 /* Handle the switch beginning at ARGV for the language indicated by
260 LANG_MASK. Returns the number of switches consumed. */
262 handle_option (const char **argv
, unsigned int lang_mask
)
265 const char *opt
, *arg
= 0;
268 unsigned int result
= 0;
269 const struct cl_option
*option
;
273 /* Drop the "no-" from negative switches. */
274 if ((opt
[1] == 'W' || opt
[1] == 'f')
275 && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-')
277 size_t len
= strlen (opt
) - 3;
279 dup
= xmalloc (len
+ 1);
282 memcpy (dup
+ 2, opt
+ 5, len
- 2 + 1);
287 opt_index
= find_opt (opt
+ 1, lang_mask
| CL_COMMON
);
288 if (opt_index
== cl_options_count
)
291 option
= &cl_options
[opt_index
];
293 /* Reject negative form of switches that don't take negatives as
295 if (!value
&& (option
->flags
& CL_REJECT_NEGATIVE
))
298 /* We've recognized this switch. */
301 /* Sort out any argument the switch takes. */
302 if (option
->flags
& CL_JOINED
)
304 /* Have arg point to the original switch. This is because
305 some code, such as disable_builtin_function, expects its
306 argument to be persistent until the program exits. */
307 arg
= argv
[0] + cl_options
[opt_index
].opt_len
+ 1;
309 arg
+= strlen ("no-");
311 if (*arg
== '\0' && !(option
->flags
& CL_MISSING_OK
))
313 if (option
->flags
& CL_SEPARATE
)
319 /* Missing argument. */
323 else if (option
->flags
& CL_SEPARATE
)
329 /* Now we've swallowed any potential argument, complain if this
330 is a switch for a different front end. */
331 if (!(option
->flags
& (lang_mask
| CL_COMMON
)))
333 complain_wrong_lang (argv
[0], option
, lang_mask
);
337 if (arg
== NULL
&& (option
->flags
& (CL_JOINED
| CL_SEPARATE
)))
339 if (!lang_hooks
.missing_argument (opt
, opt_index
))
340 error ("missing argument to \"%s\"", opt
);
344 /* If the switch takes an integer, convert it. */
345 if (arg
&& (option
->flags
& CL_UINTEGER
))
347 value
= integral_argument (arg
);
350 error ("argument to \"%s\" should be a non-negative integer",
356 if (option
->flag_var
)
358 if (option
->has_set_value
)
361 *option
->flag_var
= option
->set_value
;
363 *option
->flag_var
= !option
->set_value
;
366 *option
->flag_var
= value
;
369 if (option
->flags
& lang_mask
)
370 if (lang_hooks
.handle_option (opt_index
, arg
, value
) == 0)
373 if (result
&& (option
->flags
& CL_COMMON
))
374 if (common_handle_option (opt_index
, arg
, value
) == 0)
383 /* Decode and handle the vector of command line options. LANG_MASK
384 contains has a single bit set representing the current
387 handle_options (unsigned int argc
, const char **argv
, unsigned int lang_mask
)
391 for (i
= 1; i
< argc
; i
+= n
)
393 const char *opt
= argv
[i
];
395 /* Interpret "-" or a non-switch as a file name. */
396 if (opt
[0] != '-' || opt
[1] == '\0')
398 if (main_input_filename
== NULL
)
399 main_input_filename
= opt
;
400 add_input_filename (opt
);
405 n
= handle_option (argv
+ i
, lang_mask
);
410 error ("unrecognized command line option \"%s\"", opt
);
415 /* Handle FILENAME from the command line. */
417 add_input_filename (const char *filename
)
420 in_fnames
= xrealloc (in_fnames
, num_in_fnames
* sizeof (in_fnames
[0]));
421 in_fnames
[num_in_fnames
- 1] = filename
;
424 /* Parse command line options and set default flag values. Do minimal
425 options processing. */
427 decode_options (unsigned int argc
, const char **argv
)
429 unsigned int i
, lang_mask
;
431 /* Perform language-specific options initialization. */
432 lang_mask
= lang_hooks
.init_options (argc
, argv
);
434 lang_hooks
.initialize_diagnostics (global_dc
);
436 /* Scan to see what optimization level has been specified. That will
437 determine the default value of many flags. */
438 for (i
= 1; i
< argc
; i
++)
440 if (!strcmp (argv
[i
], "-O"))
445 else if (argv
[i
][0] == '-' && argv
[i
][1] == 'O')
447 /* Handle -Os, -O2, -O3, -O69, ... */
448 const char *p
= &argv
[i
][2];
450 if ((p
[0] == 's') && (p
[1] == 0))
454 /* Optimizing for size forces optimize to be 2. */
459 const int optimize_val
= read_integral_parameter (p
, p
- 2, -1);
460 if (optimize_val
!= -1)
462 optimize
= optimize_val
;
471 flag_merge_constants
= 0;
477 flag_thread_jumps
= 1;
479 flag_delayed_branch
= 1;
481 #ifdef CAN_DEBUG_WITHOUT_FP
482 flag_omit_frame_pointer
= 1;
484 flag_guess_branch_prob
= 1;
485 flag_cprop_registers
= 1;
486 flag_loop_optimize
= 1;
487 flag_if_conversion
= 1;
488 flag_if_conversion2
= 1;
495 flag_tree_live_range_split
= 1;
497 flag_tree_copyrename
= 1;
502 /* Loop header copying usually increases size of the code. This used
503 not to be true, since quite often it is possible to verify that
504 the condition is satisfied in the first iteration and therefore
505 to eliminate it. Jump threading handles these cases now. */
512 flag_crossjumping
= 1;
513 flag_optimize_sibling_calls
= 1;
514 flag_cse_follow_jumps
= 1;
515 flag_cse_skip_blocks
= 1;
517 flag_expensive_optimizations
= 1;
518 flag_strength_reduce
= 1;
519 flag_rerun_cse_after_loop
= 1;
520 flag_rerun_loop_opt
= 1;
521 flag_caller_saves
= 1;
524 #ifdef INSN_SCHEDULING
525 flag_schedule_insns
= 1;
526 flag_schedule_insns_after_reload
= 1;
529 flag_strict_aliasing
= 1;
530 flag_delete_null_pointer_checks
= 1;
531 flag_reorder_blocks
= 1;
532 flag_reorder_functions
= 1;
533 flag_unit_at_a_time
= 1;
538 flag_inline_functions
= 1;
539 flag_unswitch_loops
= 1;
540 flag_gcse_after_reload
= 1;
543 if (optimize
< 2 || optimize_size
)
550 /* Don't reorder blocks when optimizing for size because extra
551 jump insns may be created; also barrier may create extra padding.
553 More correctly we should have a block reordering mode that tried
554 to minimize the combined size of all the jumps. This would more
555 or less automatically remove extra jumps, but would also try to
556 use more short jumps instead of long jumps. */
557 flag_reorder_blocks
= 0;
558 flag_reorder_blocks_and_partition
= 0;
563 /* Inlining of very small functions usually reduces total size. */
564 set_param_value ("max-inline-insns-single", 5);
565 set_param_value ("max-inline-insns-auto", 5);
566 set_param_value ("max-inline-insns-rtl", 10);
567 flag_inline_functions
= 1;
570 /* Initialize whether `char' is signed. */
571 flag_signed_char
= DEFAULT_SIGNED_CHAR
;
572 /* Set this to a special "uninitialized" value. The actual default is set
573 after target options have been processed. */
574 flag_short_enums
= 2;
576 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
579 set_target_switch ("");
581 /* Unwind tables are always present in an ABI-conformant IA-64
582 object file, so the default should be ON. */
583 #ifdef IA64_UNWIND_INFO
584 flag_unwind_tables
= IA64_UNWIND_INFO
;
587 #ifdef OPTIMIZATION_OPTIONS
588 /* Allow default optimizations to be specified on a per-machine basis. */
589 OPTIMIZATION_OPTIONS (optimize
, optimize_size
);
592 handle_options (argc
, argv
, lang_mask
);
596 if (flag_pic
&& !flag_pie
)
599 if (flag_no_inline
== 2)
602 flag_really_no_inline
= flag_no_inline
;
604 /* Set flag_no_inline before the post_options () hook. The C front
605 ends use it to determine tree inlining defaults. FIXME: such
606 code should be lang-independent when all front ends use tree
607 inlining, in which case it, and this condition, should be moved
608 to the top of process_options() instead. */
611 /* Inlining does not work if not optimizing,
612 so force it not to be done. */
616 /* The c_decode_option function and decode_option hook set
617 this to `2' if -Wall is used, so we can avoid giving out
618 lots of errors for people who don't realize what -Wall does. */
619 if (warn_uninitialized
== 1)
620 warning ("-Wuninitialized is not supported without -O");
623 if (flag_really_no_inline
== 2)
624 flag_really_no_inline
= flag_no_inline
;
626 /* The optimization to partition hot and cold basic blocks into separate
627 sections of the .o and executable files does not work (currently)
628 with exception handling. If flag_exceptions is turned on we need to
629 turn off the partitioning optimization. */
631 if (flag_exceptions
&& flag_reorder_blocks_and_partition
)
634 ("-freorder-blocks-and-partition does not work with exceptions");
635 flag_reorder_blocks_and_partition
= 0;
636 flag_reorder_blocks
= 1;
640 /* Handle target- and language-independent options. Return zero to
641 generate an "unknown option" message. Only options that need
642 extra handling need to be listed here; if you simply want
643 VALUE assigned to a variable, it happens automatically. */
646 common_handle_option (size_t scode
, const char *arg
, int value
)
648 enum opt_code code
= (enum opt_code
) scode
;
654 exit_after_options
= true;
661 case OPT__target_help
:
662 display_target_options ();
663 exit_after_options
= true;
667 print_version (stderr
, "");
668 exit_after_options
= true;
672 g_switch_value
= value
;
678 /* Currently handled in a prescan. */
682 /* For backward compatibility, -W is the same as -Wextra. */
690 case OPT_Wlarger_than_
:
691 larger_than_size
= value
;
692 warn_larger_than
= value
!= -1;
695 case OPT_Wstrict_aliasing
:
696 case OPT_Wstrict_aliasing_
:
697 warn_strict_aliasing
= value
;
706 aux_info_file_name
= arg
;
707 flag_gen_aux_info
= 1;
714 case OPT_auxbase_strip
:
716 char *tmp
= xstrdup (arg
);
717 strip_off_ending (tmp
, strlen (tmp
));
724 decode_d_option (arg
);
728 dump_base_name
= arg
;
731 case OPT_falign_functions_
:
732 align_functions
= value
;
735 case OPT_falign_jumps_
:
739 case OPT_falign_labels_
:
740 align_labels
= value
;
743 case OPT_falign_loops_
:
747 case OPT_fbranch_probabilities
:
748 flag_branch_probabilities_set
= true;
751 case OPT_fcall_used_
:
752 fix_register (arg
, 0, 1);
755 case OPT_fcall_saved_
:
756 fix_register (arg
, 0, 0);
759 case OPT_fdiagnostics_show_location_
:
760 if (!strcmp (arg
, "once"))
761 diagnostic_prefixing_rule (global_dc
) = DIAGNOSTICS_SHOW_PREFIX_ONCE
;
762 else if (!strcmp (arg
, "every-line"))
763 diagnostic_prefixing_rule (global_dc
)
764 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE
;
770 if (!dump_switch_p (arg
))
775 set_fast_math_flags (value
);
779 fix_register (arg
, 1, 1);
782 case OPT_finline_limit_
:
783 case OPT_finline_limit_eq
:
784 set_param_value ("max-inline-insns-single", value
/ 2);
785 set_param_value ("max-inline-insns-auto", value
/ 2);
786 set_param_value ("max-inline-insns-rtl", value
);
789 case OPT_fmessage_length_
:
790 pp_set_line_maximum_length (global_dc
->printer
, value
);
793 case OPT_fpeel_loops
:
794 flag_peel_loops_set
= true;
797 case OPT_fprofile_arcs
:
798 profile_arc_flag_set
= true;
801 case OPT_fprofile_use
:
802 if (!flag_branch_probabilities_set
)
803 flag_branch_probabilities
= value
;
804 if (!flag_profile_values_set
)
805 flag_profile_values
= value
;
806 if (!flag_unroll_loops_set
)
807 flag_unroll_loops
= value
;
808 if (!flag_peel_loops_set
)
809 flag_peel_loops
= value
;
810 if (!flag_tracer_set
)
812 if (!flag_value_profile_transformations_set
)
813 flag_value_profile_transformations
= value
;
816 case OPT_fprofile_generate
:
817 if (!profile_arc_flag_set
)
818 profile_arc_flag
= value
;
819 if (!flag_profile_values_set
)
820 flag_profile_values
= value
;
821 if (!flag_value_profile_transformations_set
)
822 flag_value_profile_transformations
= value
;
825 case OPT_fprofile_values
:
826 flag_profile_values_set
= true;
830 flag_value_profile_transformations_set
= value
;
833 case OPT_frandom_seed
:
834 /* The real switch is -fno-random-seed. */
837 flag_random_seed
= NULL
;
840 case OPT_frandom_seed_
:
841 flag_random_seed
= arg
;
844 case OPT_fsched_verbose_
:
845 #ifdef INSN_SCHEDULING
846 fix_sched_param ("verbose", arg
);
852 case OPT_fsched_stalled_insns_
:
853 flag_sched_stalled_insns
= value
;
854 if (flag_sched_stalled_insns
== 0)
855 flag_sched_stalled_insns
= -1;
858 case OPT_fsched_stalled_insns_dep_
:
859 flag_sched_stalled_insns_dep
= value
;
862 case OPT_fstack_limit
:
863 /* The real switch is -fno-stack-limit. */
866 stack_limit_rtx
= NULL_RTX
;
869 case OPT_fstack_limit_register_
:
871 int reg
= decode_reg_name (arg
);
873 error ("unrecognized register name \"%s\"", arg
);
875 stack_limit_rtx
= gen_rtx_REG (Pmode
, reg
);
879 case OPT_fstack_limit_symbol_
:
880 stack_limit_rtx
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (arg
));
883 case OPT_ftls_model_
:
884 if (!strcmp (arg
, "global-dynamic"))
885 flag_tls_default
= TLS_MODEL_GLOBAL_DYNAMIC
;
886 else if (!strcmp (arg
, "local-dynamic"))
887 flag_tls_default
= TLS_MODEL_LOCAL_DYNAMIC
;
888 else if (!strcmp (arg
, "initial-exec"))
889 flag_tls_default
= TLS_MODEL_INITIAL_EXEC
;
890 else if (!strcmp (arg
, "local-exec"))
891 flag_tls_default
= TLS_MODEL_LOCAL_EXEC
;
893 warning ("unknown tls-model \"%s\"", arg
);
897 flag_tracer_set
= true;
900 case OPT_ftree_points_to_
:
901 if (!strcmp (arg
, "andersen"))
903 flag_tree_points_to
= PTA_ANDERSEN
;
905 warning ("Andersen's PTA not available - libbanshee not compiled.");
907 else if (!strcmp (arg
, "none"))
908 flag_tree_points_to
= PTA_NONE
;
911 warning ("`%s`: unknown points-to analysis algorithm", arg
);
916 case OPT_funroll_loops
:
917 flag_unroll_loops_set
= true;
921 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
);
925 set_debug_level (SDB_DEBUG
, false, arg
);
929 set_debug_level (DWARF2_DEBUG
, false, arg
);
933 set_debug_level (NO_DEBUG
, 2, arg
);
938 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
);
942 set_debug_level (VMS_DEBUG
, false, arg
);
947 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
);
951 set_target_switch (arg
);
958 case OPT_pedantic_errors
:
959 flag_pedantic_errors
= pedantic
= 1;
963 /* If the flag was handled in a standard way, assume the lack of
964 processing here is intentional. */
965 if (cl_options
[scode
].flag_var
)
974 /* Handle --param NAME=VALUE. */
976 handle_param (const char *carg
)
981 arg
= xstrdup (carg
);
982 equal
= strchr (arg
, '=');
984 error ("%s: --param arguments should be of the form NAME=VALUE", arg
);
987 value
= integral_argument (equal
+ 1);
989 error ("invalid --param value `%s'", equal
+ 1);
993 set_param_value (arg
, value
);
1000 /* Handle -W and -Wextra. */
1002 set_Wextra (int setting
)
1004 extra_warnings
= setting
;
1005 warn_unused_value
= setting
;
1006 warn_unused_parameter
= (setting
&& maybe_warn_unused_parameter
);
1008 /* We save the value of warn_uninitialized, since if they put
1009 -Wuninitialized on the command line, we need to generate a
1010 warning about not using it without also specifying -O. */
1012 warn_uninitialized
= 0;
1013 else if (warn_uninitialized
!= 1)
1014 warn_uninitialized
= 2;
1017 /* Initialize unused warning flags. */
1019 set_Wunused (int setting
)
1021 warn_unused_function
= setting
;
1022 warn_unused_label
= setting
;
1023 /* Unused function parameter warnings are reported when either
1024 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1025 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1026 otherwise set maybe_warn_extra_parameter, which will be picked up
1028 maybe_warn_unused_parameter
= setting
;
1029 warn_unused_parameter
= (setting
&& extra_warnings
);
1030 warn_unused_variable
= setting
;
1031 warn_unused_value
= setting
;
1034 /* The following routines are useful in setting all the flags that
1035 -ffast-math and -fno-fast-math imply. */
1037 set_fast_math_flags (int set
)
1039 flag_trapping_math
= !set
;
1040 flag_unsafe_math_optimizations
= set
;
1041 flag_finite_math_only
= set
;
1042 flag_errno_math
= !set
;
1045 flag_signaling_nans
= 0;
1046 flag_rounding_math
= 0;
1050 /* Return true iff flags are set as if -ffast-math. */
1052 fast_math_flags_set_p (void)
1054 return (!flag_trapping_math
1055 && flag_unsafe_math_optimizations
1056 && flag_finite_math_only
1057 && !flag_errno_math
);
1060 /* Handle a debug output -g switch. EXTENDED is true or false to support
1061 extended output (2 is special and means "-ggdb" was given). */
1063 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
)
1065 static bool type_explicit
;
1067 use_gnu_debug_info_extensions
= extended
;
1069 if (type
== NO_DEBUG
)
1071 if (write_symbols
== NO_DEBUG
)
1073 write_symbols
= PREFERRED_DEBUGGING_TYPE
;
1077 #ifdef DWARF2_DEBUGGING_INFO
1078 write_symbols
= DWARF2_DEBUG
;
1079 #elif defined DBX_DEBUGGING_INFO
1080 write_symbols
= DBX_DEBUG
;
1084 if (write_symbols
== NO_DEBUG
)
1085 warning ("target system does not support debug output");
1090 /* Does it conflict with an already selected type? */
1091 if (type_explicit
&& write_symbols
!= NO_DEBUG
&& type
!= write_symbols
)
1092 error ("debug format \"%s\" conflicts with prior selection",
1093 debug_type_names
[type
]);
1094 write_symbols
= type
;
1095 type_explicit
= true;
1098 /* A debug flag without a level defaults to level 2. */
1101 if (!debug_info_level
)
1102 debug_info_level
= 2;
1106 debug_info_level
= integral_argument (arg
);
1107 if (debug_info_level
== (unsigned int) -1)
1108 error ("unrecognised debug output level \"%s\"", arg
);
1109 else if (debug_info_level
> 3)
1110 error ("debug output level %s is too high", arg
);
1114 /* Output --help text. */
1121 GET_ENVIRONMENT (p
, "COLUMNS");
1124 int value
= atoi (p
);
1129 puts (_("The following options are language-independent:\n"));
1131 print_filtered_help (CL_COMMON
);
1132 print_param_help ();
1134 for (i
= 0; lang_names
[i
]; i
++)
1136 printf (_("The %s front end recognizes the following options:\n\n"),
1138 print_filtered_help (1U << i
);
1141 display_target_options ();
1144 /* Print the help for --param. */
1146 print_param_help (void)
1150 puts (_("The --param option recognizes the following as parameters:\n"));
1152 for (i
= 0; i
< LAST_PARAM
; i
++)
1154 const char *help
= compiler_params
[i
].help
;
1155 const char *param
= compiler_params
[i
].option
;
1157 if (help
== NULL
|| *help
== '\0')
1158 help
= undocumented_msg
;
1160 /* Get the translation. */
1163 wrap_help (help
, param
, strlen (param
));
1169 /* Print help for a specific front-end, etc. */
1171 print_filtered_help (unsigned int flag
)
1173 unsigned int i
, len
, filter
, indent
= 0;
1174 bool duplicates
= false;
1175 const char *help
, *opt
, *tab
;
1176 static char *printed
;
1178 if (flag
== CL_COMMON
)
1182 printed
= xmalloc (cl_options_count
);
1183 memset (printed
, 0, cl_options_count
);
1187 /* Don't print COMMON options twice. */
1188 filter
= flag
| CL_COMMON
;
1190 for (i
= 0; i
< cl_options_count
; i
++)
1192 if ((cl_options
[i
].flags
& filter
) != flag
)
1195 /* Skip help for internal switches. */
1196 if (cl_options
[i
].flags
& CL_UNDOCUMENTED
)
1199 /* Skip switches that have already been printed, mark them to be
1204 indent
= print_switch (cl_options
[i
].opt_text
, indent
);
1215 for (i
= 0; i
< cl_options_count
; i
++)
1217 if ((cl_options
[i
].flags
& filter
) != flag
)
1220 /* Skip help for internal switches. */
1221 if (cl_options
[i
].flags
& CL_UNDOCUMENTED
)
1224 /* Skip switches that have already been printed. */
1230 help
= cl_options
[i
].help
;
1232 help
= undocumented_msg
;
1234 /* Get the translation. */
1237 tab
= strchr (help
, '\t');
1246 opt
= cl_options
[i
].opt_text
;
1250 wrap_help (help
, opt
, len
);
1256 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1257 word-wrapped HELP in a second column. */
1259 print_switch (const char *text
, unsigned int indent
)
1261 unsigned int len
= strlen (text
) + 1; /* trailing comma */
1266 if (indent
+ len
> columns
)
1277 fputs (text
, stdout
);
1279 return indent
+ len
+ 1;
1282 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1283 word-wrapped HELP in a second column. */
1285 wrap_help (const char *help
, const char *item
, unsigned int item_width
)
1287 unsigned int col_width
= 27;
1288 unsigned int remaining
, room
, len
;
1290 remaining
= strlen (help
);
1294 room
= columns
- 3 - MAX (col_width
, item_width
);
1303 for (i
= 0; help
[i
]; i
++)
1305 if (i
>= room
&& len
!= remaining
)
1309 else if ((help
[i
] == '-' || help
[i
] == '/')
1310 && help
[i
+ 1] != ' '
1311 && i
> 0 && ISALPHA (help
[i
- 1]))
1316 printf( " %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1318 while (help
[len
] == ' ')