1 /* Command line option handling.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
4 Contributed by Neil Booth.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
28 #include "coretypes.h"
34 #include "langhooks.h"
40 #include "diagnostic.h"
41 #include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
42 #include "insn-attr.h" /* For INSN_SCHEDULING. */
44 #include "tree-pass.h"
46 /* Value of the -G xx switch, and whether it was passed or not. */
47 unsigned HOST_WIDE_INT g_switch_value;
50 /* True if we should exit after parsing options. */
51 bool exit_after_options;
53 /* Print various extra warnings. -W/-Wextra. */
56 /* True to warn about any objects definitions whose size is larger
57 than N bytes. Also want about function definitions whose returned
58 values are larger than N bytes, where N is `larger_than_size'. */
59 bool warn_larger_than;
60 HOST_WIDE_INT larger_than_size;
62 /* Nonzero means warn about constructs which might not be
63 strict-aliasing safe. */
64 int warn_strict_aliasing;
66 /* Nonzero means warn about optimizations which rely on undefined
68 int warn_strict_overflow;
70 /* Hack for cooperation between set_Wunused and set_Wextra. */
71 static bool maybe_warn_unused_parameter;
73 /* Type(s) of debugging information we are producing (if any). See
74 flags.h for the definitions of the different possible types of
75 debugging information. */
76 enum debug_info_type write_symbols = NO_DEBUG;
78 /* Level of debugging information we are producing. See flags.h for
79 the definitions of the different possible levels. */
80 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
82 /* Nonzero means use GNU-only extensions in the generated symbolic
83 debugging information. Currently, this only has an effect when
84 write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
85 bool use_gnu_debug_info_extensions;
87 /* The default visibility for all symbols (unless overridden) */
88 enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;
90 /* Disable unit-at-a-time for frontends that might be still broken in this
93 bool no_unit_at_a_time_default;
95 /* Global visibility options. */
96 struct visibility_flags visibility_options;
98 /* Columns of --help display. */
99 static unsigned int columns = 80;
101 /* What to print when a switch has no documentation. */
102 static const char undocumented_msg[] = N_("This switch lacks documentation");
104 /* Used for bookkeeping on whether user set these flags so
105 -fprofile-use/-fprofile-generate does not use them. */
106 static bool profile_arc_flag_set, flag_profile_values_set;
107 static bool flag_unroll_loops_set, flag_tracer_set;
108 static bool flag_value_profile_transformations_set;
109 static bool flag_peel_loops_set, flag_branch_probabilities_set;
111 /* Input file names. */
112 const char **in_fnames;
113 unsigned num_in_fnames;
115 static int common_handle_option (size_t scode, const char *arg, int value,
116 unsigned int lang_mask);
117 static void handle_param (const char *);
118 static void set_Wextra (int);
119 static unsigned int handle_option (const char **argv, unsigned int lang_mask);
120 static char *write_langs (unsigned int lang_mask);
121 static void complain_wrong_lang (const char *, const struct cl_option *,
122 unsigned int lang_mask);
123 static void handle_options (unsigned int, const char **, unsigned int);
124 static void wrap_help (const char *help, const char *item, unsigned int);
125 static void print_target_help (void);
126 static void print_help (void);
127 static void print_param_help (void);
128 static void print_filtered_help (unsigned int);
129 static unsigned int print_switch (const char *text, unsigned int indent);
130 static void set_debug_level (enum debug_info_type type, int extended,
133 /* If ARG is a non-negative integer made up solely of digits, return its
134 value, otherwise return -1. */
136 integral_argument (const char *arg)
140 while (*p && ISDIGIT (*p))
149 /* Return a malloced slash-separated list of languages in MASK. */
151 write_langs (unsigned int mask)
153 unsigned int n = 0, len = 0;
154 const char *lang_name;
157 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
158 if (mask & (1U << n))
159 len += strlen (lang_name) + 1;
161 result = XNEWVEC (char, len);
163 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
164 if (mask & (1U << n))
168 strcpy (result + len, lang_name);
169 len += strlen (lang_name);
177 /* Complain that switch OPT_INDEX does not apply to this front end. */
179 complain_wrong_lang (const char *text, const struct cl_option *option,
180 unsigned int lang_mask)
182 char *ok_langs, *bad_lang;
184 ok_langs = write_langs (option->flags);
185 bad_lang = write_langs (lang_mask);
187 /* Eventually this should become a hard error IMO. */
188 warning (0, "command line option \"%s\" is valid for %s but not for %s",
189 text, ok_langs, bad_lang);
195 /* Handle the switch beginning at ARGV for the language indicated by
196 LANG_MASK. Returns the number of switches consumed. */
198 handle_option (const char **argv, unsigned int lang_mask)
201 const char *opt, *arg = 0;
204 unsigned int result = 0;
205 const struct cl_option *option;
209 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
210 if (opt_index == cl_options_count
211 && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')
212 && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
214 /* Drop the "no-" from negative switches. */
215 size_t len = strlen (opt) - 3;
217 dup = XNEWVEC (char, len + 1);
220 memcpy (dup + 2, opt + 5, len - 2 + 1);
223 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
226 if (opt_index == cl_options_count)
229 option = &cl_options[opt_index];
231 /* Reject negative form of switches that don't take negatives as
233 if (!value && (option->flags & CL_REJECT_NEGATIVE))
236 /* We've recognized this switch. */
239 /* Check to see if the option is disabled for this configuration. */
240 if (option->flags & CL_DISABLED)
242 error ("command line option %qs"
243 " is not supported by this configuration", opt);
247 /* Sort out any argument the switch takes. */
248 if (option->flags & CL_JOINED)
250 /* Have arg point to the original switch. This is because
251 some code, such as disable_builtin_function, expects its
252 argument to be persistent until the program exits. */
253 arg = argv[0] + cl_options[opt_index].opt_len + 1;
255 arg += strlen ("no-");
257 if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
259 if (option->flags & CL_SEPARATE)
265 /* Missing argument. */
269 else if (option->flags & CL_SEPARATE)
275 /* Now we've swallowed any potential argument, complain if this
276 is a switch for a different front end. */
277 if (!(option->flags & (lang_mask | CL_COMMON | CL_TARGET)))
279 complain_wrong_lang (argv[0], option, lang_mask);
283 if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
285 if (!lang_hooks.missing_argument (opt, opt_index))
286 error ("missing argument to \"%s\"", opt);
290 /* If the switch takes an integer, convert it. */
291 if (arg && (option->flags & CL_UINTEGER))
293 value = integral_argument (arg);
296 error ("argument to \"%s\" should be a non-negative integer",
302 if (option->flag_var)
303 switch (option->var_type)
306 *(int *) option->flag_var = value;
310 *(int *) option->flag_var = (value
312 : !option->var_value);
317 if ((value != 0) == (option->var_type == CLVC_BIT_SET))
318 *(int *) option->flag_var |= option->var_value;
320 *(int *) option->flag_var &= ~option->var_value;
321 if (option->flag_var == &target_flags)
322 target_flags_explicit |= option->var_value;
326 *(const char **) option->flag_var = arg;
330 if (option->flags & lang_mask)
331 if (lang_hooks.handle_option (opt_index, arg, value) == 0)
334 if (result && (option->flags & CL_COMMON))
335 if (common_handle_option (opt_index, arg, value, lang_mask) == 0)
338 if (result && (option->flags & CL_TARGET))
339 if (!targetm.handle_option (opt_index, arg, value))
348 /* Handle FILENAME from the command line. */
350 add_input_filename (const char *filename)
353 in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));
354 in_fnames[num_in_fnames - 1] = filename;
357 /* Decode and handle the vector of command line options. LANG_MASK
358 contains has a single bit set representing the current
361 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
365 for (i = 1; i < argc; i += n)
367 const char *opt = argv[i];
369 /* Interpret "-" or a non-switch as a file name. */
370 if (opt[0] != '-' || opt[1] == '\0')
372 if (main_input_filename == NULL)
373 main_input_filename = opt;
374 add_input_filename (opt);
379 n = handle_option (argv + i, lang_mask);
384 error ("unrecognized command line option \"%s\"", opt);
389 /* Parse command line options and set default flag values. Do minimal
390 options processing. */
392 decode_options (unsigned int argc, const char **argv)
394 unsigned int i, lang_mask;
396 /* Perform language-specific options initialization. */
397 lang_mask = lang_hooks.init_options (argc, argv);
399 lang_hooks.initialize_diagnostics (global_dc);
401 /* Scan to see what optimization level has been specified. That will
402 determine the default value of many flags. */
403 for (i = 1; i < argc; i++)
405 if (!strcmp (argv[i], "-O"))
410 else if (argv[i][0] == '-' && argv[i][1] == 'O')
412 /* Handle -Os, -O2, -O3, -O69, ... */
413 const char *p = &argv[i][2];
415 if ((p[0] == 's') && (p[1] == 0))
419 /* Optimizing for size forces optimize to be 2. */
424 const int optimize_val = read_integral_parameter (p, p - 2, -1);
425 if (optimize_val != -1)
427 optimize = optimize_val;
436 flag_merge_constants = 0;
443 flag_delayed_branch = 1;
445 #ifdef CAN_DEBUG_WITHOUT_FP
446 flag_omit_frame_pointer = 1;
448 flag_guess_branch_prob = 1;
449 flag_cprop_registers = 1;
450 flag_if_conversion = 1;
451 flag_if_conversion2 = 1;
452 flag_ipa_pure_const = 1;
453 flag_ipa_reference = 1;
459 flag_tree_live_range_split = 1;
461 flag_tree_copyrename = 1;
463 flag_tree_copy_prop = 1;
465 flag_tree_salias = 1;
466 if (!no_unit_at_a_time_default)
467 flag_unit_at_a_time = 1;
471 /* Loop header copying usually increases size of the code. This used
472 not to be true, since quite often it is possible to verify that
473 the condition is satisfied in the first iteration and therefore
474 to eliminate it. Jump threading handles these cases now. */
481 flag_thread_jumps = 1;
482 flag_crossjumping = 1;
483 flag_optimize_sibling_calls = 1;
484 flag_cse_follow_jumps = 1;
485 flag_cse_skip_blocks = 1;
487 flag_expensive_optimizations = 1;
488 flag_ipa_type_escape = 1;
489 flag_rerun_cse_after_loop = 1;
490 flag_caller_saves = 1;
492 #ifdef INSN_SCHEDULING
493 flag_schedule_insns = 1;
494 flag_schedule_insns_after_reload = 1;
497 flag_strict_aliasing = 1;
498 flag_strict_overflow = 1;
499 flag_delete_null_pointer_checks = 1;
500 flag_reorder_blocks = 1;
501 flag_reorder_functions = 1;
502 flag_tree_store_ccp = 1;
503 flag_tree_store_copy_prop = 1;
504 /* XXX: some issues with ports have been traced to -ftree-vrp.
505 So remove it from -O2 and above. Note that jdk1{5,6} are affected
506 and they build with w/-O3 - so we cannot just move it to -O3. */
507 // flag_tree_vrp = 1;
511 /* PRE tends to generate bigger code. */
518 flag_inline_functions = 1;
519 flag_unswitch_loops = 1;
520 flag_gcse_after_reload = 1;
530 /* Don't reorder blocks when optimizing for size because extra
531 jump insns may be created; also barrier may create extra padding.
533 More correctly we should have a block reordering mode that tried
534 to minimize the combined size of all the jumps. This would more
535 or less automatically remove extra jumps, but would also try to
536 use more short jumps instead of long jumps. */
537 flag_reorder_blocks = 0;
538 flag_reorder_blocks_and_partition = 0;
543 /* Inlining of very small functions usually reduces total size. */
544 set_param_value ("max-inline-insns-single", 5);
545 set_param_value ("max-inline-insns-auto", 5);
546 flag_inline_functions = 1;
548 /* We want to crossjump as much as possible. */
549 set_param_value ("min-crossjump-insns", 1);
552 /* Initialize whether `char' is signed. */
553 flag_signed_char = DEFAULT_SIGNED_CHAR;
554 /* Set this to a special "uninitialized" value. The actual default is set
555 after target options have been processed. */
556 flag_short_enums = 2;
558 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
560 target_flags = targetm.default_target_flags;
562 /* Some tagets have ABI-specified unwind tables. */
563 flag_unwind_tables = targetm.unwind_tables_default;
565 #ifdef OPTIMIZATION_OPTIONS
566 /* Allow default optimizations to be specified on a per-machine basis. */
567 OPTIMIZATION_OPTIONS (optimize, optimize_size);
570 handle_options (argc, argv, lang_mask);
574 if (flag_pic && !flag_pie)
577 if (flag_no_inline == 2)
580 flag_really_no_inline = flag_no_inline;
582 /* Set flag_no_inline before the post_options () hook. The C front
583 ends use it to determine tree inlining defaults. FIXME: such
584 code should be lang-independent when all front ends use tree
585 inlining, in which case it, and this condition, should be moved
586 to the top of process_options() instead. */
589 /* Inlining does not work if not optimizing,
590 so force it not to be done. */
594 /* The c_decode_option function and decode_option hook set
595 this to `2' if -Wall is used, so we can avoid giving out
596 lots of errors for people who don't realize what -Wall does. */
597 if (warn_uninitialized == 1)
598 warning (OPT_Wuninitialized,
599 "-Wuninitialized is not supported without -O");
602 if (flag_really_no_inline == 2)
603 flag_really_no_inline = flag_no_inline;
605 /* The optimization to partition hot and cold basic blocks into separate
606 sections of the .o and executable files does not work (currently)
607 with exception handling. This is because there is no support for
608 generating unwind info. If flag_exceptions is turned on we need to
609 turn off the partitioning optimization. */
611 if (flag_exceptions && flag_reorder_blocks_and_partition)
614 ("-freorder-blocks-and-partition does not work with exceptions");
615 flag_reorder_blocks_and_partition = 0;
616 flag_reorder_blocks = 1;
619 /* If user requested unwind info, then turn off the partitioning
622 if (flag_unwind_tables && ! targetm.unwind_tables_default
623 && flag_reorder_blocks_and_partition)
625 inform ("-freorder-blocks-and-partition does not support unwind info");
626 flag_reorder_blocks_and_partition = 0;
627 flag_reorder_blocks = 1;
630 /* If the target requested unwind info, then turn off the partitioning
631 optimization with a different message. Likewise, if the target does not
632 support named sections. */
634 if (flag_reorder_blocks_and_partition
635 && (!targetm.have_named_sections
636 || (flag_unwind_tables && targetm.unwind_tables_default)))
639 ("-freorder-blocks-and-partition does not work on this architecture");
640 flag_reorder_blocks_and_partition = 0;
641 flag_reorder_blocks = 1;
645 /* Handle target- and language-independent options. Return zero to
646 generate an "unknown option" message. Only options that need
647 extra handling need to be listed here; if you simply want
648 VALUE assigned to a variable, it happens automatically. */
651 common_handle_option (size_t scode, const char *arg, int value,
652 unsigned int lang_mask)
654 enum opt_code code = (enum opt_code) scode;
660 exit_after_options = true;
667 case OPT__target_help:
668 print_target_help ();
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 new_option = XNEWVEC (char, strlen (arg) + 2);
698 strcpy (new_option+1, arg);
699 option_index = find_opt (new_option, lang_mask);
700 if (option_index == N_OPTS)
702 error ("-Werror=%s: No option -%s", arg, new_option);
706 int kind = value ? DK_ERROR : DK_WARNING;
707 diagnostic_classify_diagnostic (global_dc, option_index, kind);
709 /* -Werror=foo implies -Wfoo. */
710 if (cl_options[option_index].var_type == CLVC_BOOLEAN
711 && cl_options[option_index].flag_var
713 *(int *) cl_options[option_index].flag_var = 1;
723 case OPT_Wlarger_than_:
724 larger_than_size = value;
725 warn_larger_than = value != -1;
728 case OPT_Wstrict_aliasing:
729 case OPT_Wstrict_aliasing_:
730 warn_strict_aliasing = value;
733 case OPT_Wstrict_overflow:
734 warn_strict_overflow = (value
735 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
739 case OPT_Wstrict_overflow_:
740 warn_strict_overflow = value;
749 aux_info_file_name = arg;
750 flag_gen_aux_info = 1;
757 case OPT_auxbase_strip:
759 char *tmp = xstrdup (arg);
760 strip_off_ending (tmp, strlen (tmp));
767 decode_d_option (arg);
771 dump_base_name = arg;
774 case OPT_falign_functions_:
775 align_functions = value;
778 case OPT_falign_jumps_:
782 case OPT_falign_labels_:
783 align_labels = value;
786 case OPT_falign_loops_:
790 case OPT_fbranch_probabilities:
791 flag_branch_probabilities_set = true;
794 case OPT_fcall_used_:
795 fix_register (arg, 0, 1);
798 case OPT_fcall_saved_:
799 fix_register (arg, 0, 0);
802 case OPT_fdiagnostics_show_location_:
803 if (!strcmp (arg, "once"))
804 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
805 else if (!strcmp (arg, "every-line"))
806 diagnostic_prefixing_rule (global_dc)
807 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
812 case OPT_fdiagnostics_show_option:
813 global_dc->show_option_requested = true;
817 if (!dump_switch_p (arg))
822 set_fast_math_flags (value);
826 fix_register (arg, 1, 1);
829 case OPT_finline_limit_:
830 case OPT_finline_limit_eq:
831 set_param_value ("max-inline-insns-single", value / 2);
832 set_param_value ("max-inline-insns-auto", value / 2);
835 case OPT_fmessage_length_:
836 pp_set_line_maximum_length (global_dc->printer, value);
839 case OPT_fpack_struct_:
840 if (value <= 0 || (value & (value - 1)) || value > 16)
841 error("structure alignment must be a small power of two, not %d", value);
844 initial_max_fld_align = value;
845 maximum_field_alignment = value * BITS_PER_UNIT;
849 case OPT_fpeel_loops:
850 flag_peel_loops_set = true;
853 case OPT_fprofile_arcs:
854 profile_arc_flag_set = true;
857 case OPT_fprofile_use:
858 if (!flag_branch_probabilities_set)
859 flag_branch_probabilities = value;
860 if (!flag_profile_values_set)
861 flag_profile_values = value;
862 if (!flag_unroll_loops_set)
863 flag_unroll_loops = value;
864 if (!flag_peel_loops_set)
865 flag_peel_loops = value;
866 if (!flag_tracer_set)
868 if (!flag_value_profile_transformations_set)
869 flag_value_profile_transformations = value;
872 case OPT_fprofile_generate:
873 if (!profile_arc_flag_set)
874 profile_arc_flag = value;
875 if (!flag_profile_values_set)
876 flag_profile_values = value;
877 if (!flag_value_profile_transformations_set)
878 flag_value_profile_transformations = value;
881 case OPT_fprofile_values:
882 flag_profile_values_set = true;
885 case OPT_fvisibility_:
887 if (!strcmp(arg, "default"))
888 default_visibility = VISIBILITY_DEFAULT;
889 else if (!strcmp(arg, "internal"))
890 default_visibility = VISIBILITY_INTERNAL;
891 else if (!strcmp(arg, "hidden"))
892 default_visibility = VISIBILITY_HIDDEN;
893 else if (!strcmp(arg, "protected"))
894 default_visibility = VISIBILITY_PROTECTED;
896 error ("unrecognized visibility value \"%s\"", arg);
901 flag_value_profile_transformations_set = true;
904 case OPT_frandom_seed:
905 /* The real switch is -fno-random-seed. */
908 flag_random_seed = NULL;
911 case OPT_frandom_seed_:
912 flag_random_seed = arg;
915 case OPT_fsched_verbose_:
916 #ifdef INSN_SCHEDULING
917 fix_sched_param ("verbose", arg);
923 case OPT_fsched_stalled_insns_:
924 flag_sched_stalled_insns = value;
925 if (flag_sched_stalled_insns == 0)
926 flag_sched_stalled_insns = -1;
929 case OPT_fsched_stalled_insns_dep_:
930 flag_sched_stalled_insns_dep = value;
933 case OPT_fstack_limit:
934 /* The real switch is -fno-stack-limit. */
937 stack_limit_rtx = NULL_RTX;
940 case OPT_fstack_limit_register_:
942 int reg = decode_reg_name (arg);
944 error ("unrecognized register name \"%s\"", arg);
946 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
950 case OPT_fstack_limit_symbol_:
951 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
954 case OPT_ftree_vectorizer_verbose_:
955 vect_set_verbosity_level (arg);
958 case OPT_ftls_model_:
959 if (!strcmp (arg, "global-dynamic"))
960 flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
961 else if (!strcmp (arg, "local-dynamic"))
962 flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
963 else if (!strcmp (arg, "initial-exec"))
964 flag_tls_default = TLS_MODEL_INITIAL_EXEC;
965 else if (!strcmp (arg, "local-exec"))
966 flag_tls_default = TLS_MODEL_LOCAL_EXEC;
968 warning (0, "unknown tls-model \"%s\"", arg);
972 flag_tracer_set = true;
975 case OPT_funroll_loops:
976 flag_unroll_loops_set = true;
980 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
984 set_debug_level (SDB_DEBUG, false, arg);
988 set_debug_level (DWARF2_DEBUG, false, arg);
992 set_debug_level (NO_DEBUG, 2, arg);
997 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
1001 set_debug_level (VMS_DEBUG, false, arg);
1006 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
1010 asm_file_name = arg;
1013 case OPT_pedantic_errors:
1014 flag_pedantic_errors = pedantic = 1;
1017 case OPT_fforce_mem:
1018 warning (0, "-f[no-]force-mem is nop and option will be removed in 4.3");
1021 case OPT_floop_optimize:
1022 case OPT_frerun_loop_opt:
1023 case OPT_fstrength_reduce:
1024 /* These are no-ops, preserved for backward compatibility. */
1028 /* If the flag was handled in a standard way, assume the lack of
1029 processing here is intentional. */
1030 gcc_assert (cl_options[scode].flag_var);
1037 /* Handle --param NAME=VALUE. */
1039 handle_param (const char *carg)
1044 arg = xstrdup (carg);
1045 equal = strchr (arg, '=');
1047 error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1050 value = integral_argument (equal + 1);
1052 error ("invalid --param value %qs", equal + 1);
1056 set_param_value (arg, value);
1063 /* Handle -W and -Wextra. */
1065 set_Wextra (int setting)
1067 extra_warnings = setting;
1068 warn_unused_value = setting;
1069 warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1071 /* We save the value of warn_uninitialized, since if they put
1072 -Wuninitialized on the command line, we need to generate a
1073 warning about not using it without also specifying -O. */
1075 warn_uninitialized = 0;
1076 else if (warn_uninitialized != 1)
1077 warn_uninitialized = 2;
1080 /* Initialize unused warning flags. */
1082 set_Wunused (int setting)
1084 warn_unused_function = setting;
1085 warn_unused_label = setting;
1086 /* Unused function parameter warnings are reported when either
1087 ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1088 Thus, if -Wextra has already been seen, set warn_unused_parameter;
1089 otherwise set maybe_warn_extra_parameter, which will be picked up
1091 maybe_warn_unused_parameter = setting;
1092 warn_unused_parameter = (setting && extra_warnings);
1093 warn_unused_variable = setting;
1094 warn_unused_value = setting;
1097 /* The following routines are useful in setting all the flags that
1098 -ffast-math and -fno-fast-math imply. */
1100 set_fast_math_flags (int set)
1102 flag_trapping_math = !set;
1103 flag_unsafe_math_optimizations = set;
1104 flag_finite_math_only = set;
1105 flag_errno_math = !set;
1108 flag_signaling_nans = 0;
1109 flag_rounding_math = 0;
1110 flag_cx_limited_range = 1;
1114 /* Return true iff flags are set as if -ffast-math. */
1116 fast_math_flags_set_p (void)
1118 return (!flag_trapping_math
1119 && flag_unsafe_math_optimizations
1120 && flag_finite_math_only
1121 && !flag_errno_math);
1124 /* Handle a debug output -g switch. EXTENDED is true or false to support
1125 extended output (2 is special and means "-ggdb" was given). */
1127 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1129 static bool type_explicit;
1131 use_gnu_debug_info_extensions = extended;
1133 if (type == NO_DEBUG)
1135 if (write_symbols == NO_DEBUG)
1137 write_symbols = PREFERRED_DEBUGGING_TYPE;
1141 #ifdef DWARF2_DEBUGGING_INFO
1142 write_symbols = DWARF2_DEBUG;
1143 #elif defined DBX_DEBUGGING_INFO
1144 write_symbols = DBX_DEBUG;
1148 if (write_symbols == NO_DEBUG)
1149 warning (0, "target system does not support debug output");
1154 /* Does it conflict with an already selected type? */
1155 if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1156 error ("debug format \"%s\" conflicts with prior selection",
1157 debug_type_names[type]);
1158 write_symbols = type;
1159 type_explicit = true;
1162 /* A debug flag without a level defaults to level 2. */
1165 if (!debug_info_level)
1166 debug_info_level = 2;
1170 debug_info_level = integral_argument (arg);
1171 if (debug_info_level == (unsigned int) -1)
1172 error ("unrecognised debug output level \"%s\"", arg);
1173 else if (debug_info_level > 3)
1174 error ("debug output level %s is too high", arg);
1178 /* Display help for target options. */
1180 print_target_help (void)
1183 static bool displayed = false;
1185 /* Avoid double printing for --help --target-help. */
1190 for (i = 0; i < cl_options_count; i++)
1191 if ((cl_options[i].flags & (CL_TARGET | CL_UNDOCUMENTED)) == CL_TARGET)
1193 printf (_("\nTarget specific options:\n"));
1194 print_filtered_help (CL_TARGET);
1199 /* Output --help text. */
1206 GET_ENVIRONMENT (p, "COLUMNS");
1209 int value = atoi (p);
1214 puts (_("The following options are language-independent:\n"));
1216 print_filtered_help (CL_COMMON);
1217 print_param_help ();
1219 for (i = 0; lang_names[i]; i++)
1221 printf (_("The %s front end recognizes the following options:\n\n"),
1223 print_filtered_help (1U << i);
1225 print_target_help ();
1228 /* Print the help for --param. */
1230 print_param_help (void)
1234 puts (_("The --param option recognizes the following as parameters:\n"));
1236 for (i = 0; i < LAST_PARAM; i++)
1238 const char *help = compiler_params[i].help;
1239 const char *param = compiler_params[i].option;
1241 if (help == NULL || *help == '\0')
1242 help = undocumented_msg;
1244 /* Get the translation. */
1247 wrap_help (help, param, strlen (param));
1253 /* Print help for a specific front-end, etc. */
1255 print_filtered_help (unsigned int flag)
1257 unsigned int i, len, filter, indent = 0;
1258 bool duplicates = false;
1259 const char *help, *opt, *tab;
1260 static char *printed;
1262 if (flag == CL_COMMON || flag == CL_TARGET)
1266 printed = xmalloc (cl_options_count);
1267 memset (printed, 0, cl_options_count);
1271 /* Don't print COMMON options twice. */
1272 filter = flag | CL_COMMON;
1274 for (i = 0; i < cl_options_count; i++)
1276 if ((cl_options[i].flags & filter) != flag)
1279 /* Skip help for internal switches. */
1280 if (cl_options[i].flags & CL_UNDOCUMENTED)
1283 /* Skip switches that have already been printed, mark them to be
1288 indent = print_switch (cl_options[i].opt_text, indent);
1299 for (i = 0; i < cl_options_count; i++)
1301 if ((cl_options[i].flags & filter) != flag)
1304 /* Skip help for internal switches. */
1305 if (cl_options[i].flags & CL_UNDOCUMENTED)
1308 /* Skip switches that have already been printed. */
1314 help = cl_options[i].help;
1316 help = undocumented_msg;
1318 /* Get the translation. */
1321 tab = strchr (help, '\t');
1330 opt = cl_options[i].opt_text;
1334 wrap_help (help, opt, len);
1340 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1341 word-wrapped HELP in a second column. */
1343 print_switch (const char *text, unsigned int indent)
1345 unsigned int len = strlen (text) + 1; /* trailing comma */
1350 if (indent + len > columns)
1361 fputs (text, stdout);
1363 return indent + len + 1;
1366 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1367 word-wrapped HELP in a second column. */
1369 wrap_help (const char *help, const char *item, unsigned int item_width)
1371 unsigned int col_width = 27;
1372 unsigned int remaining, room, len;
1374 remaining = strlen (help);
1378 room = columns - 3 - MAX (col_width, item_width);
1387 for (i = 0; help[i]; i++)
1389 if (i >= room && len != remaining)
1393 else if ((help[i] == '-' || help[i] == '/')
1394 && help[i + 1] != ' '
1395 && i > 0 && ISALPHA (help[i - 1]))
1400 printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
1402 while (help[len] == ' ')
1410 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
1411 a simple on-off switch. */
1414 option_enabled (int opt_idx)
1416 const struct cl_option *option = &(cl_options[opt_idx]);
1417 if (option->flag_var)
1418 switch (option->var_type)
1421 return *(int *) option->flag_var != 0;
1424 return *(int *) option->flag_var == option->var_value;
1426 case CLVC_BIT_CLEAR:
1427 return (*(int *) option->flag_var & option->var_value) == 0;
1430 return (*(int *) option->flag_var & option->var_value) != 0;
1438 /* Fill STATE with the current state of option OPTION. Return true if
1439 there is some state to store. */
1442 get_option_state (int option, struct cl_option_state *state)
1444 if (cl_options[option].flag_var == 0)
1447 switch (cl_options[option].var_type)
1451 state->data = cl_options[option].flag_var;
1452 state->size = sizeof (int);
1455 case CLVC_BIT_CLEAR:
1457 state->ch = option_enabled (option);
1458 state->data = &state->ch;
1463 state->data = *(const char **) cl_options[option].flag_var;
1464 if (state->data == 0)
1466 state->size = strlen (state->data) + 1;