/* Command line option handling.
- Copyright (C) 2002, 2003 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
Contributed by Neil Booth.
This file is part of GCC.
#include "config.h"
#include "system.h"
+#include "intl.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "diagnostic.h"
#include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
#include "insn-attr.h" /* For INSN_SCHEDULING. */
+#include "target.h"
/* Value of the -G xx switch, and whether it was passed or not. */
unsigned HOST_WIDE_INT g_switch_value;
/* Nonzero means warn about constructs which might not be
strict-aliasing safe. */
-bool warn_strict_aliasing;
+int warn_strict_aliasing;
/* True to warn if a switch on an enum, that does not have a default
case, fails to have a case for every enum value. */
/* Hack for cooperation between set_Wunused and set_Wextra. */
static bool maybe_warn_unused_parameter;
+/* Type(s) of debugging information we are producing (if any). See
+ flags.h for the definitions of the different possible types of
+ debugging information. */
+enum debug_info_type write_symbols = NO_DEBUG;
+
+/* Level of debugging information we are producing. See flags.h for
+ the definitions of the different possible levels. */
+enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
+
+/* Nonzero means use GNU-only extensions in the generated symbolic
+ debugging information. Currently, this only has an effect when
+ write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
+bool use_gnu_debug_info_extensions;
+
+/* Columns of --help display. */
+static unsigned int columns = 80;
+
+/* What to print when a switch has no documentation. */
+static const char undocumented_msg[] = N_("This switch lacks documentation");
+
+/* Used for bookkeeping on whether user set these flags so
+ -fprofile-use/-fprofile-generate does not use them. */
+static bool profile_arc_flag_set, flag_profile_values_set;
+static bool flag_unroll_loops_set, flag_tracer_set;
+static bool flag_value_profile_transformations_set;
+static bool flag_peel_loops_set, flag_branch_probabilities_set;
+
+/* Input file names. */
+const char **in_fnames;
+unsigned num_in_fnames;
+
static size_t find_opt (const char *, int);
static int common_handle_option (size_t scode, const char *arg, int value);
static void handle_param (const char *);
static void complain_wrong_lang (const char *, const struct cl_option *,
unsigned int lang_mask);
static void handle_options (unsigned int, const char **, unsigned int);
+static void wrap_help (const char *help, const char *item, unsigned int);
+static void print_help (void);
+static void print_param_help (void);
+static void print_filtered_help (unsigned int flag);
+static unsigned int print_switch (const char *text, unsigned int indent);
+static void set_debug_level (enum debug_info_type type, int extended,
+ const char *arg);
/* Perform a binary search to find which option the command-line INPUT
matches. Returns its index in the option array, and N_OPTS
{
md = (mn + mx) / 2;
opt_len = cl_options[md].opt_len;
- comp = strncmp (input, cl_options[md].opt_text, opt_len);
+ comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
if (comp < 0)
mx = md;
const struct cl_option *opt = &cl_options[mn];
/* Is this switch a prefix of the input? */
- if (!strncmp (input, opt->opt_text, opt->opt_len))
+ if (!strncmp (input, opt->opt_text + 1, opt->opt_len))
{
/* If language is OK, and the match is exact or the switch
takes a joined argument, return it. */
if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
{
- if (!(*lang_hooks.missing_argument) (opt, opt_index))
+ if (!lang_hooks.missing_argument (opt, opt_index))
error ("missing argument to \"%s\"", opt);
goto done;
}
value = integral_argument (arg);
if (value == -1)
{
- error ("argument to \"-%s\" should be a non-negative integer",
+ error ("argument to \"%s\" should be a non-negative integer",
option->opt_text);
goto done;
}
}
if (option->flags & lang_mask)
- if ((*lang_hooks.handle_option) (opt_index, arg, value) == 0)
+ if (lang_hooks.handle_option (opt_index, arg, value) == 0)
result = 0;
if (result && (option->flags & CL_COMMON))
/* Interpret "-" or a non-switch as a file name. */
if (opt[0] != '-' || opt[1] == '\0')
{
- main_input_filename = opt;
- (*lang_hooks.handle_filename) (opt);
+ if (main_input_filename == NULL)
+ main_input_filename = opt;
+ add_input_filename (opt);
n = 1;
continue;
}
}
}
+/* Handle FILENAME from the command line. */
+void
+add_input_filename (const char *filename)
+{
+ num_in_fnames++;
+ in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));
+ in_fnames[num_in_fnames - 1] = filename;
+}
+
/* Parse command line options and set default flag values. Do minimal
options processing. */
void
unsigned int i, lang_mask;
/* Perform language-specific options initialization. */
- lang_mask = (*lang_hooks.init_options) (argc, argv);
+ lang_mask = lang_hooks.init_options (argc, argv);
+
+ lang_hooks.initialize_diagnostics (global_dc);
/* Scan to see what optimization level has been specified. That will
determine the default value of many flags. */
flag_guess_branch_prob = 1;
flag_cprop_registers = 1;
flag_loop_optimize = 1;
- flag_crossjumping = 1;
flag_if_conversion = 1;
flag_if_conversion2 = 1;
+ flag_tree_ccp = 1;
+ flag_tree_dce = 1;
+ flag_tree_dom = 1;
+ flag_tree_dse = 1;
+ flag_tree_pre = 1;
+ flag_tree_ter = 1;
+ flag_tree_live_range_split = 1;
+ flag_tree_sra = 1;
+ flag_tree_copyrename = 1;
+
+ if (!optimize_size)
+ {
+ /* Loop header copying usually increases size of the code. This used
+ not to be true, since quite often it is possible to verify that
+ the condition is satisfied in the first iteration and therefore
+ to eliminate it. Jump threading handles these cases now. */
+ flag_tree_ch = 1;
+ }
}
if (optimize >= 2)
{
+ flag_crossjumping = 1;
flag_optimize_sibling_calls = 1;
flag_cse_follow_jumps = 1;
flag_cse_skip_blocks = 1;
flag_delete_null_pointer_checks = 1;
flag_reorder_blocks = 1;
flag_reorder_functions = 1;
+ flag_unit_at_a_time = 1;
}
if (optimize >= 3)
{
flag_inline_functions = 1;
- flag_rename_registers = 1;
flag_unswitch_loops = 1;
- flag_unit_at_a_time = 1;
+ flag_gcse_after_reload = 1;
}
if (optimize < 2 || optimize_size)
or less automatically remove extra jumps, but would also try to
use more short jumps instead of long jumps. */
flag_reorder_blocks = 0;
+ flag_reorder_blocks_and_partition = 0;
+ }
+
+ if (optimize_size)
+ {
+ /* Inlining of very small functions usually reduces total size. */
+ set_param_value ("max-inline-insns-single", 5);
+ set_param_value ("max-inline-insns-auto", 5);
+ set_param_value ("max-inline-insns-rtl", 10);
+ flag_inline_functions = 1;
}
/* Initialize whether `char' is signed. */
flag_signed_char = DEFAULT_SIGNED_CHAR;
-#ifdef DEFAULT_SHORT_ENUMS
- /* Initialize how much space enums occupy, by default. */
- flag_short_enums = DEFAULT_SHORT_ENUMS;
-#endif
+ /* Set this to a special "uninitialized" value. The actual default is set
+ after target options have been processed. */
+ flag_short_enums = 2;
/* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
modify it. */
if (flag_really_no_inline == 2)
flag_really_no_inline = flag_no_inline;
+
+ /* The optimization to partition hot and cold basic blocks into separate
+ sections of the .o and executable files does not work (currently)
+ with exception handling. If flag_exceptions is turned on we need to
+ turn off the partitioning optimization. */
+
+ if (flag_exceptions && flag_reorder_blocks_and_partition)
+ {
+ warning
+ ("-freorder-blocks-and-partition does not work with exceptions");
+ flag_reorder_blocks_and_partition = 0;
+ flag_reorder_blocks = 1;
+ }
}
/* Handle target- and language-independent options. Return zero to
abort ();
case OPT__help:
- display_help ();
+ print_help ();
exit_after_options = true;
break;
set_Wextra (value);
break;
+ case OPT_Wfatal_errors:
+ flag_fatal_errors = value;
+ break;
+
case OPT_Winline:
warn_inline = value;
break;
break;
case OPT_Wstrict_aliasing:
+ case OPT_Wstrict_aliasing_:
warn_strict_aliasing = value;
break;
flag_pie = value + value;
break;
+ case OPT_fabi_version_:
+ flag_abi_version = value;
+ break;
+
case OPT_falign_functions:
align_functions = !value;
break;
break;
case OPT_fbranch_probabilities:
+ flag_branch_probabilities_set = true;
flag_branch_probabilities = value;
break;
flag_branch_target_load_optimize2 = value;
break;
+ case OPT_fbtr_bb_exclusive:
+ flag_btr_bb_exclusive = value;
+ break;
+
case OPT_fcall_used_:
fix_register (arg, 0, 1);
break;
return 0;
break;
+ case OPT_fdump_:
+ if (!dump_switch_p (arg))
+ return 0;
+ break;
+
case OPT_fdump_unnumbered:
flag_dump_unnumbered = value;
break;
flag_gcse_sm = value;
break;
- case OPT_fgnu_linker:
- flag_gnu_linker = value;
+ case OPT_fgcse_after_reload:
+ flag_gcse_after_reload = value;
+ break;
+
+ case OPT_fgcse_las:
+ flag_gcse_las = value;
break;
case OPT_fguess_branch_probability:
case OPT_finline_limit_:
case OPT_finline_limit_eq:
- set_param_value ("max-inline-insns", value);
set_param_value ("max-inline-insns-single", value / 2);
set_param_value ("max-inline-insns-auto", value / 2);
set_param_value ("max-inline-insns-rtl", value);
- if (value / 4 < MIN_INLINE_INSNS)
- {
- if (value / 4 > 10)
- set_param_value ("min-inline-insns", value / 4);
- else
- set_param_value ("min-inline-insns", 10);
- }
break;
case OPT_finstrument_functions:
break;
case OPT_fmessage_length_:
- output_set_maximum_length (&global_dc->buffer, value);
+ pp_set_line_maximum_length (global_dc->printer, value);
break;
case OPT_fmove_all_movables:
flag_move_all_movables = value;
break;
+ case OPT_fmudflap:
+ flag_mudflap = value;
+ break;
+
+ case OPT_fmudflapth:
+ flag_mudflap = value;
+ flag_mudflap_threads = value;
+ break;
+
+ case OPT_fmudflapir:
+ flag_mudflap_ignore_reads = value;
+ break;
+
case OPT_fnew_ra:
flag_new_regalloc = value;
break;
break;
case OPT_fpeel_loops:
+ flag_peel_loops_set = true;
flag_peel_loops = value;
break;
break;
case OPT_fprofile_arcs:
+ profile_arc_flag_set = true;
profile_arc_flag = value;
break;
+ case OPT_fprofile_use:
+ if (!flag_branch_probabilities_set)
+ flag_branch_probabilities = value;
+ if (!flag_profile_values_set)
+ flag_profile_values = value;
+ if (!flag_unroll_loops_set)
+ flag_unroll_loops = value;
+ if (!flag_peel_loops_set)
+ flag_peel_loops = value;
+ if (!flag_tracer_set)
+ flag_tracer = value;
+ if (!flag_value_profile_transformations_set)
+ flag_value_profile_transformations = value;
+ break;
+
+ case OPT_fprofile_generate:
+ if (!profile_arc_flag_set)
+ profile_arc_flag = value;
+ if (!flag_profile_values_set)
+ flag_profile_values = value;
+ if (!flag_value_profile_transformations_set)
+ flag_value_profile_transformations = value;
+ break;
+
+ case OPT_fprofile_values:
+ flag_profile_values_set = true;
+ flag_profile_values = value;
+ break;
+
+ case OPT_fvpt:
+ flag_value_profile_transformations_set = value;
+ flag_value_profile_transformations = value;
+ break;
+
case OPT_frandom_seed:
/* The real switch is -fno-random-seed. */
if (value)
flag_reorder_blocks = value;
break;
+ case OPT_freorder_blocks_and_partition:
+ flag_reorder_blocks_and_partition = value;
+ break;
+
case OPT_freorder_functions:
flag_reorder_functions = value;
break;
flag_rerun_loop_opt = value;
break;
+ case OPT_frounding_math:
+ flag_rounding_math = value;
+ break;
+
case OPT_fsched_interblock:
- flag_schedule_interblock= value;
+ flag_schedule_interblock = value;
break;
case OPT_fsched_spec:
flag_schedule_insns_after_reload = value;
break;
- case OPT_fshared_data:
- flag_shared_data = value;
+ case OPT_fsched_stalled_insns:
+ flag_sched_stalled_insns = value;
break;
- case OPT_fsignaling_nans:
- flag_signaling_nans = value;
+ case OPT_fsched_stalled_insns_:
+ flag_sched_stalled_insns = value;
+ if (flag_sched_stalled_insns == 0)
+ flag_sched_stalled_insns = -1;
break;
- case OPT_fsingle_precision_constant:
- flag_single_precision_constant = value;
+ case OPT_fsched_stalled_insns_dep:
+ flag_sched_stalled_insns_dep = 1;
break;
- case OPT_fssa:
- flag_ssa = value;
+ case OPT_fsched_stalled_insns_dep_:
+ flag_sched_stalled_insns_dep = value;
+ break;
+ case OPT_fmodulo_sched:
+ flag_modulo_sched = 1;
+ break;
+ case OPT_fshared_data:
+ flag_shared_data = value;
break;
- case OPT_fssa_ccp:
- flag_ssa_ccp = value;
+ case OPT_fsignaling_nans:
+ flag_signaling_nans = value;
break;
- case OPT_fssa_dce:
- flag_ssa_dce = value;
+ case OPT_fsingle_precision_constant:
+ flag_single_precision_constant = value;
break;
case OPT_fstack_check:
break;
case OPT_ftracer:
+ flag_tracer_set = true;
flag_tracer = value;
break;
flag_trapv = value;
break;
+ case OPT_ftree_based_profiling:
+ flag_tree_based_profiling = value;
+ break;
+
+ case OPT_ftree_ccp:
+ flag_tree_ccp = value;
+ break;
+
+ case OPT_ftree_dce:
+ flag_tree_dce = value;
+ break;
+
+ case OPT_ftree_combine_temps:
+ flag_tree_combine_temps = value;
+ break;
+
+ case OPT_ftree_ter:
+ flag_tree_ter = value;
+ break;
+
+ case OPT_ftree_lrs:
+ flag_tree_live_range_split = value;
+ break;
+
+ case OPT_ftree_dominator_opts:
+ flag_tree_dom = value;
+ break;
+
+ case OPT_ftree_copyrename:
+ flag_tree_copyrename = value;
+ break;
+
+ case OPT_ftree_ch:
+ flag_tree_ch = value;
+ break;
+
+ case OPT_ftree_dse:
+ flag_tree_dse = value;
+ break;
+
+ case OPT_ftree_sra:
+ flag_tree_sra = value;
+ break;
+
+ case OPT_ftree_points_to_:
+ if (!strcmp (arg, "andersen"))
+#ifdef HAVE_BANSHEE
+ flag_tree_points_to = PTA_ANDERSEN;
+#else
+ warning ("Andersen's PTA not available - libbanshee not compiled.");
+#endif
+ else if (!strcmp (arg, "none"))
+ flag_tree_points_to = PTA_NONE;
+ else
+ {
+ warning ("`%s`: unknown points-to analysis algorithm", arg);
+ return 0;
+ }
+ break;
+
+ case OPT_ftree_pre:
+ flag_tree_pre = value;
+ break;
+
case OPT_funit_at_a_time:
flag_unit_at_a_time = value;
break;
break;
case OPT_funroll_loops:
+ flag_unroll_loops_set = true;
flag_unroll_loops = value;
break;
flag_unwind_tables = value;
break;
+ case OPT_fvar_tracking:
+ flag_var_tracking = value;
+ break;
+
case OPT_fverbose_asm:
flag_verbose_asm = value;
break;
+
+ case OPT_fweb:
+ flag_web = value;
+ break;
case OPT_fwrapv:
flag_wrapv = value;
break;
- case OPT_fwritable_strings:
- flag_writable_strings = value;
- break;
-
case OPT_fzero_initialized_in_bss:
flag_zero_initialized_in_bss = value;
break;
case OPT_g:
- decode_g_option (arg);
+ set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
+ break;
+
+ case OPT_gcoff:
+ set_debug_level (SDB_DEBUG, false, arg);
+ break;
+
+ case OPT_gdwarf_2:
+ set_debug_level (DWARF2_DEBUG, false, arg);
+ break;
+
+ case OPT_ggdb:
+ set_debug_level (NO_DEBUG, 2, arg);
+ break;
+
+ case OPT_gstabs:
+ case OPT_gstabs_:
+ set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
+ break;
+
+ case OPT_gvms:
+ set_debug_level (VMS_DEBUG, false, arg);
+ break;
+
+ case OPT_gxcoff:
+ case OPT_gxcoff_:
+ set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
break;
case OPT_m:
flag_finite_math_only = set;
flag_errno_math = !set;
if (set)
- flag_signaling_nans = 0;
+ {
+ flag_signaling_nans = 0;
+ flag_rounding_math = 0;
+ }
}
/* Return true iff flags are set as if -ffast-math. */
&& flag_finite_math_only
&& !flag_errno_math);
}
+
+/* Handle a debug output -g switch. EXTENDED is true or false to support
+ extended output (2 is special and means "-ggdb" was given). */
+static void
+set_debug_level (enum debug_info_type type, int extended, const char *arg)
+{
+ static bool type_explicit;
+
+ use_gnu_debug_info_extensions = extended;
+
+ if (type == NO_DEBUG)
+ {
+ if (write_symbols == NO_DEBUG)
+ {
+ write_symbols = PREFERRED_DEBUGGING_TYPE;
+
+ if (extended == 2)
+ {
+#ifdef DWARF2_DEBUGGING_INFO
+ write_symbols = DWARF2_DEBUG;
+#elif defined DBX_DEBUGGING_INFO
+ write_symbols = DBX_DEBUG;
+#endif
+ }
+
+ if (write_symbols == NO_DEBUG)
+ warning ("target system does not support debug output");
+ }
+ }
+ else
+ {
+ /* Does it conflict with an already selected type? */
+ if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
+ error ("debug format \"%s\" conflicts with prior selection",
+ debug_type_names[type]);
+ write_symbols = type;
+ type_explicit = true;
+ }
+
+ /* A debug flag without a level defaults to level 2. */
+ if (*arg == '\0')
+ {
+ if (!debug_info_level)
+ debug_info_level = 2;
+ }
+ else
+ {
+ debug_info_level = integral_argument (arg);
+ if (debug_info_level == (unsigned int) -1)
+ error ("unrecognised debug output level \"%s\"", arg);
+ else if (debug_info_level > 3)
+ error ("debug output level %s is too high", arg);
+ }
+}
+
+/* Output --help text. */
+static void
+print_help (void)
+{
+ size_t i;
+ const char *p;
+
+ GET_ENVIRONMENT (p, "COLUMNS");
+ if (p)
+ {
+ int value = atoi (p);
+ if (value > 0)
+ columns = value;
+ }
+
+ puts (_("The following options are language-independent:\n"));
+
+ print_filtered_help (CL_COMMON);
+ print_param_help ();
+
+ for (i = 0; lang_names[i]; i++)
+ {
+ printf (_("The %s front end recognizes the following options:\n\n"),
+ lang_names[i]);
+ print_filtered_help (1U << i);
+ }
+
+ display_target_options ();
+}
+
+/* Print the help for --param. */
+static void
+print_param_help (void)
+{
+ size_t i;
+
+ puts (_("The --param option recognizes the following as parameters:\n"));
+
+ for (i = 0; i < LAST_PARAM; i++)
+ {
+ const char *help = compiler_params[i].help;
+ const char *param = compiler_params[i].option;
+
+ if (help == NULL || *help == '\0')
+ help = undocumented_msg;
+
+ /* Get the translation. */
+ help = _(help);
+
+ wrap_help (help, param, strlen (param));
+ }
+
+ putchar ('\n');
+}
+
+/* Print help for a specific front-end, etc. */
+static void
+print_filtered_help (unsigned int flag)
+{
+ unsigned int i, len, filter, indent = 0;
+ bool duplicates = false;
+ const char *help, *opt, *tab;
+ static char *printed;
+
+ if (flag == CL_COMMON)
+ {
+ filter = flag;
+ if (!printed)
+ printed = xmalloc (cl_options_count);
+ memset (printed, 0, cl_options_count);
+ }
+ else
+ {
+ /* Don't print COMMON options twice. */
+ filter = flag | CL_COMMON;
+
+ for (i = 0; i < cl_options_count; i++)
+ {
+ if ((cl_options[i].flags & filter) != flag)
+ continue;
+
+ /* Skip help for internal switches. */
+ if (cl_options[i].flags & CL_UNDOCUMENTED)
+ continue;
+
+ /* Skip switches that have already been printed, mark them to be
+ listed later. */
+ if (printed[i])
+ {
+ duplicates = true;
+ indent = print_switch (cl_options[i].opt_text, indent);
+ }
+ }
+
+ if (duplicates)
+ {
+ putchar ('\n');
+ putchar ('\n');
+ }
+ }
+
+ for (i = 0; i < cl_options_count; i++)
+ {
+ if ((cl_options[i].flags & filter) != flag)
+ continue;
+
+ /* Skip help for internal switches. */
+ if (cl_options[i].flags & CL_UNDOCUMENTED)
+ continue;
+
+ /* Skip switches that have already been printed. */
+ if (printed[i])
+ continue;
+
+ printed[i] = true;
+
+ help = cl_options[i].help;
+ if (!help)
+ help = undocumented_msg;
+
+ /* Get the translation. */
+ help = _(help);
+
+ tab = strchr (help, '\t');
+ if (tab)
+ {
+ len = tab - help;
+ opt = help;
+ help = tab + 1;
+ }
+ else
+ {
+ opt = cl_options[i].opt_text;
+ len = strlen (opt);
+ }
+
+ wrap_help (help, opt, len);
+ }
+
+ putchar ('\n');
+}
+
+/* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
+ word-wrapped HELP in a second column. */
+static unsigned int
+print_switch (const char *text, unsigned int indent)
+{
+ unsigned int len = strlen (text) + 1; /* trailing comma */
+
+ if (indent)
+ {
+ putchar (',');
+ if (indent + len > columns)
+ {
+ putchar ('\n');
+ putchar (' ');
+ indent = 1;
+ }
+ }
+ else
+ putchar (' ');
+
+ putchar (' ');
+ fputs (text, stdout);
+
+ return indent + len + 1;
+}
+
+/* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
+ word-wrapped HELP in a second column. */
+static void
+wrap_help (const char *help, const char *item, unsigned int item_width)
+{
+ unsigned int col_width = 27;
+ unsigned int remaining, room, len;
+
+ remaining = strlen (help);
+
+ do
+ {
+ room = columns - 3 - MAX (col_width, item_width);
+ if (room > columns)
+ room = 0;
+ len = remaining;
+
+ if (room < len)
+ {
+ unsigned int i;
+
+ for (i = 0; help[i]; i++)
+ {
+ if (i >= room && len != remaining)
+ break;
+ if (help[i] == ' ')
+ len = i;
+ else if ((help[i] == '-' || help[i] == '/')
+ && help[i + 1] != ' '
+ && i > 0 && ISALPHA (help[i - 1]))
+ len = i + 1;
+ }
+ }
+
+ printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
+ item_width = 0;
+ while (help[len] == ' ')
+ len++;
+ help += len;
+ remaining -= len;
+ }
+ while (remaining);
+}