1 /* Command line option handling.
2 Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
3 Contributed by Neil Booth.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "coretypes.h"
31 #include "langhooks.h"
37 #include "diagnostic.h"
38 #include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
39 #include "insn-attr.h" /* For INSN_SCHEDULING. */
42 /* Value of the -G xx switch, and whether it was passed or not. */
43 unsigned HOST_WIDE_INT g_switch_value
;
46 /* True if we should exit after parsing options. */
47 bool exit_after_options
;
49 /* Print various extra warnings. -W/-Wextra. */
52 /* True to warn about any objects definitions whose size is larger
53 than N bytes. Also want about function definitions whose returned
54 values are larger than N bytes, where N is `larger_than_size'. */
55 bool warn_larger_than
;
56 HOST_WIDE_INT larger_than_size
;
58 /* Nonzero means warn about constructs which might not be
59 strict-aliasing safe. */
60 int warn_strict_aliasing
;
62 /* Hack for cooperation between set_Wunused and set_Wextra. */
63 static bool maybe_warn_unused_parameter
;
65 /* Type(s) of debugging information we are producing (if any). See
66 flags.h for the definitions of the different possible types of
67 debugging information. */
68 enum debug_info_type write_symbols
= NO_DEBUG
;
70 /* Level of debugging information we are producing. See flags.h for
71 the definitions of the different possible levels. */
72 enum debug_info_level debug_info_level
= DINFO_LEVEL_NONE
;
74 /* Nonzero means use GNU-only extensions in the generated symbolic
75 debugging information. Currently, this only has an effect when
76 write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
77 bool use_gnu_debug_info_extensions
;
79 /* The default visibility for all symbols (unless overridden) */
80 enum symbol_visibility default_visibility
= VISIBILITY_DEFAULT
;
82 /* Global visibility options. */
83 struct visibility_flags visibility_options
;
85 /* Columns of --help display. */
86 static unsigned int columns
= 80;
88 /* What to print when a switch has no documentation. */
89 static const char undocumented_msg
[] = N_("This switch lacks documentation");
91 /* Used for bookkeeping on whether user set these flags so
92 -fprofile-use/-fprofile-generate does not use them. */
93 static bool profile_arc_flag_set
, flag_profile_values_set
;
94 static bool flag_unroll_loops_set
, flag_tracer_set
;
95 static bool flag_value_profile_transformations_set
;
96 static bool flag_peel_loops_set
, flag_branch_probabilities_set
;
98 /* Input file names. */
99 const char **in_fnames
;
100 unsigned num_in_fnames
;
102 static size_t find_opt (const char *, int);
103 static int common_handle_option (size_t scode
, const char *arg
, int value
);
104 static void handle_param (const char *);
105 static void set_Wextra (int);
106 static unsigned int handle_option (const char **argv
, unsigned int lang_mask
);
107 static char *write_langs (unsigned int lang_mask
);
108 static void complain_wrong_lang (const char *, const struct cl_option
*,
109 unsigned int lang_mask
);
110 static void handle_options (unsigned int, const char **, unsigned int);
111 static void wrap_help (const char *help
, const char *item
, unsigned int);
112 static void print_help (void);
113 static void print_param_help (void);
114 static void print_filtered_help (unsigned int flag
);
115 static unsigned int print_switch (const char *text
, unsigned int indent
);
116 static void set_debug_level (enum debug_info_type type
, int extended
,
119 /* Perform a binary search to find which option the command-line INPUT
120 matches. Returns its index in the option array, and N_OPTS
121 (cl_options_count) on failure.
123 This routine is quite subtle. A normal binary search is not good
124 enough because some options can be suffixed with an argument, and
125 multiple sub-matches can occur, e.g. input of "-pedantic" matching
126 the initial substring of "-pedantic-errors".
128 A more complicated example is -gstabs. It should match "-g" with
129 an argument of "stabs". Suppose, however, that the number and list
130 of switches are such that the binary search tests "-gen-decls"
131 before having tested "-g". This doesn't match, and as "-gen-decls"
132 is less than "-gstabs", it will become the lower bound of the
133 binary search range, and "-g" will never be seen. To resolve this
134 issue, opts.sh makes "-gen-decls" point, via the back_chain member,
135 to "-g" so that failed searches that end between "-gen-decls" and
136 the lexicographically subsequent switch know to go back and see if
137 "-g" causes a match (which it does in this example).
139 This search is done in such a way that the longest match for the
140 front end in question wins. If there is no match for the current
141 front end, the longest match for a different front end is returned
142 (or N_OPTS if none) and the caller emits an error message. */
144 find_opt (const char *input
, int lang_mask
)
146 size_t mn
, mx
, md
, opt_len
;
147 size_t match_wrong_lang
;
151 mx
= cl_options_count
;
153 /* Find mn such this lexicographical inequality holds:
154 cl_options[mn] <= input < cl_options[mn + 1]. */
158 opt_len
= cl_options
[md
].opt_len
;
159 comp
= strncmp (input
, cl_options
[md
].opt_text
+ 1, opt_len
);
167 /* This is the switch that is the best match but for a different
168 front end, or cl_options_count if there is no match at all. */
169 match_wrong_lang
= cl_options_count
;
171 /* Backtrace the chain of possible matches, returning the longest
172 one, if any, that fits best. With current GCC switches, this
173 loop executes at most twice. */
176 const struct cl_option
*opt
= &cl_options
[mn
];
178 /* Is this switch a prefix of the input? */
179 if (!strncmp (input
, opt
->opt_text
+ 1, opt
->opt_len
))
181 /* If language is OK, and the match is exact or the switch
182 takes a joined argument, return it. */
183 if ((opt
->flags
& lang_mask
)
184 && (input
[opt
->opt_len
] == '\0' || (opt
->flags
& CL_JOINED
)))
187 /* If we haven't remembered a prior match, remember this
188 one. Any prior match is necessarily better. */
189 if (match_wrong_lang
== cl_options_count
)
190 match_wrong_lang
= mn
;
193 /* Try the next possibility. This is cl_options_count if there
195 mn
= opt
->back_chain
;
197 while (mn
!= cl_options_count
);
199 /* Return the best wrong match, or cl_options_count if none. */
200 return match_wrong_lang
;
203 /* If ARG is a non-negative integer made up solely of digits, return its
204 value, otherwise return -1. */
206 integral_argument (const char *arg
)
210 while (*p
&& ISDIGIT (*p
))
219 /* Return a malloced slash-separated list of languages in MASK. */
221 write_langs (unsigned int mask
)
223 unsigned int n
= 0, len
= 0;
224 const char *lang_name
;
227 for (n
= 0; (lang_name
= lang_names
[n
]) != 0; n
++)
228 if (mask
& (1U << n
))
229 len
+= strlen (lang_name
) + 1;
231 result
= xmalloc (len
);
233 for (n
= 0; (lang_name
= lang_names
[n
]) != 0; n
++)
234 if (mask
& (1U << n
))
238 strcpy (result
+ len
, lang_name
);
239 len
+= strlen (lang_name
);
247 /* Complain that switch OPT_INDEX does not apply to this front end. */
249 complain_wrong_lang (const char *text
, const struct cl_option
*option
,
250 unsigned int lang_mask
)
252 char *ok_langs
, *bad_lang
;
254 ok_langs
= write_langs (option
->flags
);
255 bad_lang
= write_langs (lang_mask
);
257 /* Eventually this should become a hard error IMO. */
258 warning ("command line option \"%s\" is valid for %s but not for %s",
259 text
, ok_langs
, bad_lang
);
265 /* Handle the switch beginning at ARGV for the language indicated by
266 LANG_MASK. Returns the number of switches consumed. */
268 handle_option (const char **argv
, unsigned int lang_mask
)
271 const char *opt
, *arg
= 0;
274 unsigned int result
= 0;
275 const struct cl_option
*option
;
279 /* Drop the "no-" from negative switches. */
280 if ((opt
[1] == 'W' || opt
[1] == 'f')
281 && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-')
283 size_t len
= strlen (opt
) - 3;
285 dup
= xmalloc (len
+ 1);
288 memcpy (dup
+ 2, opt
+ 5, len
- 2 + 1);
293 opt_index
= find_opt (opt
+ 1, lang_mask
| CL_COMMON
);
294 if (opt_index
== cl_options_count
)
297 option
= &cl_options
[opt_index
];
299 /* Reject negative form of switches that don't take negatives as
301 if (!value
&& (option
->flags
& CL_REJECT_NEGATIVE
))
304 /* We've recognized this switch. */
307 /* Sort out any argument the switch takes. */
308 if (option
->flags
& CL_JOINED
)
310 /* Have arg point to the original switch. This is because
311 some code, such as disable_builtin_function, expects its
312 argument to be persistent until the program exits. */
313 arg
= argv
[0] + cl_options
[opt_index
].opt_len
+ 1;
315 arg
+= strlen ("no-");
317 if (*arg
== '\0' && !(option
->flags
& CL_MISSING_OK
))
319 if (option
->flags
& CL_SEPARATE
)
325 /* Missing argument. */
329 else if (option
->flags
& CL_SEPARATE
)
335 /* Now we've swallowed any potential argument, complain if this
336 is a switch for a different front end. */
337 if (!(option
->flags
& (lang_mask
| CL_COMMON
)))
339 complain_wrong_lang (argv
[0], option
, lang_mask
);
343 if (arg
== NULL
&& (option
->flags
& (CL_JOINED
| CL_SEPARATE
)))
345 if (!lang_hooks
.missing_argument (opt
, opt_index
))
346 error ("missing argument to \"%s\"", opt
);
350 /* If the switch takes an integer, convert it. */
351 if (arg
&& (option
->flags
& CL_UINTEGER
))
353 value
= integral_argument (arg
);
356 error ("argument to \"%s\" should be a non-negative integer",
362 if (option
->flag_var
)
364 if (option
->has_set_value
)
367 *option
->flag_var
= option
->set_value
;
369 *option
->flag_var
= !option
->set_value
;
372 *option
->flag_var
= value
;
375 if (option
->flags
& lang_mask
)
376 if (lang_hooks
.handle_option (opt_index
, arg
, value
) == 0)
379 if (result
&& (option
->flags
& CL_COMMON
))
380 if (common_handle_option (opt_index
, arg
, value
) == 0)
389 /* Decode and handle the vector of command line options. LANG_MASK
390 contains has a single bit set representing the current
393 handle_options (unsigned int argc
, const char **argv
, unsigned int lang_mask
)
397 for (i
= 1; i
< argc
; i
+= n
)
399 const char *opt
= argv
[i
];
401 /* Interpret "-" or a non-switch as a file name. */
402 if (opt
[0] != '-' || opt
[1] == '\0')
404 if (main_input_filename
== NULL
)
405 main_input_filename
= opt
;
406 add_input_filename (opt
);
411 n
= handle_option (argv
+ i
, lang_mask
);
416 error ("unrecognized command line option \"%s\"", opt
);
421 /* Handle FILENAME from the command line. */
423 add_input_filename (const char *filename
)
426 in_fnames
= xrealloc (in_fnames
, num_in_fnames
* sizeof (in_fnames
[0]));
427 in_fnames
[num_in_fnames
- 1] = filename
;
430 /* Parse command line options and set default flag values. Do minimal
431 options processing. */
433 decode_options (unsigned int argc
, const char **argv
)
435 unsigned int i
, lang_mask
;
437 /* Perform language-specific options initialization. */
438 lang_mask
= lang_hooks
.init_options (argc
, argv
);
440 lang_hooks
.initialize_diagnostics (global_dc
);
442 /* Scan to see what optimization level has been specified. That will
443 determine the default value of many flags. */
444 for (i
= 1; i
< argc
; i
++)
446 if (!strcmp (argv
[i
], "-O"))
451 else if (argv
[i
][0] == '-' && argv
[i
][1] == 'O')
453 /* Handle -Os, -O2, -O3, -O69, ... */
454 const char *p
= &argv
[i
][2];
456 if ((p
[0] == 's') && (p
[1] == 0))
460 /* Optimizing for size forces optimize to be 2. */
465 const int optimize_val
= read_integral_parameter (p
, p
- 2, -1);
466 if (optimize_val
!= -1)
468 optimize
= optimize_val
;
477 flag_merge_constants
= 0;
483 flag_thread_jumps
= 1;
485 flag_delayed_branch
= 1;
487 #ifdef CAN_DEBUG_WITHOUT_FP
488 flag_omit_frame_pointer
= 1;
490 flag_guess_branch_prob
= 1;
491 flag_cprop_registers
= 1;
492 flag_loop_optimize
= 1;
493 flag_if_conversion
= 1;
494 flag_if_conversion2
= 1;
501 flag_tree_live_range_split
= 1;
503 flag_tree_copyrename
= 1;
508 /* Loop header copying usually increases size of the code. This used
509 not to be true, since quite often it is possible to verify that
510 the condition is satisfied in the first iteration and therefore
511 to eliminate it. Jump threading handles these cases now. */
518 flag_crossjumping
= 1;
519 flag_optimize_sibling_calls
= 1;
520 flag_cse_follow_jumps
= 1;
521 flag_cse_skip_blocks
= 1;
523 flag_expensive_optimizations
= 1;
524 flag_strength_reduce
= 1;
525 flag_rerun_cse_after_loop
= 1;
526 flag_rerun_loop_opt
= 1;
527 flag_caller_saves
= 1;
530 #ifdef INSN_SCHEDULING
531 flag_schedule_insns
= 1;
532 flag_schedule_insns_after_reload
= 1;
535 flag_strict_aliasing
= 1;
536 flag_delete_null_pointer_checks
= 1;
537 flag_reorder_blocks
= 1;
538 flag_reorder_functions
= 1;
539 flag_unit_at_a_time
= 1;
544 flag_inline_functions
= 1;
545 flag_unswitch_loops
= 1;
546 flag_gcse_after_reload
= 1;
549 if (optimize
< 2 || optimize_size
)
556 /* Don't reorder blocks when optimizing for size because extra
557 jump insns may be created; also barrier may create extra padding.
559 More correctly we should have a block reordering mode that tried
560 to minimize the combined size of all the jumps. This would more
561 or less automatically remove extra jumps, but would also try to
562 use more short jumps instead of long jumps. */
563 flag_reorder_blocks
= 0;
564 flag_reorder_blocks_and_partition
= 0;
569 /* Inlining of very small functions usually reduces total size. */
570 set_param_value ("max-inline-insns-single", 5);
571 set_param_value ("max-inline-insns-auto", 5);
572 set_param_value ("max-inline-insns-rtl", 10);
573 flag_inline_functions
= 1;
576 /* Initialize whether `char' is signed. */
577 flag_signed_char
= DEFAULT_SIGNED_CHAR
;
578 /* Set this to a special "uninitialized" value. The actual default is set
579 after target options have been processed. */
580 flag_short_enums
= 2;
582 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
585 set_target_switch ("");
587 /* Unwind tables are always present when a target has ABI-specified unwind
588 tables, so the default should be ON. */
589 #ifdef TARGET_UNWIND_INFO
590 flag_unwind_tables
= TARGET_UNWIND_INFO
;
593 #ifdef OPTIMIZATION_OPTIONS
594 /* Allow default optimizations to be specified on a per-machine basis. */
595 OPTIMIZATION_OPTIONS (optimize
, optimize_size
);
598 handle_options (argc
, argv
, lang_mask
);
602 if (flag_pic
&& !flag_pie
)
605 if (flag_no_inline
== 2)
608 flag_really_no_inline
= flag_no_inline
;
610 /* Set flag_no_inline before the post_options () hook. The C front
611 ends use it to determine tree inlining defaults. FIXME: such
612 code should be lang-independent when all front ends use tree
613 inlining, in which case it, and this condition, should be moved
614 to the top of process_options() instead. */
617 /* Inlining does not work if not optimizing,
618 so force it not to be done. */
622 /* The c_decode_option function and decode_option hook set
623 this to `2' if -Wall is used, so we can avoid giving out
624 lots of errors for people who don't realize what -Wall does. */
625 if (warn_uninitialized
== 1)
626 warning ("-Wuninitialized is not supported without -O");
629 if (flag_really_no_inline
== 2)
630 flag_really_no_inline
= flag_no_inline
;
632 /* The optimization to partition hot and cold basic blocks into separate
633 sections of the .o and executable files does not work (currently)
634 with exception handling. If flag_exceptions is turned on we need to
635 turn off the partitioning optimization. */
637 if (flag_exceptions
&& flag_reorder_blocks_and_partition
)
640 ("-freorder-blocks-and-partition does not work with exceptions");
641 flag_reorder_blocks_and_partition
= 0;
642 flag_reorder_blocks
= 1;
646 /* Handle target- and language-independent options. Return zero to
647 generate an "unknown option" message. Only options that need
648 extra handling need to be listed here; if you simply want
649 VALUE assigned to a variable, it happens automatically. */
652 common_handle_option (size_t scode
, const char *arg
, int value
)
654 enum opt_code code
= (enum opt_code
) scode
;
660 exit_after_options
= true;
667 case OPT__target_help
:
668 display_target_options ();
669 exit_after_options
= true;
673 print_version (stderr
, "");
674 exit_after_options
= true;
678 g_switch_value
= value
;
684 /* Currently handled in a prescan. */
688 /* For backward compatibility, -W is the same as -Wextra. */
696 case OPT_Wlarger_than_
:
697 larger_than_size
= value
;
698 warn_larger_than
= value
!= -1;
701 case OPT_Wstrict_aliasing
:
702 case OPT_Wstrict_aliasing_
:
703 warn_strict_aliasing
= value
;
712 aux_info_file_name
= arg
;
713 flag_gen_aux_info
= 1;
720 case OPT_auxbase_strip
:
722 char *tmp
= xstrdup (arg
);
723 strip_off_ending (tmp
, strlen (tmp
));
730 decode_d_option (arg
);
734 dump_base_name
= arg
;
737 case OPT_falign_functions_
:
738 align_functions
= value
;
741 case OPT_falign_jumps_
:
745 case OPT_falign_labels_
:
746 align_labels
= value
;
749 case OPT_falign_loops_
:
753 case OPT_fbranch_probabilities
:
754 flag_branch_probabilities_set
= true;
757 case OPT_fcall_used_
:
758 fix_register (arg
, 0, 1);
761 case OPT_fcall_saved_
:
762 fix_register (arg
, 0, 0);
765 case OPT_fdiagnostics_show_location_
:
766 if (!strcmp (arg
, "once"))
767 diagnostic_prefixing_rule (global_dc
) = DIAGNOSTICS_SHOW_PREFIX_ONCE
;
768 else if (!strcmp (arg
, "every-line"))
769 diagnostic_prefixing_rule (global_dc
)
770 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE
;
776 if (!dump_switch_p (arg
))
781 set_fast_math_flags (value
);
785 fix_register (arg
, 1, 1);
788 case OPT_finline_limit_
:
789 case OPT_finline_limit_eq
:
790 set_param_value ("max-inline-insns-single", value
/ 2);
791 set_param_value ("max-inline-insns-auto", value
/ 2);
792 set_param_value ("max-inline-insns-rtl", value
);
795 case OPT_fmessage_length_
:
796 pp_set_line_maximum_length (global_dc
->printer
, value
);
799 case OPT_fpeel_loops
:
800 flag_peel_loops_set
= true;
803 case OPT_fprofile_arcs
:
804 profile_arc_flag_set
= true;
807 case OPT_fprofile_use
:
808 if (!flag_branch_probabilities_set
)
809 flag_branch_probabilities
= value
;
810 if (!flag_profile_values_set
)
811 flag_profile_values
= value
;
812 if (!flag_unroll_loops_set
)
813 flag_unroll_loops
= value
;
814 if (!flag_peel_loops_set
)
815 flag_peel_loops
= value
;
816 if (!flag_tracer_set
)
818 if (!flag_value_profile_transformations_set
)
819 flag_value_profile_transformations
= value
;
822 case OPT_fprofile_generate
:
823 if (!profile_arc_flag_set
)
824 profile_arc_flag
= value
;
825 if (!flag_profile_values_set
)
826 flag_profile_values
= value
;
827 if (!flag_value_profile_transformations_set
)
828 flag_value_profile_transformations
= value
;
831 case OPT_fprofile_values
:
832 flag_profile_values_set
= true;
835 case OPT_fvisibility_
:
837 if (!strcmp(arg
, "default"))
838 default_visibility
= VISIBILITY_DEFAULT
;
839 else if (!strcmp(arg
, "internal"))
840 default_visibility
= VISIBILITY_INTERNAL
;
841 else if (!strcmp(arg
, "hidden"))
842 default_visibility
= VISIBILITY_HIDDEN
;
843 else if (!strcmp(arg
, "protected"))
844 default_visibility
= VISIBILITY_PROTECTED
;
846 error ("unrecognised visibility value \"%s\"", arg
);
851 flag_value_profile_transformations_set
= value
;
854 case OPT_frandom_seed
:
855 /* The real switch is -fno-random-seed. */
858 flag_random_seed
= NULL
;
861 case OPT_frandom_seed_
:
862 flag_random_seed
= arg
;
865 case OPT_fsched_verbose_
:
866 #ifdef INSN_SCHEDULING
867 fix_sched_param ("verbose", arg
);
873 case OPT_fsched_stalled_insns_
:
874 flag_sched_stalled_insns
= value
;
875 if (flag_sched_stalled_insns
== 0)
876 flag_sched_stalled_insns
= -1;
879 case OPT_fsched_stalled_insns_dep_
:
880 flag_sched_stalled_insns_dep
= value
;
883 case OPT_fstack_limit
:
884 /* The real switch is -fno-stack-limit. */
887 stack_limit_rtx
= NULL_RTX
;
890 case OPT_fstack_limit_register_
:
892 int reg
= decode_reg_name (arg
);
894 error ("unrecognized register name \"%s\"", arg
);
896 stack_limit_rtx
= gen_rtx_REG (Pmode
, reg
);
900 case OPT_fstack_limit_symbol_
:
901 stack_limit_rtx
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (arg
));
904 case OPT_ftls_model_
:
905 if (!strcmp (arg
, "global-dynamic"))
906 flag_tls_default
= TLS_MODEL_GLOBAL_DYNAMIC
;
907 else if (!strcmp (arg
, "local-dynamic"))
908 flag_tls_default
= TLS_MODEL_LOCAL_DYNAMIC
;
909 else if (!strcmp (arg
, "initial-exec"))
910 flag_tls_default
= TLS_MODEL_INITIAL_EXEC
;
911 else if (!strcmp (arg
, "local-exec"))
912 flag_tls_default
= TLS_MODEL_LOCAL_EXEC
;
914 warning ("unknown tls-model \"%s\"", arg
);
918 flag_tracer_set
= true;
921 case OPT_ftree_points_to_
:
922 if (!strcmp (arg
, "andersen"))
924 flag_tree_points_to
= PTA_ANDERSEN
;
926 warning ("Andersen's PTA not available - libbanshee not compiled.");
928 else if (!strcmp (arg
, "none"))
929 flag_tree_points_to
= PTA_NONE
;
932 warning ("`%s`: unknown points-to analysis algorithm", arg
);
937 case OPT_funroll_loops
:
938 flag_unroll_loops_set
= true;
942 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
);
946 set_debug_level (SDB_DEBUG
, false, arg
);
950 set_debug_level (DWARF2_DEBUG
, false, arg
);
954 set_debug_level (NO_DEBUG
, 2, arg
);
959 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
);
963 set_debug_level (VMS_DEBUG
, false, arg
);
968 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
);
972 set_target_switch (arg
);
979 case OPT_pedantic_errors
:
980 flag_pedantic_errors
= pedantic
= 1;
984 /* If the flag was handled in a standard way, assume the lack of
985 processing here is intentional. */
986 if (cl_options
[scode
].flag_var
)
995 /* Handle --param NAME=VALUE. */
997 handle_param (const char *carg
)
1002 arg
= xstrdup (carg
);
1003 equal
= strchr (arg
, '=');
1005 error ("%s: --param arguments should be of the form NAME=VALUE", arg
);
1008 value
= integral_argument (equal
+ 1);
1010 error ("invalid --param value `%s'", equal
+ 1);
1014 set_param_value (arg
, value
);
1021 /* Handle -W and -Wextra. */
1023 set_Wextra (int setting
)
1025 extra_warnings
= setting
;
1026 warn_unused_value
= setting
;
1027 warn_unused_parameter
= (setting
&& maybe_warn_unused_parameter
);
1029 /* We save the value of warn_uninitialized, since if they put
1030 -Wuninitialized on the command line, we need to generate a
1031 warning about not using it without also specifying -O. */
1033 warn_uninitialized
= 0;
1034 else if (warn_uninitialized
!= 1)
1035 warn_uninitialized
= 2;
1038 /* Initialize unused warning flags. */
1040 set_Wunused (int setting
)
1042 warn_unused_function
= setting
;
1043 warn_unused_label
= setting
;
1044 /* Unused function parameter warnings are reported when either
1045 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1046 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1047 otherwise set maybe_warn_extra_parameter, which will be picked up
1049 maybe_warn_unused_parameter
= setting
;
1050 warn_unused_parameter
= (setting
&& extra_warnings
);
1051 warn_unused_variable
= setting
;
1052 warn_unused_value
= setting
;
1055 /* The following routines are useful in setting all the flags that
1056 -ffast-math and -fno-fast-math imply. */
1058 set_fast_math_flags (int set
)
1060 flag_trapping_math
= !set
;
1061 flag_unsafe_math_optimizations
= set
;
1062 flag_finite_math_only
= set
;
1063 flag_errno_math
= !set
;
1066 flag_signaling_nans
= 0;
1067 flag_rounding_math
= 0;
1071 /* Return true iff flags are set as if -ffast-math. */
1073 fast_math_flags_set_p (void)
1075 return (!flag_trapping_math
1076 && flag_unsafe_math_optimizations
1077 && flag_finite_math_only
1078 && !flag_errno_math
);
1081 /* Handle a debug output -g switch. EXTENDED is true or false to support
1082 extended output (2 is special and means "-ggdb" was given). */
1084 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
)
1086 static bool type_explicit
;
1088 use_gnu_debug_info_extensions
= extended
;
1090 if (type
== NO_DEBUG
)
1092 if (write_symbols
== NO_DEBUG
)
1094 write_symbols
= PREFERRED_DEBUGGING_TYPE
;
1098 #ifdef DWARF2_DEBUGGING_INFO
1099 write_symbols
= DWARF2_DEBUG
;
1100 #elif defined DBX_DEBUGGING_INFO
1101 write_symbols
= DBX_DEBUG
;
1105 if (write_symbols
== NO_DEBUG
)
1106 warning ("target system does not support debug output");
1111 /* Does it conflict with an already selected type? */
1112 if (type_explicit
&& write_symbols
!= NO_DEBUG
&& type
!= write_symbols
)
1113 error ("debug format \"%s\" conflicts with prior selection",
1114 debug_type_names
[type
]);
1115 write_symbols
= type
;
1116 type_explicit
= true;
1119 /* A debug flag without a level defaults to level 2. */
1122 if (!debug_info_level
)
1123 debug_info_level
= 2;
1127 debug_info_level
= integral_argument (arg
);
1128 if (debug_info_level
== (unsigned int) -1)
1129 error ("unrecognised debug output level \"%s\"", arg
);
1130 else if (debug_info_level
> 3)
1131 error ("debug output level %s is too high", arg
);
1135 /* Output --help text. */
1142 GET_ENVIRONMENT (p
, "COLUMNS");
1145 int value
= atoi (p
);
1150 puts (_("The following options are language-independent:\n"));
1152 print_filtered_help (CL_COMMON
);
1153 print_param_help ();
1155 for (i
= 0; lang_names
[i
]; i
++)
1157 printf (_("The %s front end recognizes the following options:\n\n"),
1159 print_filtered_help (1U << i
);
1162 display_target_options ();
1165 /* Print the help for --param. */
1167 print_param_help (void)
1171 puts (_("The --param option recognizes the following as parameters:\n"));
1173 for (i
= 0; i
< LAST_PARAM
; i
++)
1175 const char *help
= compiler_params
[i
].help
;
1176 const char *param
= compiler_params
[i
].option
;
1178 if (help
== NULL
|| *help
== '\0')
1179 help
= undocumented_msg
;
1181 /* Get the translation. */
1184 wrap_help (help
, param
, strlen (param
));
1190 /* Print help for a specific front-end, etc. */
1192 print_filtered_help (unsigned int flag
)
1194 unsigned int i
, len
, filter
, indent
= 0;
1195 bool duplicates
= false;
1196 const char *help
, *opt
, *tab
;
1197 static char *printed
;
1199 if (flag
== CL_COMMON
)
1203 printed
= xmalloc (cl_options_count
);
1204 memset (printed
, 0, cl_options_count
);
1208 /* Don't print COMMON options twice. */
1209 filter
= flag
| CL_COMMON
;
1211 for (i
= 0; i
< cl_options_count
; i
++)
1213 if ((cl_options
[i
].flags
& filter
) != flag
)
1216 /* Skip help for internal switches. */
1217 if (cl_options
[i
].flags
& CL_UNDOCUMENTED
)
1220 /* Skip switches that have already been printed, mark them to be
1225 indent
= print_switch (cl_options
[i
].opt_text
, indent
);
1236 for (i
= 0; i
< cl_options_count
; i
++)
1238 if ((cl_options
[i
].flags
& filter
) != flag
)
1241 /* Skip help for internal switches. */
1242 if (cl_options
[i
].flags
& CL_UNDOCUMENTED
)
1245 /* Skip switches that have already been printed. */
1251 help
= cl_options
[i
].help
;
1253 help
= undocumented_msg
;
1255 /* Get the translation. */
1258 tab
= strchr (help
, '\t');
1267 opt
= cl_options
[i
].opt_text
;
1271 wrap_help (help
, opt
, len
);
1277 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1278 word-wrapped HELP in a second column. */
1280 print_switch (const char *text
, unsigned int indent
)
1282 unsigned int len
= strlen (text
) + 1; /* trailing comma */
1287 if (indent
+ len
> columns
)
1298 fputs (text
, stdout
);
1300 return indent
+ len
+ 1;
1303 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1304 word-wrapped HELP in a second column. */
1306 wrap_help (const char *help
, const char *item
, unsigned int item_width
)
1308 unsigned int col_width
= 27;
1309 unsigned int remaining
, room
, len
;
1311 remaining
= strlen (help
);
1315 room
= columns
- 3 - MAX (col_width
, item_width
);
1324 for (i
= 0; help
[i
]; i
++)
1326 if (i
>= room
&& len
!= remaining
)
1330 else if ((help
[i
] == '-' || help
[i
] == '/')
1331 && help
[i
+ 1] != ' '
1332 && i
> 0 && ISALPHA (help
[i
- 1]))
1337 printf( " %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1339 while (help
[len
] == ' ')