/* Command line option handling.
- Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
Free Software Foundation, Inc.
Contributed by Neil Booth.
#include "tm.h"
#include "tree.h"
#include "rtl.h"
+#include "expr.h"
#include "ggc.h"
#include "output.h"
#include "langhooks.h"
unsigned HOST_WIDE_INT g_switch_value;
bool g_switch_set;
+/* Same for selective scheduling. */
+bool sel_sched_switch_set;
+
/* True if we should exit after parsing options. */
bool exit_after_options;
bool warn_frame_larger_than;
HOST_WIDE_INT frame_larger_than_size;
-/* 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. */
/* 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;
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;
-static bool flag_inline_functions_set;
+static bool flag_inline_functions_set, flag_ipa_cp_set, flag_ipa_cp_clone_set;
+static bool flag_predictive_commoning_set, flag_unswitch_loops_set, flag_gcse_after_reload_set;
/* Functions excluded from profiling. */
static VEC(const_char_p,heap) *ignored_options;
-/* Function calls disallowed under -Wdisallowed-function-list=... */
-static VEC(char_p,heap) *warning_disallowed_functions;
-
-/* If -Wdisallowed-function-list=... */
-bool warn_disallowed_functions = false;
-
/* Input file names. */
const char **in_fnames;
unsigned num_in_fnames;
}
-/* Return whether this function call is disallowed. */
-void
-warn_if_disallowed_function_p (const_tree exp)
-{
- if (TREE_CODE(exp) == CALL_EXPR
- && VEC_length (char_p, warning_disallowed_functions) > 0)
- {
- int i;
- char *s;
- const char *fnname =
- IDENTIFIER_POINTER (DECL_NAME (get_callee_fndecl (exp)));
- for (i = 0; VEC_iterate (char_p, warning_disallowed_functions, i, s);
- ++i)
- {
- if (strcmp (fnname, s) == 0)
- {
- warning (OPT_Wdisallowed_function_list_,
- "disallowed call to %qs", fnname);
- break;
- }
- }
- }
-}
-
/* Decode and handle the vector of command line options. LANG_MASK
contains has a single bit set representing the current
language. */
decode_options (unsigned int argc, const char **argv)
{
static bool first_time_p = true;
- static int initial_max_aliased_vops;
- static int initial_avg_aliased_vops;
static int initial_min_crossjump_insns;
static int initial_max_fields_for_field_sensitive;
+ static int initial_loop_invariant_max_bbs_in_loop;
static unsigned int initial_lang_mask;
unsigned int i, lang_mask;
lang_hooks.initialize_diagnostics (global_dc);
/* Save initial values of parameters we reset. */
- initial_max_aliased_vops = MAX_ALIASED_VOPS;
- initial_avg_aliased_vops = AVG_ALIASED_VOPS;
initial_min_crossjump_insns
= compiler_params[PARAM_MIN_CROSSJUMP_INSNS].value;
initial_max_fields_for_field_sensitive
= compiler_params[PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE].value;
+ initial_loop_invariant_max_bbs_in_loop
+ = compiler_params[PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP].value;
}
else
lang_mask = initial_lang_mask;
}
}
}
-
-
- if (!flag_unit_at_a_time)
- {
- flag_section_anchors = 0;
- flag_toplevel_reorder = 0;
- flag_unit_at_a_time = 1;
- }
- if (!flag_toplevel_reorder)
- {
- if (flag_section_anchors == 1)
- error ("Section anchors must be disabled when toplevel reorder is disabled.");
- flag_section_anchors = 0;
- }
-
- /* Originally we just set the variables if a particular optimization level,
- but with the advent of being able to change the optimization level for a
- function, we need to reset optimizations. */
- if (!optimize)
- {
- flag_merge_constants = 0;
-
- /* We disable toplevel reordering at -O0 to disable transformations that
- might be surprising to end users and to get -fno-toplevel-reorder
- tested, but we keep section anchors. */
- if (flag_toplevel_reorder == 2)
- flag_toplevel_reorder = 0;
- }
- else
- flag_merge_constants = 1;
+
+ /* Use priority coloring if cover classes is not defined for the
+ target. */
+ if (targetm.ira_cover_classes == NULL)
+ flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
/* -O1 optimizations. */
opt1 = (optimize >= 1);
flag_if_conversion2 = opt1;
flag_ipa_pure_const = opt1;
flag_ipa_reference = opt1;
+ flag_merge_constants = opt1;
flag_split_wide_types = opt1;
flag_tree_ccp = opt1;
flag_tree_dce = opt1;
/* -O2 optimizations. */
opt2 = (optimize >= 2);
flag_inline_small_functions = opt2;
+ flag_indirect_inlining = opt2;
flag_thread_jumps = opt2;
flag_crossjumping = opt2;
flag_optimize_sibling_calls = opt2;
flag_regmove = opt2;
flag_strict_aliasing = opt2;
flag_strict_overflow = opt2;
- flag_delete_null_pointer_checks = opt2;
flag_reorder_blocks = opt2;
flag_reorder_functions = opt2;
- flag_tree_store_ccp = opt2;
flag_tree_vrp = opt2;
flag_tree_builtin_call_dce = opt2;
flag_tree_pre = opt2;
- flag_tree_switch_conversion = 1;
-
- /* Allow more virtual operators to increase alias precision. */
-
- set_param_value ("max-aliased-vops",
- (opt2) ? 500 : initial_max_aliased_vops);
+ flag_tree_switch_conversion = 1;
+ flag_ipa_cp = opt2;
/* Track fields in field-sensitive alias analysis. */
set_param_value ("max-fields-for-field-sensitive",
(opt2) ? 100 : initial_max_fields_for_field_sensitive);
+ /* For -O1 only do loop invariant motion for very small loops. */
+ set_param_value ("loop-invariant-max-bbs-in-loop",
+ (opt2) ? initial_loop_invariant_max_bbs_in_loop : 1000);
+
/* -O3 optimizations. */
opt3 = (optimize >= 3);
flag_predictive_commoning = opt3;
flag_unswitch_loops = opt3;
flag_gcse_after_reload = opt3;
flag_tree_vectorize = opt3;
-
- /* Allow even more virtual operators. Max-aliased-vops was set above for
- -O2, so don't reset it unless we are at -O3. */
- if (opt3)
- set_param_value ("max-aliased-vops", 1000);
-
- set_param_value ("avg-aliased-vops", (opt3) ? 3 : initial_avg_aliased_vops);
+ flag_ipa_cp_clone = opt3;
+ if (flag_ipa_cp_clone)
+ flag_ipa_cp = 1;
/* Just -O1/-O0 optimizations. */
opt1_max = (optimize <= 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 = 0;
-
- /* Conditional DCE generates bigger code. */
- flag_tree_builtin_call_dce = 0;
-
- /* PRE tends to generate bigger code. */
- flag_tree_pre = 0;
-
- /* These options are set with -O3, so reset for -Os */
- flag_predictive_commoning = 0;
- flag_inline_functions = 0;
- flag_unswitch_loops = 0;
- flag_gcse_after_reload = 0;
- flag_tree_vectorize = 0;
-
- /* Don't reorder blocks when optimizing for size because extra jump insns may
- be created; also barrier may create extra padding.
-
- More correctly we should have a block reordering mode that tried to
- minimize the combined size of all the jumps. This would more 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;
-
/* Inlining of functions reducing size is a good idea regardless of them
being declared inline. */
flag_inline_functions = 1;
- /* Don't align code. */
- align_loops = 1;
- align_jumps = 1;
- align_labels = 1;
- align_functions = 1;
-
- /* Unroll/prefetch switches that may be set on the command line, and tend to
- generate bigger code. */
- flag_unroll_loops = 0;
- flag_unroll_all_loops = 0;
- flag_prefetch_loop_arrays = 0;
-
/* Basic optimization options. */
optimize_size = 1;
if (optimize > 2)
handle_options (argc, argv, lang_mask);
+ /* Handle related options for unit-at-a-time, toplevel-reorder, and
+ section-anchors. */
+ if (!flag_unit_at_a_time)
+ {
+ if (flag_section_anchors == 1)
+ error ("Section anchors must be disabled when unit-at-a-time "
+ "is disabled.");
+ flag_section_anchors = 0;
+ if (flag_toplevel_reorder == 1)
+ error ("Toplevel reorder must be disabled when unit-at-a-time "
+ "is disabled.");
+ flag_toplevel_reorder = 0;
+ }
+ /* Unless the user has asked for section anchors, we disable toplevel
+ reordering at -O0 to disable transformations that might be surprising
+ to end users and to get -fno-toplevel-reorder tested. */
+ if (!optimize && flag_toplevel_reorder == 2 && flag_section_anchors != 1)
+ {
+ flag_toplevel_reorder = 0;
+ flag_section_anchors = 0;
+ }
+ if (!flag_toplevel_reorder)
+ {
+ if (flag_section_anchors == 1)
+ error ("section anchors must be disabled when toplevel reorder"
+ " is disabled");
+ flag_section_anchors = 0;
+ }
+
if (first_time_p)
{
if (flag_pie)
flag_pic = flag_pie;
if (flag_pic && !flag_pie)
flag_shlib = 1;
-
- if (flag_no_inline == 2)
- flag_no_inline = 0;
- else
- flag_really_no_inline = flag_no_inline;
}
- /* Set flag_no_inline before the post_options () hook. The C front
- ends use it to determine tree inlining defaults. FIXME: such
- code should be lang-independent when all front ends use tree
- inlining, in which case it, and this condition, should be moved
- to the top of process_options() instead. */
if (optimize == 0)
{
/* Inlining does not work if not optimizing,
so force it not to be done. */
- flag_no_inline = 1;
warn_inline = 0;
-
- /* The c_decode_option function and decode_option hook set
- 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 (OPT_Wuninitialized,
- "-Wuninitialized is not supported without -O");
- }
-
- if (flag_really_no_inline == 2)
- flag_really_no_inline = flag_no_inline;
-
- /* Inlining of functions called just once will only work if we can look
- at the complete translation unit. */
- if (flag_inline_functions_called_once && !flag_unit_at_a_time)
- {
- flag_inline_functions_called_once = 0;
- warning (OPT_Wdisabled_optimization,
- "-funit-at-a-time is required for inlining of functions "
- "that are only called once");
+ flag_no_inline = 1;
}
/* The optimization to partition hot and cold basic blocks into separate
if (flag_exceptions && flag_reorder_blocks_and_partition)
{
- inform
- ("-freorder-blocks-and-partition does not work with exceptions");
+ inform (input_location,
+ "-freorder-blocks-and-partition does not work with exceptions");
flag_reorder_blocks_and_partition = 0;
flag_reorder_blocks = 1;
}
if (flag_unwind_tables && ! targetm.unwind_tables_default
&& flag_reorder_blocks_and_partition)
{
- inform ("-freorder-blocks-and-partition does not support unwind info");
+ inform (input_location, "-freorder-blocks-and-partition does not support unwind info");
flag_reorder_blocks_and_partition = 0;
flag_reorder_blocks = 1;
}
&& (!targetm.have_named_sections
|| (flag_unwind_tables && targetm.unwind_tables_default)))
{
- inform
- ("-freorder-blocks-and-partition does not work on this architecture");
+ inform (input_location,
+ "-freorder-blocks-and-partition does not work on this architecture");
flag_reorder_blocks_and_partition = 0;
flag_reorder_blocks = 1;
}
+ /* Pipelining of outer loops is only possible when general pipelining
+ capabilities are requested. */
+ if (!flag_sel_sched_pipelining)
+ flag_sel_sched_pipelining_outer_loops = 0;
+
+ if (!targetm.ira_cover_classes
+ && flag_ira_algorithm == IRA_ALGORITHM_CB)
+ {
+ inform (input_location,
+ "-fira-algorithm=CB does not work on this architecture");
+ flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
+ }
+
/* Save the current optimization options if this is the first call. */
if (first_time_p)
{
optimization_current_node = optimization_default_node;
first_time_p = false;
}
+ if (flag_conserve_stack)
+ {
+ if (!PARAM_SET_P (PARAM_LARGE_STACK_FRAME))
+ PARAM_VALUE (PARAM_LARGE_STACK_FRAME) = 100;
+ if (!PARAM_SET_P (PARAM_STACK_FRAME_GROWTH))
+ PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) = 40;
+ }
+
}
#define LEFT_COLUMN 27
default:
if (i >= cl_lang_count)
break;
- if ((exclude_flags & ((1U << cl_lang_count) - 1)) != 0)
+ if (exclude_flags & all_langs_mask)
description = _("The following options are specific to just the language ");
else
description = _("The following options are supported by the language ");
{
if (any_flags == 0)
{
- if (include_flags == CL_UNDOCUMENTED)
+ if (include_flags & CL_UNDOCUMENTED)
description = _("The following options are not documented");
+ else if (include_flags & CL_SEPARATE)
+ description = _("The following options take separate arguments");
+ else if (include_flags & CL_JOINED)
+ description = _("The following options take joined arguments");
else
{
internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
len = strlen (a);
else
len = comma - a;
+ if (len == 0)
+ {
+ a = comma + 1;
+ continue;
+ }
/* Check to see if the string matches an option class name. */
for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
specific_flag = specifics[i].flag;
break;
}
-
+
/* Check to see if the string matches a language name.
Note - we rely upon the alpha-sorted nature of the entries in
the lang_names array, specifically that shorter names appear
set_Wextra (value);
break;
- case OPT_Wdisallowed_function_list_:
- warn_disallowed_functions = true;
- add_comma_separated_to_vector
- (&warning_disallowed_functions, arg);
- break;
-
case OPT_Werror_:
enable_warning_as_error (arg, value, lang_mask);
break;
break;
case OPT_Wunused:
- set_Wunused (value);
+ warn_unused = value;
break;
case OPT_aux_info:
return 0;
break;
+ case OPT_fexcess_precision_:
+ if (!strcmp (arg, "fast"))
+ flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
+ else if (!strcmp (arg, "standard"))
+ flag_excess_precision_cmdline = EXCESS_PRECISION_STANDARD;
+ else
+ error ("unknown excess precision style \"%s\"", arg);
+ break;
+
case OPT_ffast_math:
set_fast_math_flags (value);
break;
flag_value_profile_transformations = value;
if (!flag_inline_functions_set)
flag_inline_functions = value;
+ if (!flag_ipa_cp_set)
+ flag_ipa_cp = value;
+ if (!flag_ipa_cp_clone_set
+ && value && flag_ipa_cp)
+ flag_ipa_cp_clone = value;
+ if (!flag_predictive_commoning_set)
+ flag_predictive_commoning = value;
+ if (!flag_unswitch_loops_set)
+ flag_unswitch_loops = value;
+ if (!flag_gcse_after_reload_set)
+ flag_gcse_after_reload = value;
break;
case OPT_fprofile_generate_:
set_random_seed (arg);
break;
+ case OPT_fselective_scheduling:
+ case OPT_fselective_scheduling2:
+ sel_sched_switch_set = true;
+ break;
+
case OPT_fsched_verbose_:
#ifdef INSN_SCHEDULING
fix_sched_param ("verbose", arg);
flag_sched_stalled_insns_dep = value;
break;
+ case OPT_fstack_check_:
+ if (!strcmp (arg, "no"))
+ flag_stack_check = NO_STACK_CHECK;
+ else if (!strcmp (arg, "generic"))
+ /* This is the old stack checking method. */
+ flag_stack_check = STACK_CHECK_BUILTIN
+ ? FULL_BUILTIN_STACK_CHECK
+ : GENERIC_STACK_CHECK;
+ else if (!strcmp (arg, "specific"))
+ /* This is the new stack checking method. */
+ flag_stack_check = STACK_CHECK_BUILTIN
+ ? FULL_BUILTIN_STACK_CHECK
+ : STACK_CHECK_STATIC_BUILTIN
+ ? STATIC_BUILTIN_STACK_CHECK
+ : GENERIC_STACK_CHECK;
+ else
+ warning (0, "unknown stack check parameter \"%s\"", arg);
+ break;
+
+ case OPT_fstack_check:
+ /* This is the same as the "specific" mode above. */
+ if (value)
+ flag_stack_check = STACK_CHECK_BUILTIN
+ ? FULL_BUILTIN_STACK_CHECK
+ : STACK_CHECK_STATIC_BUILTIN
+ ? STATIC_BUILTIN_STACK_CHECK
+ : GENERIC_STACK_CHECK;
+ else
+ flag_stack_check = NO_STACK_CHECK;
+ break;
+
case OPT_fstack_limit:
/* The real switch is -fno-stack-limit. */
if (value)
warning (0, "unknown tls-model \"%s\"", arg);
break;
+ case OPT_fira_algorithm_:
+ if (!strcmp (arg, "CB"))
+ flag_ira_algorithm = IRA_ALGORITHM_CB;
+ else if (!strcmp (arg, "priority"))
+ flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
+ else
+ warning (0, "unknown ira algorithm \"%s\"", arg);
+ break;
+
+ case OPT_fira_region_:
+ if (!strcmp (arg, "one"))
+ flag_ira_region = IRA_REGION_ONE;
+ else if (!strcmp (arg, "all"))
+ flag_ira_region = IRA_REGION_ALL;
+ else if (!strcmp (arg, "mixed"))
+ flag_ira_region = IRA_REGION_MIXED;
+ else
+ warning (0, "unknown ira region \"%s\"", arg);
+ break;
+
+ case OPT_fira_verbose_:
+ flag_ira_verbose = value;
+ break;
+
case OPT_ftracer:
flag_tracer_set = true;
break;
+ case OPT_fipa_cp:
+ flag_ipa_cp_set = true;
+ break;
+
+ case OPT_fipa_cp_clone:
+ flag_ipa_cp_clone_set = true;
+ break;
+
+ case OPT_fpredictive_commoning:
+ flag_predictive_commoning_set = true;
+ break;
+
+ case OPT_funswitch_loops:
+ flag_unswitch_loops_set = true;
+ break;
+
+ case OPT_fgcse_after_reload:
+ flag_gcse_after_reload_set = true;
+ break;
+
case OPT_funroll_loops:
flag_unroll_loops_set = true;
break;
case OPT_ftree_store_copy_prop:
case OPT_fforce_addr:
case OPT_ftree_salias:
+ case OPT_ftree_store_ccp:
/* These are no-ops, preserved for backward compatibility. */
break;
set_Wextra (int setting)
{
extra_warnings = setting;
- warn_unused_parameter = (setting && maybe_warn_unused_parameter);
/* We save the value of warn_uninitialized, since if they put
-Wuninitialized on the command line, we need to generate a
warn_uninitialized = 2;
}
-/* Initialize unused warning flags. */
-void
-set_Wunused (int setting)
-{
- warn_unused_function = setting;
- warn_unused_label = setting;
- /* Unused function parameter warnings are reported when either
- ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
- Thus, if -Wextra has already been seen, set warn_unused_parameter;
- otherwise set maybe_warn_extra_parameter, which will be picked up
- by set_Wextra. */
- maybe_warn_unused_parameter = setting;
- warn_unused_parameter = (setting && extra_warnings);
- warn_unused_variable = setting;
- warn_unused_value = setting;
-}
-
/* Used to set the level of strict aliasing warnings,
when no level is specified (i.e., when -Wstrict-aliasing, and not
-Wstrict-aliasing=level was given).
OSDN Git Service
