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, 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 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_help (void);
114 static void print_param_help (void);
115 static void print_filtered_help (unsigned int flag
);
116 static unsigned int print_switch (const char *text
, unsigned int indent
);
117 static void set_debug_level (enum debug_info_type type
, int extended
,
120 /* Perform a binary search to find which option the command-line INPUT
121 matches. Returns its index in the option array, and N_OPTS
122 (cl_options_count) on failure.
124 This routine is quite subtle. A normal binary search is not good
125 enough because some options can be suffixed with an argument, and
126 multiple sub-matches can occur, e.g. input of "-pedantic" matching
127 the initial substring of "-pedantic-errors".
129 A more complicated example is -gstabs. It should match "-g" with
130 an argument of "stabs". Suppose, however, that the number and list
131 of switches are such that the binary search tests "-gen-decls"
132 before having tested "-g". This doesn't match, and as "-gen-decls"
133 is less than "-gstabs", it will become the lower bound of the
134 binary search range, and "-g" will never be seen. To resolve this
135 issue, opts.sh makes "-gen-decls" point, via the back_chain member,
136 to "-g" so that failed searches that end between "-gen-decls" and
137 the lexicographically subsequent switch know to go back and see if
138 "-g" causes a match (which it does in this example).
140 This search is done in such a way that the longest match for the
141 front end in question wins. If there is no match for the current
142 front end, the longest match for a different front end is returned
143 (or N_OPTS if none) and the caller emits an error message. */
145 find_opt (const char *input
, int lang_mask
)
147 size_t mn
, mx
, md
, opt_len
;
148 size_t match_wrong_lang
;
152 mx
= cl_options_count
;
154 /* Find mn such this lexicographical inequality holds:
155 cl_options[mn] <= input < cl_options[mn + 1]. */
159 opt_len
= cl_options
[md
].opt_len
;
160 comp
= strncmp (input
, cl_options
[md
].opt_text
+ 1, opt_len
);
168 /* This is the switch that is the best match but for a different
169 front end, or cl_options_count if there is no match at all. */
170 match_wrong_lang
= cl_options_count
;
172 /* Backtrace the chain of possible matches, returning the longest
173 one, if any, that fits best. With current GCC switches, this
174 loop executes at most twice. */
177 const struct cl_option
*opt
= &cl_options
[mn
];
179 /* Is the input either an exact match or a prefix that takes a
181 if (!strncmp (input
, opt
->opt_text
+ 1, opt
->opt_len
)
182 && (input
[opt
->opt_len
] == '\0' || (opt
->flags
& CL_JOINED
)))
184 /* If language is OK, return it. */
185 if (opt
->flags
& lang_mask
)
188 /* If we haven't remembered a prior match, remember this
189 one. Any prior match is necessarily better. */
190 if (match_wrong_lang
== cl_options_count
)
191 match_wrong_lang
= mn
;
194 /* Try the next possibility. This is cl_options_count if there
196 mn
= opt
->back_chain
;
198 while (mn
!= cl_options_count
);
200 /* Return the best wrong match, or cl_options_count if none. */
201 return match_wrong_lang
;
204 /* If ARG is a non-negative integer made up solely of digits, return its
205 value, otherwise return -1. */
207 integral_argument (const char *arg
)
211 while (*p
&& ISDIGIT (*p
))
220 /* Return a malloced slash-separated list of languages in MASK. */
222 write_langs (unsigned int mask
)
224 unsigned int n
= 0, len
= 0;
225 const char *lang_name
;
228 for (n
= 0; (lang_name
= lang_names
[n
]) != 0; n
++)
229 if (mask
& (1U << n
))
230 len
+= strlen (lang_name
) + 1;
232 result
= xmalloc (len
);
234 for (n
= 0; (lang_name
= lang_names
[n
]) != 0; n
++)
235 if (mask
& (1U << n
))
239 strcpy (result
+ len
, lang_name
);
240 len
+= strlen (lang_name
);
248 /* Complain that switch OPT_INDEX does not apply to this front end. */
250 complain_wrong_lang (const char *text
, const struct cl_option
*option
,
251 unsigned int lang_mask
)
253 char *ok_langs
, *bad_lang
;
255 ok_langs
= write_langs (option
->flags
);
256 bad_lang
= write_langs (lang_mask
);
258 /* Eventually this should become a hard error IMO. */
259 warning ("command line option \"%s\" is valid for %s but not for %s",
260 text
, ok_langs
, bad_lang
);
266 /* Handle the switch beginning at ARGV for the language indicated by
267 LANG_MASK. Returns the number of switches consumed. */
269 handle_option (const char **argv
, unsigned int lang_mask
)
272 const char *opt
, *arg
= 0;
275 unsigned int result
= 0;
276 const struct cl_option
*option
;
280 /* Drop the "no-" from negative switches. */
281 if ((opt
[1] == 'W' || opt
[1] == 'f')
282 && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-')
284 size_t len
= strlen (opt
) - 3;
286 dup
= xmalloc (len
+ 1);
289 memcpy (dup
+ 2, opt
+ 5, len
- 2 + 1);
294 opt_index
= find_opt (opt
+ 1, lang_mask
| CL_COMMON
);
295 if (opt_index
== cl_options_count
)
298 option
= &cl_options
[opt_index
];
300 /* Reject negative form of switches that don't take negatives as
302 if (!value
&& (option
->flags
& CL_REJECT_NEGATIVE
))
305 /* We've recognized this switch. */
308 /* Sort out any argument the switch takes. */
309 if (option
->flags
& CL_JOINED
)
311 /* Have arg point to the original switch. This is because
312 some code, such as disable_builtin_function, expects its
313 argument to be persistent until the program exits. */
314 arg
= argv
[0] + cl_options
[opt_index
].opt_len
+ 1;
316 arg
+= strlen ("no-");
318 if (*arg
== '\0' && !(option
->flags
& CL_MISSING_OK
))
320 if (option
->flags
& CL_SEPARATE
)
326 /* Missing argument. */
330 else if (option
->flags
& CL_SEPARATE
)
336 /* Now we've swallowed any potential argument, complain if this
337 is a switch for a different front end. */
338 if (!(option
->flags
& (lang_mask
| CL_COMMON
)))
340 complain_wrong_lang (argv
[0], option
, lang_mask
);
344 if (arg
== NULL
&& (option
->flags
& (CL_JOINED
| CL_SEPARATE
)))
346 if (!lang_hooks
.missing_argument (opt
, opt_index
))
347 error ("missing argument to \"%s\"", opt
);
351 /* If the switch takes an integer, convert it. */
352 if (arg
&& (option
->flags
& CL_UINTEGER
))
354 value
= integral_argument (arg
);
357 error ("argument to \"%s\" should be a non-negative integer",
363 if (option
->flag_var
)
365 if (option
->has_set_value
)
368 *option
->flag_var
= option
->set_value
;
370 *option
->flag_var
= !option
->set_value
;
373 *option
->flag_var
= value
;
376 if (option
->flags
& lang_mask
)
377 if (lang_hooks
.handle_option (opt_index
, arg
, value
) == 0)
380 if (result
&& (option
->flags
& CL_COMMON
))
381 if (common_handle_option (opt_index
, arg
, value
) == 0)
390 /* Handle FILENAME from the command line. */
392 add_input_filename (const char *filename
)
395 in_fnames
= xrealloc (in_fnames
, num_in_fnames
* sizeof (in_fnames
[0]));
396 in_fnames
[num_in_fnames
- 1] = filename
;
399 /* Decode and handle the vector of command line options. LANG_MASK
400 contains has a single bit set representing the current
403 handle_options (unsigned int argc
, const char **argv
, unsigned int lang_mask
)
407 for (i
= 1; i
< argc
; i
+= n
)
409 const char *opt
= argv
[i
];
411 /* Interpret "-" or a non-switch as a file name. */
412 if (opt
[0] != '-' || opt
[1] == '\0')
414 if (main_input_filename
== NULL
)
415 main_input_filename
= opt
;
416 add_input_filename (opt
);
421 n
= handle_option (argv
+ i
, lang_mask
);
426 error ("unrecognized command line option \"%s\"", opt
);
431 /* Parse command line options and set default flag values. Do minimal
432 options processing. */
434 decode_options (unsigned int argc
, const char **argv
)
436 unsigned int i
, lang_mask
;
438 /* Perform language-specific options initialization. */
439 lang_mask
= lang_hooks
.init_options (argc
, argv
);
441 lang_hooks
.initialize_diagnostics (global_dc
);
443 /* Scan to see what optimization level has been specified. That will
444 determine the default value of many flags. */
445 for (i
= 1; i
< argc
; i
++)
447 if (!strcmp (argv
[i
], "-O"))
452 else if (argv
[i
][0] == '-' && argv
[i
][1] == 'O')
454 /* Handle -Os, -O2, -O3, -O69, ... */
455 const char *p
= &argv
[i
][2];
457 if ((p
[0] == 's') && (p
[1] == 0))
461 /* Optimizing for size forces optimize to be 2. */
466 const int optimize_val
= read_integral_parameter (p
, p
- 2, -1);
467 if (optimize_val
!= -1)
469 optimize
= optimize_val
;
478 flag_merge_constants
= 0;
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;
500 flag_tree_live_range_split
= 1;
502 flag_tree_copyrename
= 1;
507 /* Loop header copying usually increases size of the code. This used
508 not to be true, since quite often it is possible to verify that
509 the condition is satisfied in the first iteration and therefore
510 to eliminate it. Jump threading handles these cases now. */
517 flag_thread_jumps
= 1;
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;
543 /* PRE tends to generate bigger code. */
550 flag_inline_functions
= 1;
551 flag_unswitch_loops
= 1;
552 flag_gcse_after_reload
= 1;
555 if (optimize
< 2 || optimize_size
)
562 /* Don't reorder blocks when optimizing for size because extra
563 jump insns may be created; also barrier may create extra padding.
565 More correctly we should have a block reordering mode that tried
566 to minimize the combined size of all the jumps. This would more
567 or less automatically remove extra jumps, but would also try to
568 use more short jumps instead of long jumps. */
569 flag_reorder_blocks
= 0;
570 flag_reorder_blocks_and_partition
= 0;
575 /* Inlining of very small functions usually reduces total size. */
576 set_param_value ("max-inline-insns-single", 5);
577 set_param_value ("max-inline-insns-auto", 5);
578 flag_inline_functions
= 1;
580 /* We want to crossjump as much as possible. */
581 set_param_value ("min-crossjump-insns", 1);
584 /* Initialize whether `char' is signed. */
585 flag_signed_char
= DEFAULT_SIGNED_CHAR
;
586 /* Set this to a special "uninitialized" value. The actual default is set
587 after target options have been processed. */
588 flag_short_enums
= 2;
590 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
593 set_target_switch ("");
595 /* Unwind tables are always present when a target has ABI-specified unwind
596 tables, so the default should be ON. */
597 #ifdef TARGET_UNWIND_INFO
598 flag_unwind_tables
= TARGET_UNWIND_INFO
;
601 #ifdef OPTIMIZATION_OPTIONS
602 /* Allow default optimizations to be specified on a per-machine basis. */
603 OPTIMIZATION_OPTIONS (optimize
, optimize_size
);
606 handle_options (argc
, argv
, lang_mask
);
610 if (flag_pic
&& !flag_pie
)
613 if (flag_no_inline
== 2)
616 flag_really_no_inline
= flag_no_inline
;
618 /* Set flag_no_inline before the post_options () hook. The C front
619 ends use it to determine tree inlining defaults. FIXME: such
620 code should be lang-independent when all front ends use tree
621 inlining, in which case it, and this condition, should be moved
622 to the top of process_options() instead. */
625 /* Inlining does not work if not optimizing,
626 so force it not to be done. */
630 /* The c_decode_option function and decode_option hook set
631 this to `2' if -Wall is used, so we can avoid giving out
632 lots of errors for people who don't realize what -Wall does. */
633 if (warn_uninitialized
== 1)
634 warning ("-Wuninitialized is not supported without -O");
637 if (flag_really_no_inline
== 2)
638 flag_really_no_inline
= flag_no_inline
;
640 /* The optimization to partition hot and cold basic blocks into separate
641 sections of the .o and executable files does not work (currently)
642 with exception handling. If flag_exceptions is turned on we need to
643 turn off the partitioning optimization. */
645 if (flag_exceptions
&& flag_reorder_blocks_and_partition
)
648 ("-freorder-blocks-and-partition does not work with exceptions");
649 flag_reorder_blocks_and_partition
= 0;
650 flag_reorder_blocks
= 1;
653 /* The optimization to partition hot and cold basic blocks into
654 separate sections of the .o and executable files does not currently
655 work correctly with DWARF debugging turned on. Until this is fixed
656 we will disable the optimization when DWARF debugging is set. */
658 if (flag_reorder_blocks_and_partition
&& write_symbols
== DWARF2_DEBUG
)
661 ("-freorder-blocks-and-partition does not work with -g (currently)");
662 flag_reorder_blocks_and_partition
= 0;
663 flag_reorder_blocks
= 1;
667 /* Handle target- and language-independent options. Return zero to
668 generate an "unknown option" message. Only options that need
669 extra handling need to be listed here; if you simply want
670 VALUE assigned to a variable, it happens automatically. */
673 common_handle_option (size_t scode
, const char *arg
, int value
)
675 enum opt_code code
= (enum opt_code
) scode
;
681 exit_after_options
= true;
688 case OPT__target_help
:
689 display_target_options ();
690 exit_after_options
= true;
694 print_version (stderr
, "");
695 exit_after_options
= true;
699 g_switch_value
= value
;
705 /* Currently handled in a prescan. */
709 /* For backward compatibility, -W is the same as -Wextra. */
717 case OPT_Wlarger_than_
:
718 larger_than_size
= value
;
719 warn_larger_than
= value
!= -1;
722 case OPT_Wstrict_aliasing
:
723 case OPT_Wstrict_aliasing_
:
724 warn_strict_aliasing
= value
;
733 aux_info_file_name
= arg
;
734 flag_gen_aux_info
= 1;
741 case OPT_auxbase_strip
:
743 char *tmp
= xstrdup (arg
);
744 strip_off_ending (tmp
, strlen (tmp
));
751 decode_d_option (arg
);
755 dump_base_name
= arg
;
758 case OPT_falign_functions_
:
759 align_functions
= value
;
762 case OPT_falign_jumps_
:
766 case OPT_falign_labels_
:
767 align_labels
= value
;
770 case OPT_falign_loops_
:
774 case OPT_fbranch_probabilities
:
775 flag_branch_probabilities_set
= true;
778 case OPT_fcall_used_
:
779 fix_register (arg
, 0, 1);
782 case OPT_fcall_saved_
:
783 fix_register (arg
, 0, 0);
786 case OPT_fdiagnostics_show_location_
:
787 if (!strcmp (arg
, "once"))
788 diagnostic_prefixing_rule (global_dc
) = DIAGNOSTICS_SHOW_PREFIX_ONCE
;
789 else if (!strcmp (arg
, "every-line"))
790 diagnostic_prefixing_rule (global_dc
)
791 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE
;
797 if (!dump_switch_p (arg
))
802 set_fast_math_flags (value
);
806 fix_register (arg
, 1, 1);
809 case OPT_finline_limit_
:
810 case OPT_finline_limit_eq
:
811 set_param_value ("max-inline-insns-single", value
/ 2);
812 set_param_value ("max-inline-insns-auto", value
/ 2);
815 case OPT_fmessage_length_
:
816 pp_set_line_maximum_length (global_dc
->printer
, value
);
819 case OPT_fpack_struct_
:
820 if (value
<= 0 || (value
& (value
- 1)) || value
> 16)
821 error("structure alignment must be a small power of two, not %d", value
);
824 initial_max_fld_align
= value
;
825 maximum_field_alignment
= value
* BITS_PER_UNIT
;
829 case OPT_fpeel_loops
:
830 flag_peel_loops_set
= true;
833 case OPT_fprofile_arcs
:
834 profile_arc_flag_set
= true;
837 case OPT_fprofile_use
:
838 if (!flag_branch_probabilities_set
)
839 flag_branch_probabilities
= value
;
840 if (!flag_profile_values_set
)
841 flag_profile_values
= value
;
842 if (!flag_unroll_loops_set
)
843 flag_unroll_loops
= value
;
844 if (!flag_peel_loops_set
)
845 flag_peel_loops
= value
;
846 if (!flag_tracer_set
)
848 if (!flag_value_profile_transformations_set
)
849 flag_value_profile_transformations
= value
;
851 if (0 && !flag_speculative_prefetching_set
)
852 flag_speculative_prefetching
= value
;
856 case OPT_fprofile_generate
:
857 if (!profile_arc_flag_set
)
858 profile_arc_flag
= value
;
859 if (!flag_profile_values_set
)
860 flag_profile_values
= value
;
861 if (!flag_value_profile_transformations_set
)
862 flag_value_profile_transformations
= value
;
863 if (!flag_unroll_loops_set
)
864 flag_unroll_loops
= value
;
866 if (0 && !flag_speculative_prefetching_set
)
867 flag_speculative_prefetching
= value
;
871 case OPT_fprofile_values
:
872 flag_profile_values_set
= true;
875 case OPT_fvisibility_
:
877 if (!strcmp(arg
, "default"))
878 default_visibility
= VISIBILITY_DEFAULT
;
879 else if (!strcmp(arg
, "internal"))
880 default_visibility
= VISIBILITY_INTERNAL
;
881 else if (!strcmp(arg
, "hidden"))
882 default_visibility
= VISIBILITY_HIDDEN
;
883 else if (!strcmp(arg
, "protected"))
884 default_visibility
= VISIBILITY_PROTECTED
;
886 error ("unrecognised visibility value \"%s\"", arg
);
891 flag_value_profile_transformations_set
= true;
894 case OPT_fspeculative_prefetching
:
895 flag_speculative_prefetching_set
= true;
898 case OPT_frandom_seed
:
899 /* The real switch is -fno-random-seed. */
902 flag_random_seed
= NULL
;
905 case OPT_frandom_seed_
:
906 flag_random_seed
= arg
;
909 case OPT_fsched_verbose_
:
910 #ifdef INSN_SCHEDULING
911 fix_sched_param ("verbose", arg
);
917 case OPT_fsched_stalled_insns_
:
918 flag_sched_stalled_insns
= value
;
919 if (flag_sched_stalled_insns
== 0)
920 flag_sched_stalled_insns
= -1;
923 case OPT_fsched_stalled_insns_dep_
:
924 flag_sched_stalled_insns_dep
= value
;
927 case OPT_fstack_limit
:
928 /* The real switch is -fno-stack-limit. */
931 stack_limit_rtx
= NULL_RTX
;
934 case OPT_fstack_limit_register_
:
936 int reg
= decode_reg_name (arg
);
938 error ("unrecognized register name \"%s\"", arg
);
940 stack_limit_rtx
= gen_rtx_REG (Pmode
, reg
);
944 case OPT_fstack_limit_symbol_
:
945 stack_limit_rtx
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (arg
));
948 case OPT_ftree_vectorizer_verbose_
:
949 vect_set_verbosity_level (arg
);
952 case OPT_ftls_model_
:
953 if (!strcmp (arg
, "global-dynamic"))
954 flag_tls_default
= TLS_MODEL_GLOBAL_DYNAMIC
;
955 else if (!strcmp (arg
, "local-dynamic"))
956 flag_tls_default
= TLS_MODEL_LOCAL_DYNAMIC
;
957 else if (!strcmp (arg
, "initial-exec"))
958 flag_tls_default
= TLS_MODEL_INITIAL_EXEC
;
959 else if (!strcmp (arg
, "local-exec"))
960 flag_tls_default
= TLS_MODEL_LOCAL_EXEC
;
962 warning ("unknown tls-model \"%s\"", arg
);
966 flag_tracer_set
= true;
969 case OPT_funroll_loops
:
970 flag_unroll_loops_set
= true;
974 set_debug_level (NO_DEBUG
, DEFAULT_GDB_EXTENSIONS
, arg
);
978 set_debug_level (SDB_DEBUG
, false, arg
);
982 set_debug_level (DWARF2_DEBUG
, false, arg
);
986 set_debug_level (NO_DEBUG
, 2, arg
);
991 set_debug_level (DBX_DEBUG
, code
== OPT_gstabs_
, arg
);
995 set_debug_level (VMS_DEBUG
, false, arg
);
1000 set_debug_level (XCOFF_DEBUG
, code
== OPT_gxcoff_
, arg
);
1004 set_target_switch (arg
);
1008 asm_file_name
= arg
;
1011 case OPT_pedantic_errors
:
1012 flag_pedantic_errors
= pedantic
= 1;
1016 /* If the flag was handled in a standard way, assume the lack of
1017 processing here is intentional. */
1018 if (cl_options
[scode
].flag_var
)
1027 /* Handle --param NAME=VALUE. */
1029 handle_param (const char *carg
)
1034 arg
= xstrdup (carg
);
1035 equal
= strchr (arg
, '=');
1037 error ("%s: --param arguments should be of the form NAME=VALUE", arg
);
1040 value
= integral_argument (equal
+ 1);
1042 error ("invalid --param value %qs", equal
+ 1);
1046 set_param_value (arg
, value
);
1053 /* Handle -W and -Wextra. */
1055 set_Wextra (int setting
)
1057 extra_warnings
= setting
;
1058 warn_unused_value
= setting
;
1059 warn_unused_parameter
= (setting
&& maybe_warn_unused_parameter
);
1061 /* We save the value of warn_uninitialized, since if they put
1062 -Wuninitialized on the command line, we need to generate a
1063 warning about not using it without also specifying -O. */
1065 warn_uninitialized
= 0;
1066 else if (warn_uninitialized
!= 1)
1067 warn_uninitialized
= 2;
1070 /* Initialize unused warning flags. */
1072 set_Wunused (int setting
)
1074 warn_unused_function
= setting
;
1075 warn_unused_label
= setting
;
1076 /* Unused function parameter warnings are reported when either
1077 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1078 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1079 otherwise set maybe_warn_extra_parameter, which will be picked up
1081 maybe_warn_unused_parameter
= setting
;
1082 warn_unused_parameter
= (setting
&& extra_warnings
);
1083 warn_unused_variable
= setting
;
1084 warn_unused_value
= setting
;
1087 /* The following routines are useful in setting all the flags that
1088 -ffast-math and -fno-fast-math imply. */
1090 set_fast_math_flags (int set
)
1092 flag_trapping_math
= !set
;
1093 flag_unsafe_math_optimizations
= set
;
1094 flag_finite_math_only
= set
;
1095 flag_errno_math
= !set
;
1098 flag_signaling_nans
= 0;
1099 flag_rounding_math
= 0;
1100 flag_cx_limited_range
= 1;
1104 /* Return true iff flags are set as if -ffast-math. */
1106 fast_math_flags_set_p (void)
1108 return (!flag_trapping_math
1109 && flag_unsafe_math_optimizations
1110 && flag_finite_math_only
1111 && !flag_errno_math
);
1114 /* Handle a debug output -g switch. EXTENDED is true or false to support
1115 extended output (2 is special and means "-ggdb" was given). */
1117 set_debug_level (enum debug_info_type type
, int extended
, const char *arg
)
1119 static bool type_explicit
;
1121 use_gnu_debug_info_extensions
= extended
;
1123 if (type
== NO_DEBUG
)
1125 if (write_symbols
== NO_DEBUG
)
1127 write_symbols
= PREFERRED_DEBUGGING_TYPE
;
1131 #ifdef DWARF2_DEBUGGING_INFO
1132 write_symbols
= DWARF2_DEBUG
;
1133 #elif defined DBX_DEBUGGING_INFO
1134 write_symbols
= DBX_DEBUG
;
1138 if (write_symbols
== NO_DEBUG
)
1139 warning ("target system does not support debug output");
1144 /* Does it conflict with an already selected type? */
1145 if (type_explicit
&& write_symbols
!= NO_DEBUG
&& type
!= write_symbols
)
1146 error ("debug format \"%s\" conflicts with prior selection",
1147 debug_type_names
[type
]);
1148 write_symbols
= type
;
1149 type_explicit
= true;
1152 /* A debug flag without a level defaults to level 2. */
1155 if (!debug_info_level
)
1156 debug_info_level
= 2;
1160 debug_info_level
= integral_argument (arg
);
1161 if (debug_info_level
== (unsigned int) -1)
1162 error ("unrecognised debug output level \"%s\"", arg
);
1163 else if (debug_info_level
> 3)
1164 error ("debug output level %s is too high", arg
);
1168 /* Output --help text. */
1175 GET_ENVIRONMENT (p
, "COLUMNS");
1178 int value
= atoi (p
);
1183 puts (_("The following options are language-independent:\n"));
1185 print_filtered_help (CL_COMMON
);
1186 print_param_help ();
1188 for (i
= 0; lang_names
[i
]; i
++)
1190 printf (_("The %s front end recognizes the following options:\n\n"),
1192 print_filtered_help (1U << i
);
1195 display_target_options ();
1198 /* Print the help for --param. */
1200 print_param_help (void)
1204 puts (_("The --param option recognizes the following as parameters:\n"));
1206 for (i
= 0; i
< LAST_PARAM
; i
++)
1208 const char *help
= compiler_params
[i
].help
;
1209 const char *param
= compiler_params
[i
].option
;
1211 if (help
== NULL
|| *help
== '\0')
1212 help
= undocumented_msg
;
1214 /* Get the translation. */
1217 wrap_help (help
, param
, strlen (param
));
1223 /* Print help for a specific front-end, etc. */
1225 print_filtered_help (unsigned int flag
)
1227 unsigned int i
, len
, filter
, indent
= 0;
1228 bool duplicates
= false;
1229 const char *help
, *opt
, *tab
;
1230 static char *printed
;
1232 if (flag
== CL_COMMON
)
1236 printed
= xmalloc (cl_options_count
);
1237 memset (printed
, 0, cl_options_count
);
1241 /* Don't print COMMON options twice. */
1242 filter
= flag
| CL_COMMON
;
1244 for (i
= 0; i
< cl_options_count
; i
++)
1246 if ((cl_options
[i
].flags
& filter
) != flag
)
1249 /* Skip help for internal switches. */
1250 if (cl_options
[i
].flags
& CL_UNDOCUMENTED
)
1253 /* Skip switches that have already been printed, mark them to be
1258 indent
= print_switch (cl_options
[i
].opt_text
, indent
);
1269 for (i
= 0; i
< cl_options_count
; i
++)
1271 if ((cl_options
[i
].flags
& filter
) != flag
)
1274 /* Skip help for internal switches. */
1275 if (cl_options
[i
].flags
& CL_UNDOCUMENTED
)
1278 /* Skip switches that have already been printed. */
1284 help
= cl_options
[i
].help
;
1286 help
= undocumented_msg
;
1288 /* Get the translation. */
1291 tab
= strchr (help
, '\t');
1300 opt
= cl_options
[i
].opt_text
;
1304 wrap_help (help
, opt
, len
);
1310 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1311 word-wrapped HELP in a second column. */
1313 print_switch (const char *text
, unsigned int indent
)
1315 unsigned int len
= strlen (text
) + 1; /* trailing comma */
1320 if (indent
+ len
> columns
)
1331 fputs (text
, stdout
);
1333 return indent
+ len
+ 1;
1336 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1337 word-wrapped HELP in a second column. */
1339 wrap_help (const char *help
, const char *item
, unsigned int item_width
)
1341 unsigned int col_width
= 27;
1342 unsigned int remaining
, room
, len
;
1344 remaining
= strlen (help
);
1348 room
= columns
- 3 - MAX (col_width
, item_width
);
1357 for (i
= 0; help
[i
]; i
++)
1359 if (i
>= room
&& len
!= remaining
)
1363 else if ((help
[i
] == '-' || help
[i
] == '/')
1364 && help
[i
+ 1] != ' '
1365 && i
> 0 && ISALPHA (help
[i
- 1]))
1370 printf( " %-*.*s %.*s\n", col_width
, item_width
, item
, len
, help
);
1372 while (help
[len
] == ' ')