/* Command line option handling.
- Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
+ Free Software Foundation, Inc.
Contributed by Neil Booth.
This file is part of GCC.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA. */
#include "config.h"
#include "system.h"
#include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
#include "insn-attr.h" /* For INSN_SCHEDULING. */
#include "target.h"
+#include "tree-pass.h"
/* Value of the -G xx switch, and whether it was passed or not. */
unsigned HOST_WIDE_INT g_switch_value;
/* True if we should exit after parsing options. */
bool exit_after_options;
-/* If -version. */
-bool version_flag;
-
/* Print various extra warnings. -W/-Wextra. */
bool extra_warnings;
-/* Don't print warning messages. -w. */
-bool inhibit_warnings;
-
-/* Treat warnings as errors. -Werror. */
-bool warnings_are_errors;
-
-/* Warn if a function returns an aggregate, since there are often
- incompatible calling conventions for doing this. */
-bool warn_aggregate_return;
-
-/* Nonzero means warn about pointer casts that increase the required
- alignment of the target type (and might therefore lead to a crash
- due to a misaligned access). */
-bool warn_cast_align;
-
-/* Nonzero means warn about uses of __attribute__((deprecated))
- declarations. */
-bool warn_deprecated_decl = true;
-
-/* Warn when an optimization pass is disabled. */
-bool warn_disabled_optimization;
-
-/* Nonzero means warn if inline function is too large. */
-bool warn_inline;
-
/* True to warn about any objects definitions whose size is larger
than N bytes. Also want about function definitions whose returned
values are larger than N bytes, where N is `larger_than_size'. */
bool warn_larger_than;
HOST_WIDE_INT larger_than_size;
-/* Warn about functions which might be candidates for attribute noreturn. */
-bool warn_missing_noreturn;
-
-/* True to warn about code which is never reached. */
-bool warn_notreached;
-
-/* Warn if packed attribute on struct is unnecessary and inefficient. */
-bool warn_packed;
-
-/* Warn when gcc pads a structure to an alignment boundary. */
-bool warn_padded;
-
-/* True means warn about all declarations which shadow others. */
-bool warn_shadow;
-
/* Nonzero means warn about constructs which might not be
strict-aliasing safe. */
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. */
-bool warn_switch;
-
-/* Warn if a switch does not have a default case. */
-bool warn_switch_default;
-
-/* Warn if a switch on an enum fails to have a case for every enum
- value (regardless of the presence or otherwise of a default case). */
-bool warn_switch_enum;
-
-/* Don't suppress warnings from system headers. -Wsystem-headers. */
-bool warn_system_headers;
-
-/* True to warn about variables used before they are initialized. */
-int warn_uninitialized;
-
-/* True to warn about unused variables, functions et.al. */
-bool warn_unused_function;
-bool warn_unused_label;
-bool warn_unused_parameter;
-bool warn_unused_variable;
-bool warn_unused_value;
+/* Nonzero means warn about optimizations which rely on undefined
+ signed overflow. */
+int warn_strict_overflow;
/* Hack for cooperation between set_Wunused and set_Wextra. */
static bool maybe_warn_unused_parameter;
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;
+/* The default visibility for all symbols (unless overridden) */
+enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;
+
+/* Disable unit-at-a-time for frontends that might be still broken in this
+ respect. */
+
+bool no_unit_at_a_time_default;
+
+/* Global visibility options. */
+struct visibility_flags visibility_options;
/* What to print when a switch has no documentation. */
static const char undocumented_msg[] = N_("This switch lacks documentation");
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 int common_handle_option (size_t scode, const char *arg, int value,
+ unsigned int lang_mask);
static void handle_param (const char *);
static void set_Wextra (int);
static unsigned int handle_option (const char **argv, unsigned int lang_mask);
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
- (cl_options_count) on failure.
-
- This routine is quite subtle. A normal binary search is not good
- enough because some options can be suffixed with an argument, and
- multiple sub-matches can occur, e.g. input of "-pedantic" matching
- the initial substring of "-pedantic-errors".
-
- A more complicated example is -gstabs. It should match "-g" with
- an argument of "stabs". Suppose, however, that the number and list
- of switches are such that the binary search tests "-gen-decls"
- before having tested "-g". This doesn't match, and as "-gen-decls"
- is less than "-gstabs", it will become the lower bound of the
- binary search range, and "-g" will never be seen. To resolve this
- issue, opts.sh makes "-gen-decls" point, via the back_chain member,
- to "-g" so that failed searches that end between "-gen-decls" and
- the lexicographically subsequent switch know to go back and see if
- "-g" causes a match (which it does in this example).
-
- This search is done in such a way that the longest match for the
- front end in question wins. If there is no match for the current
- front end, the longest match for a different front end is returned
- (or N_OPTS if none) and the caller emits an error message. */
-static size_t
-find_opt (const char *input, int lang_mask)
-{
- size_t mn, mx, md, opt_len;
- size_t match_wrong_lang;
- int comp;
-
- mn = 0;
- mx = cl_options_count;
-
- /* Find mn such this lexicographical inequality holds:
- cl_options[mn] <= input < cl_options[mn + 1]. */
- while (mx - mn > 1)
- {
- md = (mn + mx) / 2;
- opt_len = cl_options[md].opt_len;
- comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
-
- if (comp < 0)
- mx = md;
- else
- mn = md;
- }
-
- /* This is the switch that is the best match but for a different
- front end, or cl_options_count if there is no match at all. */
- match_wrong_lang = cl_options_count;
-
- /* Backtrace the chain of possible matches, returning the longest
- one, if any, that fits best. With current GCC switches, this
- loop executes at most twice. */
- do
- {
- const struct cl_option *opt = &cl_options[mn];
-
- /* Is this switch a prefix of the input? */
- 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 ((opt->flags & lang_mask)
- && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
- return mn;
-
- /* If we haven't remembered a prior match, remember this
- one. Any prior match is necessarily better. */
- if (match_wrong_lang == cl_options_count)
- match_wrong_lang = mn;
- }
-
- /* Try the next possibility. This is cl_options_count if there
- are no more. */
- mn = opt->back_chain;
- }
- while (mn != cl_options_count);
-
- /* Return the best wrong match, or cl_options_count if none. */
- return match_wrong_lang;
-}
-
/* If ARG is a non-negative integer made up solely of digits, return its
value, otherwise return -1. */
static int
if (mask & (1U << n))
len += strlen (lang_name) + 1;
- result = xmalloc (len);
+ result = XNEWVEC (char, len);
len = 0;
for (n = 0; (lang_name = lang_names[n]) != 0; n++)
if (mask & (1U << n))
bad_lang = write_langs (lang_mask);
/* Eventually this should become a hard error IMO. */
- warning ("command line option \"%s\" is valid for %s but not for %s",
+ warning (0, "command line option \"%s\" is valid for %s but not for %s",
text, ok_langs, bad_lang);
free (ok_langs);
opt = argv[0];
- /* Drop the "no-" from negative switches. */
- if ((opt[1] == 'W' || opt[1] == 'f')
+ opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
+ if (opt_index == cl_options_count
+ && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')
&& opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
{
+ /* Drop the "no-" from negative switches. */
size_t len = strlen (opt) - 3;
- dup = xmalloc (len + 1);
+ dup = XNEWVEC (char, len + 1);
dup[0] = '-';
dup[1] = opt[1];
memcpy (dup + 2, opt + 5, len - 2 + 1);
opt = dup;
value = 0;
+ opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
}
- opt_index = find_opt (opt + 1, lang_mask | CL_COMMON);
if (opt_index == cl_options_count)
goto done;
/* We've recognized this switch. */
result = 1;
+ /* Check to see if the option is disabled for this configuration. */
+ if (option->flags & CL_DISABLED)
+ {
+ error ("command line option %qs"
+ " is not supported by this configuration", opt);
+ goto done;
+ }
+
/* Sort out any argument the switch takes. */
if (option->flags & CL_JOINED)
{
/* Now we've swallowed any potential argument, complain if this
is a switch for a different front end. */
- if (!(option->flags & (lang_mask | CL_COMMON)))
+ if (!(option->flags & (lang_mask | CL_COMMON | CL_TARGET)))
+ {
+ complain_wrong_lang (argv[0], option, lang_mask);
+ goto done;
+ }
+ else if ((option->flags & CL_TARGET)
+ && (option->flags & CL_LANG_ALL)
+ && !(option->flags & lang_mask))
{
+ /* Complain for target flag language mismatches if any languages
+ are specified. */
complain_wrong_lang (argv[0], option, lang_mask);
goto done;
}
}
}
+ if (option->flag_var)
+ switch (option->var_type)
+ {
+ case CLVC_BOOLEAN:
+ *(int *) option->flag_var = value;
+ break;
+
+ case CLVC_EQUAL:
+ *(int *) option->flag_var = (value
+ ? option->var_value
+ : !option->var_value);
+ break;
+
+ case CLVC_BIT_CLEAR:
+ case CLVC_BIT_SET:
+ if ((value != 0) == (option->var_type == CLVC_BIT_SET))
+ *(int *) option->flag_var |= option->var_value;
+ else
+ *(int *) option->flag_var &= ~option->var_value;
+ if (option->flag_var == &target_flags)
+ target_flags_explicit |= option->var_value;
+ break;
+
+ case CLVC_STRING:
+ *(const char **) option->flag_var = arg;
+ break;
+ }
+
if (option->flags & lang_mask)
if (lang_hooks.handle_option (opt_index, arg, value) == 0)
result = 0;
if (result && (option->flags & CL_COMMON))
- if (common_handle_option (opt_index, arg, value) == 0)
+ if (common_handle_option (opt_index, arg, value, lang_mask) == 0)
+ result = 0;
+
+ if (result && (option->flags & CL_TARGET))
+ if (!targetm.handle_option (opt_index, arg, value))
result = 0;
done:
return result;
}
+/* Handle FILENAME from the command line. */
+static 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;
+}
+
/* Decode and handle the vector of command line options. LANG_MASK
contains has a single bit set representing the current
language. */
}
}
-/* 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
if (optimize >= 1)
{
flag_defer_pop = 1;
- flag_thread_jumps = 1;
#ifdef DELAY_SLOTS
flag_delayed_branch = 1;
#endif
#endif
flag_guess_branch_prob = 1;
flag_cprop_registers = 1;
- flag_loop_optimize = 1;
flag_if_conversion = 1;
flag_if_conversion2 = 1;
+ flag_ipa_pure_const = 1;
+ flag_ipa_reference = 1;
+ flag_split_wide_types = 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;
+ flag_tree_fre = 1;
+ flag_tree_copy_prop = 1;
+ flag_tree_sink = 1;
+ flag_tree_salias = 1;
+ if (!no_unit_at_a_time_default)
+ flag_unit_at_a_time = 1;
if (!optimize_size)
{
if (optimize >= 2)
{
+ flag_thread_jumps = 1;
flag_crossjumping = 1;
flag_optimize_sibling_calls = 1;
+ flag_forward_propagate = 1;
flag_cse_follow_jumps = 1;
- flag_cse_skip_blocks = 1;
flag_gcse = 1;
flag_expensive_optimizations = 1;
- flag_strength_reduce = 1;
+ flag_ipa_type_escape = 1;
flag_rerun_cse_after_loop = 1;
- flag_rerun_loop_opt = 1;
flag_caller_saves = 1;
- flag_force_mem = 1;
flag_peephole2 = 1;
#ifdef INSN_SCHEDULING
flag_schedule_insns = 1;
#endif
flag_regmove = 1;
flag_strict_aliasing = 1;
+ flag_strict_overflow = 1;
flag_delete_null_pointer_checks = 1;
flag_reorder_blocks = 1;
flag_reorder_functions = 1;
- flag_unit_at_a_time = 1;
+ flag_tree_store_ccp = 1;
+ flag_tree_store_copy_prop = 1;
+ flag_tree_vrp = 1;
+
+ if (!optimize_size)
+ {
+ /* PRE tends to generate bigger code. */
+ flag_tree_pre = 1;
+ }
}
if (optimize >= 3)
/* 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;
+
+ /* We want to crossjump as much as possible. */
+ set_param_value ("min-crossjump-insns", 1);
}
/* Initialize whether `char' is signed. */
/* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
modify it. */
- target_flags = 0;
- set_target_switch ("");
+ target_flags = targetm.default_target_flags;
- /* Unwind tables are always present in an ABI-conformant IA-64
- object file, so the default should be ON. */
-#ifdef IA64_UNWIND_INFO
- flag_unwind_tables = IA64_UNWIND_INFO;
-#endif
+ /* Some tagets have ABI-specified unwind tables. */
+ flag_unwind_tables = targetm.unwind_tables_default;
#ifdef OPTIMIZATION_OPTIONS
/* Allow default optimizations to be specified on a per-machine basis. */
this to `2' if -Wall is used, so we can avoid giving out
lots of errors for people who don't realize what -Wall does. */
if (warn_uninitialized == 1)
- warning ("-Wuninitialized is not supported without -O");
+ warning (OPT_Wuninitialized,
+ "-Wuninitialized is not supported without -O");
}
if (flag_really_no_inline == 2)
/* 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
+ with exception handling. This is because there is no support for
+ generating unwind info. If flag_exceptions is turned on we need to
turn off the partitioning optimization. */
if (flag_exceptions && flag_reorder_blocks_and_partition)
{
- warning
+ inform
("-freorder-blocks-and-partition does not work with exceptions");
flag_reorder_blocks_and_partition = 0;
flag_reorder_blocks = 1;
}
+
+ /* If user requested unwind info, then turn off the partitioning
+ optimization. */
+
+ if (flag_unwind_tables && ! targetm.unwind_tables_default
+ && flag_reorder_blocks_and_partition)
+ {
+ inform ("-freorder-blocks-and-partition does not support unwind info");
+ flag_reorder_blocks_and_partition = 0;
+ flag_reorder_blocks = 1;
+ }
+
+ /* If the target requested unwind info, then turn off the partitioning
+ optimization with a different message. Likewise, if the target does not
+ support named sections. */
+
+ if (flag_reorder_blocks_and_partition
+ && (!targetm.have_named_sections
+ || (flag_unwind_tables && targetm.unwind_tables_default)))
+ {
+ inform
+ ("-freorder-blocks-and-partition does not work on this architecture");
+ flag_reorder_blocks_and_partition = 0;
+ flag_reorder_blocks = 1;
+ }
+}
+
+#define LEFT_COLUMN 27
+
+/* 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 columns)
+{
+ unsigned int col_width = LEFT_COLUMN;
+ 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);
+}
+
+/* Print help for a specific front-end, etc. */
+static void
+print_filtered_help (unsigned int include_flags,
+ unsigned int exclude_flags,
+ unsigned int any_flags,
+ unsigned int columns)
+{
+ unsigned int i;
+ const char *help;
+ static char *printed = NULL;
+ bool found = false;
+ bool displayed = false;
+
+ if (include_flags == CL_PARAMS)
+ {
+ for (i = 0; i < LAST_PARAM; i++)
+ {
+ const char *param = compiler_params[i].option;
+
+ help = compiler_params[i].help;
+ if (help == NULL || *help == '\0')
+ {
+ if (exclude_flags & CL_UNDOCUMENTED)
+ continue;
+ help = undocumented_msg;
+ }
+
+ /* Get the translation. */
+ help = _(help);
+
+ wrap_help (help, param, strlen (param), columns);
+ }
+ putchar ('\n');
+ return;
+ }
+
+ if (!printed)
+ printed = xcalloc (1, cl_options_count);
+
+ for (i = 0; i < cl_options_count; i++)
+ {
+ static char new_help[128];
+ const struct cl_option *option = cl_options + i;
+ unsigned int len;
+ const char *opt;
+ const char *tab;
+
+ if (include_flags == 0
+ || ((option->flags & include_flags) != include_flags))
+ {
+ if ((option->flags & any_flags) == 0)
+ continue;
+ }
+
+ /* Skip unwanted switches. */
+ if ((option->flags & exclude_flags) != 0)
+ continue;
+
+ found = true;
+ /* Skip switches that have already been printed. */
+ if (printed[i])
+ continue;
+
+ printed[i] = true;
+
+ help = option->help;
+ if (help == NULL)
+ {
+ if (exclude_flags & CL_UNDOCUMENTED)
+ continue;
+ help = undocumented_msg;
+ }
+
+ /* Get the translation. */
+ help = _(help);
+
+ /* Find the gap between the name of the
+ option and its descriptive text. */
+ tab = strchr (help, '\t');
+ if (tab)
+ {
+ len = tab - help;
+ opt = help;
+ help = tab + 1;
+ }
+ else
+ {
+ opt = option->opt_text;
+ len = strlen (opt);
+ }
+
+ /* With the -Q option enabled we change the descriptive text associated
+ with an option to be an indication of its current setting. */
+ if (!quiet_flag)
+ {
+ if (len < (LEFT_COLUMN + 2))
+ strcpy (new_help, "\t\t");
+ else
+ strcpy (new_help, "\t");
+
+ if (option->flag_var != NULL)
+ {
+ if (option->flags & CL_JOINED)
+ {
+ if (option->var_type == CLVC_STRING)
+ {
+ if (* (const char **) option->flag_var != NULL)
+ snprintf (new_help + strlen (new_help),
+ sizeof (new_help) - strlen (new_help),
+ * (const char **) option->flag_var);
+ }
+ else
+ sprintf (new_help + strlen (new_help),
+ "%#x", * (int *) option->flag_var);
+ }
+ else
+ strcat (new_help, option_enabled (i)
+ ? _("[enabled]") : _("[disabled]"));
+ }
+
+ help = new_help;
+ }
+
+ wrap_help (help, opt, len, columns);
+ displayed = true;
+ }
+
+ if (! found)
+ printf (_(" No options with the desired characteristics were found\n"));
+ else if (! displayed)
+ printf (_(" All options with the desired characteristics have already been displayed\n"));
+
+ putchar ('\n');
+}
+
+/* Display help for a specified type of option.
+ The options must have ALL of the INCLUDE_FLAGS set
+ ANY of the flags in the ANY_FLAGS set
+ and NONE of the EXCLUDE_FLAGS set. */
+static void
+print_specific_help (unsigned int include_flags,
+ unsigned int exclude_flags,
+ unsigned int any_flags)
+{
+ unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
+ const char * description = NULL;
+ const char * descrip_extra = "";
+ size_t i;
+ unsigned int flag;
+ static unsigned int columns = 0;
+
+ /* Sanity check: Make sure that we do not have more
+ languages than we have bits available to enumerate them. */
+ gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
+
+ /* If we have not done so already, obtain
+ the desired maximum width of the output. */
+ if (columns == 0)
+ {
+ const char *p;
+
+ GET_ENVIRONMENT (p, "COLUMNS");
+ if (p != NULL)
+ {
+ int value = atoi (p);
+
+ if (value > 0)
+ columns = value;
+ }
+
+ if (columns == 0)
+ /* Use a reasonable default. */
+ columns = 80;
+ }
+
+ /* Decide upon the title for the options that we are going to display. */
+ for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
+ {
+ switch (flag & include_flags)
+ {
+ case 0:
+ break;
+
+ case CL_TARGET:
+ description = _("The following options are target specific");
+ break;
+ case CL_WARNING:
+ description = _("The following options control compiler warning messages");
+ break;
+ case CL_OPTIMIZATION:
+ description = _("The following options control optimizations");
+ break;
+ case CL_COMMON:
+ description = _("The following options are language-independent");
+ break;
+ case CL_PARAMS:
+ description = _("The --param option recognizes the following as parameters");
+ break;
+ default:
+ if (i >= cl_lang_count)
+ break;
+ if ((exclude_flags & ((1U << cl_lang_count) - 1)) != 0)
+ {
+ description = _("The following options are specific to the language ");
+ descrip_extra = lang_names [i];
+ }
+ else
+ description = _("The following options are supported by, amoung others, the language ");
+ break;
+ }
+ }
+
+ if (description == NULL)
+ {
+ if (any_flags == 0)
+ {
+ if (include_flags == CL_UNDOCUMENTED)
+ description = _("The following options are not documented");
+ else
+ {
+ internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
+ include_flags);
+ return;
+ }
+ }
+ else
+ {
+ if (any_flags & all_langs_mask)
+ description = _("The following options are language-related");
+ else
+ description = _("The following options are language-independent");
+ }
+ }
+
+ printf ("%s%s:\n", description, descrip_extra);
+ print_filtered_help (include_flags, exclude_flags, any_flags, columns);
}
/* Handle target- and language-independent options. Return zero to
- generate an "unknown option" message. */
+ generate an "unknown option" message. Only options that need
+ extra handling need to be listed here; if you simply want
+ VALUE assigned to a variable, it happens automatically. */
+
static int
-common_handle_option (size_t scode, const char *arg,
- int value ATTRIBUTE_UNUSED)
+common_handle_option (size_t scode, const char *arg, int value,
+ unsigned int lang_mask)
{
enum opt_code code = (enum opt_code) scode;
switch (code)
{
- default:
- abort ();
-
- case OPT__help:
- print_help ();
- exit_after_options = true;
- break;
-
case OPT__param:
handle_param (arg);
break;
+ case OPT_fhelp:
+ case OPT__help:
+ {
+ unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
+ unsigned int undoc_mask;
+ unsigned int i;
+
+ undoc_mask = extra_warnings ? 0 : CL_UNDOCUMENTED;
+ /* First display any single language specific options. */
+ for (i = 0; i < cl_lang_count; i++)
+ print_specific_help
+ (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0);
+ /* Next display any multi language specific options. */
+ print_specific_help (0, undoc_mask, all_langs_mask);
+ /* Then display any remaining, non-language options. */
+ for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
+ print_specific_help (i, undoc_mask, 0);
+ exit_after_options = true;
+ break;
+ }
+
+ case OPT_ftarget_help:
case OPT__target_help:
- display_target_options ();
+ print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0);
exit_after_options = true;
break;
+ case OPT_fhelp_:
+ case OPT__help_:
+ {
+ const char * a = arg;
+ unsigned int include_flags = 0;
+ /* Note - by default we include undocumented options when listing
+ specific classes. If you only want to see documented options
+ then add ",^undocumented" to the --help= option. e.g.:
+
+ --help=target,^undocumented */
+ unsigned int exclude_flags = 0;
+
+ /* Walk along the argument string, parsing each word in turn.
+ The format is:
+ arg = [^]{word}[,{arg}]
+ word = {optimizers|target|warnings|undocumented|params} */
+ while (* a != 0)
+ {
+ static struct
+ {
+ const char * string;
+ unsigned int flag;
+ }
+ specifics[] =
+ {
+ { "optimizers", CL_OPTIMIZATION },
+ { "target", CL_TARGET },
+ { "warnings", CL_WARNING },
+ { "undocumented", CL_UNDOCUMENTED },
+ { "params", CL_PARAMS },
+ { "joined", CL_JOINED },
+ { "separate", CL_SEPARATE },
+ { NULL, 0 }
+ };
+ unsigned int * pflags;
+ char * comma;
+ unsigned int len;
+ unsigned int i;
+
+ if (* a == '^')
+ {
+ ++ a;
+ pflags = & exclude_flags;
+ }
+ else
+ pflags = & include_flags;
+
+ comma = strchr (a, ',');
+ if (comma == NULL)
+ len = strlen (a);
+ else
+ len = comma - a;
+
+ for (i = 0; specifics[i].string != NULL; i++)
+ if (strncasecmp (a, specifics[i].string, len) == 0)
+ {
+ * pflags |= specifics[i].flag;
+ break;
+ }
+
+ if (specifics[i].string == NULL)
+ {
+ /* Check to see if the string matches a language name. */
+ for (i = 0; i < cl_lang_count; i++)
+ if (strncasecmp (a, lang_names[i], len) == 0)
+ {
+ * pflags |= 1U << i;
+ break;
+ }
+
+ if (i == cl_lang_count)
+ fnotice (stderr,
+ "warning: unrecognized argument to --help= switch: %.*s\n",
+ len, a);
+ }
+
+ if (comma == NULL)
+ break;
+ a = comma + 1;
+ }
+
+ if (include_flags)
+ print_specific_help (include_flags, exclude_flags, 0);
+ exit_after_options = true;
+ break;
+ }
+
case OPT__version:
print_version (stderr, "");
exit_after_options = true;
set_Wextra (value);
break;
- case OPT_Waggregate_return:
- warn_aggregate_return = value;
+ case OPT_Werror_:
+ enable_warning_as_error (arg, value, lang_mask);
break;
- case OPT_Wcast_align:
- warn_cast_align = value;
- break;
-
- case OPT_Wdeprecated_declarations:
- warn_deprecated_decl = value;
- break;
-
- case OPT_Wdisabled_optimization:
- warn_disabled_optimization = value;
- break;
-
- case OPT_Werror:
- warnings_are_errors = value;
- break;
-
- case OPT_Wextra:
- set_Wextra (value);
- break;
-
- case OPT_Wfatal_errors:
- flag_fatal_errors = value;
- break;
-
- case OPT_Winline:
- warn_inline = value;
+ case OPT_Wextra:
+ set_Wextra (value);
break;
case OPT_Wlarger_than_:
warn_larger_than = value != -1;
break;
- case OPT_Wmissing_noreturn:
- warn_missing_noreturn = value;
- break;
-
- case OPT_Wpacked:
- warn_packed = value;
- break;
-
- case OPT_Wpadded:
- warn_padded = value;
- break;
-
- case OPT_Wshadow:
- warn_shadow = value;
- break;
-
case OPT_Wstrict_aliasing:
case OPT_Wstrict_aliasing_:
warn_strict_aliasing = value;
break;
- case OPT_Wswitch:
- warn_switch = value;
- break;
-
- case OPT_Wswitch_default:
- warn_switch_default = value;
- break;
-
- case OPT_Wswitch_enum:
- warn_switch_enum = value;
- break;
-
- case OPT_Wsystem_headers:
- warn_system_headers = value;
- break;
-
- case OPT_Wuninitialized:
- warn_uninitialized = value;
+ case OPT_Wstrict_overflow:
+ warn_strict_overflow = (value
+ ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
+ : 0);
break;
- case OPT_Wunreachable_code:
- warn_notreached = value;
+ case OPT_Wstrict_overflow_:
+ warn_strict_overflow = value;
break;
case OPT_Wunused:
set_Wunused (value);
break;
- case OPT_Wunused_function:
- warn_unused_function = value;
- break;
-
- case OPT_Wunused_label:
- warn_unused_label = value;
- break;
-
- case OPT_Wunused_parameter:
- warn_unused_parameter = value;
- break;
-
- case OPT_Wunused_value:
- warn_unused_value = value;
- break;
-
- case OPT_Wunused_variable:
- warn_unused_variable = value;
- break;
-
case OPT_aux_info:
case OPT_aux_info_:
aux_info_file_name = arg;
dump_base_name = arg;
break;
- case OPT_fPIC:
- flag_pic = value + value;
- break;
-
- case OPT_fPIE:
- flag_pie = value + value;
- break;
-
- case OPT_fabi_version_:
- flag_abi_version = value;
- break;
-
- case OPT_falign_functions:
- align_functions = !value;
- break;
-
case OPT_falign_functions_:
align_functions = value;
break;
- case OPT_falign_jumps:
- align_jumps = !value;
- break;
-
case OPT_falign_jumps_:
align_jumps = value;
break;
- case OPT_falign_labels:
- align_labels = !value;
- break;
-
case OPT_falign_labels_:
align_labels = value;
break;
- case OPT_falign_loops:
- align_loops = !value;
- break;
-
case OPT_falign_loops_:
align_loops = value;
break;
- case OPT_fargument_alias:
- flag_argument_noalias = !value;
- break;
-
- case OPT_fargument_noalias:
- flag_argument_noalias = value;
- break;
-
- case OPT_fargument_noalias_global:
- flag_argument_noalias = value + value;
- break;
-
- case OPT_fasynchronous_unwind_tables:
- flag_asynchronous_unwind_tables = value;
- break;
-
- case OPT_fbounds_check:
- flag_bounds_check = value;
- break;
-
- case OPT_fbranch_count_reg:
- flag_branch_on_count_reg = value;
- break;
-
case OPT_fbranch_probabilities:
flag_branch_probabilities_set = true;
- flag_branch_probabilities = value;
- break;
-
- case OPT_fbranch_target_load_optimize:
- flag_branch_target_load_optimize = value;
- break;
-
- case OPT_fbranch_target_load_optimize2:
- 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, 0);
break;
- case OPT_fcaller_saves:
- flag_caller_saves = value;
- break;
-
- case OPT_fcommon:
- flag_no_common = !value;
- break;
-
- case OPT_fcprop_registers:
- flag_cprop_registers = value;
- break;
-
- case OPT_fcrossjumping:
- flag_crossjumping = value;
- break;
-
- case OPT_fcse_follow_jumps:
- flag_cse_follow_jumps = value;
- break;
-
- case OPT_fcse_skip_blocks:
- flag_cse_skip_blocks = value;
- break;
-
- case OPT_fdata_sections:
- flag_data_sections = value;
- break;
-
- case OPT_fdefer_pop:
- flag_defer_pop = value;
- break;
-
- case OPT_fdelayed_branch:
- flag_delayed_branch = value;
- break;
-
- case OPT_fdelete_null_pointer_checks:
- flag_delete_null_pointer_checks = value;
- break;
-
case OPT_fdiagnostics_show_location_:
if (!strcmp (arg, "once"))
diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
return 0;
break;
+ case OPT_fdiagnostics_show_option:
+ global_dc->show_option_requested = true;
+ break;
+
case OPT_fdump_:
if (!dump_switch_p (arg))
return 0;
break;
- case OPT_fdump_unnumbered:
- flag_dump_unnumbered = value;
- break;
-
- case OPT_feliminate_dwarf2_dups:
- flag_eliminate_dwarf2_dups = value;
- break;
-
- case OPT_feliminate_unused_debug_types:
- flag_eliminate_unused_debug_types = value;
- break;
-
- case OPT_feliminate_unused_debug_symbols:
- flag_debug_only_used_symbols = value;
- break;
-
- case OPT_fexceptions:
- flag_exceptions = value;
- break;
-
- case OPT_fexpensive_optimizations:
- flag_expensive_optimizations = value;
- break;
-
case OPT_ffast_math:
set_fast_math_flags (value);
break;
- case OPT_ffinite_math_only:
- flag_finite_math_only = value;
- break;
-
case OPT_ffixed_:
fix_register (arg, 1, 1);
break;
- case OPT_ffunction_cse:
- flag_no_function_cse = !value;
- break;
-
- case OPT_ffloat_store:
- flag_float_store = value;
- break;
-
- case OPT_fforce_addr:
- flag_force_addr = value;
- break;
-
- case OPT_fforce_mem:
- flag_force_mem = value;
- break;
-
- case OPT_ffunction_sections:
- flag_function_sections = value;
- break;
-
- case OPT_fgcse:
- flag_gcse = value;
- break;
-
- case OPT_fgcse_lm:
- flag_gcse_lm = value;
- break;
-
- case OPT_fgcse_sm:
- flag_gcse_sm = value;
- break;
-
- 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:
- flag_guess_branch_prob = value;
- break;
-
- case OPT_fident:
- flag_no_ident = !value;
- break;
-
- case OPT_fif_conversion:
- flag_if_conversion = value;
- break;
-
- case OPT_fif_conversion2:
- flag_if_conversion2 = value;
- break;
-
- case OPT_finhibit_size_directive:
- flag_inhibit_size_directive = value;
- break;
-
- case OPT_finline:
- flag_no_inline = !value;
- break;
-
- case OPT_finline_functions:
- flag_inline_functions = value;
- break;
-
case OPT_finline_limit_:
case OPT_finline_limit_eq:
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);
- break;
-
- case OPT_finstrument_functions:
- flag_instrument_function_entry_exit = value;
- break;
-
- case OPT_fkeep_inline_functions:
- flag_keep_inline_functions =value;
- break;
-
- case OPT_fkeep_static_consts:
- flag_keep_static_consts = value;
- break;
-
- case OPT_fleading_underscore:
- flag_leading_underscore = value;
- break;
-
- case OPT_floop_optimize:
- flag_loop_optimize = value;
- break;
-
- case OPT_fmath_errno:
- flag_errno_math = value;
- break;
-
- case OPT_fmem_report:
- mem_report = value;
- break;
-
- case OPT_fmerge_all_constants:
- flag_merge_constants = value + value;
- break;
-
- case OPT_fmerge_constants:
- flag_merge_constants = value;
break;
case OPT_fmessage_length_:
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;
-
- case OPT_fnon_call_exceptions:
- flag_non_call_exceptions = value;
- break;
-
- case OPT_fold_unroll_all_loops:
- flag_old_unroll_all_loops = value;
- break;
-
- case OPT_fold_unroll_loops:
- flag_old_unroll_loops = value;
- break;
-
- case OPT_fomit_frame_pointer:
- flag_omit_frame_pointer = value;
- break;
-
- case OPT_foptimize_register_move:
- flag_regmove = value;
- break;
-
- case OPT_foptimize_sibling_calls:
- flag_optimize_sibling_calls = value;
- break;
-
- case OPT_fpack_struct:
- flag_pack_struct = value;
+ case OPT_fpack_struct_:
+ if (value <= 0 || (value & (value - 1)) || value > 16)
+ error ("structure alignment must be a small power of two, not %d", value);
+ else
+ {
+ initial_max_fld_align = value;
+ maximum_field_alignment = value * BITS_PER_UNIT;
+ }
break;
case OPT_fpeel_loops:
flag_peel_loops_set = true;
- flag_peel_loops = value;
- break;
-
- case OPT_fpcc_struct_return:
- flag_pcc_struct_return = value;
- break;
-
- case OPT_fpeephole:
- flag_no_peephole = !value;
- break;
-
- case OPT_fpeephole2:
- flag_peephole2 = value;
- break;
-
- case OPT_fpic:
- flag_pic = value;
- break;
-
- case OPT_fpie:
- flag_pie = value;
- break;
-
- case OPT_fprefetch_loop_arrays:
- flag_prefetch_loop_arrays = value;
- break;
-
- case OPT_fprofile:
- profile_flag = value;
break;
case OPT_fprofile_arcs:
profile_arc_flag_set = true;
- profile_arc_flag = value;
break;
case OPT_fprofile_use:
case OPT_fprofile_values:
flag_profile_values_set = true;
- flag_profile_values = value;
+ break;
+
+ case OPT_fvisibility_:
+ {
+ if (!strcmp(arg, "default"))
+ default_visibility = VISIBILITY_DEFAULT;
+ else if (!strcmp(arg, "internal"))
+ default_visibility = VISIBILITY_INTERNAL;
+ else if (!strcmp(arg, "hidden"))
+ default_visibility = VISIBILITY_HIDDEN;
+ else if (!strcmp(arg, "protected"))
+ default_visibility = VISIBILITY_PROTECTED;
+ else
+ error ("unrecognized visibility value \"%s\"", arg);
+ }
break;
case OPT_fvpt:
- flag_value_profile_transformations_set = value;
- flag_value_profile_transformations = value;
+ flag_value_profile_transformations_set = true;
break;
case OPT_frandom_seed:
/* The real switch is -fno-random-seed. */
if (value)
return 0;
- flag_random_seed = NULL;
+ set_random_seed (NULL);
break;
case OPT_frandom_seed_:
- flag_random_seed = arg;
- break;
-
- case OPT_freduce_all_givs:
- flag_reduce_all_givs = value;
- break;
-
- case OPT_freg_struct_return:
- flag_pcc_struct_return = !value;
- break;
-
- case OPT_fregmove:
- flag_regmove = value;
- break;
-
- case OPT_frename_registers:
- flag_rename_registers = value;
- break;
-
- case OPT_freorder_blocks:
- 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;
-
- case OPT_frerun_cse_after_loop:
- flag_rerun_cse_after_loop = value;
- break;
-
- case OPT_frerun_loop_opt:
- flag_rerun_loop_opt = value;
- break;
-
- case OPT_frounding_math:
- flag_rounding_math = value;
- break;
-
- case OPT_fsched_interblock:
- flag_schedule_interblock = value;
- break;
-
- case OPT_fsched_spec:
- flag_schedule_speculative = value;
- break;
-
- case OPT_fsched_spec_load:
- flag_schedule_speculative_load = value;
- break;
-
- case OPT_fsched_spec_load_dangerous:
- flag_schedule_speculative_load_dangerous = value;
+ set_random_seed (arg);
break;
case OPT_fsched_verbose_:
return 0;
#endif
- case OPT_fsched2_use_superblocks:
- flag_sched2_use_superblocks = value;
- break;
-
- case OPT_fsched2_use_traces:
- flag_sched2_use_traces = value;
- break;
-
- case OPT_fschedule_insns:
- flag_schedule_insns = value;
- break;
-
- case OPT_fschedule_insns2:
- flag_schedule_insns_after_reload = value;
- break;
-
- case OPT_fsched_stalled_insns:
- flag_sched_stalled_insns = value;
- break;
-
case OPT_fsched_stalled_insns_:
flag_sched_stalled_insns = value;
if (flag_sched_stalled_insns == 0)
flag_sched_stalled_insns = -1;
break;
- case OPT_fsched_stalled_insns_dep:
- flag_sched_stalled_insns_dep = 1;
- break;
-
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_fsignaling_nans:
- flag_signaling_nans = value;
- break;
-
- case OPT_fsingle_precision_constant:
- flag_single_precision_constant = value;
- break;
-
- case OPT_fstack_check:
- flag_stack_check = value;
- break;
case OPT_fstack_limit:
/* The real switch is -fno-stack-limit. */
stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
break;
- case OPT_fstrength_reduce:
- flag_strength_reduce = value;
- break;
-
- case OPT_fstrict_aliasing:
- flag_strict_aliasing = value;
- break;
-
- case OPT_fsyntax_only:
- flag_syntax_only = value;
- break;
-
- case OPT_ftest_coverage:
- flag_test_coverage = value;
- break;
-
- case OPT_fthread_jumps:
- flag_thread_jumps = value;
- break;
-
- case OPT_ftime_report:
- time_report = value;
+ case OPT_ftree_vectorizer_verbose_:
+ vect_set_verbosity_level (arg);
break;
case OPT_ftls_model_:
else if (!strcmp (arg, "local-exec"))
flag_tls_default = TLS_MODEL_LOCAL_EXEC;
else
- warning ("unknown tls-model \"%s\"", arg);
+ warning (0, "unknown tls-model \"%s\"", arg);
break;
case OPT_ftracer:
flag_tracer_set = true;
- flag_tracer = value;
- break;
-
- case OPT_ftrapping_math:
- flag_trapping_math = value;
- break;
-
- case OPT_ftrapv:
- 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;
-
- case OPT_funroll_all_loops:
- flag_unroll_all_loops = value;
break;
case OPT_funroll_loops:
flag_unroll_loops_set = true;
- flag_unroll_loops = value;
- break;
-
- case OPT_funsafe_math_optimizations:
- flag_unsafe_math_optimizations = value;
- break;
-
- case OPT_funswitch_loops:
- flag_unswitch_loops = value;
- break;
-
- case OPT_funwind_tables:
- 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_fzero_initialized_in_bss:
- flag_zero_initialized_in_bss = value;
break;
case OPT_g:
set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
break;
- case OPT_m:
- set_target_switch (arg);
- break;
-
case OPT_o:
asm_file_name = arg;
break;
- case OPT_p:
- profile_flag = 1;
- break;
-
- case OPT_pedantic:
- pedantic = 1;
- break;
-
case OPT_pedantic_errors:
flag_pedantic_errors = pedantic = 1;
break;
- case OPT_quiet:
- quiet_flag = 1;
+ case OPT_floop_optimize:
+ case OPT_frerun_loop_opt:
+ case OPT_fstrength_reduce:
+ /* These are no-ops, preserved for backward compatibility. */
break;
- case OPT_version:
- version_flag = 1;
+ default:
+ /* If the flag was handled in a standard way, assume the lack of
+ processing here is intentional. */
+ gcc_assert (cl_options[scode].flag_var);
break;
-
- case OPT_w:
- inhibit_warnings = true;
- break;
}
return 1;
{
value = integral_argument (equal + 1);
if (value == -1)
- error ("invalid --param value `%s'", equal + 1);
+ error ("invalid --param value %qs", equal + 1);
else
{
*equal = '\0';
set_Wextra (int setting)
{
extra_warnings = setting;
- warn_unused_value = setting;
warn_unused_parameter = (setting && maybe_warn_unused_parameter);
/* We save the value of warn_uninitialized, since if they put
flag_trapping_math = !set;
flag_unsafe_math_optimizations = set;
flag_finite_math_only = set;
+ flag_signed_zeros = !set;
flag_errno_math = !set;
if (set)
{
flag_signaling_nans = 0;
flag_rounding_math = 0;
+ flag_cx_limited_range = 1;
}
}
return (!flag_trapping_math
&& flag_unsafe_math_optimizations
&& flag_finite_math_only
+ && !flag_signed_zeros
&& !flag_errno_math);
}
}
if (write_symbols == NO_DEBUG)
- warning ("target system does not support debug output");
+ warning (0, "target system does not support debug output");
}
}
else
}
}
-/* 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 ();
-}
+/* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
+ a simple on-off switch. */
-/* Print the help for --param. */
-static void
-print_param_help (void)
+int
+option_enabled (int opt_idx)
{
- size_t i;
+ const struct cl_option *option = &(cl_options[opt_idx]);
- puts (_("The --param option recognizes the following as parameters:\n"));
+ if (option->flag_var)
+ switch (option->var_type)
+ {
+ case CLVC_BOOLEAN:
+ return *(int *) option->flag_var != 0;
- for (i = 0; i < LAST_PARAM; i++)
- {
- const char *help = compiler_params[i].help;
- const char *param = compiler_params[i].option;
+ case CLVC_EQUAL:
+ return *(int *) option->flag_var == option->var_value;
- if (help == NULL || *help == '\0')
- help = undocumented_msg;
+ case CLVC_BIT_CLEAR:
+ return (*(int *) option->flag_var & option->var_value) == 0;
- /* Get the translation. */
- help = _(help);
-
- wrap_help (help, param, strlen (param));
- }
+ case CLVC_BIT_SET:
+ return (*(int *) option->flag_var & option->var_value) != 0;
- putchar ('\n');
+ case CLVC_STRING:
+ break;
+ }
+ return -1;
}
-/* 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;
+/* Fill STATE with the current state of option OPTION. Return true if
+ there is some state to store. */
- 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');
- }
- }
+bool
+get_option_state (int option, struct cl_option_state *state)
+{
+ if (cl_options[option].flag_var == 0)
+ return false;
- for (i = 0; i < cl_options_count; i++)
+ switch (cl_options[option].var_type)
{
- 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);
+ case CLVC_BOOLEAN:
+ case CLVC_EQUAL:
+ state->data = cl_options[option].flag_var;
+ state->size = sizeof (int);
+ break;
- tab = strchr (help, '\t');
- if (tab)
- {
- len = tab - help;
- opt = help;
- help = tab + 1;
- }
- else
- {
- opt = cl_options[i].opt_text;
- len = strlen (opt);
- }
+ case CLVC_BIT_CLEAR:
+ case CLVC_BIT_SET:
+ state->ch = option_enabled (option);
+ state->data = &state->ch;
+ state->size = 1;
+ break;
- wrap_help (help, opt, len);
+ case CLVC_STRING:
+ state->data = *(const char **) cl_options[option].flag_var;
+ if (state->data == 0)
+ state->data = "";
+ state->size = strlen (state->data) + 1;
+ break;
}
-
- putchar ('\n');
+ return true;
}
-/* 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 */
+/* Enable a warning option as an error. This is used by -Werror= and
+ also by legacy Werror-implicit-function-declaration. */
- if (indent)
+void
+enable_warning_as_error (const char *arg, int value, unsigned int lang_mask)
+{
+ char *new_option;
+ int option_index;
+
+ new_option = XNEWVEC (char, strlen (arg) + 2);
+ new_option[0] = 'W';
+ strcpy (new_option + 1, arg);
+ option_index = find_opt (new_option, lang_mask);
+ if (option_index == N_OPTS)
{
- putchar (',');
- if (indent + len > columns)
- {
- putchar ('\n');
- putchar (' ');
- indent = 1;
- }
+ error ("-Werror=%s: No option -%s", arg, new_option);
}
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;
+ int kind = value ? DK_ERROR : DK_WARNING;
+ diagnostic_classify_diagnostic (global_dc, option_index, kind);
+
+ /* -Werror=foo implies -Wfoo. */
+ if (cl_options[option_index].var_type == CLVC_BOOLEAN
+ && cl_options[option_index].flag_var
+ && kind == DK_ERROR)
+ *(int *) cl_options[option_index].flag_var = 1;
}
- while (remaining);
+ free (new_option);
}