Daily bump.
[official-gcc.git] / gcc / opts.c
blob788c2cee7c6aa231929977b378cbcb821cfccd5e
1 /* Command line option handling.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006 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
10 version.
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
15 for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301, USA. */
22 #include "config.h"
23 #include "system.h"
24 #include "intl.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "tree.h"
28 #include "rtl.h"
29 #include "ggc.h"
30 #include "output.h"
31 #include "langhooks.h"
32 #include "opts.h"
33 #include "options.h"
34 #include "flags.h"
35 #include "toplev.h"
36 #include "params.h"
37 #include "diagnostic.h"
38 #include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
39 #include "insn-attr.h" /* For INSN_SCHEDULING. */
40 #include "target.h"
41 #include "tree-pass.h"
43 /* Value of the -G xx switch, and whether it was passed or not. */
44 unsigned HOST_WIDE_INT g_switch_value;
45 bool g_switch_set;
47 /* True if we should exit after parsing options. */
48 bool exit_after_options;
50 /* Print various extra warnings. -W/-Wextra. */
51 bool extra_warnings;
53 /* True to warn about any objects definitions whose size is larger
54 than N bytes. Also want about function definitions whose returned
55 values are larger than N bytes, where N is `larger_than_size'. */
56 bool warn_larger_than;
57 HOST_WIDE_INT larger_than_size;
59 /* Nonzero means warn about constructs which might not be
60 strict-aliasing safe. */
61 int warn_strict_aliasing;
63 /* Hack for cooperation between set_Wunused and set_Wextra. */
64 static bool maybe_warn_unused_parameter;
66 /* Type(s) of debugging information we are producing (if any). See
67 flags.h for the definitions of the different possible types of
68 debugging information. */
69 enum debug_info_type write_symbols = NO_DEBUG;
71 /* Level of debugging information we are producing. See flags.h for
72 the definitions of the different possible levels. */
73 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
75 /* Nonzero means use GNU-only extensions in the generated symbolic
76 debugging information. Currently, this only has an effect when
77 write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
78 bool use_gnu_debug_info_extensions;
80 /* The default visibility for all symbols (unless overridden) */
81 enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;
83 /* Disable unit-at-a-time for frontends that might be still broken in this
84 respect. */
86 bool no_unit_at_a_time_default;
88 /* Global visibility options. */
89 struct visibility_flags visibility_options;
91 /* Columns of --help display. */
92 static unsigned int columns = 80;
94 /* What to print when a switch has no documentation. */
95 static const char undocumented_msg[] = N_("This switch lacks documentation");
97 /* Used for bookkeeping on whether user set these flags so
98 -fprofile-use/-fprofile-generate does not use them. */
99 static bool profile_arc_flag_set, flag_profile_values_set;
100 static bool flag_unroll_loops_set, flag_tracer_set;
101 static bool flag_value_profile_transformations_set;
102 static bool flag_peel_loops_set, flag_branch_probabilities_set;
104 /* Input file names. */
105 const char **in_fnames;
106 unsigned num_in_fnames;
108 static int common_handle_option (size_t scode, const char *arg, int value,
109 unsigned int lang_mask);
110 static void handle_param (const char *);
111 static void set_Wextra (int);
112 static unsigned int handle_option (const char **argv, unsigned int lang_mask);
113 static char *write_langs (unsigned int lang_mask);
114 static void complain_wrong_lang (const char *, const struct cl_option *,
115 unsigned int lang_mask);
116 static void handle_options (unsigned int, const char **, unsigned int);
117 static void wrap_help (const char *help, const char *item, unsigned int);
118 static void print_target_help (void);
119 static void print_help (void);
120 static void print_param_help (void);
121 static void print_filtered_help (unsigned int);
122 static unsigned int print_switch (const char *text, unsigned int indent);
123 static void set_debug_level (enum debug_info_type type, int extended,
124 const char *arg);
126 /* If ARG is a non-negative integer made up solely of digits, return its
127 value, otherwise return -1. */
128 static int
129 integral_argument (const char *arg)
131 const char *p = arg;
133 while (*p && ISDIGIT (*p))
134 p++;
136 if (*p == '\0')
137 return atoi (arg);
139 return -1;
142 /* Return a malloced slash-separated list of languages in MASK. */
143 static char *
144 write_langs (unsigned int mask)
146 unsigned int n = 0, len = 0;
147 const char *lang_name;
148 char *result;
150 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
151 if (mask & (1U << n))
152 len += strlen (lang_name) + 1;
154 result = XNEWVEC (char, len);
155 len = 0;
156 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
157 if (mask & (1U << n))
159 if (len)
160 result[len++] = '/';
161 strcpy (result + len, lang_name);
162 len += strlen (lang_name);
165 result[len] = 0;
167 return result;
170 /* Complain that switch OPT_INDEX does not apply to this front end. */
171 static void
172 complain_wrong_lang (const char *text, const struct cl_option *option,
173 unsigned int lang_mask)
175 char *ok_langs, *bad_lang;
177 ok_langs = write_langs (option->flags);
178 bad_lang = write_langs (lang_mask);
180 /* Eventually this should become a hard error IMO. */
181 warning (0, "command line option \"%s\" is valid for %s but not for %s",
182 text, ok_langs, bad_lang);
184 free (ok_langs);
185 free (bad_lang);
188 /* Handle the switch beginning at ARGV for the language indicated by
189 LANG_MASK. Returns the number of switches consumed. */
190 static unsigned int
191 handle_option (const char **argv, unsigned int lang_mask)
193 size_t opt_index;
194 const char *opt, *arg = 0;
195 char *dup = 0;
196 int value = 1;
197 unsigned int result = 0;
198 const struct cl_option *option;
200 opt = argv[0];
202 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
203 if (opt_index == cl_options_count
204 && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')
205 && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
207 /* Drop the "no-" from negative switches. */
208 size_t len = strlen (opt) - 3;
210 dup = XNEWVEC (char, len + 1);
211 dup[0] = '-';
212 dup[1] = opt[1];
213 memcpy (dup + 2, opt + 5, len - 2 + 1);
214 opt = dup;
215 value = 0;
216 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
219 if (opt_index == cl_options_count)
220 goto done;
222 option = &cl_options[opt_index];
224 /* Reject negative form of switches that don't take negatives as
225 unrecognized. */
226 if (!value && (option->flags & CL_REJECT_NEGATIVE))
227 goto done;
229 /* We've recognized this switch. */
230 result = 1;
232 /* Check to see if the option is disabled for this configuration. */
233 if (option->flags & CL_DISABLED)
235 error ("command line option %qs"
236 " is not supported by this configuration", opt);
237 goto done;
240 /* Sort out any argument the switch takes. */
241 if (option->flags & CL_JOINED)
243 /* Have arg point to the original switch. This is because
244 some code, such as disable_builtin_function, expects its
245 argument to be persistent until the program exits. */
246 arg = argv[0] + cl_options[opt_index].opt_len + 1;
247 if (!value)
248 arg += strlen ("no-");
250 if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
252 if (option->flags & CL_SEPARATE)
254 arg = argv[1];
255 result = 2;
257 else
258 /* Missing argument. */
259 arg = NULL;
262 else if (option->flags & CL_SEPARATE)
264 arg = argv[1];
265 result = 2;
268 /* Now we've swallowed any potential argument, complain if this
269 is a switch for a different front end. */
270 if (!(option->flags & (lang_mask | CL_COMMON | CL_TARGET)))
272 complain_wrong_lang (argv[0], option, lang_mask);
273 goto done;
276 if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
278 if (!lang_hooks.missing_argument (opt, opt_index))
279 error ("missing argument to \"%s\"", opt);
280 goto done;
283 /* If the switch takes an integer, convert it. */
284 if (arg && (option->flags & CL_UINTEGER))
286 value = integral_argument (arg);
287 if (value == -1)
289 error ("argument to \"%s\" should be a non-negative integer",
290 option->opt_text);
291 goto done;
295 if (option->flag_var)
296 switch (option->var_type)
298 case CLVC_BOOLEAN:
299 *(int *) option->flag_var = value;
300 break;
302 case CLVC_EQUAL:
303 *(int *) option->flag_var = (value
304 ? option->var_value
305 : !option->var_value);
306 break;
308 case CLVC_BIT_CLEAR:
309 case CLVC_BIT_SET:
310 if ((value != 0) == (option->var_type == CLVC_BIT_SET))
311 *(int *) option->flag_var |= option->var_value;
312 else
313 *(int *) option->flag_var &= ~option->var_value;
314 if (option->flag_var == &target_flags)
315 target_flags_explicit |= option->var_value;
316 break;
318 case CLVC_STRING:
319 *(const char **) option->flag_var = arg;
320 break;
323 if (option->flags & lang_mask)
324 if (lang_hooks.handle_option (opt_index, arg, value) == 0)
325 result = 0;
327 if (result && (option->flags & CL_COMMON))
328 if (common_handle_option (opt_index, arg, value, lang_mask) == 0)
329 result = 0;
331 if (result && (option->flags & CL_TARGET))
332 if (!targetm.handle_option (opt_index, arg, value))
333 result = 0;
335 done:
336 if (dup)
337 free (dup);
338 return result;
341 /* Handle FILENAME from the command line. */
342 static void
343 add_input_filename (const char *filename)
345 num_in_fnames++;
346 in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));
347 in_fnames[num_in_fnames - 1] = filename;
350 /* Decode and handle the vector of command line options. LANG_MASK
351 contains has a single bit set representing the current
352 language. */
353 static void
354 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
356 unsigned int n, i;
358 for (i = 1; i < argc; i += n)
360 const char *opt = argv[i];
362 /* Interpret "-" or a non-switch as a file name. */
363 if (opt[0] != '-' || opt[1] == '\0')
365 if (main_input_filename == NULL)
366 main_input_filename = opt;
367 add_input_filename (opt);
368 n = 1;
369 continue;
372 n = handle_option (argv + i, lang_mask);
374 if (!n)
376 n = 1;
377 error ("unrecognized command line option \"%s\"", opt);
382 /* Parse command line options and set default flag values. Do minimal
383 options processing. */
384 void
385 decode_options (unsigned int argc, const char **argv)
387 unsigned int i, lang_mask;
389 /* Perform language-specific options initialization. */
390 lang_mask = lang_hooks.init_options (argc, argv);
392 lang_hooks.initialize_diagnostics (global_dc);
394 /* Scan to see what optimization level has been specified. That will
395 determine the default value of many flags. */
396 for (i = 1; i < argc; i++)
398 if (!strcmp (argv[i], "-O"))
400 optimize = 1;
401 optimize_size = 0;
403 else if (argv[i][0] == '-' && argv[i][1] == 'O')
405 /* Handle -Os, -O2, -O3, -O69, ... */
406 const char *p = &argv[i][2];
408 if ((p[0] == 's') && (p[1] == 0))
410 optimize_size = 1;
412 /* Optimizing for size forces optimize to be 2. */
413 optimize = 2;
415 else
417 const int optimize_val = read_integral_parameter (p, p - 2, -1);
418 if (optimize_val != -1)
420 optimize = optimize_val;
421 optimize_size = 0;
427 if (!optimize)
429 flag_merge_constants = 0;
432 if (optimize >= 1)
434 flag_defer_pop = 1;
435 #ifdef DELAY_SLOTS
436 flag_delayed_branch = 1;
437 #endif
438 #ifdef CAN_DEBUG_WITHOUT_FP
439 flag_omit_frame_pointer = 1;
440 #endif
441 flag_guess_branch_prob = 1;
442 flag_cprop_registers = 1;
443 flag_if_conversion = 1;
444 flag_if_conversion2 = 1;
445 flag_ipa_pure_const = 1;
446 flag_ipa_reference = 1;
447 flag_tree_ccp = 1;
448 flag_tree_dce = 1;
449 flag_tree_dom = 1;
450 flag_tree_dse = 1;
451 flag_tree_ter = 1;
452 flag_tree_sra = 1;
453 flag_tree_copyrename = 1;
454 flag_tree_fre = 1;
455 flag_tree_copy_prop = 1;
456 flag_tree_sink = 1;
457 flag_tree_salias = 1;
458 if (!no_unit_at_a_time_default)
459 flag_unit_at_a_time = 1;
461 if (!optimize_size)
463 /* Loop header copying usually increases size of the code. This used
464 not to be true, since quite often it is possible to verify that
465 the condition is satisfied in the first iteration and therefore
466 to eliminate it. Jump threading handles these cases now. */
467 flag_tree_ch = 1;
471 if (optimize >= 2)
473 flag_thread_jumps = 1;
474 flag_crossjumping = 1;
475 flag_optimize_sibling_calls = 1;
476 flag_forward_propagate = 1;
477 flag_cse_follow_jumps = 1;
478 flag_gcse = 1;
479 flag_expensive_optimizations = 1;
480 flag_ipa_type_escape = 1;
481 flag_rerun_cse_after_loop = 1;
482 flag_caller_saves = 1;
483 flag_peephole2 = 1;
484 #ifdef INSN_SCHEDULING
485 flag_schedule_insns = 1;
486 flag_schedule_insns_after_reload = 1;
487 #endif
488 flag_regmove = 1;
489 flag_strict_aliasing = 1;
490 flag_delete_null_pointer_checks = 1;
491 flag_reorder_blocks = 1;
492 flag_reorder_functions = 1;
493 flag_tree_store_ccp = 1;
494 flag_tree_store_copy_prop = 1;
495 flag_tree_vrp = 1;
497 if (!optimize_size)
499 /* PRE tends to generate bigger code. */
500 flag_tree_pre = 1;
504 if (optimize >= 3)
506 flag_inline_functions = 1;
507 flag_unswitch_loops = 1;
508 flag_gcse_after_reload = 1;
511 if (optimize < 2 || optimize_size)
513 align_loops = 1;
514 align_jumps = 1;
515 align_labels = 1;
516 align_functions = 1;
518 /* Don't reorder blocks when optimizing for size because extra
519 jump insns may be created; also barrier may create extra padding.
521 More correctly we should have a block reordering mode that tried
522 to minimize the combined size of all the jumps. This would more
523 or less automatically remove extra jumps, but would also try to
524 use more short jumps instead of long jumps. */
525 flag_reorder_blocks = 0;
526 flag_reorder_blocks_and_partition = 0;
529 if (optimize_size)
531 /* Inlining of very small functions usually reduces total size. */
532 set_param_value ("max-inline-insns-single", 5);
533 set_param_value ("max-inline-insns-auto", 5);
534 flag_inline_functions = 1;
536 /* We want to crossjump as much as possible. */
537 set_param_value ("min-crossjump-insns", 1);
540 /* Initialize whether `char' is signed. */
541 flag_signed_char = DEFAULT_SIGNED_CHAR;
542 /* Set this to a special "uninitialized" value. The actual default is set
543 after target options have been processed. */
544 flag_short_enums = 2;
546 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
547 modify it. */
548 target_flags = targetm.default_target_flags;
550 /* Some tagets have ABI-specified unwind tables. */
551 flag_unwind_tables = targetm.unwind_tables_default;
553 #ifdef OPTIMIZATION_OPTIONS
554 /* Allow default optimizations to be specified on a per-machine basis. */
555 OPTIMIZATION_OPTIONS (optimize, optimize_size);
556 #endif
558 handle_options (argc, argv, lang_mask);
560 if (flag_pie)
561 flag_pic = flag_pie;
562 if (flag_pic && !flag_pie)
563 flag_shlib = 1;
565 if (flag_no_inline == 2)
566 flag_no_inline = 0;
567 else
568 flag_really_no_inline = flag_no_inline;
570 /* Set flag_no_inline before the post_options () hook. The C front
571 ends use it to determine tree inlining defaults. FIXME: such
572 code should be lang-independent when all front ends use tree
573 inlining, in which case it, and this condition, should be moved
574 to the top of process_options() instead. */
575 if (optimize == 0)
577 /* Inlining does not work if not optimizing,
578 so force it not to be done. */
579 flag_no_inline = 1;
580 warn_inline = 0;
582 /* The c_decode_option function and decode_option hook set
583 this to `2' if -Wall is used, so we can avoid giving out
584 lots of errors for people who don't realize what -Wall does. */
585 if (warn_uninitialized == 1)
586 warning (OPT_Wuninitialized,
587 "-Wuninitialized is not supported without -O");
590 if (flag_really_no_inline == 2)
591 flag_really_no_inline = flag_no_inline;
593 /* The optimization to partition hot and cold basic blocks into separate
594 sections of the .o and executable files does not work (currently)
595 with exception handling. This is because there is no support for
596 generating unwind info. If flag_exceptions is turned on we need to
597 turn off the partitioning optimization. */
599 if (flag_exceptions && flag_reorder_blocks_and_partition)
601 inform
602 ("-freorder-blocks-and-partition does not work with exceptions");
603 flag_reorder_blocks_and_partition = 0;
604 flag_reorder_blocks = 1;
607 /* If user requested unwind info, then turn off the partitioning
608 optimization. */
610 if (flag_unwind_tables && ! targetm.unwind_tables_default
611 && flag_reorder_blocks_and_partition)
613 inform ("-freorder-blocks-and-partition does not support unwind info");
614 flag_reorder_blocks_and_partition = 0;
615 flag_reorder_blocks = 1;
618 /* If the target requested unwind info, then turn off the partitioning
619 optimization with a different message. Likewise, if the target does not
620 support named sections. */
622 if (flag_reorder_blocks_and_partition
623 && (!targetm.have_named_sections
624 || (flag_unwind_tables && targetm.unwind_tables_default)))
626 inform
627 ("-freorder-blocks-and-partition does not work on this architecture");
628 flag_reorder_blocks_and_partition = 0;
629 flag_reorder_blocks = 1;
633 /* Handle target- and language-independent options. Return zero to
634 generate an "unknown option" message. Only options that need
635 extra handling need to be listed here; if you simply want
636 VALUE assigned to a variable, it happens automatically. */
638 static int
639 common_handle_option (size_t scode, const char *arg, int value,
640 unsigned int lang_mask)
642 enum opt_code code = (enum opt_code) scode;
644 switch (code)
646 case OPT__help:
647 print_help ();
648 exit_after_options = true;
649 break;
651 case OPT__param:
652 handle_param (arg);
653 break;
655 case OPT__target_help:
656 print_target_help ();
657 exit_after_options = true;
658 break;
660 case OPT__version:
661 print_version (stderr, "");
662 exit_after_options = true;
663 break;
665 case OPT_G:
666 g_switch_value = value;
667 g_switch_set = true;
668 break;
670 case OPT_O:
671 case OPT_Os:
672 /* Currently handled in a prescan. */
673 break;
675 case OPT_W:
676 /* For backward compatibility, -W is the same as -Wextra. */
677 set_Wextra (value);
678 break;
680 case OPT_Werror_:
682 char *new_option;
683 int option_index;
684 new_option = XNEWVEC (char, strlen (arg) + 2);
685 new_option[0] = 'W';
686 strcpy (new_option+1, arg);
687 option_index = find_opt (new_option, lang_mask);
688 if (option_index == N_OPTS)
690 error ("-Werror-%s: No option -%s", arg, new_option);
692 else
694 int kind = value ? DK_ERROR : DK_WARNING;
695 diagnostic_classify_diagnostic (global_dc, option_index, kind);
697 /* -Werror=foo implies -Wfoo. */
698 if (cl_options[option_index].var_type == CLVC_BOOLEAN
699 && cl_options[option_index].flag_var
700 && kind == DK_ERROR)
701 *(int *) cl_options[option_index].flag_var = 1;
702 free (new_option);
705 break;
707 case OPT_Wextra:
708 set_Wextra (value);
709 break;
711 case OPT_Wlarger_than_:
712 larger_than_size = value;
713 warn_larger_than = value != -1;
714 break;
716 case OPT_Wstrict_aliasing:
717 case OPT_Wstrict_aliasing_:
718 warn_strict_aliasing = value;
719 break;
721 case OPT_Wunused:
722 set_Wunused (value);
723 break;
725 case OPT_aux_info:
726 case OPT_aux_info_:
727 aux_info_file_name = arg;
728 flag_gen_aux_info = 1;
729 break;
731 case OPT_auxbase:
732 aux_base_name = arg;
733 break;
735 case OPT_auxbase_strip:
737 char *tmp = xstrdup (arg);
738 strip_off_ending (tmp, strlen (tmp));
739 if (tmp[0])
740 aux_base_name = tmp;
742 break;
744 case OPT_d:
745 decode_d_option (arg);
746 break;
748 case OPT_dumpbase:
749 dump_base_name = arg;
750 break;
752 case OPT_falign_functions_:
753 align_functions = value;
754 break;
756 case OPT_falign_jumps_:
757 align_jumps = value;
758 break;
760 case OPT_falign_labels_:
761 align_labels = value;
762 break;
764 case OPT_falign_loops_:
765 align_loops = value;
766 break;
768 case OPT_fbranch_probabilities:
769 flag_branch_probabilities_set = true;
770 break;
772 case OPT_fcall_used_:
773 fix_register (arg, 0, 1);
774 break;
776 case OPT_fcall_saved_:
777 fix_register (arg, 0, 0);
778 break;
780 case OPT_fdiagnostics_show_location_:
781 if (!strcmp (arg, "once"))
782 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
783 else if (!strcmp (arg, "every-line"))
784 diagnostic_prefixing_rule (global_dc)
785 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
786 else
787 return 0;
788 break;
790 case OPT_fdiagnostics_show_option:
791 global_dc->show_option_requested = true;
792 break;
794 case OPT_fdump_:
795 if (!dump_switch_p (arg))
796 return 0;
797 break;
799 case OPT_ffast_math:
800 set_fast_math_flags (value);
801 break;
803 case OPT_ffixed_:
804 fix_register (arg, 1, 1);
805 break;
807 case OPT_finline_limit_:
808 case OPT_finline_limit_eq:
809 set_param_value ("max-inline-insns-single", value / 2);
810 set_param_value ("max-inline-insns-auto", value / 2);
811 break;
813 case OPT_fmessage_length_:
814 pp_set_line_maximum_length (global_dc->printer, value);
815 break;
817 case OPT_fpack_struct_:
818 if (value <= 0 || (value & (value - 1)) || value > 16)
819 error("structure alignment must be a small power of two, not %d", value);
820 else
822 initial_max_fld_align = value;
823 maximum_field_alignment = value * BITS_PER_UNIT;
825 break;
827 case OPT_fpeel_loops:
828 flag_peel_loops_set = true;
829 break;
831 case OPT_fprofile_arcs:
832 profile_arc_flag_set = true;
833 break;
835 case OPT_fprofile_use:
836 if (!flag_branch_probabilities_set)
837 flag_branch_probabilities = value;
838 if (!flag_profile_values_set)
839 flag_profile_values = value;
840 if (!flag_unroll_loops_set)
841 flag_unroll_loops = value;
842 if (!flag_peel_loops_set)
843 flag_peel_loops = value;
844 if (!flag_tracer_set)
845 flag_tracer = value;
846 if (!flag_value_profile_transformations_set)
847 flag_value_profile_transformations = value;
848 break;
850 case OPT_fprofile_generate:
851 if (!profile_arc_flag_set)
852 profile_arc_flag = value;
853 if (!flag_profile_values_set)
854 flag_profile_values = value;
855 if (!flag_value_profile_transformations_set)
856 flag_value_profile_transformations = value;
857 break;
859 case OPT_fprofile_values:
860 flag_profile_values_set = true;
861 break;
863 case OPT_fvisibility_:
865 if (!strcmp(arg, "default"))
866 default_visibility = VISIBILITY_DEFAULT;
867 else if (!strcmp(arg, "internal"))
868 default_visibility = VISIBILITY_INTERNAL;
869 else if (!strcmp(arg, "hidden"))
870 default_visibility = VISIBILITY_HIDDEN;
871 else if (!strcmp(arg, "protected"))
872 default_visibility = VISIBILITY_PROTECTED;
873 else
874 error ("unrecognized visibility value \"%s\"", arg);
876 break;
878 case OPT_fvpt:
879 flag_value_profile_transformations_set = true;
880 break;
882 case OPT_frandom_seed:
883 /* The real switch is -fno-random-seed. */
884 if (value)
885 return 0;
886 flag_random_seed = NULL;
887 break;
889 case OPT_frandom_seed_:
890 flag_random_seed = arg;
891 break;
893 case OPT_fsched_verbose_:
894 #ifdef INSN_SCHEDULING
895 fix_sched_param ("verbose", arg);
896 break;
897 #else
898 return 0;
899 #endif
901 case OPT_fsched_stalled_insns_:
902 flag_sched_stalled_insns = value;
903 if (flag_sched_stalled_insns == 0)
904 flag_sched_stalled_insns = -1;
905 break;
907 case OPT_fsched_stalled_insns_dep_:
908 flag_sched_stalled_insns_dep = value;
909 break;
911 case OPT_fstack_limit:
912 /* The real switch is -fno-stack-limit. */
913 if (value)
914 return 0;
915 stack_limit_rtx = NULL_RTX;
916 break;
918 case OPT_fstack_limit_register_:
920 int reg = decode_reg_name (arg);
921 if (reg < 0)
922 error ("unrecognized register name \"%s\"", arg);
923 else
924 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
926 break;
928 case OPT_fstack_limit_symbol_:
929 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
930 break;
932 case OPT_ftree_vectorizer_verbose_:
933 vect_set_verbosity_level (arg);
934 break;
936 case OPT_ftls_model_:
937 if (!strcmp (arg, "global-dynamic"))
938 flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
939 else if (!strcmp (arg, "local-dynamic"))
940 flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
941 else if (!strcmp (arg, "initial-exec"))
942 flag_tls_default = TLS_MODEL_INITIAL_EXEC;
943 else if (!strcmp (arg, "local-exec"))
944 flag_tls_default = TLS_MODEL_LOCAL_EXEC;
945 else
946 warning (0, "unknown tls-model \"%s\"", arg);
947 break;
949 case OPT_ftracer:
950 flag_tracer_set = true;
951 break;
953 case OPT_funroll_loops:
954 flag_unroll_loops_set = true;
955 break;
957 case OPT_g:
958 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
959 break;
961 case OPT_gcoff:
962 set_debug_level (SDB_DEBUG, false, arg);
963 break;
965 case OPT_gdwarf_2:
966 set_debug_level (DWARF2_DEBUG, false, arg);
967 break;
969 case OPT_ggdb:
970 set_debug_level (NO_DEBUG, 2, arg);
971 break;
973 case OPT_gstabs:
974 case OPT_gstabs_:
975 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
976 break;
978 case OPT_gvms:
979 set_debug_level (VMS_DEBUG, false, arg);
980 break;
982 case OPT_gxcoff:
983 case OPT_gxcoff_:
984 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
985 break;
987 case OPT_o:
988 asm_file_name = arg;
989 break;
991 case OPT_pedantic_errors:
992 flag_pedantic_errors = pedantic = 1;
993 break;
995 case OPT_floop_optimize:
996 case OPT_frerun_loop_opt:
997 case OPT_fstrength_reduce:
998 /* These are no-ops, preserved for backward compatibility. */
999 break;
1001 default:
1002 /* If the flag was handled in a standard way, assume the lack of
1003 processing here is intentional. */
1004 gcc_assert (cl_options[scode].flag_var);
1005 break;
1008 return 1;
1011 /* Handle --param NAME=VALUE. */
1012 static void
1013 handle_param (const char *carg)
1015 char *equal, *arg;
1016 int value;
1018 arg = xstrdup (carg);
1019 equal = strchr (arg, '=');
1020 if (!equal)
1021 error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1022 else
1024 value = integral_argument (equal + 1);
1025 if (value == -1)
1026 error ("invalid --param value %qs", equal + 1);
1027 else
1029 *equal = '\0';
1030 set_param_value (arg, value);
1034 free (arg);
1037 /* Handle -W and -Wextra. */
1038 static void
1039 set_Wextra (int setting)
1041 extra_warnings = setting;
1042 warn_unused_value = setting;
1043 warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1045 /* We save the value of warn_uninitialized, since if they put
1046 -Wuninitialized on the command line, we need to generate a
1047 warning about not using it without also specifying -O. */
1048 if (setting == 0)
1049 warn_uninitialized = 0;
1050 else if (warn_uninitialized != 1)
1051 warn_uninitialized = 2;
1054 /* Initialize unused warning flags. */
1055 void
1056 set_Wunused (int setting)
1058 warn_unused_function = setting;
1059 warn_unused_label = setting;
1060 /* Unused function parameter warnings are reported when either
1061 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1062 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1063 otherwise set maybe_warn_extra_parameter, which will be picked up
1064 by set_Wextra. */
1065 maybe_warn_unused_parameter = setting;
1066 warn_unused_parameter = (setting && extra_warnings);
1067 warn_unused_variable = setting;
1068 warn_unused_value = setting;
1071 /* The following routines are useful in setting all the flags that
1072 -ffast-math and -fno-fast-math imply. */
1073 void
1074 set_fast_math_flags (int set)
1076 flag_trapping_math = !set;
1077 flag_unsafe_math_optimizations = set;
1078 flag_finite_math_only = set;
1079 flag_errno_math = !set;
1080 if (set)
1082 flag_signaling_nans = 0;
1083 flag_rounding_math = 0;
1084 flag_cx_limited_range = 1;
1088 /* Return true iff flags are set as if -ffast-math. */
1089 bool
1090 fast_math_flags_set_p (void)
1092 return (!flag_trapping_math
1093 && flag_unsafe_math_optimizations
1094 && flag_finite_math_only
1095 && !flag_errno_math);
1098 /* Handle a debug output -g switch. EXTENDED is true or false to support
1099 extended output (2 is special and means "-ggdb" was given). */
1100 static void
1101 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1103 static bool type_explicit;
1105 use_gnu_debug_info_extensions = extended;
1107 if (type == NO_DEBUG)
1109 if (write_symbols == NO_DEBUG)
1111 write_symbols = PREFERRED_DEBUGGING_TYPE;
1113 if (extended == 2)
1115 #ifdef DWARF2_DEBUGGING_INFO
1116 write_symbols = DWARF2_DEBUG;
1117 #elif defined DBX_DEBUGGING_INFO
1118 write_symbols = DBX_DEBUG;
1119 #endif
1122 if (write_symbols == NO_DEBUG)
1123 warning (0, "target system does not support debug output");
1126 else
1128 /* Does it conflict with an already selected type? */
1129 if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1130 error ("debug format \"%s\" conflicts with prior selection",
1131 debug_type_names[type]);
1132 write_symbols = type;
1133 type_explicit = true;
1136 /* A debug flag without a level defaults to level 2. */
1137 if (*arg == '\0')
1139 if (!debug_info_level)
1140 debug_info_level = 2;
1142 else
1144 debug_info_level = integral_argument (arg);
1145 if (debug_info_level == (unsigned int) -1)
1146 error ("unrecognised debug output level \"%s\"", arg);
1147 else if (debug_info_level > 3)
1148 error ("debug output level %s is too high", arg);
1152 /* Display help for target options. */
1153 static void
1154 print_target_help (void)
1156 unsigned int i;
1157 static bool displayed = false;
1159 /* Avoid double printing for --help --target-help. */
1160 if (displayed)
1161 return;
1163 displayed = true;
1164 for (i = 0; i < cl_options_count; i++)
1165 if ((cl_options[i].flags & (CL_TARGET | CL_UNDOCUMENTED)) == CL_TARGET)
1167 printf (_("\nTarget specific options:\n"));
1168 print_filtered_help (CL_TARGET);
1169 break;
1173 /* Output --help text. */
1174 static void
1175 print_help (void)
1177 size_t i;
1178 const char *p;
1180 GET_ENVIRONMENT (p, "COLUMNS");
1181 if (p)
1183 int value = atoi (p);
1184 if (value > 0)
1185 columns = value;
1188 puts (_("The following options are language-independent:\n"));
1190 print_filtered_help (CL_COMMON);
1191 print_param_help ();
1193 for (i = 0; lang_names[i]; i++)
1195 printf (_("The %s front end recognizes the following options:\n\n"),
1196 lang_names[i]);
1197 print_filtered_help (1U << i);
1199 print_target_help ();
1202 /* Print the help for --param. */
1203 static void
1204 print_param_help (void)
1206 size_t i;
1208 puts (_("The --param option recognizes the following as parameters:\n"));
1210 for (i = 0; i < LAST_PARAM; i++)
1212 const char *help = compiler_params[i].help;
1213 const char *param = compiler_params[i].option;
1215 if (help == NULL || *help == '\0')
1216 help = undocumented_msg;
1218 /* Get the translation. */
1219 help = _(help);
1221 wrap_help (help, param, strlen (param));
1224 putchar ('\n');
1227 /* Print help for a specific front-end, etc. */
1228 static void
1229 print_filtered_help (unsigned int flag)
1231 unsigned int i, len, filter, indent = 0;
1232 bool duplicates = false;
1233 const char *help, *opt, *tab;
1234 static char *printed;
1236 if (flag == CL_COMMON || flag == CL_TARGET)
1238 filter = flag;
1239 if (!printed)
1240 printed = xmalloc (cl_options_count);
1241 memset (printed, 0, cl_options_count);
1243 else
1245 /* Don't print COMMON options twice. */
1246 filter = flag | CL_COMMON;
1248 for (i = 0; i < cl_options_count; i++)
1250 if ((cl_options[i].flags & filter) != flag)
1251 continue;
1253 /* Skip help for internal switches. */
1254 if (cl_options[i].flags & CL_UNDOCUMENTED)
1255 continue;
1257 /* Skip switches that have already been printed, mark them to be
1258 listed later. */
1259 if (printed[i])
1261 duplicates = true;
1262 indent = print_switch (cl_options[i].opt_text, indent);
1266 if (duplicates)
1268 putchar ('\n');
1269 putchar ('\n');
1273 for (i = 0; i < cl_options_count; i++)
1275 if ((cl_options[i].flags & filter) != flag)
1276 continue;
1278 /* Skip help for internal switches. */
1279 if (cl_options[i].flags & CL_UNDOCUMENTED)
1280 continue;
1282 /* Skip switches that have already been printed. */
1283 if (printed[i])
1284 continue;
1286 printed[i] = true;
1288 help = cl_options[i].help;
1289 if (!help)
1290 help = undocumented_msg;
1292 /* Get the translation. */
1293 help = _(help);
1295 tab = strchr (help, '\t');
1296 if (tab)
1298 len = tab - help;
1299 opt = help;
1300 help = tab + 1;
1302 else
1304 opt = cl_options[i].opt_text;
1305 len = strlen (opt);
1308 wrap_help (help, opt, len);
1311 putchar ('\n');
1314 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1315 word-wrapped HELP in a second column. */
1316 static unsigned int
1317 print_switch (const char *text, unsigned int indent)
1319 unsigned int len = strlen (text) + 1; /* trailing comma */
1321 if (indent)
1323 putchar (',');
1324 if (indent + len > columns)
1326 putchar ('\n');
1327 putchar (' ');
1328 indent = 1;
1331 else
1332 putchar (' ');
1334 putchar (' ');
1335 fputs (text, stdout);
1337 return indent + len + 1;
1340 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1341 word-wrapped HELP in a second column. */
1342 static void
1343 wrap_help (const char *help, const char *item, unsigned int item_width)
1345 unsigned int col_width = 27;
1346 unsigned int remaining, room, len;
1348 remaining = strlen (help);
1352 room = columns - 3 - MAX (col_width, item_width);
1353 if (room > columns)
1354 room = 0;
1355 len = remaining;
1357 if (room < len)
1359 unsigned int i;
1361 for (i = 0; help[i]; i++)
1363 if (i >= room && len != remaining)
1364 break;
1365 if (help[i] == ' ')
1366 len = i;
1367 else if ((help[i] == '-' || help[i] == '/')
1368 && help[i + 1] != ' '
1369 && i > 0 && ISALPHA (help[i - 1]))
1370 len = i + 1;
1374 printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
1375 item_width = 0;
1376 while (help[len] == ' ')
1377 len++;
1378 help += len;
1379 remaining -= len;
1381 while (remaining);
1384 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
1385 a simple on-off switch. */
1388 option_enabled (int opt_idx)
1390 const struct cl_option *option = &(cl_options[opt_idx]);
1391 if (option->flag_var)
1392 switch (option->var_type)
1394 case CLVC_BOOLEAN:
1395 return *(int *) option->flag_var != 0;
1397 case CLVC_EQUAL:
1398 return *(int *) option->flag_var == option->var_value;
1400 case CLVC_BIT_CLEAR:
1401 return (*(int *) option->flag_var & option->var_value) == 0;
1403 case CLVC_BIT_SET:
1404 return (*(int *) option->flag_var & option->var_value) != 0;
1406 case CLVC_STRING:
1407 break;
1409 return -1;
1412 /* Fill STATE with the current state of option OPTION. Return true if
1413 there is some state to store. */
1415 bool
1416 get_option_state (int option, struct cl_option_state *state)
1418 if (cl_options[option].flag_var == 0)
1419 return false;
1421 switch (cl_options[option].var_type)
1423 case CLVC_BOOLEAN:
1424 case CLVC_EQUAL:
1425 state->data = cl_options[option].flag_var;
1426 state->size = sizeof (int);
1427 break;
1429 case CLVC_BIT_CLEAR:
1430 case CLVC_BIT_SET:
1431 state->ch = option_enabled (option);
1432 state->data = &state->ch;
1433 state->size = 1;
1434 break;
1436 case CLVC_STRING:
1437 state->data = *(const char **) cl_options[option].flag_var;
1438 if (state->data == 0)
1439 state->data = "";
1440 state->size = strlen (state->data) + 1;
1441 break;
1443 return true;