@@ -309,13 +309,13 @@ asan_mark_p (gimple *stmt, enum asan_mark_flags flag)
bool
asan_sanitize_stack_p (void)
{
- return (sanitize_flags_p (SANITIZE_ADDRESS) && ASAN_STACK);
+ return (sanitize_flags_p (SANITIZE_ADDRESS) && param_asan_stack);
}
bool
asan_sanitize_allocas_p (void)
{
- return (asan_sanitize_stack_p () && ASAN_PROTECT_ALLOCAS);
+ return (asan_sanitize_stack_p () && param_asan_protect_allocas);
}
/* Checks whether section SEC should be sanitized. */
@@ -1429,7 +1429,7 @@ asan_emit_stack_protection (rtx base, rtx pbase, unsigned int alignb,
/* Emit the prologue sequence. */
if (asan_frame_size > 32 && asan_frame_size <= 65536 && pbase
- && ASAN_USE_AFTER_RETURN)
+ && param_asan_use_after_return)
{
use_after_return_class = floor_log2 (asan_frame_size - 1) - 5;
/* __asan_stack_malloc_N guarantees alignment
@@ -1750,7 +1750,7 @@ is_odr_indicator (tree decl)
bool
asan_protect_global (tree decl, bool ignore_decl_rtl_set_p)
{
- if (!ASAN_GLOBALS)
+ if (!param_asan_globals)
return false;
rtx rtl, symbol;
@@ -2190,9 +2190,9 @@ static void
instrument_derefs (gimple_stmt_iterator *iter, tree t,
location_t location, bool is_store)
{
- if (is_store && !ASAN_INSTRUMENT_WRITES)
+ if (is_store && !param_asan_instrument_writes)
return;
- if (!is_store && !ASAN_INSTRUMENT_READS)
+ if (!is_store && !param_asan_instrument_reads)
return;
tree type, base;
@@ -2253,7 +2253,7 @@ instrument_derefs (gimple_stmt_iterator *iter, tree t,
{
if (DECL_THREAD_LOCAL_P (inner))
return;
- if (!ASAN_GLOBALS && is_global_var (inner))
+ if (!param_asan_globals && is_global_var (inner))
return;
if (!TREE_STATIC (inner))
{
@@ -2346,7 +2346,7 @@ instrument_mem_region_access (tree base, tree len,
static bool
instrument_builtin_call (gimple_stmt_iterator *iter)
{
- if (!ASAN_MEMINTRIN)
+ if (!param_asan_memintrin)
return false;
bool iter_advanced_p = false;
@@ -3219,7 +3219,7 @@ asan_expand_mark_ifn (gimple_stmt_iterator *iter)
tree base_addr = gimple_assign_lhs (g);
/* Generate direct emission if size_in_bytes is small. */
- if (size_in_bytes <= ASAN_PARAM_USE_AFTER_SCOPE_DIRECT_EMISSION_THRESHOLD)
+ if (size_in_bytes <= (unsigned)param_use_after_scope_direct_emission_threshold)
{
const unsigned HOST_WIDE_INT shadow_size
= shadow_mem_size (size_in_bytes);
@@ -1631,7 +1631,7 @@ auto_profile (void)
function before annotation, so the profile inside bar@loc_foo2
will be useful. */
autofdo::stmt_set promoted_stmts;
- for (int i = 0; i < PARAM_VALUE (PARAM_EARLY_INLINER_MAX_ITERATIONS); i++)
+ for (int i = 0; i < param_early_inliner_max_iterations; i++)
{
if (!flag_value_profile_transformations
|| !autofdo::afdo_vpt_for_early_inline (&promoted_stmts))
@@ -1371,7 +1371,7 @@ copy_bb_p (const_basic_block bb, int code_may_grow)
return false;
if (code_may_grow && optimize_bb_for_speed_p (bb))
- max_size *= PARAM_VALUE (PARAM_MAX_GROW_COPY_BB_INSNS);
+ max_size *= param_max_grow_copy_bb_insns;
FOR_BB_INSNS (bb, insn)
{
@@ -2751,7 +2751,7 @@ duplicate_computed_gotos (function *fun)
/* Never copy a block larger than this. */
int max_size
- = uncond_jump_length * PARAM_VALUE (PARAM_MAX_GOTO_DUPLICATION_INSNS);
+ = uncond_jump_length * param_max_goto_duplication_insns;
bool changed = false;
@@ -7214,7 +7214,7 @@ inline_expand_builtin_string_cmp (tree exp, rtx target)
/* If the length of the comparision is larger than the threshold,
do nothing. */
if (length > (unsigned HOST_WIDE_INT)
- PARAM_VALUE (BUILTIN_STRING_CMP_INLINE_LENGTH))
+ param_builtin_string_cmp_inline_length)
return NULL_RTX;
machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
@@ -354,7 +354,7 @@ c_parser_parse_gimple_body (c_parser *cparser, char *gimple_pass,
if (cfun->curr_properties & PROP_cfg)
{
ENTRY_BLOCK_PTR_FOR_FN (cfun)->count = entry_bb_count;
- gcov_type t = PARAM_VALUE (PARAM_GIMPLE_FE_COMPUTED_HOT_BB_THRESHOLD);
+ gcov_type t = param_gimple_fe_computed_hot_bb_threshold;
set_hot_bb_threshold (t);
update_max_bb_count ();
cgraph_node::get_create (cfun->decl);
@@ -2022,7 +2022,7 @@ try_crossjump_to_edge (int mode, edge e1, edge e2,
of matching instructions or the 'from' block was totally matched
(such that its predecessors will hopefully be redirected and the
block removed). */
- if ((nmatch < PARAM_VALUE (PARAM_MIN_CROSSJUMP_INSNS))
+ if ((nmatch < param_min_crossjump_insns)
&& (newpos1 != BB_HEAD (src1)))
return false;
@@ -2215,7 +2215,7 @@ try_crossjump_bb (int mode, basic_block bb)
a block that falls through into BB, as that adds no branches to the
program. We'll try that combination first. */
fallthru = NULL;
- max = PARAM_VALUE (PARAM_MAX_CROSSJUMP_EDGES);
+ max = param_max_crossjump_edges;
if (EDGE_COUNT (bb->preds) > max)
return false;
@@ -1548,7 +1548,7 @@ defer_stack_allocation (tree var, bool toplevel)
bool smallish
= (poly_int_tree_p (size_unit, &size)
&& (estimated_poly_value (size)
- < PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING)));
+ < param_min_size_for_stack_sharing));
/* If stack protection is enabled, *all* stack variables must be deferred,
so that we can re-order the strings to the top of the frame.
@@ -1788,7 +1788,7 @@ stack_protect_classify_type (tree type)
|| t == signed_char_type_node
|| t == unsigned_char_type_node)
{
- unsigned HOST_WIDE_INT max = PARAM_VALUE (PARAM_SSP_BUFFER_SIZE);
+ unsigned HOST_WIDE_INT max = param_ssp_buffer_size;
unsigned HOST_WIDE_INT len;
if (!TYPE_SIZE_UNIT (type)
@@ -6435,7 +6435,7 @@ pass_expand::execute (function *fun)
warning (OPT_Wstack_protector,
"stack protector not protecting function: "
"all local arrays are less than %d bytes long",
- (int) PARAM_VALUE (PARAM_SSP_BUFFER_SIZE));
+ (int) param_ssp_buffer_size);
}
/* Set up parameters and prepare for return, for the function. */
@@ -6545,7 +6545,7 @@ pass_expand::execute (function *fun)
/* If the function has too many markers, drop them while expanding. */
if (cfun->debug_marker_count
- >= PARAM_VALUE (PARAM_MAX_DEBUG_MARKER_COUNT))
+ >= param_max_debug_marker_count)
cfun->debug_nonbind_markers = false;
lab_rtx_for_bb = new hash_map<basic_block, rtx_code_label *>;
@@ -256,7 +256,7 @@ expected_loop_iterations_unbounded (const class loop *loop,
{
if (by_profile_only)
return -1;
- expected = PARAM_VALUE (PARAM_AVG_LOOP_NITER);
+ expected = param_avg_loop_niter;
}
else if (loop->latch && (loop->latch->count.initialized_p ()
|| loop->header->count.initialized_p ()))
@@ -274,7 +274,7 @@ expected_loop_iterations_unbounded (const class loop *loop,
{
if (by_profile_only)
return -1;
- expected = PARAM_VALUE (PARAM_AVG_LOOP_NITER);
+ expected = param_avg_loop_niter;
}
else if (!count_in.nonzero_p ())
{
@@ -295,7 +295,7 @@ expected_loop_iterations_unbounded (const class loop *loop,
{
if (by_profile_only)
return -1;
- expected = PARAM_VALUE (PARAM_AVG_LOOP_NITER);
+ expected = param_avg_loop_niter;
}
if (!by_profile_only)
@@ -427,7 +427,7 @@ estimate_reg_pressure_cost (unsigned n_new, unsigned n_old, bool speed,
if (optimize && (flag_ira_region == IRA_REGION_ALL
|| flag_ira_region == IRA_REGION_MIXED)
- && number_of_loops (cfun) <= (unsigned) IRA_MAX_LOOPS_NUM)
+ && number_of_loops (cfun) <= (unsigned) param_ira_max_loops_num)
/* IRA regional allocation deals with high register pressure
better. So decrease the cost (to do more accurate the cost
calculation for IRA, we need to know how many registers lives
@@ -2738,7 +2738,7 @@ cgraph_edge::maybe_hot_p (void)
if (caller->frequency == NODE_FREQUENCY_EXECUTED_ONCE
&& sreal_frequency () * 2 < 3)
return false;
- if (sreal_frequency () * PARAM_VALUE (HOT_BB_FREQUENCY_FRACTION) <= 1)
+ if (sreal_frequency () * param_hot_bb_frequency_fraction <= 1)
return false;
return true;
}
@@ -1251,7 +1251,7 @@ combine_instructions (rtx_insn *f, unsigned int nregs)
init_reg_last ();
setup_incoming_promotions (first);
last_bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
- int max_combine = PARAM_VALUE (PARAM_MAX_COMBINE_INSNS);
+ int max_combine = param_max_combine_insns;
FOR_EACH_BB_FN (this_basic_block, cfun)
{
@@ -13282,7 +13282,7 @@ record_value_for_reg (rtx reg, rtx_insn *insn, rtx value)
{
/* If there are two or more occurrences of REG in VALUE,
prevent the value from growing too much. */
- if (count_rtxs (tem) > MAX_LAST_VALUE_RTL)
+ if (count_rtxs (tem) > param_max_last_value_rtl)
tem = gen_rtx_CLOBBER (GET_MODE (tem), const0_rtx);
}
@@ -73,7 +73,7 @@ static bool
aarch64_option_validate_param (const int value, const int param)
{
/* Check that both parameters are the same. */
- if (param == (int) PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE)
+ if (param == param_stack_clash_protection_guard_size)
{
if (value != 12 && value != 16)
{
@@ -93,18 +93,15 @@ static void
aarch64_option_default_params (void)
{
/* We assume the guard page is 64k. */
- int index = (int) PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE;
- set_default_param_value (PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE,
- DEFAULT_STK_CLASH_GUARD_SIZE == 0
- ? 16 : DEFAULT_STK_CLASH_GUARD_SIZE);
+ int index = (int) param_stack_clash_protection_guard_size;
+ param_stack_clash_protection_guard_size
+ = (DEFAULT_STK_CLASH_GUARD_SIZE == 0 ? 16 : DEFAULT_STK_CLASH_GUARD_SIZE);
- int guard_size
- = default_param_value (PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE);
+ int guard_size = param_stack_clash_protection_guard_size;
/* Set the interval parameter to be the same as the guard size. This way the
mid-end code does the right thing for us. */
- set_default_param_value (PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL,
- guard_size);
+ param_stack_clash_protection_probe_interval = guard_size;
/* Validate the options. */
aarch64_option_validate_param (guard_size, index);
@@ -88,13 +88,13 @@ static void
ia64_option_default_params (void)
{
/* Let the scheduler form additional regions. */
- set_default_param_value (PARAM_MAX_SCHED_EXTEND_REGIONS_ITERS, 2);
+ param_max_sched_extend_regions_iters = 2;
/* Set the default values for cache-related parameters. */
- set_default_param_value (PARAM_SIMULTANEOUS_PREFETCHES, 6);
- set_default_param_value (PARAM_L1_CACHE_LINE_SIZE, 32);
+ param_simultaneous_prefetches = 6;
+ param_l1_cache_line_size = 32;
- set_default_param_value (PARAM_SCHED_MEM_TRUE_DEP_COST, 4);
+ param_sched_mem_true_dep_cost = 4;
}
#undef TARGET_OPTION_OPTIMIZATION_TABLE
@@ -57,7 +57,7 @@ static void
rs6000_option_default_params (void)
{
/* Double growth factor to counter reduced min jump length. */
- set_default_param_value (PARAM_MAX_GROW_COPY_BB_INSNS, 16);
+ param_max_grow_copy_bb_insns = 16;
}
/* If not otherwise specified by a target, make 'long double' equivalent to
@@ -69,7 +69,7 @@ static void
rs6000_option_default_params (void)
{
/* Double growth factor to counter reduced min jump length. */
- set_default_param_value (PARAM_MAX_GROW_COPY_BB_INSNS, 16);
+ param_max_grow_copy_bb_insns = 16;
}
/* If not otherwise specified by a target, make 'long double' equivalent to
@@ -149,7 +149,7 @@ sh_handle_option (struct gcc_options *opts,
static void
sh_option_default_params (void)
{
- set_default_param_value (PARAM_SIMULTANEOUS_PREFETCHES, 2);
+ param_simultaneous_prefetches = 2;
}
#undef TARGET_OPTION_OPTIMIZATION_TABLE
@@ -5589,7 +5589,7 @@ aarch64_output_probe_stack_range (rtx reg1, rtx reg2)
ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, loop_lab);
HOST_WIDE_INT stack_clash_probe_interval
- = 1 << PARAM_VALUE (PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE);
+ = 1 << param_stack_clash_protection_guard_size;
/* TEST_ADDR = TEST_ADDR + PROBE_INTERVAL. */
xops[0] = reg1;
@@ -6842,7 +6842,7 @@ aarch64_allocate_and_probe_stack_space (rtx temp1, rtx temp2,
bool final_adjustment_p)
{
HOST_WIDE_INT guard_size
- = 1 << PARAM_VALUE (PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE);
+ = 1 << param_stack_clash_protection_guard_size;
HOST_WIDE_INT guard_used_by_caller = STACK_CLASH_CALLER_GUARD;
HOST_WIDE_INT min_probe_threshold
= (final_adjustment_p
@@ -7364,7 +7364,7 @@ aarch64_expand_epilogue (bool for_sibcall)
for each allocation. For stack clash we are in a usable state if
the adjustment is less than GUARD_SIZE - GUARD_USED_BY_CALLER. */
HOST_WIDE_INT guard_size
- = 1 << PARAM_VALUE (PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE);
+ = 1 << param_stack_clash_protection_guard_size;
HOST_WIDE_INT guard_used_by_caller = STACK_CLASH_CALLER_GUARD;
/* We can re-use the registers when:
@@ -13306,73 +13306,62 @@ aarch64_override_options_internal (struct gcc_options *opts)
/* We don't mind passing in global_options_set here as we don't use
the *options_set structs anyway. */
- maybe_set_param_value (PARAM_SCHED_AUTOPREF_QUEUE_DEPTH,
- queue_depth,
- opts->x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (opts, &global_options_set,
+ param_sched_autopref_queue_depth, queue_depth);
/* Set up parameters to be used in prefetching algorithm. Do not
override the defaults unless we are tuning for a core we have
researched values for. */
if (aarch64_tune_params.prefetch->num_slots > 0)
- maybe_set_param_value (PARAM_SIMULTANEOUS_PREFETCHES,
- aarch64_tune_params.prefetch->num_slots,
- opts->x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (opts, &global_options_set,
+ param_simultaneous_prefetches,
+ aarch64_tune_params.prefetch->num_slots);
if (aarch64_tune_params.prefetch->l1_cache_size >= 0)
- maybe_set_param_value (PARAM_L1_CACHE_SIZE,
- aarch64_tune_params.prefetch->l1_cache_size,
- opts->x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (opts, &global_options_set,
+ param_l1_cache_size,
+ aarch64_tune_params.prefetch->l1_cache_size);
if (aarch64_tune_params.prefetch->l1_cache_line_size >= 0)
- maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE,
- aarch64_tune_params.prefetch->l1_cache_line_size,
- opts->x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (opts, &global_options_set,
+ param_l1_cache_line_size,
+ aarch64_tune_params.prefetch->l1_cache_line_size);
if (aarch64_tune_params.prefetch->l2_cache_size >= 0)
- maybe_set_param_value (PARAM_L2_CACHE_SIZE,
- aarch64_tune_params.prefetch->l2_cache_size,
- opts->x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (opts, &global_options_set,
+ param_l2_cache_size,
+ aarch64_tune_params.prefetch->l2_cache_size);
if (!aarch64_tune_params.prefetch->prefetch_dynamic_strides)
- maybe_set_param_value (PARAM_PREFETCH_DYNAMIC_STRIDES,
- 0,
- opts->x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (opts, &global_options_set,
+ param_prefetch_dynamic_strides, 0);
if (aarch64_tune_params.prefetch->minimum_stride >= 0)
- maybe_set_param_value (PARAM_PREFETCH_MINIMUM_STRIDE,
- aarch64_tune_params.prefetch->minimum_stride,
- opts->x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (opts, &global_options_set,
+ param_prefetch_minimum_stride,
+ aarch64_tune_params.prefetch->minimum_stride);
/* Use the alternative scheduling-pressure algorithm by default. */
- maybe_set_param_value (PARAM_SCHED_PRESSURE_ALGORITHM, SCHED_PRESSURE_MODEL,
- opts->x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (opts, &global_options_set,
+ param_sched_pressure_algorithm,
+ SCHED_PRESSURE_MODEL);
/* If the user hasn't changed it via configure then set the default to 64 KB
for the backend. */
- maybe_set_param_value (PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE,
- DEFAULT_STK_CLASH_GUARD_SIZE == 0
- ? 16 : DEFAULT_STK_CLASH_GUARD_SIZE,
- opts->x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (opts, &global_options_set,
+ param_stack_clash_protection_guard_size,
+ (DEFAULT_STK_CLASH_GUARD_SIZE == 0
+ ? 16 : DEFAULT_STK_CLASH_GUARD_SIZE));
/* Validate the guard size. */
- int guard_size = PARAM_VALUE (PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE);
+ int guard_size = param_stack_clash_protection_guard_size;
/* Enforce that interval is the same size as size so the mid-end does the
right thing. */
- maybe_set_param_value (PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL,
- guard_size,
- opts->x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (opts, &global_options_set,
+ param_stack_clash_protection_probe_interval,
+ guard_size);
/* The maybe_set calls won't update the value if the user has explicitly set
one. Which means we need to validate that probing interval and guard size
are equal. */
int probe_interval
- = PARAM_VALUE (PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL);
+ = param_stack_clash_protection_probe_interval;
if (guard_size != probe_interval)
error ("stack clash guard size %<%d%> must be equal to probing interval "
"%<%d%>", guard_size, probe_interval);
@@ -68,6 +68,7 @@ along with GCC; see the file COPYING3. If not see
#include "builtins.h"
#include "rtl-iter.h"
#include "flags.h"
+#include "opts.h"
/* This file should be included last. */
#include "target-def.h"
@@ -484,17 +485,14 @@ alpha_option_override (void)
}
if (line_size)
- maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE, line_size,
- global_options.x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_l1_cache_line_size, line_size);
if (l1_size)
- maybe_set_param_value (PARAM_L1_CACHE_SIZE, l1_size,
- global_options.x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_l1_cache_size, l1_size);
if (l2_size)
- maybe_set_param_value (PARAM_L2_CACHE_SIZE, l2_size,
- global_options.x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_l2_cache_size, l2_size);
/* Do some sanity checks on the above options. */
@@ -3521,9 +3521,8 @@ arm_option_override (void)
but measurable, size reduction for PIC code. Therefore, we decrease
the bar for unrestricted expression hoisting to the cost of PIC address
calculation, which is 2 instructions. */
- maybe_set_param_value (PARAM_GCSE_UNRESTRICTED_COST, 2,
- global_options.x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_gcse_unrestricted_cost, 2);
/* ARM EABI defaults to strict volatile bitfields. */
if (TARGET_AAPCS_BASED && flag_strict_volatile_bitfields < 0
@@ -3543,47 +3542,43 @@ arm_option_override (void)
override the defaults unless we are tuning for a core we have
researched values for. */
if (current_tune->prefetch.num_slots > 0)
- maybe_set_param_value (PARAM_SIMULTANEOUS_PREFETCHES,
- current_tune->prefetch.num_slots,
- global_options.x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_simultaneous_prefetches,
+ current_tune->prefetch.num_slots);
if (current_tune->prefetch.l1_cache_line_size >= 0)
- maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE,
- current_tune->prefetch.l1_cache_line_size,
- global_options.x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_l1_cache_line_size,
+ current_tune->prefetch.l1_cache_line_size);
if (current_tune->prefetch.l1_cache_size >= 0)
- maybe_set_param_value (PARAM_L1_CACHE_SIZE,
- current_tune->prefetch.l1_cache_size,
- global_options.x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_l1_cache_size,
+ current_tune->prefetch.l1_cache_size);
/* Look through ready list and all of queue for instructions
relevant for L2 auto-prefetcher. */
- int param_sched_autopref_queue_depth;
+ int sched_autopref_queue_depth;
switch (current_tune->sched_autopref)
{
case tune_params::SCHED_AUTOPREF_OFF:
- param_sched_autopref_queue_depth = -1;
+ sched_autopref_queue_depth = -1;
break;
case tune_params::SCHED_AUTOPREF_RANK:
- param_sched_autopref_queue_depth = 0;
+ sched_autopref_queue_depth = 0;
break;
case tune_params::SCHED_AUTOPREF_FULL:
- param_sched_autopref_queue_depth = max_insn_queue_index + 1;
+ sched_autopref_queue_depth = max_insn_queue_index + 1;
break;
default:
gcc_unreachable ();
}
- maybe_set_param_value (PARAM_SCHED_AUTOPREF_QUEUE_DEPTH,
- param_sched_autopref_queue_depth,
- global_options.x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_sched_autopref_queue_depth,
+ sched_autopref_queue_depth);
/* Currently, for slow flash data, we just disable literal pools. We also
disable it for pure-code. */
@@ -31740,8 +31735,6 @@ arm_valid_target_attribute_p (tree fndecl, tree ARG_UNUSED (name),
DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl) = new_optimize;
- finalize_options_struct (&func_options);
-
return ret;
}
@@ -2618,22 +2618,14 @@ ix86_option_override_internal (bool main_args_p,
if (!TARGET_SCHEDULE)
opts->x_flag_schedule_insns_after_reload = opts->x_flag_schedule_insns = 0;
- maybe_set_param_value (PARAM_SIMULTANEOUS_PREFETCHES,
- ix86_tune_cost->simultaneous_prefetches,
- opts->x_param_values,
- opts_set->x_param_values);
- maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE,
- ix86_tune_cost->prefetch_block,
- opts->x_param_values,
- opts_set->x_param_values);
- maybe_set_param_value (PARAM_L1_CACHE_SIZE,
- ix86_tune_cost->l1_cache_size,
- opts->x_param_values,
- opts_set->x_param_values);
- maybe_set_param_value (PARAM_L2_CACHE_SIZE,
- ix86_tune_cost->l2_cache_size,
- opts->x_param_values,
- opts_set->x_param_values);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_simultaneous_prefetches,
+ ix86_tune_cost->simultaneous_prefetches);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_l1_cache_line_size,
+ ix86_tune_cost->prefetch_block);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_l1_cache_size,
+ ix86_tune_cost->l1_cache_size);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_l2_cache_size,
+ ix86_tune_cost->l2_cache_size);
/* Enable sw prefetching at -O3 for CPUS that prefetching is helpful. */
if (opts->x_flag_prefetch_loop_arrays < 0
@@ -2868,13 +2860,9 @@ ix86_option_override_internal (bool main_args_p,
= (cf_protection_level) (opts->x_flag_cf_protection | CF_SET);
if (ix86_tune_features [X86_TUNE_AVOID_256FMA_CHAINS])
- maybe_set_param_value (PARAM_AVOID_FMA_MAX_BITS, 256,
- opts->x_param_values,
- opts_set->x_param_values);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_avoid_fma_max_bits, 256);
else if (ix86_tune_features [X86_TUNE_AVOID_128FMA_CHAINS])
- maybe_set_param_value (PARAM_AVOID_FMA_MAX_BITS, 128,
- opts->x_param_values,
- opts_set->x_param_values);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_avoid_fma_max_bits, 128);
/* PR86952: jump table usage with retpolines is slow.
The PR provides some numbers about the slowness. */
@@ -5773,7 +5773,7 @@ get_probe_interval (void)
{
if (flag_stack_clash_protection)
return (HOST_WIDE_INT_1U
- << PARAM_VALUE (PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL));
+ << param_stack_clash_protection_probe_interval);
else
return (HOST_WIDE_INT_1U << STACK_CHECK_PROBE_INTERVAL_EXP);
}
@@ -6942,7 +6942,7 @@ ix86_adjust_stack_and_probe_stack_clash (HOST_WIDE_INT size,
/* If we allocate less than the size of the guard statically,
then no probing is necessary, but we do need to allocate
the stack. */
- if (size < (1 << PARAM_VALUE (PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE)))
+ if (size < (1 << param_stack_clash_protection_guard_size))
{
pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
GEN_INT (-size), -1,
@@ -21468,18 +21468,18 @@ static unsigned int
ix86_max_noce_ifcvt_seq_cost (edge e)
{
bool predictable_p = predictable_edge_p (e);
-
- enum compiler_param param
- = (predictable_p
- ? PARAM_MAX_RTL_IF_CONVERSION_PREDICTABLE_COST
- : PARAM_MAX_RTL_IF_CONVERSION_UNPREDICTABLE_COST);
-
- /* If we have a parameter set, use that, otherwise take a guess using
- BRANCH_COST. */
- if (global_options_set.x_param_values[param])
- return PARAM_VALUE (param);
+ if (predictable_p)
+ {
+ if (global_options_set.x_param_max_rtl_if_conversion_predictable_cost)
+ return param_max_rtl_if_conversion_predictable_cost;
+ }
else
- return BRANCH_COST (true, predictable_p) * COSTS_N_INSNS (2);
+ {
+ if (global_options_set.x_param_max_rtl_if_conversion_unpredictable_cost)
+ return param_max_rtl_if_conversion_unpredictable_cost;
+ }
+
+ return BRANCH_COST (true, predictable_p) * COSTS_N_INSNS (2);
}
/* Return true if SEQ is a good candidate as a replacement for the
@@ -7307,7 +7307,7 @@ ia64_adjust_cost (rtx_insn *insn, int dep_type1, rtx_insn *dep_insn,
if (dw == MIN_DEP_WEAK)
/* Store and load are likely to alias, use higher cost to avoid stall. */
- return PARAM_VALUE (PARAM_SCHED_MEM_TRUE_DEP_COST);
+ return param_sched_mem_true_dep_cost;
else if (dw > MIN_DEP_WEAK)
{
/* Store and load are less likely to alias. */
@@ -1515,14 +1515,14 @@ static HOST_WIDE_INT
get_stack_clash_protection_probe_interval (void)
{
return (HOST_WIDE_INT_1U
- << PARAM_VALUE (PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL));
+ << param_stack_clash_protection_probe_interval);
}
static HOST_WIDE_INT
get_stack_clash_protection_guard_size (void)
{
return (HOST_WIDE_INT_1U
- << PARAM_VALUE (PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE));
+ << param_stack_clash_protection_guard_size);
}
/* Allocate ORIG_SIZE bytes on the stack and probe the newly
@@ -80,6 +80,7 @@
#include "tree-vrp.h"
#include "tree-ssanames.h"
#include "rs6000-internal.h"
+#include "opts.h"
/* This file should be included last. */
#include "target-def.h"
@@ -4511,46 +4512,38 @@ rs6000_option_override_internal (bool global_init_p)
if (global_init_p)
{
- maybe_set_param_value (PARAM_SIMULTANEOUS_PREFETCHES,
- rs6000_cost->simultaneous_prefetches,
- global_options.x_param_values,
- global_options_set.x_param_values);
- maybe_set_param_value (PARAM_L1_CACHE_SIZE, rs6000_cost->l1_cache_size,
- global_options.x_param_values,
- global_options_set.x_param_values);
- maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE,
- rs6000_cost->cache_line_size,
- global_options.x_param_values,
- global_options_set.x_param_values);
- maybe_set_param_value (PARAM_L2_CACHE_SIZE, rs6000_cost->l2_cache_size,
- global_options.x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_simultaneous_prefetches,
+ rs6000_cost->simultaneous_prefetches);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_l1_cache_size,
+ rs6000_cost->l1_cache_size);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_l1_cache_line_size,
+ rs6000_cost->cache_line_size);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_l2_cache_size,
+ rs6000_cost->l2_cache_size);
/* Increase loop peeling limits based on performance analysis. */
- maybe_set_param_value (PARAM_MAX_PEELED_INSNS, 400,
- global_options.x_param_values,
- global_options_set.x_param_values);
- maybe_set_param_value (PARAM_MAX_COMPLETELY_PEELED_INSNS, 400,
- global_options.x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_max_peeled_insns, 400);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_max_completely_peeled_insns, 400);
/* Use the 'model' -fsched-pressure algorithm by default. */
- maybe_set_param_value (PARAM_SCHED_PRESSURE_ALGORITHM,
- SCHED_PRESSURE_MODEL,
- global_options.x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_sched_pressure_algorithm,
+ SCHED_PRESSURE_MODEL);
/* unroll very small loops 2 time if no -funroll-loops. */
if (!global_options_set.x_flag_unroll_loops
&& !global_options_set.x_flag_unroll_all_loops)
{
- maybe_set_param_value (PARAM_MAX_UNROLL_TIMES, 2,
- global_options.x_param_values,
- global_options_set.x_param_values);
-
- maybe_set_param_value (PARAM_MAX_UNROLLED_INSNS, 20,
- global_options.x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_max_unroll_times, 2);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_max_unrolled_insns, 20);
/* If fweb or frename-registers are not specificed in command-line,
do not turn them on implicitly. */
@@ -10968,9 +10968,9 @@ allocate_stack_space (rtx size, HOST_WIDE_INT last_probe_offset,
{
bool temp_reg_clobbered_p = false;
HOST_WIDE_INT probe_interval
- = 1 << PARAM_VALUE (PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL);
+ = 1 << param_stack_clash_protection_probe_interval;
HOST_WIDE_INT guard_size
- = 1 << PARAM_VALUE (PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE);
+ = 1 << param_stack_clash_protection_guard_size;
if (flag_stack_clash_protection)
{
@@ -11086,7 +11086,7 @@ s390_emit_prologue (void)
only exception is when TARGET_BACKCHAIN is active, in which case
we know *sp (offset 0) was written. */
HOST_WIDE_INT probe_interval
- = 1 << PARAM_VALUE (PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL);
+ = 1 << param_stack_clash_protection_probe_interval;
HOST_WIDE_INT last_probe_offset
= (TARGET_BACKCHAIN
? (TARGET_PACKED_STACK ? STACK_POINTER_OFFSET - UNITS_PER_LONG : 0)
@@ -15264,10 +15264,8 @@ s390_option_override_internal (struct gcc_options *opts,
displacements. Trim that value down to 4k if that happens. This
might result in too many probes being generated only on the
oldest supported machine level z900. */
- if (!DISP_IN_RANGE ((1 << PARAM_VALUE (PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL))))
- set_param_value ("stack-clash-protection-probe-interval", 12,
- opts->x_param_values,
- opts_set->x_param_values);
+ if (!DISP_IN_RANGE ((1 << param_stack_clash_protection_probe_interval)))
+ param_stack_clash_protection_probe_interval = 12;
#ifdef TARGET_DEFAULT_LONG_DOUBLE_128
if (!TARGET_LONG_DOUBLE_128_P (opts_set->x_target_flags))
@@ -15276,62 +15274,37 @@ s390_option_override_internal (struct gcc_options *opts,
if (opts->x_s390_tune >= PROCESSOR_2097_Z10)
{
- maybe_set_param_value (PARAM_MAX_UNROLLED_INSNS, 100,
- opts->x_param_values,
- opts_set->x_param_values);
- maybe_set_param_value (PARAM_MAX_UNROLL_TIMES, 32,
- opts->x_param_values,
- opts_set->x_param_values);
- maybe_set_param_value (PARAM_MAX_COMPLETELY_PEELED_INSNS, 2000,
- opts->x_param_values,
- opts_set->x_param_values);
- maybe_set_param_value (PARAM_MAX_COMPLETELY_PEEL_TIMES, 64,
- opts->x_param_values,
- opts_set->x_param_values);
- }
-
- maybe_set_param_value (PARAM_MAX_PENDING_LIST_LENGTH, 256,
- opts->x_param_values,
- opts_set->x_param_values);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_max_unrolled_insns,
+ 100);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_max_unroll_times, 32);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_max_completely_peeled_insns,
+ 2000);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_max_completely_peel_times,
+ 64);
+ }
+
+ SET_OPTION_IF_UNSET (opts, opts_set, param_max_pending_list_length,
+ 256);
/* values for loop prefetching */
- maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE, 256,
- opts->x_param_values,
- opts_set->x_param_values);
- maybe_set_param_value (PARAM_L1_CACHE_SIZE, 128,
- opts->x_param_values,
- opts_set->x_param_values);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_l1_cache_line_size, 256);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_l1_cache_size, 128);
/* s390 has more than 2 levels and the size is much larger. Since
we are always running virtualized assume that we only get a small
part of the caches above l1. */
- maybe_set_param_value (PARAM_L2_CACHE_SIZE, 1500,
- opts->x_param_values,
- opts_set->x_param_values);
- maybe_set_param_value (PARAM_PREFETCH_MIN_INSN_TO_MEM_RATIO, 2,
- opts->x_param_values,
- opts_set->x_param_values);
- maybe_set_param_value (PARAM_SIMULTANEOUS_PREFETCHES, 6,
- opts->x_param_values,
- opts_set->x_param_values);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_l2_cache_size, 1500);
+ SET_OPTION_IF_UNSET (opts, opts_set,
+ param_prefetch_min_insn_to_mem_ratio, 2);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_simultaneous_prefetches, 6);
/* Use the alternative scheduling-pressure algorithm by default. */
- maybe_set_param_value (PARAM_SCHED_PRESSURE_ALGORITHM, 2,
- opts->x_param_values,
- opts_set->x_param_values);
-
- maybe_set_param_value (PARAM_MIN_VECT_LOOP_BOUND, 2,
- opts->x_param_values,
- opts_set->x_param_values);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_sched_pressure_algorithm, 2);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_min_vect_loop_bound, 2);
/* Use aggressive inlining parameters. */
if (opts->x_s390_tune >= PROCESSOR_2964_Z13)
{
- maybe_set_param_value (PARAM_INLINE_MIN_SPEEDUP, 2,
- opts->x_param_values,
- opts_set->x_param_values);
-
- maybe_set_param_value (PARAM_MAX_INLINE_INSNS_AUTO, 80,
- opts->x_param_values,
- opts_set->x_param_values);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_inline_min_speedup, 2);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_max_inline_insns_auto, 80);
}
/* Set the default alignment. */
@@ -61,6 +61,7 @@ along with GCC; see the file COPYING3. If not see
#include "context.h"
#include "builtins.h"
#include "tree-vector-builder.h"
+#include "opts.h"
/* This file should be included last. */
#include "target-def.h"
@@ -2010,7 +2011,7 @@ sparc_option_override (void)
gcc_unreachable ();
};
- /* PARAM_SIMULTANEOUS_PREFETCHES is the number of prefetches that
+ /* param_simultaneous_prefetches is the number of prefetches that
can run at the same time. More important, it is the threshold
defining when additional prefetches will be dropped by the
hardware.
@@ -2033,21 +2034,20 @@ sparc_option_override (void)
single-threaded program. Experimental results show that setting
this parameter to 32 works well when the number of threads is not
high. */
- maybe_set_param_value (PARAM_SIMULTANEOUS_PREFETCHES,
- ((sparc_cpu == PROCESSOR_ULTRASPARC
- || sparc_cpu == PROCESSOR_NIAGARA
- || sparc_cpu == PROCESSOR_NIAGARA2
- || sparc_cpu == PROCESSOR_NIAGARA3
- || sparc_cpu == PROCESSOR_NIAGARA4)
- ? 2
- : (sparc_cpu == PROCESSOR_ULTRASPARC3
- ? 8 : ((sparc_cpu == PROCESSOR_NIAGARA7
- || sparc_cpu == PROCESSOR_M8)
- ? 32 : 3))),
- global_options.x_param_values,
- global_options_set.x_param_values);
-
- /* PARAM_L1_CACHE_LINE_SIZE is the size of the L1 cache line, in
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_simultaneous_prefetches,
+ ((sparc_cpu == PROCESSOR_ULTRASPARC
+ || sparc_cpu == PROCESSOR_NIAGARA
+ || sparc_cpu == PROCESSOR_NIAGARA2
+ || sparc_cpu == PROCESSOR_NIAGARA3
+ || sparc_cpu == PROCESSOR_NIAGARA4)
+ ? 2
+ : (sparc_cpu == PROCESSOR_ULTRASPARC3
+ ? 8 : ((sparc_cpu == PROCESSOR_NIAGARA7
+ || sparc_cpu == PROCESSOR_M8)
+ ? 32 : 3))));
+
+ /* param_l1_cache_line_size is the size of the L1 cache line, in
bytes.
The Oracle SPARC Architecture (previously the UltraSPARC
@@ -2064,38 +2064,33 @@ sparc_option_override (void)
L2 and L3, but only 32B are brought into the L1D$. (Assuming it
is a read_n prefetch, which is the only type which allocates to
the L1.) */
- maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE,
- (sparc_cpu == PROCESSOR_M8
- ? 64 : 32),
- global_options.x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_l1_cache_line_size,
+ (sparc_cpu == PROCESSOR_M8 ? 64 : 32));
- /* PARAM_L1_CACHE_SIZE is the size of the L1D$ (most SPARC chips use
+ /* param_l1_cache_size is the size of the L1D$ (most SPARC chips use
Hardvard level-1 caches) in kilobytes. Both UltraSPARC and
Niagara processors feature a L1D$ of 16KB. */
- maybe_set_param_value (PARAM_L1_CACHE_SIZE,
- ((sparc_cpu == PROCESSOR_ULTRASPARC
- || sparc_cpu == PROCESSOR_ULTRASPARC3
- || sparc_cpu == PROCESSOR_NIAGARA
- || sparc_cpu == PROCESSOR_NIAGARA2
- || sparc_cpu == PROCESSOR_NIAGARA3
- || sparc_cpu == PROCESSOR_NIAGARA4
- || sparc_cpu == PROCESSOR_NIAGARA7
- || sparc_cpu == PROCESSOR_M8)
- ? 16 : 64),
- global_options.x_param_values,
- global_options_set.x_param_values);
-
-
- /* PARAM_L2_CACHE_SIZE is the size fo the L2 in kilobytes. Note
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_l1_cache_size,
+ ((sparc_cpu == PROCESSOR_ULTRASPARC
+ || sparc_cpu == PROCESSOR_ULTRASPARC3
+ || sparc_cpu == PROCESSOR_NIAGARA
+ || sparc_cpu == PROCESSOR_NIAGARA2
+ || sparc_cpu == PROCESSOR_NIAGARA3
+ || sparc_cpu == PROCESSOR_NIAGARA4
+ || sparc_cpu == PROCESSOR_NIAGARA7
+ || sparc_cpu == PROCESSOR_M8)
+ ? 16 : 64));
+
+ /* param_l2_cache_size is the size fo the L2 in kilobytes. Note
that 512 is the default in params.def. */
- maybe_set_param_value (PARAM_L2_CACHE_SIZE,
- ((sparc_cpu == PROCESSOR_NIAGARA4
- || sparc_cpu == PROCESSOR_M8)
- ? 128 : (sparc_cpu == PROCESSOR_NIAGARA7
- ? 256 : 512)),
- global_options.x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_l2_cache_size,
+ ((sparc_cpu == PROCESSOR_NIAGARA4
+ || sparc_cpu == PROCESSOR_M8)
+ ? 128 : (sparc_cpu == PROCESSOR_NIAGARA7
+ ? 256 : 512)));
/* Disable save slot sharing for call-clobbered registers by default.
@@ -57,6 +57,7 @@
#include "tree-pass.h"
#include "context.h"
#include "builtins.h"
+#include "opts.h"
/* This file should be included last. */
#include "target-def.h"
@@ -457,9 +458,8 @@ visium_option_override (void)
/* Allow the size of compilation units to double because of inlining.
In practice the global size of the object code is hardly affected
because the additional instructions will take up the padding. */
- maybe_set_param_value (PARAM_INLINE_UNIT_GROWTH, 100,
- global_options.x_param_values,
- global_options_set.x_param_values);
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ param_inline_unit_growth, 100);
}
/* Likewise for loops. */
@@ -324,7 +324,7 @@ get_coverage_counts (unsigned counter, unsigned cfg_checksum,
}
return NULL;
}
- if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID))
+ if (param_profile_func_internal_id)
elt.ident = current_function_funcdef_no + 1;
else
{
@@ -560,7 +560,7 @@ coverage_compute_profile_id (struct cgraph_node *n)
{
expanded_location xloc
= expand_location (DECL_SOURCE_LOCATION (n->decl));
- bool use_name_only = (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID) == 0);
+ bool use_name_only = (param_profile_func_internal_id == 0);
chksum = (use_name_only ? 0 : xloc.line);
if (xloc.file)
@@ -628,7 +628,7 @@ coverage_begin_function (unsigned lineno_checksum, unsigned cfg_checksum)
/* Announce function */
offset = gcov_write_tag (GCOV_TAG_FUNCTION);
- if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID))
+ if (param_profile_func_internal_id)
gcov_write_unsigned (current_function_funcdef_no + 1);
else
{
@@ -682,7 +682,7 @@ coverage_end_function (unsigned lineno_checksum, unsigned cfg_checksum)
item = ggc_alloc<coverage_data> ();
- if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID))
+ if (param_profile_func_internal_id)
item->ident = current_function_funcdef_no + 1;
else
{
@@ -5358,7 +5358,7 @@ namespace_hints::namespace_hints (location_t loc, tree name)
m_candidates = vNULL;
m_limited = false;
- m_limit = PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP);
+ m_limit = param_cxx_max_namespaces_for_diagnostic_help;
/* Breadth-first search of namespaces. Up to limit namespaces
searched (limit zero == unlimited). */
@@ -1498,7 +1498,7 @@ comptypes (tree t1, tree t2, int strict)
perform a deep check. */
return structural_comptypes (t1, t2, strict);
- if (flag_checking && USE_CANONICAL_TYPES)
+ if (flag_checking && param_use_canonical_types)
{
bool result = structural_comptypes (t1, t2, strict);
@@ -1519,7 +1519,7 @@ comptypes (tree t1, tree t2, int strict)
return result;
}
- if (!flag_checking && USE_CANONICAL_TYPES)
+ if (!flag_checking && param_use_canonical_types)
return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
else
return structural_comptypes (t1, t2, strict);
@@ -6414,7 +6414,7 @@ cse_find_path (basic_block first_bb, struct cse_basic_block_data *data,
if (follow_jumps)
{
bb = data->path[path_size - 1].bb;
- while (bb && path_size < PARAM_VALUE (PARAM_MAX_CSE_PATH_LENGTH))
+ while (bb && path_size < param_max_cse_path_length)
{
if (single_succ_p (bb))
e = single_succ_edge (bb);
@@ -6592,7 +6592,7 @@ cse_extended_basic_block (struct cse_basic_block_data *ebb_data)
FIXME: This is a real kludge and needs to be done some other
way. */
if (NONDEBUG_INSN_P (insn)
- && num_insns++ > PARAM_VALUE (PARAM_MAX_CSE_INSNS))
+ && num_insns++ > param_max_cse_insns)
{
flush_hash_table ();
num_insns = 0;
@@ -6736,7 +6736,7 @@ cse_main (rtx_insn *f ATTRIBUTE_UNUSED, int nregs)
init_cse_reg_info (nregs);
ebb_data.path = XNEWVEC (struct branch_path,
- PARAM_VALUE (PARAM_MAX_CSE_PATH_LENGTH));
+ param_max_cse_path_length);
cse_cfg_altered = false;
cse_jumps_altered = false;
@@ -2297,7 +2297,7 @@ cselib_invalidate_mem (rtx mem_rtx)
p = &(*p)->next;
continue;
}
- if (num_mems < PARAM_VALUE (PARAM_MAX_CSELIB_MEMORY_LOCATIONS)
+ if (num_mems < param_max_cselib_memory_locations
&& ! canon_anti_dependence (x, false, mem_rtx,
GET_MODE (mem_rtx), mem_addr))
{
@@ -2657,7 +2657,7 @@ dse_step1 (void)
/* For -O1 reduce the maximum number of active local stores for RTL DSE
since this can consume huge amounts of memory (PR89115). */
- int max_active_local_stores = PARAM_VALUE (PARAM_MAX_DSE_ACTIVE_LOCAL_STORES);
+ int max_active_local_stores = param_max_dse_active_local_stores;
if (optimize < 2)
max_active_local_stores /= 10;
@@ -2762,15 +2762,15 @@ set_new_first_and_last_insn (rtx_insn *first, rtx_insn *last)
set_last_insn (last);
cur_insn_uid = 0;
- if (MIN_NONDEBUG_INSN_UID || MAY_HAVE_DEBUG_INSNS)
+ if (param_min_nondebug_insn_uid || MAY_HAVE_DEBUG_INSNS)
{
int debug_count = 0;
- cur_insn_uid = MIN_NONDEBUG_INSN_UID - 1;
+ cur_insn_uid = param_min_nondebug_insn_uid - 1;
cur_debug_insn_uid = 0;
for (insn = first; insn; insn = NEXT_INSN (insn))
- if (INSN_UID (insn) < MIN_NONDEBUG_INSN_UID)
+ if (INSN_UID (insn) < param_min_nondebug_insn_uid)
cur_debug_insn_uid = MAX (cur_debug_insn_uid, INSN_UID (insn));
else
{
@@ -2780,7 +2780,7 @@ set_new_first_and_last_insn (rtx_insn *first, rtx_insn *last)
}
if (debug_count)
- cur_debug_insn_uid = MIN_NONDEBUG_INSN_UID + debug_count;
+ cur_debug_insn_uid = param_min_nondebug_insn_uid + debug_count;
else
cur_debug_insn_uid++;
}
@@ -3445,10 +3445,10 @@ get_max_insn_count (void)
differences due to debug insns, and not be affected by
-fmin-insn-uid, to avoid excessive table size and to simplify
debugging of -fcompare-debug failures. */
- if (cur_debug_insn_uid > MIN_NONDEBUG_INSN_UID)
+ if (cur_debug_insn_uid > param_min_nondebug_insn_uid)
n -= cur_debug_insn_uid;
else
- n -= MIN_NONDEBUG_INSN_UID;
+ n -= param_min_nondebug_insn_uid;
return n;
}
@@ -4085,7 +4085,7 @@ make_debug_insn_raw (rtx pattern)
insn = as_a <rtx_debug_insn *> (rtx_alloc (DEBUG_INSN));
INSN_UID (insn) = cur_debug_insn_uid++;
- if (cur_debug_insn_uid > MIN_NONDEBUG_INSN_UID)
+ if (cur_debug_insn_uid > param_min_nondebug_insn_uid)
INSN_UID (insn) = cur_insn_uid++;
PATTERN (insn) = pattern;
@@ -5860,8 +5860,8 @@ init_emit (void)
{
set_first_insn (NULL);
set_last_insn (NULL);
- if (MIN_NONDEBUG_INSN_UID)
- cur_insn_uid = MIN_NONDEBUG_INSN_UID;
+ if (param_min_nondebug_insn_uid)
+ cur_insn_uid = param_min_nondebug_insn_uid;
else
cur_insn_uid = 1;
cur_debug_insn_uid = 1;
@@ -1837,7 +1837,7 @@ compute_stack_clash_protection_loop_data (rtx *rounded_size, rtx *last_addr,
{
/* Round SIZE down to STACK_CLASH_PROTECTION_PROBE_INTERVAL */
*probe_interval
- = 1 << PARAM_VALUE (PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL);
+ = 1 << param_stack_clash_protection_probe_interval;
*rounded_size = simplify_gen_binary (AND, Pmode, size,
GEN_INT (-*probe_interval));
@@ -657,7 +657,7 @@ compute_alignments (void)
}
loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
profile_count count_threshold = cfun->cfg->count_max.apply_scale
- (1, PARAM_VALUE (PARAM_ALIGN_THRESHOLD));
+ (1, param_align_threshold);
if (dump_file)
{
@@ -743,7 +743,7 @@ compute_alignments (void)
&& branch_count + fallthru_count > count_threshold
&& (branch_count
> fallthru_count.apply_scale
- (PARAM_VALUE (PARAM_ALIGN_LOOP_ITERATIONS), 1)))
+ (param_align_loop_iterations, 1)))
{
align_flags alignment = LOOP_ALIGN (label);
if (dump_file)
@@ -5925,9 +5925,9 @@ fold_range_test (location_t loc, enum tree_code code, tree type,
short-circuited branch and the underlying object on both sides
is the same, make a non-short-circuit operation. */
bool logical_op_non_short_circuit = LOGICAL_OP_NON_SHORT_CIRCUIT;
- if (PARAM_VALUE (PARAM_LOGICAL_OP_NON_SHORT_CIRCUIT) != -1)
+ if (param_logical_op_non_short_circuit != -1)
logical_op_non_short_circuit
- = PARAM_VALUE (PARAM_LOGICAL_OP_NON_SHORT_CIRCUIT);
+ = param_logical_op_non_short_circuit;
if (logical_op_non_short_circuit
&& !flag_sanitize_coverage
&& lhs != 0 && rhs != 0
@@ -8596,9 +8596,9 @@ fold_truth_andor (location_t loc, enum tree_code code, tree type,
return tem;
bool logical_op_non_short_circuit = LOGICAL_OP_NON_SHORT_CIRCUIT;
- if (PARAM_VALUE (PARAM_LOGICAL_OP_NON_SHORT_CIRCUIT) != -1)
+ if (param_logical_op_non_short_circuit != -1)
logical_op_non_short_circuit
- = PARAM_VALUE (PARAM_LOGICAL_OP_NON_SHORT_CIRCUIT);
+ = param_logical_op_non_short_circuit;
if (logical_op_non_short_circuit
&& !flag_sanitize_coverage
&& (code == TRUTH_AND_EXPR
@@ -13361,7 +13361,7 @@ tree_single_nonnegative_warnv_p (tree t, bool *strict_overflow_p, int depth)
would not, passes that need this information could be revised
to provide it through dataflow propagation. */
return (!name_registered_for_update_p (t)
- && depth < PARAM_VALUE (PARAM_MAX_SSA_NAME_QUERY_DEPTH)
+ && depth < param_max_ssa_name_query_depth
&& gimple_stmt_nonnegative_warnv_p (SSA_NAME_DEF_STMT (t),
strict_overflow_p, depth));
@@ -14009,7 +14009,7 @@ integer_valued_real_single_p (tree t, int depth)
would not, passes that need this information could be revised
to provide it through dataflow propagation. */
return (!name_registered_for_update_p (t)
- && depth < PARAM_VALUE (PARAM_MAX_SSA_NAME_QUERY_DEPTH)
+ && depth < param_max_ssa_name_query_depth
&& gimple_stmt_integer_valued_real_p (SSA_NAME_DEF_STMT (t),
depth));
@@ -799,10 +799,10 @@ want_to_gcse_p (rtx x, machine_mode mode, HOST_WIDE_INT *max_distance_ptr)
&& optimize_function_for_size_p (cfun));
cost = set_src_cost (x, mode, 0);
- if (cost < COSTS_N_INSNS (GCSE_UNRESTRICTED_COST))
+ if (cost < COSTS_N_INSNS (param_gcse_unrestricted_cost))
{
max_distance
- = ((HOST_WIDE_INT)GCSE_COST_DISTANCE_RATIO * cost) / 10;
+ = ((HOST_WIDE_INT)param_gcse_cost_distance_ratio * cost) / 10;
if (max_distance == 0)
return 0;
@@ -1844,7 +1844,7 @@ prune_insertions_deletions (int n_elems)
PRUNE_EXPRS. */
for (j = 0; j < (unsigned) n_elems; j++)
if (deletions[j]
- && ((unsigned) insertions[j] / deletions[j]) > MAX_GCSE_INSERTION_RATIO)
+ && (insertions[j] / deletions[j]) > param_max_gcse_insertion_ratio)
bitmap_set_bit (prune_exprs, j);
/* Now prune PRE_INSERT_MAP and PRE_DELETE_MAP based on PRUNE_EXPRS. */
@@ -3133,7 +3133,7 @@ hoist_code (void)
expressions, nothing gets hoisted from the entry block. */
FOR_EACH_VEC_ELT (dom_tree_walk, dom_tree_walk_index, bb)
{
- domby = get_dominated_to_depth (CDI_DOMINATORS, bb, MAX_HOIST_DEPTH);
+ domby = get_dominated_to_depth (CDI_DOMINATORS, bb, param_max_hoist_depth);
if (domby.length () == 0)
continue;
@@ -3982,9 +3982,9 @@ update_ld_motion_stores (struct gcse_expr * expr)
bool
gcse_or_cprop_is_too_expensive (const char *pass)
{
- unsigned int memory_request = (n_basic_blocks_for_fn (cfun)
- * SBITMAP_SET_SIZE (max_reg_num ())
- * sizeof (SBITMAP_ELT_TYPE));
+ int memory_request = (n_basic_blocks_for_fn (cfun)
+ * SBITMAP_SET_SIZE (max_reg_num ())
+ * sizeof (SBITMAP_ELT_TYPE));
/* Trying to perform global optimizations on flow graphs which have
a high connectivity will take a long time and is unlikely to be
@@ -4007,7 +4007,7 @@ gcse_or_cprop_is_too_expensive (const char *pass)
/* If allocating memory for the dataflow bitmaps would take up too much
storage it's better just to disable the optimization. */
- if (memory_request > MAX_GCSE_MEMORY)
+ if (memory_request > param_max_gcse_memory)
{
warning (OPT_Wdisabled_optimization,
"%s: %d basic blocks and %d registers; "
@@ -814,8 +814,8 @@ void
init_ggc_heuristics (void)
{
#if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT
- set_default_param_value (GGC_MIN_EXPAND, ggc_min_expand_heuristic ());
- set_default_param_value (GGC_MIN_HEAPSIZE, ggc_min_heapsize_heuristic ());
+ param_ggc_min_expand = ggc_min_expand_heuristic ();
+ param_ggc_min_heapsize = ggc_min_heapsize_heuristic ();
#endif
}
@@ -2185,9 +2185,9 @@ ggc_collect (void)
total allocations haven't expanded much since the last
collection. */
float allocated_last_gc =
- MAX (G.allocated_last_gc, (size_t)PARAM_VALUE (GGC_MIN_HEAPSIZE) * 1024);
+ MAX (G.allocated_last_gc, (size_t)param_ggc_min_heapsize * 1024);
- float min_expand = allocated_last_gc * PARAM_VALUE (GGC_MIN_EXPAND) / 100;
+ float min_expand = allocated_last_gc * param_ggc_min_expand / 100;
if (G.allocated < allocated_last_gc + min_expand && !ggc_force_collect)
return;
@@ -78,14 +78,14 @@ along with GCC; see the file COPYING3. If not see
simple reduction of inner loop and double reduction of the loop nest. */
/* Maximum number of stmts in each loop that should be interchanged. */
-#define MAX_NUM_STMT (PARAM_VALUE (PARAM_LOOP_INTERCHANGE_MAX_NUM_STMTS))
+#define MAX_NUM_STMT (param_loop_interchange_max_num_stmts)
/* Maximum number of data references in loop nest. */
-#define MAX_DATAREFS (PARAM_VALUE (PARAM_LOOP_MAX_DATAREFS_FOR_DATADEPS))
+#define MAX_DATAREFS (param_loop_max_datarefs_for_datadeps)
/* Comparison ratio of access stride between inner/outer loops to be
interchanged. This is the minimum stride ratio for loop interchange
to be profitable. */
-#define OUTER_STRIDE_RATIO (PARAM_VALUE (PARAM_LOOP_INTERCHANGE_STRIDE_RATIO))
+#define OUTER_STRIDE_RATIO (param_loop_interchange_stride_ratio)
/* The same as above, but we require higher ratio for interchanging the
innermost two loops. */
#define INNER_STRIDE_RATIO ((OUTER_STRIDE_RATIO) + 1)
@@ -572,15 +572,15 @@ tree_loop_unroll_and_jam (void)
/* We regard a user-specified minimum percentage of zero as a request
to ignore all profitability concerns and apply the transformation
always. */
- if (!PARAM_VALUE (PARAM_UNROLL_JAM_MIN_PERCENT))
+ if (!param_unroll_jam_min_percent)
profit_unroll = MAX(2, profit_unroll);
else if (removed * 100 / datarefs.length ()
- < (unsigned)PARAM_VALUE (PARAM_UNROLL_JAM_MIN_PERCENT))
+ < (unsigned)param_unroll_jam_min_percent)
profit_unroll = 1;
if (unroll_factor > profit_unroll)
unroll_factor = profit_unroll;
- if (unroll_factor > (unsigned)PARAM_VALUE (PARAM_UNROLL_JAM_MAX_UNROLL))
- unroll_factor = PARAM_VALUE (PARAM_UNROLL_JAM_MAX_UNROLL);
+ if (unroll_factor > (unsigned)param_unroll_jam_max_unroll)
+ unroll_factor = param_unroll_jam_max_unroll;
unroll = (unroll_factor > 1
&& can_unroll_loop_p (outer, unroll_factor, &desc));
@@ -605,8 +605,8 @@ unsigned int
loop_versioning::max_insns_for_loop (class loop *loop)
{
return (loop->inner
- ? PARAM_VALUE (PARAM_LOOP_VERSIONING_MAX_OUTER_INSNS)
- : PARAM_VALUE (PARAM_LOOP_VERSIONING_MAX_INNER_INSNS));
+ ? param_loop_versioning_max_outer_insns
+ : param_loop_versioning_max_inner_insns);
}
/* Return true if for cost reasons we should avoid versioning any loop
@@ -366,7 +366,7 @@ is_feasible_trace (basic_block bb)
/* Upper Hard limit on the number statements to copy. */
if (num_stmts_in_join
- >= PARAM_VALUE (PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS))
+ >= param_max_jump_thread_duplication_stmts)
return false;
return true;
@@ -2502,7 +2502,7 @@ imm_store_chain_info::try_coalesce_bswap (merged_store_group *merged_store,
return false;
bool allow_unaligned
- = !STRICT_ALIGNMENT && PARAM_VALUE (PARAM_STORE_MERGING_ALLOW_UNALIGNED);
+ = !STRICT_ALIGNMENT && param_store_merging_allow_unaligned;
/* Punt if the combined store would not be aligned and we need alignment. */
if (!allow_unaligned)
{
@@ -2762,7 +2762,7 @@ imm_store_chain_info::coalesce_immediate_stores ()
if (info->order >= merged_store->first_nonmergeable_order
|| (((new_bitregion_end - new_bitregion_start + 1) / BITS_PER_UNIT)
- > (unsigned) PARAM_VALUE (PARAM_STORE_MERGING_MAX_SIZE)))
+ > (unsigned) param_store_merging_max_size))
;
/* |---store 1---|
@@ -3668,7 +3668,7 @@ imm_store_chain_info::output_merged_store (merged_store_group *group)
auto_vec<class split_store *, 32> split_stores;
bool allow_unaligned_store
- = !STRICT_ALIGNMENT && PARAM_VALUE (PARAM_STORE_MERGING_ALLOW_UNALIGNED);
+ = !STRICT_ALIGNMENT && param_store_merging_allow_unaligned;
bool allow_unaligned_load = allow_unaligned_store;
bool bzero_first = false;
if (group->stores[0]->rhs_code == INTEGER_CST
@@ -4752,7 +4752,7 @@ pass_store_merging::process_store (gimple *stmt)
/* If we reach the limit of stores to merge in a chain terminate and
process the chain now. */
if ((*chain_info)->m_store_info.length ()
- == (unsigned int) PARAM_VALUE (PARAM_MAX_STORES_TO_MERGE))
+ == (unsigned int) param_max_stores_to_merge)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
@@ -546,7 +546,7 @@ find_basis_for_base_expr (slsr_cand_t c, tree base_expr)
// Limit potential of N^2 behavior for long candidate chains.
int iters = 0;
- int max_iters = PARAM_VALUE (PARAM_MAX_SLSR_CANDIDATE_SCAN);
+ int max_iters = param_max_slsr_candidate_scan;
mapping_key.base_expr = base_expr;
chain = base_cand_map->find (&mapping_key);
@@ -203,7 +203,7 @@ class translate_isl_ast_to_gimple
{
codegen_error = true;
gcc_assert (! flag_checking
- || PARAM_VALUE (PARAM_GRAPHITE_ALLOW_CODEGEN_ERRORS));
+ || param_graphite_allow_codegen_errors);
}
bool is_constant (tree op) const
@@ -1383,7 +1383,7 @@ scop_to_isl_ast (scop_p scop)
{
int old_err = isl_options_get_on_error (scop->isl_context);
int old_max_operations = isl_ctx_get_max_operations (scop->isl_context);
- int max_operations = PARAM_VALUE (PARAM_MAX_ISL_OPERATIONS);
+ int max_operations = param_max_isl_operations;
if (max_operations)
isl_ctx_set_max_operations (scop->isl_context, max_operations);
isl_options_set_on_error (scop->isl_context, ISL_ON_ERROR_CONTINUE);
@@ -64,7 +64,7 @@ get_schedule_for_node_st (__isl_take isl_schedule_node *node, void *user)
if (type != isl_schedule_node_leaf)
return node;
- long tile_size = PARAM_VALUE (PARAM_LOOP_BLOCK_TILE_SIZE);
+ long tile_size = param_loop_block_tile_size;
if (dims <= 1
|| tile_size == 0
|| !isl_schedule_node_band_get_permutable (node))
@@ -115,7 +115,7 @@ optimize_isl (scop_p scop)
{
int old_err = isl_options_get_on_error (scop->isl_context);
int old_max_operations = isl_ctx_get_max_operations (scop->isl_context);
- int max_operations = PARAM_VALUE (PARAM_MAX_ISL_OPERATIONS);
+ int max_operations = param_max_isl_operations;
if (max_operations)
isl_ctx_set_max_operations (scop->isl_context, max_operations);
isl_options_set_on_error (scop->isl_context, ISL_ON_ERROR_CONTINUE);
@@ -1639,7 +1639,7 @@ build_scops (vec<scop_p> *scops)
continue;
}
- unsigned max_arrays = PARAM_VALUE (PARAM_GRAPHITE_MAX_ARRAYS_PER_SCOP);
+ unsigned max_arrays = param_graphite_max_arrays_per_scop;
if (max_arrays > 0
&& scop->drs.length () >= max_arrays)
{
@@ -1652,7 +1652,7 @@ build_scops (vec<scop_p> *scops)
}
find_scop_parameters (scop);
- graphite_dim_t max_dim = PARAM_VALUE (PARAM_GRAPHITE_MAX_NB_SCOP_PARAMS);
+ graphite_dim_t max_dim = param_graphite_max_nb_scop_params;
if (max_dim > 0
&& scop_nb_params (scop) > max_dim)
{
@@ -584,7 +584,7 @@ set_modulo_params (int ii, int max_stages, int insns, int max_uid)
modulo_max_stages = max_stages;
modulo_n_insns = insns;
modulo_iter0_max_uid = max_uid;
- modulo_backtracks_left = PARAM_VALUE (PARAM_MAX_MODULO_BACKTRACK_ATTEMPTS);
+ modulo_backtracks_left = param_max_modulo_backtrack_attempts;
}
/* A structure to record a pair of insns where the first one is a real
@@ -2712,7 +2712,7 @@ rank_for_schedule (const void *x, const void *y)
if (flag_sched_critical_path_heuristic && priority_val)
return rfs_result (RFS_PRIORITY, priority_val, tmp, tmp2);
- if (PARAM_VALUE (PARAM_SCHED_AUTOPREF_QUEUE_DEPTH) >= 0)
+ if (param_sched_autopref_queue_depth >= 0)
{
int autopref = autopref_rank_for_schedule (tmp, tmp2);
if (autopref != 0)
@@ -3413,7 +3413,7 @@ model_remove_from_worklist (struct model_insn_info *insn)
}
/* Add INSN to the model worklist. Start looking for a suitable position
- between neighbors PREV and NEXT, testing at most MAX_SCHED_READY_INSNS
+ between neighbors PREV and NEXT, testing at most param_max_sched_ready_insns
insns either side. A null PREV indicates the beginning of the list and
a null NEXT indicates the end. */
@@ -3424,7 +3424,7 @@ model_add_to_worklist (struct model_insn_info *insn,
{
int count;
- count = MAX_SCHED_READY_INSNS;
+ count = param_max_sched_ready_insns;
if (count > 0 && prev && model_order_p (insn, prev))
do
{
@@ -3452,7 +3452,7 @@ model_promote_insn (struct model_insn_info *insn)
int count;
prev = insn->prev;
- count = MAX_SCHED_READY_INSNS;
+ count = param_max_sched_ready_insns;
while (count > 0 && prev && model_order_p (insn, prev))
{
count--;
@@ -3738,7 +3738,7 @@ model_choose_insn (void)
{
fprintf (sched_dump, ";;\t+--- worklist:\n");
insn = model_worklist;
- count = MAX_SCHED_READY_INSNS;
+ count = param_max_sched_ready_insns;
while (count > 0 && insn)
{
fprintf (sched_dump, ";;\t+--- %d [%d, %d, %d, %d]\n",
@@ -3770,7 +3770,7 @@ model_choose_insn (void)
Failing that, just pick the highest-priority instruction in the
worklist. */
- count = MAX_SCHED_READY_INSNS;
+ count = param_max_sched_ready_insns;
insn = model_worklist;
fallback = 0;
for (;;)
@@ -5147,12 +5147,12 @@ queue_to_ready (struct ready_list *ready)
/* If the ready list is full, delay the insn for 1 cycle.
See the comment in schedule_block for the rationale. */
if (!reload_completed
- && (ready->n_ready - ready->n_debug > MAX_SCHED_READY_INSNS
+ && (ready->n_ready - ready->n_debug > param_max_sched_ready_insns
|| (sched_pressure == SCHED_PRESSURE_MODEL
- /* Limit pressure recalculations to MAX_SCHED_READY_INSNS
+ /* Limit pressure recalculations to param_max_sched_ready_insns
instructions too. */
&& model_index (insn) > (model_curr_point
- + MAX_SCHED_READY_INSNS)))
+ + param_max_sched_ready_insns)))
&& !(sched_pressure == SCHED_PRESSURE_MODEL
&& model_curr_point < model_num_insns
/* Always allow the next model instruction to issue. */
@@ -5743,7 +5743,7 @@ autopref_multipass_dfa_lookahead_guard (rtx_insn *insn1, int ready_index)
/* Exit early if the param forbids this or if we're not entering here through
normal haifa scheduling. This can happen if selective scheduling is
explicitly enabled. */
- if (!insn_queue || PARAM_VALUE (PARAM_SCHED_AUTOPREF_QUEUE_DEPTH) <= 0)
+ if (!insn_queue || param_sched_autopref_queue_depth <= 0)
return 0;
if (sched_verbose >= 2 && ready_index == 0)
@@ -5796,14 +5796,14 @@ autopref_multipass_dfa_lookahead_guard (rtx_insn *insn1, int ready_index)
}
}
- if (PARAM_VALUE (PARAM_SCHED_AUTOPREF_QUEUE_DEPTH) == 1)
+ if (param_sched_autopref_queue_depth == 1)
continue;
/* Everything from the current queue slot should have been moved to
the ready list. */
gcc_assert (insn_queue[NEXT_Q_AFTER (q_ptr, 0)] == NULL_RTX);
- int n_stalls = PARAM_VALUE (PARAM_SCHED_AUTOPREF_QUEUE_DEPTH) - 1;
+ int n_stalls = param_sched_autopref_queue_depth - 1;
if (n_stalls > max_insn_queue_index)
n_stalls = max_insn_queue_index;
@@ -6552,14 +6552,14 @@ schedule_block (basic_block *target_bb, state_t init_state)
time in the worst case. Before reload we are more likely to have
big lists so truncate them to a reasonable size. */
if (!reload_completed
- && ready.n_ready - ready.n_debug > MAX_SCHED_READY_INSNS)
+ && ready.n_ready - ready.n_debug > param_max_sched_ready_insns)
{
ready_sort_debug (&ready);
ready_sort_real (&ready);
- /* Find first free-standing insn past MAX_SCHED_READY_INSNS.
+ /* Find first free-standing insn past param_max_sched_ready_insns.
If there are debug insns, we know they're first. */
- for (i = MAX_SCHED_READY_INSNS + ready.n_debug; i < ready.n_ready; i++)
+ for (i = param_max_sched_ready_insns + ready.n_debug; i < ready.n_ready; i++)
if (!SCHED_GROUP_P (ready_element (&ready, i)))
break;
@@ -7258,7 +7258,7 @@ sched_init (void)
&& !reload_completed
&& common_sched_info->sched_pass_id == SCHED_RGN_PASS)
sched_pressure = ((enum sched_pressure_algorithm)
- PARAM_VALUE (PARAM_SCHED_PRESSURE_ALGORITHM));
+ param_sched_pressure_algorithm);
else
sched_pressure = SCHED_PRESSURE_NONE;
@@ -7274,9 +7274,9 @@ sched_init (void)
if (spec_info->mask != 0)
{
spec_info->data_weakness_cutoff =
- (PARAM_VALUE (PARAM_SCHED_SPEC_PROB_CUTOFF) * MAX_DEP_WEAK) / 100;
+ (param_sched_spec_prob_cutoff * MAX_DEP_WEAK) / 100;
spec_info->control_weakness_cutoff =
- (PARAM_VALUE (PARAM_SCHED_SPEC_PROB_CUTOFF)
+ (param_sched_spec_prob_cutoff
* REG_BR_PROB_BASE) / 100;
}
else
@@ -5940,7 +5940,7 @@ init_prologue (void)
unsigned index = hsa_get_number_decl_kernel_mappings ();
/* Emit store to debug argument. */
- if (PARAM_VALUE (PARAM_HSA_GEN_DEBUG_STORES) > 0)
+ if (param_hsa_gen_debug_stores > 0)
set_debug_value (prologue, new hsa_op_immed (1000 + index, BRIG_TYPE_U64));
}
@@ -3311,7 +3311,7 @@ bb_ok_for_noce_convert_multiple_sets (basic_block test_bb)
{
rtx_insn *insn;
unsigned count = 0;
- unsigned param = PARAM_VALUE (PARAM_MAX_RTL_IF_CONVERSION_INSNS);
+ unsigned param = param_max_rtl_if_conversion_insns;
FOR_BB_INSNS (test_bb, insn)
{
@@ -3838,7 +3838,7 @@ cond_move_process_if_block (struct noce_if_info *if_info)
vec<rtx> else_regs = vNULL;
unsigned int i;
int success_p = FALSE;
- int limit = PARAM_VALUE (PARAM_MAX_RTL_IF_CONVERSION_INSNS);
+ int limit = param_max_rtl_if_conversion_insns;
/* Build a mapping for each block to the value used for each
register. */
@@ -1609,7 +1609,7 @@ ipcp_lattice<valtype>::add_value (valtype newval, cgraph_edge *cs,
return false;
}
- if (values_count == PARAM_VALUE (PARAM_IPA_CP_VALUE_LIST_SIZE))
+ if (values_count == param_ipa_cp_value_list_size)
{
/* We can only free sources, not the values themselves, because sources
of other values in this SCC might point to them. */
@@ -2086,7 +2086,7 @@ merge_agg_lats_step (class ipcp_param_lattices *dest_plats,
set_agg_lats_to_bottom (dest_plats);
return false;
}
- if (dest_plats->aggs_count == PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS))
+ if (dest_plats->aggs_count == param_ipa_max_agg_items)
return false;
dest_plats->aggs_count++;
new_al = ipcp_agg_lattice_pool.allocate ();
@@ -2639,11 +2639,11 @@ devirtualization_time_bonus (struct cgraph_node *node,
int size = ipa_size_summaries->get (callee)->size;
/* FIXME: The values below need re-considering and perhaps also
integrating into the cost metrics, at lest in some very basic way. */
- if (size <= MAX_INLINE_INSNS_AUTO / 4)
+ if (size <= param_max_inline_insns_auto / 4)
res += 31 / ((int)speculative + 1);
- else if (size <= MAX_INLINE_INSNS_AUTO / 2)
+ else if (size <= param_max_inline_insns_auto / 2)
res += 15 / ((int)speculative + 1);
- else if (size <= MAX_INLINE_INSNS_AUTO
+ else if (size <= param_max_inline_insns_auto
|| DECL_DECLARED_INLINE_P (callee->decl))
res += 7 / ((int)speculative + 1);
}
@@ -2658,7 +2658,7 @@ hint_time_bonus (ipa_hints hints)
{
int result = 0;
if (hints & (INLINE_HINT_loop_iterations | INLINE_HINT_loop_stride))
- result += PARAM_VALUE (PARAM_IPA_CP_LOOP_HINT_BONUS);
+ result += param_ipa_cp_loop_hint_bonus;
return result;
}
@@ -2670,11 +2670,11 @@ incorporate_penalties (ipa_node_params *info, int64_t evaluation)
{
if (info->node_within_scc)
evaluation = (evaluation
- * (100 - PARAM_VALUE (PARAM_IPA_CP_RECURSION_PENALTY))) / 100;
+ * (100 - param_ipa_cp_recursion_penalty)) / 100;
if (info->node_calling_single_call)
evaluation = (evaluation
- * (100 - PARAM_VALUE (PARAM_IPA_CP_SINGLE_CALL_PENALTY)))
+ * (100 - param_ipa_cp_single_call_penalty))
/ 100;
return evaluation;
@@ -2714,10 +2714,10 @@ good_cloning_opportunity_p (struct cgraph_node *node, int time_benefit,
", threshold: %i\n",
info->node_within_scc ? ", scc" : "",
info->node_calling_single_call ? ", single_call" : "",
- evaluation, PARAM_VALUE (PARAM_IPA_CP_EVAL_THRESHOLD));
+ evaluation, param_ipa_cp_eval_threshold);
}
- return evaluation >= PARAM_VALUE (PARAM_IPA_CP_EVAL_THRESHOLD);
+ return evaluation >= param_ipa_cp_eval_threshold;
}
else
{
@@ -2732,9 +2732,9 @@ good_cloning_opportunity_p (struct cgraph_node *node, int time_benefit,
time_benefit, size_cost, freq_sum,
info->node_within_scc ? ", scc" : "",
info->node_calling_single_call ? ", single_call" : "",
- evaluation, PARAM_VALUE (PARAM_IPA_CP_EVAL_THRESHOLD));
+ evaluation, param_ipa_cp_eval_threshold);
- return evaluation >= PARAM_VALUE (PARAM_IPA_CP_EVAL_THRESHOLD);
+ return evaluation >= param_ipa_cp_eval_threshold;
}
}
@@ -3349,9 +3349,9 @@ ipcp_propagate_stage (class ipa_topo_info *topo)
}
max_new_size = overall_size;
- if (max_new_size < PARAM_VALUE (PARAM_LARGE_UNIT_INSNS))
- max_new_size = PARAM_VALUE (PARAM_LARGE_UNIT_INSNS);
- max_new_size += max_new_size * PARAM_VALUE (PARAM_IPCP_UNIT_GROWTH) / 100 + 1;
+ if (max_new_size < param_large_unit_insns)
+ max_new_size = param_large_unit_insns;
+ max_new_size += max_new_size * param_ipcp_unit_growth / 100 + 1;
if (dump_file)
fprintf (dump_file, "\noverall_size: %li, max_new_size: %li\n",
@@ -1201,7 +1201,7 @@ decompose_param_expr (struct ipa_func_body_info *fbi,
struct agg_position_info *aggpos,
expr_eval_ops *param_ops_p = NULL)
{
- int op_limit = PARAM_VALUE (PARAM_IPA_MAX_PARAM_EXPR_OPS);
+ int op_limit = param_ipa_max_param_expr_ops;
int op_count = 0;
if (param_ops_p)
@@ -1432,7 +1432,7 @@ set_switch_stmt_execution_predicate (struct ipa_func_body_info *fbi,
auto_vec<std::pair<tree, tree> > ranges;
tree type = TREE_TYPE (op);
- int bound_limit = PARAM_VALUE (PARAM_IPA_MAX_SWITCH_PREDICATE_BOUNDS);
+ int bound_limit = param_ipa_max_switch_predicate_bounds;
int bound_count = 0;
wide_int vr_wmin, vr_wmax;
value_range_kind vr_type = get_range_info (op, &vr_wmin, &vr_wmax);
@@ -2277,9 +2277,9 @@ fp_expression_p (gimple *stmt)
static void
analyze_function_body (struct cgraph_node *node, bool early)
{
- sreal time = PARAM_VALUE (PARAM_UNINLINED_FUNCTION_TIME);
+ sreal time = param_uninlined_function_time;
/* Estimate static overhead for function prologue/epilogue and alignment. */
- int size = PARAM_VALUE (PARAM_UNINLINED_FUNCTION_INSNS);
+ int size = param_uninlined_function_insns;
/* Benefits are scaled by probability of elimination that is in range
<0,2>. */
basic_block bb;
@@ -2328,7 +2328,7 @@ analyze_function_body (struct cgraph_node *node, bool early)
fbi.bb_infos = vNULL;
fbi.bb_infos.safe_grow_cleared (last_basic_block_for_fn (cfun));
fbi.param_count = count_formal_params (node->decl);
- fbi.aa_walk_budget = PARAM_VALUE (PARAM_IPA_MAX_AA_STEPS);
+ fbi.aa_walk_budget = param_ipa_max_aa_steps;
nonconstant_names.safe_grow_cleared
(SSANAMES (my_function)->length ());
@@ -2345,9 +2345,9 @@ analyze_function_body (struct cgraph_node *node, bool early)
info->account_size_time (0, 0, bb_predicate, bb_predicate);
bb_predicate = predicate::not_inlined ();
- info->account_size_time (PARAM_VALUE (PARAM_UNINLINED_FUNCTION_INSNS)
+ info->account_size_time (param_uninlined_function_insns
* ipa_fn_summary::size_scale,
- PARAM_VALUE (PARAM_UNINLINED_FUNCTION_TIME),
+ param_uninlined_function_time,
bb_predicate,
bb_predicate);
@@ -2745,10 +2745,8 @@ compute_fn_summary (struct cgraph_node *node, bool early)
es->call_stmt_size = eni_size_weights.call_cost;
es->call_stmt_time = eni_time_weights.call_cost;
info->account_size_time (ipa_fn_summary::size_scale
- * PARAM_VALUE
- (PARAM_UNINLINED_FUNCTION_THUNK_INSNS),
- PARAM_VALUE
- (PARAM_UNINLINED_FUNCTION_THUNK_TIME), t, t);
+ * param_uninlined_function_thunk_insns,
+ param_uninlined_function_thunk_time, t, t);
t = predicate::not_inlined ();
info->account_size_time (2 * ipa_fn_summary::size_scale, 0, t, t);
ipa_update_overall_fn_summary (node);
@@ -448,7 +448,7 @@ estimate_growth (struct cgraph_node *node)
else if (DECL_COMDAT (node->decl)
&& node->can_remove_if_no_direct_calls_p ())
d.growth -= (info->size
- * (100 - PARAM_VALUE (PARAM_COMDAT_SHARING_PROBABILITY))
+ * (100 - param_comdat_sharing_probability)
+ 50) / 100;
}
@@ -179,13 +179,13 @@ caller_growth_limits (struct cgraph_edge *e)
if (limit < what_size_info->self_size)
limit = what_size_info->self_size;
- limit += limit * PARAM_VALUE (PARAM_LARGE_FUNCTION_GROWTH) / 100;
+ limit += limit * param_large_function_growth / 100;
/* Check the size after inlining against the function limits. But allow
the function to shrink if it went over the limits by forced inlining. */
newsize = estimate_size_after_inlining (to, e);
if (newsize >= ipa_size_summaries->get (what)->size
- && newsize > PARAM_VALUE (PARAM_LARGE_FUNCTION_INSNS)
+ && newsize > param_large_function_insns
&& newsize > limit)
{
e->inline_failed = CIF_LARGE_FUNCTION_GROWTH_LIMIT;
@@ -201,7 +201,7 @@ caller_growth_limits (struct cgraph_edge *e)
on every invocation of the caller (i.e. its call statement dominates
exit block). We do not track this information, yet. */
stack_size_limit += ((gcov_type)stack_size_limit
- * PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) / 100);
+ * param_stack_frame_growth / 100);
inlined_stack = (ipa_get_stack_frame_offset (to)
+ outer_info->estimated_self_stack_size
@@ -214,7 +214,7 @@ caller_growth_limits (struct cgraph_edge *e)
This bit overoptimistically assume that we are good at stack
packing. */
&& inlined_stack > ipa_fn_summaries->get (to)->estimated_stack_size
- && inlined_stack > PARAM_VALUE (PARAM_LARGE_STACK_FRAME))
+ && inlined_stack > param_large_stack_frame)
{
e->inline_failed = CIF_LARGE_STACK_FRAME_GROWTH_LIMIT;
return false;
@@ -399,16 +399,16 @@ inline_insns_single (cgraph_node *n, bool hint)
if (opt_for_fn (n->decl, optimize) >= 3)
{
if (hint)
- return PARAM_VALUE (PARAM_MAX_INLINE_INSNS_SINGLE)
- * PARAM_VALUE (PARAM_INLINE_HEURISTICS_HINT_PERCENT) / 100;
- return PARAM_VALUE (PARAM_MAX_INLINE_INSNS_SINGLE);
+ return param_max_inline_insns_single
+ * param_inline_heuristics_hint_percent / 100;
+ return param_max_inline_insns_single;
}
else
{
if (hint)
- return PARAM_VALUE (PARAM_MAX_INLINE_INSNS_SINGLE_O2)
- * PARAM_VALUE (PARAM_INLINE_HEURISTICS_HINT_PERCENT_O2) / 100;
- return PARAM_VALUE (PARAM_MAX_INLINE_INSNS_SINGLE_O2);
+ return param_max_inline_insns_single_o2
+ * param_inline_heuristics_hint_percent_o2 / 100;
+ return param_max_inline_insns_single_o2;
}
}
@@ -421,16 +421,16 @@ inline_insns_auto (cgraph_node *n, bool hint)
if (opt_for_fn (n->decl, optimize) >= 3)
{
if (hint)
- return PARAM_VALUE (PARAM_MAX_INLINE_INSNS_AUTO)
- * PARAM_VALUE (PARAM_INLINE_HEURISTICS_HINT_PERCENT) / 100;
- return PARAM_VALUE (PARAM_MAX_INLINE_INSNS_AUTO);
+ return param_max_inline_insns_auto
+ * param_inline_heuristics_hint_percent / 100;
+ return param_max_inline_insns_auto;
}
else
{
if (hint)
- return PARAM_VALUE (PARAM_MAX_INLINE_INSNS_AUTO_O2)
- * PARAM_VALUE (PARAM_INLINE_HEURISTICS_HINT_PERCENT_O2) / 100;
- return PARAM_VALUE (PARAM_MAX_INLINE_INSNS_AUTO_O2);
+ return param_max_inline_insns_auto_o2
+ * param_inline_heuristics_hint_percent_o2 / 100;
+ return param_max_inline_insns_auto_o2;
}
}
@@ -567,14 +567,14 @@ can_inline_edge_by_limits_p (struct cgraph_edge *e, bool report,
inlinable = false;
}
/* If callee is optimized for size and caller is not, allow inlining if
- code shrinks or we are in MAX_INLINE_INSNS_SINGLE limit and callee
+ code shrinks or we are in param_max_inline_insns_single limit and callee
is inline (and thus likely an unified comdat). This will allow caller
to run faster. */
else if (opt_for_fn (callee->decl, optimize_size)
> opt_for_fn (caller->decl, optimize_size))
{
int growth = estimate_edge_growth (e);
- if (growth > PARAM_VALUE (PARAM_MAX_INLINE_INSNS_SIZE)
+ if (growth > param_max_inline_insns_size
&& (!DECL_DECLARED_INLINE_P (callee->decl)
&& growth >= MAX (inline_insns_single (caller, false),
inline_insns_auto (caller, false))))
@@ -686,11 +686,11 @@ want_early_inline_function_p (struct cgraph_edge *e)
int growth = estimate_edge_growth (e);
int n;
int early_inlining_insns = opt_for_fn (e->caller->decl, optimize) >= 3
- ? PARAM_VALUE (PARAM_EARLY_INLINING_INSNS)
- : PARAM_VALUE (PARAM_EARLY_INLINING_INSNS_O2);
+ ? param_early_inlining_insns
+ : param_early_inlining_insns_o2;
- if (growth <= PARAM_VALUE (PARAM_MAX_INLINE_INSNS_SIZE))
+ if (growth <= param_max_inline_insns_size)
;
else if (!e->maybe_hot_p ())
{
@@ -793,8 +793,8 @@ big_speedup_p (struct cgraph_edge *e)
? e->caller->inlined_to
: e->caller);
int limit = opt_for_fn (caller->decl, optimize) >= 3
- ? PARAM_VALUE (PARAM_INLINE_MIN_SPEEDUP)
- : PARAM_VALUE (PARAM_INLINE_MIN_SPEEDUP_O2);
+ ? param_inline_min_speedup
+ : param_inline_min_speedup_o2;
if ((time - inlined_time) * 100 > time * limit)
return true;
@@ -861,9 +861,9 @@ want_inline_small_function_p (struct cgraph_edge *e, bool report)
| INLINE_HINT_loop_iterations
| INLINE_HINT_loop_stride));
- if (growth <= PARAM_VALUE (PARAM_MAX_INLINE_INSNS_SIZE))
+ if (growth <= param_max_inline_insns_size)
;
- /* Apply MAX_INLINE_INSNS_SINGLE limit. Do not do so when
+ /* Apply param_max_inline_insns_single limit. Do not do so when
hints suggests that inlining given function is very profitable.
Avoid computation of big_speedup_p when not necessary to change
outcome of decision. */
@@ -881,7 +881,7 @@ want_inline_small_function_p (struct cgraph_edge *e, bool report)
}
else if (!DECL_DECLARED_INLINE_P (callee->decl)
&& !opt_for_fn (e->caller->decl, flag_inline_functions)
- && growth >= PARAM_VALUE (PARAM_MAX_INLINE_INSNS_SMALL))
+ && growth >= param_max_inline_insns_small)
{
/* growth_likely_positive is expensive, always test it last. */
if (growth >= inline_insns_single (e->caller, false)
@@ -891,7 +891,7 @@ want_inline_small_function_p (struct cgraph_edge *e, bool report)
want_inline = false;
}
}
- /* Apply MAX_INLINE_INSNS_AUTO limit for functions not declared inline.
+ /* Apply param_max_inline_insns_auto limit for functions not declared inline.
Bypass the limit when speedup seems big. */
else if (!DECL_DECLARED_INLINE_P (callee->decl)
&& growth >= inline_insns_auto (e->caller, apply_hints)
@@ -944,10 +944,10 @@ want_inline_self_recursive_call_p (struct cgraph_edge *edge,
char const *reason = NULL;
bool want_inline = true;
sreal caller_freq = 1;
- int max_depth = PARAM_VALUE (PARAM_MAX_INLINE_RECURSIVE_DEPTH_AUTO);
+ int max_depth = param_max_inline_recursive_depth_auto;
if (DECL_DECLARED_INLINE_P (edge->caller->decl))
- max_depth = PARAM_VALUE (PARAM_MAX_INLINE_RECURSIVE_DEPTH);
+ max_depth = param_max_inline_recursive_depth;
if (!edge->maybe_hot_p ())
{
@@ -1009,7 +1009,7 @@ want_inline_self_recursive_call_p (struct cgraph_edge *edge,
{
if (edge->sreal_frequency () * 100
<= caller_freq
- * PARAM_VALUE (PARAM_MIN_INLINE_RECURSIVE_PROBABILITY))
+ * param_min_inline_recursive_probability)
{
reason = "frequency of recursive call is too small";
want_inline = false;
@@ -1206,8 +1206,7 @@ edge_badness (struct cgraph_edge *edge, bool dump)
frequency still indicates splitting is a win ... */
|| (callee->split_part && !caller->split_part
&& edge->sreal_frequency () * 100
- < PARAM_VALUE
- (PARAM_PARTIAL_INLINING_ENTRY_PROBABILITY)
+ < param_partial_inlining_entry_probability
/* ... and do not overwrite user specified hints. */
&& (!DECL_DECLARED_INLINE_P (edge->callee->decl)
|| DECL_DECLARED_INLINE_P (caller->decl)))))
@@ -1537,7 +1536,7 @@ static bool
recursive_inlining (struct cgraph_edge *edge,
vec<cgraph_edge *> *new_edges)
{
- int limit = PARAM_VALUE (PARAM_MAX_INLINE_INSNS_RECURSIVE_AUTO);
+ int limit = param_max_inline_insns_recursive_auto;
edge_heap_t heap (sreal::min ());
struct cgraph_node *node;
struct cgraph_edge *e;
@@ -1550,7 +1549,7 @@ recursive_inlining (struct cgraph_edge *edge,
node = node->inlined_to;
if (DECL_DECLARED_INLINE_P (node->decl))
- limit = PARAM_VALUE (PARAM_MAX_INLINE_INSNS_RECURSIVE);
+ limit = param_max_inline_insns_recursive;
/* Make sure that function is small enough to be considered for inlining. */
if (estimate_size_after_inlining (node, edge) >= limit)
@@ -1675,11 +1674,11 @@ static int
compute_max_insns (int insns)
{
int max_insns = insns;
- if (max_insns < PARAM_VALUE (PARAM_LARGE_UNIT_INSNS))
- max_insns = PARAM_VALUE (PARAM_LARGE_UNIT_INSNS);
+ if (max_insns < param_large_unit_insns)
+ max_insns = param_large_unit_insns;
return ((int64_t) max_insns
- * (100 + PARAM_VALUE (PARAM_INLINE_UNIT_GROWTH)) / 100);
+ * (100 + param_inline_unit_growth) / 100);
}
@@ -2895,7 +2894,7 @@ early_inliner (function *fun)
}
/* We iterate incremental inlining to get trivial cases of indirect
inlining. */
- while (iterations < PARAM_VALUE (PARAM_EARLY_INLINER_MAX_ITERATIONS)
+ while (iterations < param_early_inliner_max_iterations
&& early_inline_small_functions (node))
{
timevar_push (TV_INTEGRATION);
@@ -2922,7 +2921,7 @@ early_inliner (function *fun)
edge->call_stmt_cannot_inline_p = true;
}
}
- if (iterations < PARAM_VALUE (PARAM_EARLY_INLINER_MAX_ITERATIONS) - 1)
+ if (iterations < param_early_inliner_max_iterations - 1)
ipa_update_overall_fn_summary (node);
timevar_pop (TV_INTEGRATION);
iterations++;
@@ -1400,7 +1400,7 @@ record_known_type (struct type_change_info *tci, tree type, HOST_WIDE_INT offset
static inline bool
csftc_abort_walking_p (unsigned speculative)
{
- unsigned max = PARAM_VALUE (PARAM_MAX_SPECULATIVE_DEVIRT_MAYDEFS);
+ unsigned max = param_max_speculative_devirt_maydefs;
return speculative > max ? true : false;
}
@@ -506,7 +506,7 @@ ipa_profile (void)
gcc_assert (overall_size);
- cutoff = (overall_time * PARAM_VALUE (HOT_BB_COUNT_WS_PERMILLE) + 500) / 1000;
+ cutoff = (overall_time * param_hot_bb_count_ws_permille + 500) / 1000;
threshold = 0;
for (i = 0; cumulated < cutoff; i++)
{
@@ -1601,7 +1601,7 @@ determine_known_aggregate_parts (gcall *call, tree arg,
struct ipa_known_agg_contents_list *list = NULL, *all_list = NULL;
bitmap visited = NULL;
int item_count = 0, const_count = 0;
- int ipa_max_agg_items = PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS);
+ int ipa_max_agg_items = param_ipa_max_agg_items;
HOST_WIDE_INT arg_offset, arg_size;
tree arg_base;
bool check_ref, by_ref;
@@ -2632,7 +2632,7 @@ ipa_analyze_node (struct cgraph_node *node)
fbi.bb_infos = vNULL;
fbi.bb_infos.safe_grow_cleared (last_basic_block_for_fn (cfun));
fbi.param_count = ipa_get_param_count (info);
- fbi.aa_walk_budget = PARAM_VALUE (PARAM_IPA_MAX_AA_STEPS);
+ fbi.aa_walk_budget = param_ipa_max_aa_steps;
for (struct cgraph_edge *cs = node->callees; cs; cs = cs->next_callee)
{
@@ -5291,7 +5291,7 @@ ipcp_transform_function (struct cgraph_node *node)
fbi.bb_infos = vNULL;
fbi.bb_infos.safe_grow_cleared (last_basic_block_for_fn (cfun));
fbi.param_count = param_count;
- fbi.aa_walk_budget = PARAM_VALUE (PARAM_IPA_MAX_AA_STEPS);
+ fbi.aa_walk_budget = param_ipa_max_aa_steps;
vec_safe_grow_cleared (descriptors, param_count);
ipa_populate_param_decls (node, *descriptors);
@@ -453,7 +453,7 @@ consider_split (class split_point *current, bitmap non_ssa_vars,
is unknown. */
if (!(current->count
< (ENTRY_BLOCK_PTR_FOR_FN (cfun)->count.apply_scale
- (PARAM_VALUE (PARAM_PARTIAL_INLINING_ENTRY_PROBABILITY), 100))))
+ (param_partial_inlining_entry_probability, 100))))
{
/* When profile is guessed, we cannot expect it to give us
realistic estimate on likelyness of function taking the
@@ -563,8 +563,8 @@ consider_split (class split_point *current, bitmap non_ssa_vars,
that. Next stage1 we should try to be more meaningful here. */
if (current->header_size + call_overhead
>= (unsigned int)(DECL_DECLARED_INLINE_P (current_function_decl)
- ? MAX_INLINE_INSNS_SINGLE
- : MAX_INLINE_INSNS_AUTO) + 10)
+ ? param_max_inline_insns_single
+ : param_max_inline_insns_auto) + 10)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
@@ -577,7 +577,7 @@ consider_split (class split_point *current, bitmap non_ssa_vars,
Limit this duplication. This is consistent with limit in tree-sra.c
FIXME: with LTO we ought to be able to do better! */
if (DECL_ONE_ONLY (current_function_decl)
- && current->split_size >= (unsigned int) MAX_INLINE_INSNS_AUTO + 10)
+ && current->split_size >= (unsigned int) param_max_inline_insns_auto + 10)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
@@ -589,7 +589,7 @@ consider_split (class split_point *current, bitmap non_ssa_vars,
FIXME: with LTO we ought to be able to do better! */
if (DECL_ONE_ONLY (current_function_decl)
&& current->split_size
- <= (unsigned int) PARAM_VALUE (PARAM_EARLY_INLINING_INSNS) / 2)
+ <= (unsigned int) param_early_inlining_insns / 2)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
@@ -1266,7 +1266,7 @@ allocate_access (gensum_param_desc *desc,
HOST_WIDE_INT offset, HOST_WIDE_INT size)
{
if (desc->access_count
- == (unsigned) PARAM_VALUE (PARAM_IPA_SRA_MAX_REPLACEMENTS))
+ == (unsigned) param_ipa_sra_max_replacements)
{
disqualify_split_candidate (desc, "Too many replacement candidates");
return NULL;
@@ -2280,8 +2280,7 @@ process_scan_results (cgraph_node *node, struct function *fun,
if (!desc->by_ref || optimize_function_for_size_p (fun))
param_size_limit = cur_param_size;
else
- param_size_limit = (PARAM_VALUE (PARAM_IPA_SRA_PTR_GROWTH_FACTOR)
- * cur_param_size);
+ param_size_limit = param_ipa_sra_ptr_growth_factor * cur_param_size;
if (nonarg_acc_size > param_size_limit
|| (!desc->by_ref && nonarg_acc_size == param_size_limit))
{
@@ -2501,7 +2500,7 @@ ipa_sra_summarize_function (cgraph_node *node)
bb_dereferences = XCNEWVEC (HOST_WIDE_INT,
by_ref_count
* last_basic_block_for_fn (fun));
- aa_walking_limit = PARAM_VALUE (PARAM_IPA_MAX_AA_STEPS);
+ aa_walking_limit = param_ipa_max_aa_steps;
scan_function (node, fun);
if (dump_file)
@@ -3337,7 +3336,7 @@ pull_accesses_from_callee (isra_param_desc *param_desc,
return NULL;
if ((prop_count + pclen
- > (unsigned) PARAM_VALUE (PARAM_IPA_SRA_MAX_REPLACEMENTS))
+ > (unsigned) param_ipa_sra_max_replacements)
|| size_would_violate_limit_p (param_desc,
param_desc->size_reached + prop_size))
return "propagating accesses would violate the count or size limit";
@@ -2217,7 +2217,7 @@ loop_compare_func (const void *v1p, const void *v2p)
hardly helps (for irregular register file architecture it could
help by choosing a better hard register in the loop but we prefer
faster allocation even in this case). We also remove cheap loops
- if there are more than IRA_MAX_LOOPS_NUM of them. Loop with EH
+ if there are more than param_ira_max_loops_num of them. Loop with EH
exit or enter edges are removed too because the allocation might
require put pseudo moves on the EH edges (we could still do this
for pseudos with caller saved hard registers in some cases but it
@@ -2253,7 +2253,7 @@ mark_loops_for_removal (void)
);
}
qsort (sorted_loops, n, sizeof (ira_loop_tree_node_t), loop_compare_func);
- for (i = 0; i < n - IRA_MAX_LOOPS_NUM; i++)
+ for (i = 0; i < n - param_ira_max_loops_num; i++)
{
sorted_loops[i]->to_remove_p = true;
if (internal_flag_ira_verbose > 1 && ira_dump_file != NULL)
@@ -113,13 +113,13 @@ build_conflict_bit_table (void)
/ IRA_INT_BITS);
allocated_words_num += conflict_bit_vec_words_num;
if ((uint64_t) allocated_words_num * sizeof (IRA_INT_TYPE)
- > (uint64_t) IRA_MAX_CONFLICT_TABLE_SIZE * 1024 * 1024)
+ > (uint64_t) param_ira_max_conflict_table_size * 1024 * 1024)
{
if (internal_flag_ira_verbose > 0 && ira_dump_file != NULL)
fprintf
(ira_dump_file,
"+++Conflict table will be too big(>%dMB) -- don't use it\n",
- IRA_MAX_CONFLICT_TABLE_SIZE);
+ param_ira_max_conflict_table_size);
return false;
}
}
@@ -651,7 +651,7 @@ doloop_optimize (class loop *loop)
}
max_cost
- = COSTS_N_INSNS (PARAM_VALUE (PARAM_MAX_ITERATIONS_COMPUTATION_COST));
+ = COSTS_N_INSNS (param_max_iterations_computation_cost);
if (set_src_cost (desc->niter_expr, mode, optimize_loop_for_speed_p (loop))
> max_cost)
{
@@ -1491,7 +1491,7 @@ gain_for_invariant (struct invariant *inv, unsigned *regs_needed,
if ((int) new_regs[pressure_class]
+ (int) regs_needed[pressure_class]
+ LOOP_DATA (curr_loop)->max_reg_pressure[pressure_class]
- + IRA_LOOP_RESERVED_REGS
+ + param_ira_loop_reserved_regs
> ira_class_hard_regs_num[pressure_class])
break;
}
@@ -2279,7 +2279,7 @@ move_loop_invariants (void)
/* move_single_loop_invariants for very large loops is time consuming
and might need a lot of memory. For -O1 only do loop invariant
motion for very small loops. */
- unsigned max_bbs = LOOP_INVARIANT_MAX_BBS_IN_LOOP;
+ unsigned max_bbs = param_loop_invariant_max_bbs_in_loop;
if (optimize < 2)
max_bbs /= 10;
if (loop->num_nodes <= max_bbs)
@@ -364,13 +364,13 @@ decide_unroll_constant_iterations (class loop *loop, int flags)
/* nunroll = total number of copies of the original loop body in
unrolled loop (i.e. if it is 2, we have to duplicate loop body once). */
- nunroll = PARAM_VALUE (PARAM_MAX_UNROLLED_INSNS) / loop->ninsns;
+ nunroll = param_max_unrolled_insns / loop->ninsns;
nunroll_by_av
- = PARAM_VALUE (PARAM_MAX_AVERAGE_UNROLLED_INSNS) / loop->av_ninsns;
+ = param_max_average_unrolled_insns / loop->av_ninsns;
if (nunroll > nunroll_by_av)
nunroll = nunroll_by_av;
- if (nunroll > (unsigned) PARAM_VALUE (PARAM_MAX_UNROLL_TIMES))
- nunroll = PARAM_VALUE (PARAM_MAX_UNROLL_TIMES);
+ if (nunroll > (unsigned) param_max_unroll_times)
+ nunroll = param_max_unroll_times;
if (targetm.loop_unroll_adjust)
nunroll = targetm.loop_unroll_adjust (nunroll, loop);
@@ -684,12 +684,12 @@ decide_unroll_runtime_iterations (class loop *loop, int flags)
/* nunroll = total number of copies of the original loop body in
unrolled loop (i.e. if it is 2, we have to duplicate loop body once. */
- nunroll = PARAM_VALUE (PARAM_MAX_UNROLLED_INSNS) / loop->ninsns;
- nunroll_by_av = PARAM_VALUE (PARAM_MAX_AVERAGE_UNROLLED_INSNS) / loop->av_ninsns;
+ nunroll = param_max_unrolled_insns / loop->ninsns;
+ nunroll_by_av = param_max_average_unrolled_insns / loop->av_ninsns;
if (nunroll > nunroll_by_av)
nunroll = nunroll_by_av;
- if (nunroll > (unsigned) PARAM_VALUE (PARAM_MAX_UNROLL_TIMES))
- nunroll = PARAM_VALUE (PARAM_MAX_UNROLL_TIMES);
+ if (nunroll > (unsigned) param_max_unroll_times)
+ nunroll = param_max_unroll_times;
if (targetm.loop_unroll_adjust)
nunroll = targetm.loop_unroll_adjust (nunroll, loop);
@@ -1167,13 +1167,13 @@ decide_unroll_stupid (class loop *loop, int flags)
/* nunroll = total number of copies of the original loop body in
unrolled loop (i.e. if it is 2, we have to duplicate loop body once. */
- nunroll = PARAM_VALUE (PARAM_MAX_UNROLLED_INSNS) / loop->ninsns;
+ nunroll = param_max_unrolled_insns / loop->ninsns;
nunroll_by_av
- = PARAM_VALUE (PARAM_MAX_AVERAGE_UNROLLED_INSNS) / loop->av_ninsns;
+ = param_max_average_unrolled_insns / loop->av_ninsns;
if (nunroll > nunroll_by_av)
nunroll = nunroll_by_av;
- if (nunroll > (unsigned) PARAM_VALUE (PARAM_MAX_UNROLL_TIMES))
- nunroll = PARAM_VALUE (PARAM_MAX_UNROLL_TIMES);
+ if (nunroll > (unsigned) param_max_unroll_times)
+ nunroll = param_max_unroll_times;
if (targetm.loop_unroll_adjust)
nunroll = targetm.loop_unroll_adjust (nunroll, loop);
@@ -1824,7 +1824,7 @@ expand_var_during_unrolling (struct var_to_expand *ve, rtx_insn *insn)
/* Generate a new register only if the expansion limit has not been
reached. Else reuse an already existing expansion. */
- if (PARAM_VALUE (PARAM_MAX_VARIABLE_EXPANSIONS) > ve->expansion_count)
+ if (param_max_variable_expansions > ve->expansion_count)
{
really_new_expansion = true;
new_reg = gen_reg_rtx (GET_MODE (ve->reg));
@@ -1008,7 +1008,7 @@ spill_for (int regno, bitmap spilled_pseudo_bitmap, bool first_p)
}
n = 0;
if (sparseset_cardinality (live_range_reload_inheritance_pseudos)
- <= (unsigned)LRA_MAX_CONSIDERED_RELOAD_PSEUDOS)
+ <= (unsigned)param_lra_max_considered_reload_pseudos)
EXECUTE_IF_SET_IN_SPARSESET (live_range_reload_inheritance_pseudos,
reload_regno)
if ((int) reload_regno != regno
@@ -6682,7 +6682,7 @@ inherit_in_ebb (rtx_insn *head, rtx_insn *tail)
a BB is not greater than the following value, we don't add the BB
to EBB. */
#define EBB_PROBABILITY_CUTOFF \
- ((REG_BR_PROB_BASE * LRA_INHERITANCE_EBB_PROBABILITY_CUTOFF) / 100)
+ ((REG_BR_PROB_BASE * param_lra_inheritance_ebb_probability_cutoff) / 100)
/* Current number of inheritance/split iteration. */
int lra_inheritance_iter;
@@ -560,13 +560,13 @@ lto_balanced_map (int n_lto_partitions, int max_partition_size)
varpool_order.qsort (varpool_node_cmp);
/* Compute partition size and create the first partition. */
- if (PARAM_VALUE (MIN_PARTITION_SIZE) > max_partition_size)
+ if (param_min_partition_size > max_partition_size)
fatal_error (input_location, "min partition size cannot be greater "
"than max partition size");
partition_size = total_size / n_lto_partitions;
- if (partition_size < PARAM_VALUE (MIN_PARTITION_SIZE))
- partition_size = PARAM_VALUE (MIN_PARTITION_SIZE);
+ if (partition_size < param_min_partition_size)
+ partition_size = param_min_partition_size;
npartitions = 1;
partition = new_partition ("");
if (dump_file)
@@ -816,8 +816,8 @@ lto_balanced_map (int n_lto_partitions, int max_partition_size)
fprintf (dump_file,
"Total size: %" PRId64 " partition_size: %" PRId64 "\n",
total_size, partition_size);
- if (partition_size < PARAM_VALUE (MIN_PARTITION_SIZE))
- partition_size = PARAM_VALUE (MIN_PARTITION_SIZE);
+ if (partition_size < param_min_partition_size)
+ partition_size = param_min_partition_size;
npartitions ++;
}
}
@@ -436,14 +436,14 @@ do_whole_program_analysis (void)
/* TODO: jobserver communication is not supported, yet. */
if (!strcmp (flag_wpa, "jobserver"))
- lto_parallelism = PARAM_VALUE (PARAM_MAX_LTO_STREAMING_PARALLELISM);
+ lto_parallelism = param_max_lto_streaming_parallelism;
else
{
lto_parallelism = atoi (flag_wpa);
if (lto_parallelism <= 0)
lto_parallelism = 0;
- if (lto_parallelism >= PARAM_VALUE (PARAM_MAX_LTO_STREAMING_PARALLELISM))
- lto_parallelism = PARAM_VALUE (PARAM_MAX_LTO_STREAMING_PARALLELISM);
+ if (lto_parallelism >= param_max_lto_streaming_parallelism)
+ lto_parallelism = param_max_lto_streaming_parallelism;
}
timevar_start (TV_PHASE_OPT_GEN);
@@ -492,8 +492,8 @@ do_whole_program_analysis (void)
else if (flag_lto_partition == LTO_PARTITION_ONE)
lto_balanced_map (1, INT_MAX);
else if (flag_lto_partition == LTO_PARTITION_BALANCED)
- lto_balanced_map (PARAM_VALUE (PARAM_LTO_PARTITIONS),
- PARAM_VALUE (MAX_PARTITION_SIZE));
+ lto_balanced_map (param_lto_partitions,
+ param_max_partition_size);
else
gcc_unreachable ();
@@ -1433,7 +1433,7 @@ sms_schedule (void)
if ( latch_edge->count () > profile_count::zero ()
&& (latch_edge->count()
< single_exit (loop)->count ().apply_scale
- (SMS_LOOP_AVERAGE_COUNT_THRESHOLD, 1)))
+ (param_sms_loop_average_count_threshold, 1)))
{
if (dump_file)
{
@@ -1640,7 +1640,7 @@ sms_schedule (void)
/* The default value of PARAM_SMS_MIN_SC is 2 as stage count of
1 means that there is no interleaving between iterations thus
we let the scheduling passes do the job in this case. */
- if (stage_count < PARAM_VALUE (PARAM_SMS_MIN_SC)
+ if (stage_count < param_sms_min_sc
|| (count_init && (loop_count <= stage_count))
|| (max_trip_count >= 0 && max_trip_count <= stage_count)
|| (trip_count >= 0 && trip_count <= stage_count))
@@ -1832,7 +1832,7 @@ sms_schedule (void)
/* A limit on the number of cycles that resource conflicts can span. ??? Should
be provided by DFA, and be dependent on the type of insn scheduled. Currently
set to 0 to save compile time. */
-#define DFA_HISTORY SMS_DFA_HISTORY
+#define DFA_HISTORY param_sms_dfa_history
/* A threshold for the number of repeated unsuccessful attempts to insert
an empty row, before we flush the partial schedule and start over. */
@@ -667,25 +667,18 @@ default_options_optimization (struct gcc_options *opts,
opts->x_flag_ipa_pta = true;
/* Track fields in field-sensitive alias analysis. */
- maybe_set_param_value
- (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE,
- opt2 ? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE),
- opts->x_param_values, opts_set->x_param_values);
+ if (opt2)
+ SET_OPTION_IF_UNSET (opts, opts_set, param_max_fields_for_field_sensitive,
+ 100);
if (opts->x_optimize_size)
/* We want to crossjump as much as possible. */
- maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS, 1,
- opts->x_param_values, opts_set->x_param_values);
- else
- maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS,
- default_param_value (PARAM_MIN_CROSSJUMP_INSNS),
- opts->x_param_values, opts_set->x_param_values);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_min_crossjump_insns, 1);
/* Restrict the amount of work combine does at -Og while retaining
most of its useful transforms. */
if (opts->x_optimize_debug)
- maybe_set_param_value (PARAM_MAX_COMBINE_INSNS, 2,
- opts->x_param_values, opts_set->x_param_values);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_max_combine_insns, 2);
/* Allow default optimizations to be specified on a per-machine basis. */
maybe_default_options (opts, opts_set,
@@ -1036,10 +1029,8 @@ finish_options (struct gcc_options *opts, struct gcc_options *opts_set,
if (opts->x_flag_conserve_stack)
{
- maybe_set_param_value (PARAM_LARGE_STACK_FRAME, 100,
- opts->x_param_values, opts_set->x_param_values);
- maybe_set_param_value (PARAM_STACK_FRAME_GROWTH, 40,
- opts->x_param_values, opts_set->x_param_values);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_large_stack_frame, 100);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_stack_frame_growth, 40);
}
if (opts->x_flag_lto)
@@ -2272,19 +2263,13 @@ common_handle_option (struct gcc_options *opts,
all features. */
if (opts->x_flag_sanitize & SANITIZE_KERNEL_ADDRESS)
{
- maybe_set_param_value (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD,
- 0, opts->x_param_values,
- opts_set->x_param_values);
- maybe_set_param_value (PARAM_ASAN_GLOBALS, 0, opts->x_param_values,
- opts_set->x_param_values);
- maybe_set_param_value (PARAM_ASAN_STACK, 0, opts->x_param_values,
- opts_set->x_param_values);
- maybe_set_param_value (PARAM_ASAN_PROTECT_ALLOCAS, 0,
- opts->x_param_values,
- opts_set->x_param_values);
- maybe_set_param_value (PARAM_ASAN_USE_AFTER_RETURN, 0,
- opts->x_param_values,
- opts_set->x_param_values);
+ SET_OPTION_IF_UNSET (opts, opts_set,
+ param_asan_instrumentation_with_call_threshold,
+ 0);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_asan_globals, 0);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_asan_stack, 0);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_asan_protect_allocas, 0);
+ SET_OPTION_IF_UNSET (opts, opts_set, param_asan_use_after_return, 0);
}
break;
@@ -2586,9 +2571,8 @@ common_handle_option (struct gcc_options *opts,
enable_fdo_optimizations (opts, opts_set, value);
if (!opts_set->x_flag_profile_correction)
opts->x_flag_profile_correction = value;
- maybe_set_param_value (
- PARAM_EARLY_INLINER_MAX_ITERATIONS, 10,
- opts->x_param_values, opts_set->x_param_values);
+ SET_OPTION_IF_UNSET (opts, opts_set,
+ param_early_inliner_max_iterations, 10);
break;
case OPT_fprofile_generate_:
@@ -1146,17 +1146,17 @@ eliminate_partially_redundant_load (basic_block bb, rtx_insn *insn,
/* Check if it's worth applying the partial redundancy elimination. */
if (ok_count.to_gcov_type ()
- < GCSE_AFTER_RELOAD_PARTIAL_FRACTION * not_ok_count.to_gcov_type ())
+ < param_gcse_after_reload_partial_fraction * not_ok_count.to_gcov_type ())
goto cleanup;
gcov_type threshold;
#if (GCC_VERSION >= 5000)
- if (__builtin_mul_overflow (GCSE_AFTER_RELOAD_CRITICAL_FRACTION,
+ if (__builtin_mul_overflow (param_gcse_after_reload_critical_fraction,
critical_count.to_gcov_type (), &threshold))
threshold = profile_count::max_count;
#else
threshold
- = GCSE_AFTER_RELOAD_CRITICAL_FRACTION * critical_count.to_gcov_type ();
+ = param_gcse_after_reload_critical_fraction * critical_count.to_gcov_type ();
#endif
if (ok_count.to_gcov_type () < threshold)
@@ -132,7 +132,7 @@ get_hot_bb_threshold ()
{
if (min_count == -1)
{
- const int hot_frac = PARAM_VALUE (HOT_BB_COUNT_FRACTION);
+ const int hot_frac = param_hot_bb_count_fraction;
const gcov_type min_hot_count
= hot_frac
? profile_info->sum_max / hot_frac
@@ -177,7 +177,7 @@ maybe_hot_count_p (struct function *fun, profile_count count)
if (node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
&& count < (ENTRY_BLOCK_PTR_FOR_FN (fun)->count.apply_scale (2, 3)))
return false;
- if (count.apply_scale (PARAM_VALUE (HOT_BB_FREQUENCY_FRACTION), 1)
+ if (count.apply_scale (param_hot_bb_frequency_fraction, 1)
< ENTRY_BLOCK_PTR_FOR_FN (fun)->count)
return false;
return true;
@@ -223,7 +223,7 @@ probably_never_executed (struct function *fun, profile_count count)
desirable. */
if (count.precise_p () && profile_status_for_fn (fun) == PROFILE_READ)
{
- const int unlikely_frac = PARAM_VALUE (UNLIKELY_BB_COUNT_FRACTION);
+ const int unlikely_frac = param_unlikely_bb_count_fraction;
if (count.apply_scale (unlikely_frac, 1) >= profile_info->runs)
return false;
return true;
@@ -412,9 +412,9 @@ predictable_edge_p (edge e)
if (!e->probability.initialized_p ())
return false;
if ((e->probability.to_reg_br_prob_base ()
- <= PARAM_VALUE (PARAM_PREDICTABLE_BRANCH_OUTCOME) * REG_BR_PROB_BASE / 100)
+ <= param_predictable_branch_outcome * REG_BR_PROB_BASE / 100)
|| (REG_BR_PROB_BASE - e->probability.to_reg_br_prob_base ()
- <= PARAM_VALUE (PARAM_PREDICTABLE_BRANCH_OUTCOME) * REG_BR_PROB_BASE / 100))
+ <= param_predictable_branch_outcome * REG_BR_PROB_BASE / 100))
return true;
return false;
}
@@ -1963,7 +1963,7 @@ predict_loops (void)
{
tree niter = NULL;
HOST_WIDE_INT nitercst;
- int max = PARAM_VALUE (PARAM_MAX_PREDICTED_ITERATIONS);
+ int max = param_max_predicted_iterations;
int probability;
enum br_predictor predictor;
widest_int nit;
@@ -2443,7 +2443,7 @@ expr_expected_value_1 (tree type, tree op0, enum tree_code code,
*predictor = (enum br_predictor) tree_to_uhwi (val2);
if (*predictor == PRED_BUILTIN_EXPECT)
*probability
- = HITRATE (PARAM_VALUE (BUILTIN_EXPECT_PROBABILITY));
+ = HITRATE (param_builtin_expect_probability);
return gimple_call_arg (def, 1);
}
return NULL;
@@ -2469,7 +2469,7 @@ expr_expected_value_1 (tree type, tree op0, enum tree_code code,
return val;
*predictor = PRED_BUILTIN_EXPECT;
*probability
- = HITRATE (PARAM_VALUE (BUILTIN_EXPECT_PROBABILITY));
+ = HITRATE (param_builtin_expect_probability);
return gimple_call_arg (def, 1);
}
case BUILT_IN_EXPECT_WITH_PROBABILITY:
@@ -2660,7 +2660,7 @@ tree_predict_by_opcode (basic_block bb)
edge e = find_taken_edge_switch_expr (sw, val);
if (predictor == PRED_BUILTIN_EXPECT)
{
- int percent = PARAM_VALUE (BUILTIN_EXPECT_PROBABILITY);
+ int percent = param_builtin_expect_probability;
gcc_assert (percent >= 0 && percent <= 100);
predict_edge (e, PRED_BUILTIN_EXPECT,
HITRATE (percent));
@@ -3531,7 +3531,7 @@ drop_profile (struct cgraph_node *node, profile_count call_count)
void
handle_missing_profiles (void)
{
- const int unlikely_frac = PARAM_VALUE (UNLIKELY_BB_COUNT_FRACTION);
+ const int unlikely_frac = param_unlikely_bb_count_fraction;
struct cgraph_node *node;
auto_vec<struct cgraph_node *, 64> worklist;
@@ -6717,7 +6717,7 @@ find_equiv_reg (rtx goal, rtx_insn *insn, enum reg_class rclass, int other,
continue;
num++;
if (p == 0 || LABEL_P (p)
- || num > PARAM_VALUE (PARAM_MAX_RELOAD_SEARCH_INSNS))
+ || num > param_max_reload_search_insns)
return 0;
/* Don't reuse register contents from before a setjmp-type
@@ -1489,7 +1489,7 @@ redundant_insn (rtx insn, rtx_insn *target, const vec<rtx_insn *> &delay_list)
/* Scan backwards looking for a match. */
for (trial = PREV_INSN (target),
- insns_to_search = MAX_DELAY_SLOT_INSN_SEARCH;
+ insns_to_search = param_max_delay_slot_insn_search;
trial && insns_to_search > 0;
trial = PREV_INSN (trial))
{
@@ -1593,7 +1593,7 @@ redundant_insn (rtx insn, rtx_insn *target, const vec<rtx_insn *> &delay_list)
INSN sets or sets something insn uses or sets. */
for (trial = PREV_INSN (target),
- insns_to_search = MAX_DELAY_SLOT_INSN_SEARCH;
+ insns_to_search = param_max_delay_slot_insn_search;
trial && !LABEL_P (trial) && insns_to_search > 0;
trial = PREV_INSN (trial))
{
@@ -928,7 +928,7 @@ mark_target_live_regs (rtx_insn *insns, rtx target_maybe_return, struct resource
}
if (b == -1)
- b = find_basic_block (target, MAX_DELAY_SLOT_LIVE_SEARCH);
+ b = find_basic_block (target, param_max_delay_slot_live_search);
if (target_hash_table != NULL)
{
@@ -1289,7 +1289,7 @@ clear_hashed_info_for_insn (rtx_insn *insn)
void
incr_ticks_for_insn (rtx_insn *insn)
{
- int b = find_basic_block (insn, MAX_DELAY_SLOT_LIVE_SEARCH);
+ int b = find_basic_block (insn, param_max_delay_slot_live_search);
if (b != -1)
bb_ticks[b]++;
@@ -1289,8 +1289,8 @@ pass_sanopt::execute (function *fun)
if (asan_sanitize_stack_p ())
sanitize_rewrite_addressable_params (fun);
- bool use_calls = ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD < INT_MAX
- && asan_num_accesses >= ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD;
+ bool use_calls = param_asan_instrumentation_with_call_threshold < INT_MAX
+ && asan_num_accesses >= param_asan_instrumentation_with_call_threshold;
hash_map<tree, tree> shadow_vars_mapping;
bool need_commit_edge_insert = false;
@@ -2480,7 +2480,7 @@ sched_analyze_1 (class deps_desc *deps, rtx x, rtx_insn *insn)
/* Pending lists can't get larger with a readonly context. */
if (!deps->readonly
&& ((deps->pending_read_list_length + deps->pending_write_list_length)
- >= MAX_PENDING_LIST_LENGTH))
+ >= param_max_pending_list_length))
{
/* Flush all pending reads and writes to prevent the pending lists
from getting any larger. Insn scheduling runs too slowly when
@@ -2697,7 +2697,7 @@ sched_analyze_2 (class deps_desc *deps, rtx x, rtx_insn *insn)
{
if ((deps->pending_read_list_length
+ deps->pending_write_list_length)
- >= MAX_PENDING_LIST_LENGTH
+ >= param_max_pending_list_length
&& !DEBUG_INSN_P (insn))
flush_pending_lists (deps, insn, true, true);
add_insn_mem_dependence (deps, true, insn, x);
@@ -3222,8 +3222,8 @@ sched_analyze_insn (class deps_desc *deps, rtx x, rtx_insn *insn)
EXECUTE_IF_SET_IN_REG_SET (reg_pending_clobbers, 0, i, rsi)
{
struct deps_reg *reg_last = &deps->reg_last[i];
- if (reg_last->uses_length >= MAX_PENDING_LIST_LENGTH
- || reg_last->clobbers_length >= MAX_PENDING_LIST_LENGTH)
+ if (reg_last->uses_length >= param_max_pending_list_length
+ || reg_last->clobbers_length >= param_max_pending_list_length)
{
add_dependence_list_and_free (deps, insn, ®_last->sets, 0,
REG_DEP_OUTPUT, false);
@@ -3679,7 +3679,7 @@ deps_analyze_insn (class deps_desc *deps, rtx_insn *insn)
&& sel_insn_is_speculation_check (insn)))
{
/* Keep the list a reasonable size. */
- if (deps->pending_flush_length++ >= MAX_PENDING_LIST_LENGTH)
+ if (deps->pending_flush_length++ >= param_max_pending_list_length)
flush_pending_lists (deps, insn, true, true);
else
deps->pending_jump_insns
@@ -620,9 +620,9 @@ schedule_ebbs (void)
return;
if (profile_info && profile_status_for_fn (cfun) == PROFILE_READ)
- probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY_FEEDBACK);
+ probability_cutoff = param_tracer_min_branch_probability_feedback;
else
- probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY);
+ probability_cutoff = param_tracer_min_branch_probability;
probability_cutoff = REG_BR_PROB_BASE / 100 * probability_cutoff;
schedule_ebbs_init ();
@@ -485,9 +485,9 @@ find_single_block_region (bool ebbs_p)
if (ebbs_p) {
int probability_cutoff;
if (profile_info && profile_status_for_fn (cfun) == PROFILE_READ)
- probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY_FEEDBACK);
+ probability_cutoff = param_tracer_min_branch_probability_feedback;
else
- probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY);
+ probability_cutoff = param_tracer_min_branch_probability;
probability_cutoff = REG_BR_PROB_BASE / 100 * probability_cutoff;
FOR_EACH_BB_FN (ebb_start, cfun)
@@ -569,8 +569,8 @@ too_large (int block, int *num_bbs, int *num_insns)
(*num_insns) += (common_sched_info->estimate_number_of_insns
(BASIC_BLOCK_FOR_FN (cfun, block)));
- return ((*num_bbs > PARAM_VALUE (PARAM_MAX_SCHED_REGION_BLOCKS))
- || (*num_insns > PARAM_VALUE (PARAM_MAX_SCHED_REGION_INSNS)));
+ return ((*num_bbs > param_max_sched_region_blocks)
+ || (*num_insns > param_max_sched_region_insns));
}
/* Update_loop_relations(blk, hdr): Check if the loop headed by max_hdr[blk]
@@ -800,7 +800,7 @@ haifa_find_rgns (void)
queue = XNEWVEC (int, n_basic_blocks_for_fn (cfun));
- extend_regions_p = PARAM_VALUE (PARAM_MAX_SCHED_EXTEND_REGIONS_ITERS) > 0;
+ extend_regions_p = param_max_sched_extend_regions_iters > 0;
if (extend_regions_p)
{
degree1 = XNEWVEC (int, last_basic_block_for_fn (cfun));
@@ -1161,7 +1161,7 @@ extend_rgns (int *degree, int *idxp, sbitmap header, int *loop_hdr)
int *order, i, rescan = 0, idx = *idxp, iter = 0, max_iter, *max_hdr;
int nblocks = n_basic_blocks_for_fn (cfun) - NUM_FIXED_BLOCKS;
- max_iter = PARAM_VALUE (PARAM_MAX_SCHED_EXTEND_REGIONS_ITERS);
+ max_iter = param_max_sched_extend_regions_iters;
max_hdr = XNEWVEC (int, last_basic_block_for_fn (cfun));
@@ -2224,7 +2224,7 @@ new_ready (rtx_insn *next, ds_t ts)
|| (IS_SPECULATIVE_INSN (next)
&& ((recog_memoized (next) >= 0
&& min_insn_conflict_delay (curr_state, next, next)
- > PARAM_VALUE (PARAM_MAX_SCHED_INSN_CONFLICT_DELAY))
+ > param_max_sched_insn_conflict_delay)
|| IS_SPECULATION_CHECK_P (next)
|| !check_live (next, INSN_BB (next))
|| (not_ex_free = !is_exception_free (next, INSN_BB (next),
@@ -3189,7 +3189,7 @@ schedule_region (int rgn)
if (f
&& (!f->probability.initialized_p ()
|| f->probability.to_reg_br_prob_base () * 100 / REG_BR_PROB_BASE >=
- PARAM_VALUE (PARAM_SCHED_STATE_EDGE_PROB_CUTOFF)))
+ param_sched_state_edge_prob_cutoff))
{
memcpy (bb_state[f->dest->index], curr_state,
dfa_state_size);
@@ -3229,7 +3229,7 @@ schedule_region (int rgn)
void
sched_rgn_init (bool single_blocks_p)
{
- min_spec_prob = ((PARAM_VALUE (PARAM_MIN_SPEC_PROB) * REG_BR_PROB_BASE)
+ min_spec_prob = ((param_min_spec_prob * REG_BR_PROB_BASE)
/ 100);
nr_inter = 0;
@@ -6012,7 +6012,7 @@ make_region_from_loop (class loop *loop)
basic_block preheader_block;
if (loop->num_nodes
- > (unsigned) PARAM_VALUE (PARAM_MAX_PIPELINE_REGION_BLOCKS))
+ > (unsigned) param_max_pipeline_region_blocks)
return -1;
/* Don't pipeline loops whose latch belongs to some of its inner loops. */
@@ -6021,7 +6021,7 @@ make_region_from_loop (class loop *loop)
return -1;
loop->ninsns = num_loop_insns (loop);
- if ((int) loop->ninsns > PARAM_VALUE (PARAM_MAX_PIPELINE_REGION_INSNS))
+ if ((int) loop->ninsns > param_max_pipeline_region_insns)
return -1;
loop_blocks = get_loop_body_in_custom_order (loop, bb_top_order_comparator);
@@ -969,7 +969,7 @@ extern bool preheader_removed;
/* Software lookahead window size.
According to the results in Nakatani and Ebcioglu [1993], window size of 16
is enough to extract most ILP in integer code. */
-#define MAX_WS (PARAM_VALUE (PARAM_SELSCHED_MAX_LOOKAHEAD))
+#define MAX_WS (param_selsched_max_lookahead)
extern regset sel_all_regs;
@@ -3454,7 +3454,7 @@ process_pipelined_exprs (av_set_t *av_ptr)
FOR_EACH_EXPR_1 (expr, si, av_ptr)
{
if (EXPR_SCHED_TIMES (expr)
- >= PARAM_VALUE (PARAM_SELSCHED_MAX_SCHED_TIMES))
+ >= param_selsched_max_sched_times)
av_set_iter_remove (&si);
}
}
@@ -6806,7 +6806,7 @@ sel_setup_region_sched_flags (void)
&& (flag_sel_sched_pipelining != 0)
&& current_loop_nest != NULL
&& loop_has_exit_edges (current_loop_nest));
- max_insns_to_rename = PARAM_VALUE (PARAM_SELSCHED_INSNS_TO_RENAME);
+ max_insns_to_rename = param_selsched_insns_to_rename;
max_ws = MAX_WS;
}
@@ -775,7 +775,7 @@ try_shrink_wrapping (edge *entry_edge, rtx_insn *prologue_seq)
vec.quick_push (pro);
unsigned max_grow_size = get_uncond_jump_length ();
- max_grow_size *= PARAM_VALUE (PARAM_MAX_GROW_COPY_BB_INSNS);
+ max_grow_size *= param_max_grow_copy_bb_insns;
while (!vec.is_empty () && pro != entry)
{
@@ -2274,17 +2274,18 @@ default_max_noce_ifcvt_seq_cost (edge e)
{
bool predictable_p = predictable_edge_p (e);
- enum compiler_param param
- = (predictable_p
- ? PARAM_MAX_RTL_IF_CONVERSION_PREDICTABLE_COST
- : PARAM_MAX_RTL_IF_CONVERSION_UNPREDICTABLE_COST);
-
- /* If we have a parameter set, use that, otherwise take a guess using
- BRANCH_COST. */
- if (global_options_set.x_param_values[param])
- return PARAM_VALUE (param);
+ if (predictable_p)
+ {
+ if (global_options_set.x_param_max_rtl_if_conversion_predictable_cost)
+ return param_max_rtl_if_conversion_predictable_cost;
+ }
else
- return BRANCH_COST (true, predictable_p) * COSTS_N_INSNS (3);
+ {
+ if (global_options_set.x_param_max_rtl_if_conversion_unpredictable_cost)
+ return param_max_rtl_if_conversion_unpredictable_cost;
+ }
+
+ return BRANCH_COST (true, predictable_p) * COSTS_N_INSNS (3);
}
/* Default implementation of TARGET_MIN_ARITHMETIC_PRECISION. */
@@ -679,7 +679,7 @@ print_version (FILE *file, const char *indent, bool show_global_state)
fprintf (file,
file == stderr ? _(fmt4) : fmt4,
indent, *indent != 0 ? " " : "",
- PARAM_VALUE (GGC_MIN_EXPAND), PARAM_VALUE (GGC_MIN_HEAPSIZE));
+ param_ggc_min_expand, param_ggc_min_heapsize);
print_plugins_versions (file, indent);
}
@@ -1863,7 +1863,7 @@ process_options (void)
if (flag_checking >= 2)
hash_table_sanitize_eq_limit
- = PARAM_VALUE (PARAM_HASH_TABLE_VERIFICATION_LIMIT);
+ = param_hash_table_verification_limit;
/* Please don't change global_options after this point, those changes won't
be reflected in optimization_{default,current}_node. */
@@ -276,13 +276,13 @@ tail_duplicate (void)
initialize_original_copy_tables ();
if (profile_info && profile_status_for_fn (cfun) == PROFILE_READ)
- probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY_FEEDBACK);
+ probability_cutoff = param_tracer_min_branch_probability_feedback;
else
- probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY);
+ probability_cutoff = param_tracer_min_branch_probability;
probability_cutoff = REG_BR_PROB_BASE / 100 * probability_cutoff;
branch_ratio_cutoff =
- (REG_BR_PROB_BASE / 100 * PARAM_VALUE (TRACER_MIN_BRANCH_RATIO));
+ (REG_BR_PROB_BASE / 100 * param_tracer_min_branch_ratio);
FOR_EACH_BB_FN (bb, cfun)
{
@@ -296,11 +296,11 @@ tail_duplicate (void)
}
if (profile_info && profile_status_for_fn (cfun) == PROFILE_READ)
- cover_insns = PARAM_VALUE (TRACER_DYNAMIC_COVERAGE_FEEDBACK);
+ cover_insns = param_tracer_dynamic_coverage_feedback;
else
- cover_insns = PARAM_VALUE (TRACER_DYNAMIC_COVERAGE);
+ cover_insns = param_tracer_dynamic_coverage;
cover_insns = (weighted_insns * cover_insns + 50) / 100;
- max_dup_insns = (ninsns * PARAM_VALUE (TRACER_MAX_CODE_GROWTH) + 50) / 100;
+ max_dup_insns = (ninsns * param_tracer_max_code_growth + 50) / 100;
while (traced_insns < cover_insns && nduplicated < max_dup_insns
&& !heap.empty ())
@@ -1108,7 +1108,7 @@ tm_log_add (basic_block entry_block, tree addr, gimple *stmt)
&& TYPE_SIZE_UNIT (type) != NULL
&& tree_fits_uhwi_p (TYPE_SIZE_UNIT (type))
&& ((HOST_WIDE_INT) tree_to_uhwi (TYPE_SIZE_UNIT (type))
- < PARAM_VALUE (PARAM_TM_MAX_AGGREGATE_SIZE))
+ < param_tm_max_aggregate_size)
/* We must be able to copy this type normally. I.e., no
special constructors and the like. */
&& !TREE_ADDRESSABLE (type))
@@ -333,9 +333,9 @@ chrec_fold_plus_1 (enum tree_code code, tree type,
int size = 0;
if ((tree_contains_chrecs (op0, &size)
|| tree_contains_chrecs (op1, &size))
- && size < PARAM_VALUE (PARAM_SCEV_MAX_EXPR_SIZE))
+ && size < param_scev_max_expr_size)
return build2 (code, type, op0, op1);
- else if (size < PARAM_VALUE (PARAM_SCEV_MAX_EXPR_SIZE))
+ else if (size < param_scev_max_expr_size)
{
if (code == POINTER_PLUS_EXPR)
return fold_build_pointer_plus (fold_convert (type, op0),
@@ -836,7 +836,7 @@ split_constant_offset (tree exp, tree *var, tree *off,
void
split_constant_offset (tree exp, tree *var, tree *off)
{
- unsigned limit = PARAM_VALUE (PARAM_SSA_NAME_DEF_CHAIN_LIMIT);
+ unsigned limit = param_ssa_name_def_chain_limit;
static hash_map<tree, std::pair<tree, tree> > *cache;
if (!cache)
cache = new hash_map<tree, std::pair<tree, tree> > (37);
@@ -4917,7 +4917,7 @@ compute_all_dependences (vec<data_reference_p> datarefs,
unsigned int i, j;
if ((int) datarefs.length ()
- > PARAM_VALUE (PARAM_LOOP_MAX_DATAREFS_FOR_DATADEPS))
+ > param_loop_max_datarefs_for_datadeps)
{
struct data_dependence_relation *ddr;
@@ -125,7 +125,7 @@ along with GCC; see the file COPYING3. If not see
/* Only handle PHIs with no more arguments unless we are asked to by
simd pragma. */
#define MAX_PHI_ARG_NUM \
- ((unsigned) PARAM_VALUE (PARAM_MAX_TREE_IF_CONVERSION_PHI_ARGS))
+ ((unsigned) param_max_tree_if_conversion_phi_args)
/* True if we've converted a statement that was only executed when some
condition C was true, and if for correctness we need to predicate the
@@ -1812,7 +1812,7 @@ remap_gimple_stmt (gimple *stmt, copy_body_data *id)
/* If the inlined function has too many debug markers,
don't copy them. */
if (id->src_cfun->debug_marker_count
- > PARAM_VALUE (PARAM_MAX_DEBUG_MARKER_COUNT))
+ > param_max_debug_marker_count)
return stmts;
gdebug *copy = as_a <gdebug *> (gimple_copy (stmt));
@@ -119,7 +119,7 @@ along with GCC; see the file COPYING3. If not see
#define MAX_DATAREFS_NUM \
- ((unsigned) PARAM_VALUE (PARAM_LOOP_MAX_DATAREFS_FOR_DATADEPS))
+ ((unsigned) param_loop_max_datarefs_for_datadeps)
/* Threshold controlling number of distributed partitions. Given it may
be unnecessary if a memory stream cost model is invented in the future,
@@ -890,7 +890,7 @@ parloops_force_simple_reduction (loop_vec_info loop_info, stmt_vec_info phi_info
/* Minimal number of iterations of a loop that should be executed in each
thread. */
-#define MIN_PER_THREAD PARAM_VALUE (PARAM_PARLOOPS_MIN_PER_THREAD)
+#define MIN_PER_THREAD param_parloops_min_per_thread
/* Element of the hashtable, representing a
reduction in the current loop. */
@@ -2875,25 +2875,23 @@ create_parallel_loop (class loop *loop, tree loop_fn, tree data,
else
{
t = build_omp_clause (loc, OMP_CLAUSE_SCHEDULE);
- int chunk_size = PARAM_VALUE (PARAM_PARLOOPS_CHUNK_SIZE);
- enum PARAM_PARLOOPS_SCHEDULE_KIND schedule_type \
- = (enum PARAM_PARLOOPS_SCHEDULE_KIND) PARAM_VALUE (PARAM_PARLOOPS_SCHEDULE);
- switch (schedule_type)
+ int chunk_size = param_parloops_chunk_size;
+ switch (param_parloops_schedule)
{
- case PARAM_PARLOOPS_SCHEDULE_KIND_static:
+ case PARLOOPS_SCHEDULE_STATIC:
OMP_CLAUSE_SCHEDULE_KIND (t) = OMP_CLAUSE_SCHEDULE_STATIC;
break;
- case PARAM_PARLOOPS_SCHEDULE_KIND_dynamic:
+ case PARLOOPS_SCHEDULE_DYNAMIC:
OMP_CLAUSE_SCHEDULE_KIND (t) = OMP_CLAUSE_SCHEDULE_DYNAMIC;
break;
- case PARAM_PARLOOPS_SCHEDULE_KIND_guided:
+ case PARLOOPS_SCHEDULE_GUIDED:
OMP_CLAUSE_SCHEDULE_KIND (t) = OMP_CLAUSE_SCHEDULE_GUIDED;
break;
- case PARAM_PARLOOPS_SCHEDULE_KIND_auto:
+ case PARLOOPS_SCHEDULE_AUTO:
OMP_CLAUSE_SCHEDULE_KIND (t) = OMP_CLAUSE_SCHEDULE_AUTO;
chunk_size = 0;
break;
- case PARAM_PARLOOPS_SCHEDULE_KIND_runtime:
+ case PARLOOPS_SCHEDULE_RUNTIME:
OMP_CLAUSE_SCHEDULE_KIND (t) = OMP_CLAUSE_SCHEDULE_RUNTIME;
chunk_size = 0;
break;
@@ -2194,7 +2194,7 @@ determine_unroll_factor (vec<chain_p> chains)
{
chain_p chain;
unsigned factor = 1, af, nfactor, i;
- unsigned max = PARAM_VALUE (PARAM_MAX_UNROLL_TIMES);
+ unsigned max = param_max_unroll_times;
FOR_EACH_VEC_ELT (chains, i, chain)
{
@@ -1149,7 +1149,7 @@ tail_recurse:
return t_false;
/* Give up if the path is longer than the MAX that we allow. */
- if (limit > PARAM_VALUE (PARAM_SCEV_MAX_EXPR_COMPLEXITY))
+ if (limit > param_scev_max_expr_complexity)
{
*evolution_of_loop = chrec_dont_know;
return t_dont_know;
@@ -2623,7 +2623,7 @@ instantiate_scev_r (edge instantiate_below,
bool *fold_conversions, int size_expr)
{
/* Give up if the expression is larger than the MAX that we allow. */
- if (size_expr++ > PARAM_VALUE (PARAM_SCEV_MAX_EXPR_SIZE))
+ if (size_expr++ > param_scev_max_expr_size)
return chrec_dont_know;
if (chrec == NULL_TREE
@@ -2786,16 +2786,21 @@ analyze_all_variable_accesses (void)
unsigned i;
bool optimize_speed_p = !optimize_function_for_size_p (cfun);
- enum compiler_param param = optimize_speed_p
- ? PARAM_SRA_MAX_SCALARIZATION_SIZE_SPEED
- : PARAM_SRA_MAX_SCALARIZATION_SIZE_SIZE;
-
/* If the user didn't set PARAM_SRA_MAX_SCALARIZATION_SIZE_<...>,
fall back to a target default. */
unsigned HOST_WIDE_INT max_scalarization_size
- = global_options_set.x_param_values[param]
- ? PARAM_VALUE (param)
- : get_move_ratio (optimize_speed_p) * UNITS_PER_WORD;
+ = get_move_ratio (optimize_speed_p) * UNITS_PER_WORD;
+
+ if (optimize_speed_p)
+ {
+ if (global_options_set.x_param_sra_max_scalarization_size_speed)
+ max_scalarization_size = param_sra_max_scalarization_size_speed;
+ }
+ else
+ {
+ if (global_options_set.x_param_sra_max_scalarization_size_size)
+ max_scalarization_size = param_sra_max_scalarization_size_size;
+ }
max_scalarization_size *= BITS_PER_UNIT;
@@ -2195,7 +2195,7 @@ fold_builtin_alloca_with_align (gimple *stmt)
size = tree_to_uhwi (arg);
/* Heuristic: don't fold large allocas. */
- threshold = (unsigned HOST_WIDE_INT)PARAM_VALUE (PARAM_LARGE_STACK_FRAME);
+ threshold = (unsigned HOST_WIDE_INT)param_large_stack_frame;
/* In case the alloca is located at function entry, it has the same lifetime
as a declared array, so we allow a larger size. */
block = gimple_block (stmt);
@@ -238,7 +238,7 @@ setup_live_bytes_from_ref (ao_ref *ref, sbitmap live_bytes)
if (valid_ao_ref_for_dse (ref)
&& ref->size.is_constant (&const_size)
&& (const_size / BITS_PER_UNIT
- <= PARAM_VALUE (PARAM_DSE_MAX_OBJECT_SIZE)))
+ <= param_dse_max_object_size))
{
bitmap_clear (live_bytes);
bitmap_set_range (live_bytes, 0, const_size / BITS_PER_UNIT);
@@ -611,7 +611,7 @@ dse_optimize_redundant_stores (gimple *stmt)
FOR_EACH_IMM_USE_STMT (use_stmt, ui, defvar)
{
/* Limit stmt walking. */
- if (++cnt > PARAM_VALUE (PARAM_DSE_MAX_ALIAS_QUERIES_PER_STORE))
+ if (++cnt > param_dse_max_alias_queries_per_store)
BREAK_FROM_IMM_USE_STMT (ui);
/* If USE_STMT stores 0 into one or more of the same locations
@@ -704,7 +704,7 @@ dse_classify_store (ao_ref *ref, gimple *stmt,
FOR_EACH_IMM_USE_STMT (use_stmt, ui, defvar)
{
/* Limit stmt walking. */
- if (++cnt > PARAM_VALUE (PARAM_DSE_MAX_ALIAS_QUERIES_PER_STORE))
+ if (++cnt > param_dse_max_alias_queries_per_store)
{
fail = true;
BREAK_FROM_IMM_USE_STMT (ui);
@@ -853,7 +853,7 @@ class dse_dom_walker : public dom_walker
public:
dse_dom_walker (cdi_direction direction)
: dom_walker (direction),
- m_live_bytes (PARAM_VALUE (PARAM_DSE_MAX_OBJECT_SIZE)),
+ m_live_bytes (param_dse_max_object_size),
m_byte_tracking_enabled (false) {}
virtual edge before_dom_children (basic_block);
@@ -565,9 +565,9 @@ ifcombine_ifandif (basic_block inner_cond_bb, bool inner_inv,
tree t1, t2;
gimple_stmt_iterator gsi;
bool logical_op_non_short_circuit = LOGICAL_OP_NON_SHORT_CIRCUIT;
- if (PARAM_VALUE (PARAM_LOGICAL_OP_NON_SHORT_CIRCUIT) != -1)
+ if (param_logical_op_non_short_circuit != -1)
logical_op_non_short_circuit
- = PARAM_VALUE (PARAM_LOGICAL_OP_NON_SHORT_CIRCUIT);
+ = param_logical_op_non_short_circuit;
if (!logical_op_non_short_circuit || flag_sanitize_coverage)
return false;
/* Only do this optimization if the inner bb contains only the conditional. */
@@ -368,7 +368,7 @@ ch_base::copy_headers (function *fun)
FOR_EACH_LOOP (loop, 0)
{
- int initial_limit = PARAM_VALUE (PARAM_MAX_LOOP_HEADER_INSNS);
+ int initial_limit = param_max_loop_header_insns;
int remaining_limit = initial_limit;
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
@@ -230,7 +230,7 @@ static bool ref_indep_loop_p (class loop *, im_mem_ref *);
static bool ref_always_accessed_p (class loop *, im_mem_ref *, bool);
/* Minimum cost of an expensive expression. */
-#define LIM_EXPENSIVE ((unsigned) PARAM_VALUE (PARAM_LIM_EXPENSIVE))
+#define LIM_EXPENSIVE ((unsigned) param_lim_expensive)
/* The outermost loop for which execution of the header guarantees that the
block will be executed. */
@@ -739,7 +739,7 @@ try_unroll_loop_completely (class loop *loop,
return false;
if (!loop->unroll
- && n_unroll > (unsigned) PARAM_VALUE (PARAM_MAX_COMPLETELY_PEEL_TIMES))
+ && n_unroll > (unsigned) param_max_completely_peel_times)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Not unrolling loop %d "
@@ -780,7 +780,7 @@ try_unroll_loop_completely (class loop *loop,
bool large
= tree_estimate_loop_size
(loop, remove_exit ? exit : NULL, edge_to_cancel, &size,
- PARAM_VALUE (PARAM_MAX_COMPLETELY_PEELED_INSNS));
+ param_max_completely_peeled_insns);
if (large)
{
if (dump_file && (dump_flags & TDF_DETAILS))
@@ -864,7 +864,7 @@ try_unroll_loop_completely (class loop *loop,
blow the branch predictor tables. Limit number of
branches on the hot path through the peeled sequence. */
else if (size.num_branches_on_hot_path * (int)n_unroll
- > PARAM_VALUE (PARAM_MAX_PEEL_BRANCHES))
+ > param_max_peel_branches)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Not unrolling loop %d: "
@@ -874,7 +874,7 @@ try_unroll_loop_completely (class loop *loop,
return false;
}
else if (unr_insns
- > (unsigned) PARAM_VALUE (PARAM_MAX_COMPLETELY_PEELED_INSNS))
+ > (unsigned) param_max_completely_peeled_insns)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Not unrolling loop %d: "
@@ -998,7 +998,7 @@ try_peel_loop (class loop *loop,
int peeled_size;
if (!flag_peel_loops
- || PARAM_VALUE (PARAM_MAX_PEEL_TIMES) <= 0
+ || param_max_peel_times <= 0
|| !peeled_loops)
return false;
@@ -1057,7 +1057,7 @@ try_peel_loop (class loop *loop,
/* We want to peel estimated number of iterations + 1 (so we never
enter the loop on quick path). Check against PARAM_MAX_PEEL_TIMES
and be sure to avoid overflows. */
- if (npeel > PARAM_VALUE (PARAM_MAX_PEEL_TIMES) - 1)
+ if (npeel > param_max_peel_times - 1)
{
if (dump_file)
fprintf (dump_file, "Not peeling: rolls too much "
@@ -1068,9 +1068,9 @@ try_peel_loop (class loop *loop,
/* Check peeled loops size. */
tree_estimate_loop_size (loop, exit, NULL, &size,
- PARAM_VALUE (PARAM_MAX_PEELED_INSNS));
+ param_max_peeled_insns);
if ((peeled_size = estimated_peeled_sequence_size (&size, (int) npeel))
- > PARAM_VALUE (PARAM_MAX_PEELED_INSNS))
+ > param_max_peeled_insns)
{
if (dump_file)
fprintf (dump_file, "Not peeling: peeled sequence size is too large "
@@ -1502,7 +1502,7 @@ tree_unroll_loops_completely (bool may_increase_size, bool unroll_outer)
BITMAP_FREE (loop_closed_ssa_invalidated);
}
while (changed
- && ++iteration <= PARAM_VALUE (PARAM_MAX_UNROLL_ITERATIONS));
+ && ++iteration <= param_max_unroll_iterations);
BITMAP_FREE (father_bbs);
@@ -151,8 +151,8 @@ avg_loop_niter (class loop *loop)
{
niter = likely_max_stmt_executions_int (loop);
- if (niter == -1 || niter > PARAM_VALUE (PARAM_AVG_LOOP_NITER))
- return PARAM_VALUE (PARAM_AVG_LOOP_NITER);
+ if (niter == -1 || niter > param_avg_loop_niter)
+ return param_avg_loop_niter;
}
return niter;
@@ -715,19 +715,19 @@ struct iv_ca_delta
/* Bound on number of candidates below that all candidates are considered. */
#define CONSIDER_ALL_CANDIDATES_BOUND \
- ((unsigned) PARAM_VALUE (PARAM_IV_CONSIDER_ALL_CANDIDATES_BOUND))
+ ((unsigned) param_iv_consider_all_candidates_bound)
/* If there are more iv occurrences, we just give up (it is quite unlikely that
optimizing such a loop would help, and it would take ages). */
#define MAX_CONSIDERED_GROUPS \
- ((unsigned) PARAM_VALUE (PARAM_IV_MAX_CONSIDERED_USES))
+ ((unsigned) param_iv_max_considered_uses)
/* If there are at most this number of ivs in the set, try removing unnecessary
ivs from the set always. */
#define ALWAYS_PRUNE_CAND_SET_BOUND \
- ((unsigned) PARAM_VALUE (PARAM_IV_ALWAYS_PRUNE_CAND_SET_BOUND))
+ ((unsigned) param_iv_always_prune_cand_set_bound)
/* The list of trees for that the decl_rtl field must be reset is stored
here. */
@@ -984,7 +984,7 @@ can_unroll_loop_p (class loop *loop, unsigned factor,
/* The final loop should be small enough. */
if (tree_num_loop_insns (loop, &eni_size_weights) * factor
- > (unsigned) PARAM_VALUE (PARAM_MAX_UNROLLED_INSNS))
+ > (unsigned) param_max_unrolled_insns)
return false;
return true;
@@ -2863,7 +2863,7 @@ finite_loop_p (class loop *loop)
/* Bound on the number of iterations we try to evaluate. */
#define MAX_ITERATIONS_TO_TRACK \
- ((unsigned) PARAM_VALUE (PARAM_MAX_ITERATIONS_TO_TRACK))
+ ((unsigned) param_max_iterations_to_track)
/* Returns the loop phi node of LOOP such that ssa name X is derived from its
result by a chain of operations such that all but exactly one of their
@@ -167,7 +167,7 @@ along with GCC; see the file COPYING3. If not see
of cache hierarchy). */
#ifndef PREFETCH_BLOCK
-#define PREFETCH_BLOCK L1_CACHE_LINE_SIZE
+#define PREFETCH_BLOCK param_l1_cache_line_size
#endif
/* Do we have a forward hardware sequential prefetching? */
@@ -191,8 +191,8 @@ along with GCC; see the file COPYING3. If not see
#define ACCEPTABLE_MISS_RATE 50
#endif
-#define L1_CACHE_SIZE_BYTES ((unsigned) (L1_CACHE_SIZE * 1024))
-#define L2_CACHE_SIZE_BYTES ((unsigned) (L2_CACHE_SIZE * 1024))
+#define L1_CACHE_SIZE_BYTES ((unsigned) (param_l1_cache_size * 1024))
+#define L2_CACHE_SIZE_BYTES ((unsigned) (param_l2_cache_size * 1024))
/* We consider a memory access nontemporal if it is not reused sooner than
after L2_CACHE_SIZE_BYTES of memory are accessed. However, we ignore
@@ -993,7 +993,7 @@ static bool
should_issue_prefetch_p (struct mem_ref *ref)
{
/* Do we want to issue prefetches for non-constant strides? */
- if (!cst_and_fits_in_hwi (ref->group->step) && PREFETCH_DYNAMIC_STRIDES == 0)
+ if (!cst_and_fits_in_hwi (ref->group->step) && param_prefetch_dynamic_strides == 0)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
@@ -1008,14 +1008,14 @@ should_issue_prefetch_p (struct mem_ref *ref)
range. */
if (cst_and_fits_in_hwi (ref->group->step)
&& abs_hwi (int_cst_value (ref->group->step))
- < (HOST_WIDE_INT) PREFETCH_MINIMUM_STRIDE)
+ < (HOST_WIDE_INT) param_prefetch_minimum_stride)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
"Step for reference %u:%u (" HOST_WIDE_INT_PRINT_DEC
") is less than the mininum required stride of %d\n",
ref->group->uid, ref->uid, int_cst_value (ref->group->step),
- PREFETCH_MINIMUM_STRIDE);
+ param_prefetch_minimum_stride);
return false;
}
@@ -1055,8 +1055,8 @@ schedule_prefetches (struct mem_ref_group *groups, unsigned unroll_factor,
struct mem_ref *ref;
bool any = false;
- /* At most SIMULTANEOUS_PREFETCHES should be running at the same time. */
- remaining_prefetch_slots = SIMULTANEOUS_PREFETCHES;
+ /* At most param_simultaneous_prefetches should be running at the same time. */
+ remaining_prefetch_slots = param_simultaneous_prefetches;
/* The prefetch will run for AHEAD iterations of the original loop, i.e.,
AHEAD / UNROLL_FACTOR iterations of the unrolled loop. In each iteration,
@@ -1406,7 +1406,7 @@ determine_unroll_factor (class loop *loop, struct mem_ref_group *refs,
us from unrolling the loops too many times in cases where we only expect
gains from better scheduling and decreasing loop overhead, which is not
the case here. */
- upper_bound = PARAM_VALUE (PARAM_MAX_UNROLLED_INSNS) / ninsns;
+ upper_bound = param_max_unrolled_insns / ninsns;
/* If we unrolled the loop more times than it iterates, the unrolled version
of the loop would be never entered. */
@@ -1459,7 +1459,7 @@ volume_of_references (struct mem_ref_group *refs)
accessed in each iteration. TODO -- in the latter case, we should
take the size of the reference into account, rounding it up on cache
line size multiple. */
- volume += L1_CACHE_LINE_SIZE / ref->prefetch_mod;
+ volume += param_l1_cache_line_size / ref->prefetch_mod;
}
return volume;
}
@@ -1512,7 +1512,7 @@ add_subscript_strides (tree access_fn, unsigned stride,
if (tree_fits_shwi_p (step))
astep = tree_to_shwi (step);
else
- astep = L1_CACHE_LINE_SIZE;
+ astep = param_l1_cache_line_size;
strides[n - 1 - loop_depth (loop) + loop_depth (aloop)] += astep * stride;
@@ -1562,7 +1562,7 @@ self_reuse_distance (data_reference_p dr, unsigned *loop_sizes, unsigned n,
if (tree_fits_uhwi_p (stride))
astride = tree_to_uhwi (stride);
else
- astride = L1_CACHE_LINE_SIZE;
+ astride = param_l1_cache_line_size;
ref = TREE_OPERAND (ref, 0);
}
@@ -1578,7 +1578,7 @@ self_reuse_distance (data_reference_p dr, unsigned *loop_sizes, unsigned n,
s = strides[i] < 0 ? -strides[i] : strides[i];
- if (s < (unsigned) L1_CACHE_LINE_SIZE
+ if (s < (unsigned) param_l1_cache_line_size
&& (loop_sizes[i]
> (unsigned) (L1_CACHE_SIZE_BYTES / NONTEMPORAL_FRACTION)))
{
@@ -1825,7 +1825,7 @@ mem_ref_count_reasonable_p (unsigned ninsns, unsigned mem_ref_count)
should account for cache misses. */
insn_to_mem_ratio = ninsns / mem_ref_count;
- if (insn_to_mem_ratio < PREFETCH_MIN_INSN_TO_MEM_RATIO)
+ if (insn_to_mem_ratio < param_prefetch_min_insn_to_mem_ratio)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
@@ -1862,7 +1862,7 @@ insn_to_prefetch_ratio_too_small_p (unsigned ninsns, unsigned prefetch_count,
and the exit branches will get eliminated), so it might be better to use
tree_estimate_loop_size + estimated_unrolled_size. */
insn_to_prefetch_ratio = (unroll_factor * ninsns) / prefetch_count;
- if (insn_to_prefetch_ratio < MIN_INSN_TO_PREFETCH_RATIO)
+ if (insn_to_prefetch_ratio < param_min_insn_to_prefetch_ratio)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
@@ -1902,7 +1902,7 @@ loop_prefetch_arrays (class loop *loop)
if (time == 0)
return false;
- ahead = (PREFETCH_LATENCY + time - 1) / time;
+ ahead = (param_prefetch_latency + time - 1) / time;
est_niter = estimated_stmt_executions_int (loop);
if (est_niter == -1)
est_niter = likely_max_stmt_executions_int (loop);
@@ -1998,17 +1998,17 @@ tree_ssa_prefetch_arrays (void)
{
fprintf (dump_file, "Prefetching parameters:\n");
fprintf (dump_file, " simultaneous prefetches: %d\n",
- SIMULTANEOUS_PREFETCHES);
- fprintf (dump_file, " prefetch latency: %d\n", PREFETCH_LATENCY);
+ param_simultaneous_prefetches);
+ fprintf (dump_file, " prefetch latency: %d\n", param_prefetch_latency);
fprintf (dump_file, " prefetch block size: %d\n", PREFETCH_BLOCK);
fprintf (dump_file, " L1 cache size: %d lines, %d kB\n",
- L1_CACHE_SIZE_BYTES / L1_CACHE_LINE_SIZE, L1_CACHE_SIZE);
- fprintf (dump_file, " L1 cache line size: %d\n", L1_CACHE_LINE_SIZE);
- fprintf (dump_file, " L2 cache size: %d kB\n", L2_CACHE_SIZE);
+ L1_CACHE_SIZE_BYTES / param_l1_cache_line_size, param_l1_cache_size);
+ fprintf (dump_file, " L1 cache line size: %d\n", param_l1_cache_line_size);
+ fprintf (dump_file, " L2 cache size: %d kB\n", param_l2_cache_size);
fprintf (dump_file, " min insn-to-prefetch ratio: %d \n",
- MIN_INSN_TO_PREFETCH_RATIO);
+ param_min_insn_to_prefetch_ratio);
fprintf (dump_file, " min insn-to-mem ratio: %d \n",
- PREFETCH_MIN_INSN_TO_MEM_RATIO);
+ param_prefetch_min_insn_to_mem_ratio);
fprintf (dump_file, "\n");
}
@@ -288,7 +288,7 @@ tree_unswitch_single_loop (class loop *loop, int num)
/* The loop should not be too large, to limit code growth. */
if (tree_num_loop_insns (loop, &eni_size_weights)
- > (unsigned) PARAM_VALUE (PARAM_MAX_UNSWITCH_INSNS))
+ > (unsigned) param_max_unswitch_insns)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, ";; Not unswitching, loop too big\n");
@@ -323,7 +323,7 @@ tree_unswitch_single_loop (class loop *loop, int num)
if (i == loop->num_nodes)
{
if (dump_file
- && num > PARAM_VALUE (PARAM_MAX_UNSWITCH_LEVEL)
+ && num > param_max_unswitch_level
&& (dump_flags & TDF_DETAILS))
fprintf (dump_file, ";; Not unswitching anymore, hit max level\n");
@@ -352,7 +352,7 @@ tree_unswitch_single_loop (class loop *loop, int num)
changed = true;
}
/* Do not unswitch too much. */
- else if (num > PARAM_VALUE (PARAM_MAX_UNSWITCH_LEVEL))
+ else if (num > param_max_unswitch_level)
{
i++;
continue;
@@ -1975,7 +1975,7 @@ gimple_expand_builtin_pow (gimple_stmt_iterator *gsi, location_t loc,
&& !HONOR_SIGNED_ZEROS (mode))
{
unsigned int max_depth = speed_p
- ? PARAM_VALUE (PARAM_MAX_POW_SQRT_DEPTH)
+ ? param_max_pow_sqrt_depth
: 2;
tree expand_with_sqrts
@@ -3089,7 +3089,7 @@ convert_mult_to_fma (gimple *mul_stmt, tree op1, tree op2,
bool check_defer
= (state->m_deferring_p
&& (tree_to_shwi (TYPE_SIZE (type))
- <= PARAM_VALUE (PARAM_AVOID_FMA_MAX_BITS)));
+ <= param_avoid_fma_max_bits));
bool defer = check_defer;
bool seen_negate_p = false;
/* Make sure that the multiplication statement becomes dead after
@@ -3744,7 +3744,7 @@ math_opts_dom_walker::after_dom_children (basic_block bb)
{
gimple_stmt_iterator gsi;
- fma_deferring_state fma_state (PARAM_VALUE (PARAM_AVOID_FMA_MAX_BITS) > 0);
+ fma_deferring_state fma_state (param_avoid_fma_max_bits > 0);
for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi);)
{
@@ -2469,7 +2469,7 @@ cond_if_else_store_replacement (basic_block then_bb, basic_block else_bb,
/* If either vectorization or if-conversion is disabled then do
not sink any stores. */
- if (MAX_STORES_TO_SINK == 0
+ if (param_max_stores_to_sink == 0
|| (!flag_tree_loop_vectorize && !flag_tree_slp_vectorize)
|| !flag_tree_loop_if_convert)
return false;
@@ -2528,7 +2528,7 @@ cond_if_else_store_replacement (basic_block then_bb, basic_block else_bb,
/* No pairs of stores found. */
if (!then_stores.length ()
- || then_stores.length () > (unsigned) MAX_STORES_TO_SINK)
+ || then_stores.length () > (unsigned) param_max_stores_to_sink)
{
free_data_refs (then_datarefs);
free_data_refs (else_datarefs);
@@ -2658,7 +2658,7 @@ static void
hoist_adjacent_loads (basic_block bb0, basic_block bb1,
basic_block bb2, basic_block bb3)
{
- int param_align = PARAM_VALUE (PARAM_L1_CACHE_LINE_SIZE);
+ int param_align = param_l1_cache_line_size;
unsigned param_align_bits = (unsigned) (param_align * BITS_PER_UNIT);
gphi_iterator gsi;
@@ -2808,7 +2808,7 @@ static bool
gate_hoist_loads (void)
{
return (flag_hoist_adjacent_loads == 1
- && PARAM_VALUE (PARAM_L1_CACHE_LINE_SIZE)
+ && param_l1_cache_line_size
&& HAVE_conditional_move);
}
@@ -1156,7 +1156,7 @@ translate_vuse_through_block (vec<vn_reference_op_s> operands,
if (gimple_bb (phi) != phiblock)
return vuse;
- unsigned int cnt = PARAM_VALUE (PARAM_SCCVN_MAX_ALIAS_QUERIES_PER_ACCESS);
+ unsigned int cnt = param_sccvn_max_alias_queries_per_access;
use_oracle = ao_ref_init_from_vn_reference (&ref, set, type, operands);
/* Use the alias-oracle to find either the PHI node in this block,
@@ -2235,7 +2235,7 @@ compute_partial_antic_aux (basic_block block,
bitmap_set_t PA_OUT;
edge e;
edge_iterator ei;
- unsigned long max_pa = PARAM_VALUE (PARAM_MAX_PARTIAL_ANTIC_LENGTH);
+ unsigned long max_pa = param_max_partial_antic_length;
old_PA_IN = PA_OUT = NULL;
@@ -4945,7 +4945,7 @@ static int
get_reassociation_width (int ops_num, enum tree_code opc,
machine_mode mode)
{
- int param_width = PARAM_VALUE (PARAM_TREE_REASSOC_WIDTH);
+ int param_width = param_tree_reassoc_width;
int width;
int width_min;
int cycles_best;
@@ -3073,7 +3073,7 @@ vn_reference_lookup_pieces (tree vuse, alias_set_type set, tree type,
&& vr1.vuse)
{
ao_ref r;
- unsigned limit = PARAM_VALUE (PARAM_SCCVN_MAX_ALIAS_QUERIES_PER_ACCESS);
+ unsigned limit = param_sccvn_max_alias_queries_per_access;
vn_walk_cb_data data (&vr1, NULL_TREE, NULL, kind, true);
if (ao_ref_init_from_vn_reference (&r, set, type, vr1.operands))
*vnresult =
@@ -3124,7 +3124,7 @@ vn_reference_lookup (tree op, tree vuse, vn_lookup_kind kind,
{
vn_reference_t wvnresult;
ao_ref r;
- unsigned limit = PARAM_VALUE (PARAM_SCCVN_MAX_ALIAS_QUERIES_PER_ACCESS);
+ unsigned limit = param_sccvn_max_alias_queries_per_access;
/* Make sure to use a valueized reference if we valueized anything.
Otherwise preserve the full reference for advanced TBAA. */
if (!valuezied_anything
@@ -6984,7 +6984,7 @@ do_rpo_vn (function *fn, edge entry, bitmap exit_bbs,
if (iterate)
{
loop_p loop;
- unsigned max_depth = PARAM_VALUE (PARAM_RPO_VN_MAX_LOOP_DEPTH);
+ unsigned max_depth = param_rpo_vn_max_loop_depth;
FOR_EACH_LOOP (loop, LI_ONLY_INNERMOST)
if (loop_depth (loop) > max_depth)
for (unsigned i = 2;
@@ -292,7 +292,7 @@ avail_exprs_stack::lookup_avail_expr (gimple *stmt, bool insert, bool tbaa_p)
up the virtual use-def chain using walk_non_aliased_vuses.
But don't do this when removing expressions from the hash. */
ao_ref ref;
- unsigned limit = PARAM_VALUE (PARAM_SCCVN_MAX_ALIAS_QUERIES_PER_ACCESS);
+ unsigned limit = param_sccvn_max_alias_queries_per_access;
if (!(vuse1 && vuse2
&& gimple_assign_single_p (stmt)
&& TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME
@@ -215,7 +215,7 @@ select_best_block (basic_block early_bb,
/* Get the sinking threshold. If the statement to be moved has memory
operands, then increase the threshold by 7% as those are even more
profitable to avoid, clamping at 100%. */
- threshold = PARAM_VALUE (PARAM_SINK_FREQUENCY_THRESHOLD);
+ threshold = param_sink_frequency_threshold;
if (gimple_vuse (stmt) || gimple_vdef (stmt))
{
threshold += 7;
@@ -528,7 +528,7 @@ static int
new_stridx (tree exp)
{
int idx;
- if (max_stridx >= PARAM_VALUE (PARAM_MAX_TRACKED_STRLENS))
+ if (max_stridx >= param_max_tracked_strlens)
return 0;
if (TREE_CODE (exp) == SSA_NAME)
{
@@ -557,7 +557,7 @@ static int
new_addr_stridx (tree exp)
{
int *pidx;
- if (max_stridx >= PARAM_VALUE (PARAM_MAX_TRACKED_STRLENS))
+ if (max_stridx >= param_max_tracked_strlens)
return 0;
pidx = addr_stridxptr (exp);
if (pidx != NULL)
@@ -1082,7 +1082,7 @@ get_range_strlen_dynamic (tree src, c_strlen_data *pdata,
bitmap visited = NULL;
tree maxbound = pdata->maxbound;
- unsigned limit = PARAM_VALUE (PARAM_SSA_NAME_DEF_CHAIN_LIMIT);
+ unsigned limit = param_ssa_name_def_chain_limit;
if (!get_range_strlen_dynamic (src, pdata, &visited, rvals, &limit))
{
/* On failure extend the length range to an impossible maximum
@@ -3972,7 +3972,7 @@ class ssa_name_limit_t
ssa_name_limit_t ()
: visited (NULL),
- ssa_def_max (PARAM_VALUE (PARAM_SSA_NAME_DEF_CHAIN_LIMIT)) { }
+ ssa_def_max (param_ssa_name_def_chain_limit) { }
int next_ssa_name (tree);
@@ -5691,9 +5691,9 @@ push_fields_onto_fieldstack (tree type, vec<fieldoff_s> *fieldstack,
return false;
/* If the vector of fields is growing too big, bail out early.
- Callers check for vec::length <= MAX_FIELDS_FOR_FIELD_SENSITIVE, make
+ Callers check for vec::length <= param_max_fields_for_field_sensitive, make
sure this fails. */
- if (fieldstack->length () > MAX_FIELDS_FOR_FIELD_SENSITIVE)
+ if (fieldstack->length () > (unsigned)param_max_fields_for_field_sensitive)
return false;
for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
@@ -6114,7 +6114,7 @@ create_variable_info_for_1 (tree decl, const char *name, bool add_id,
/* If we didn't end up collecting sub-variables create a full
variable for the decl. */
if (fieldstack.length () == 0
- || fieldstack.length () > MAX_FIELDS_FOR_FIELD_SENSITIVE)
+ || fieldstack.length () > (unsigned)param_max_fields_for_field_sensitive)
{
vi = new_var_info (decl, name, add_id);
vi->offset = 0;
@@ -7179,7 +7179,7 @@ init_base_vars (void)
static void
init_alias_vars (void)
{
- use_field_sensitive = (MAX_FIELDS_FOR_FIELD_SENSITIVE > 1);
+ use_field_sensitive = (param_max_fields_for_field_sensitive > 1);
bitmap_obstack_initialize (&pta_obstack);
bitmap_obstack_initialize (&oldpta_obstack);
@@ -1469,7 +1469,7 @@ find_clusters_1 (same_succ *same_succ)
unsigned int i, j;
bitmap_iterator bi, bj;
int nr_comparisons;
- int max_comparisons = PARAM_VALUE (PARAM_MAX_TAIL_MERGE_COMPARISONS);
+ int max_comparisons = param_max_tail_merge_comparisons;
EXECUTE_IF_SET_IN_BITMAP (same_succ->bbs, 0, i, bi)
{
@@ -1731,7 +1731,7 @@ tail_merge_optimize (unsigned int todo)
int nr_bbs_removed;
bool loop_entered = false;
int iteration_nr = 0;
- int max_iterations = PARAM_VALUE (PARAM_MAX_TAIL_MERGE_ITERATIONS);
+ int max_iterations = param_max_tail_merge_iterations;
if (!flag_tree_tail_merge
|| max_iterations == 0)
@@ -157,7 +157,7 @@ thread_jumps::profitable_jump_thread_path (basic_block bbi, tree name,
return NULL;
if (m_path.length () + 1
- > (unsigned) PARAM_VALUE (PARAM_MAX_FSM_THREAD_LENGTH))
+ > (unsigned) param_max_fsm_thread_length)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "FSM jump-thread path not considered: "
@@ -367,7 +367,7 @@ thread_jumps::profitable_jump_thread_path (basic_block bbi, tree name,
as in PR 78407 this leads to noticeable improvements. */
if (m_speed_p && (optimize_edge_for_speed_p (taken_edge) || contains_hot_bb))
{
- if (n_insns >= PARAM_VALUE (PARAM_MAX_FSM_THREAD_PATH_INSNS))
+ if (n_insns >= param_max_fsm_thread_path_insns)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "FSM jump-thread path not considered: "
@@ -397,9 +397,9 @@ thread_jumps::profitable_jump_thread_path (basic_block bbi, tree name,
optimizer would have done anyway, so an irreducible loop is not
so bad. */
if (!threaded_multiway_branch && *creates_irreducible_loop
- && (n_insns * (unsigned) PARAM_VALUE (PARAM_FSM_SCALE_PATH_STMTS)
+ && (n_insns * (unsigned) param_fsm_scale_path_stmts
> (m_path.length () *
- (unsigned) PARAM_VALUE (PARAM_FSM_SCALE_PATH_BLOCKS))))
+ (unsigned) param_fsm_scale_path_blocks)))
{
if (dump_file && (dump_flags & TDF_DETAILS))
@@ -419,8 +419,8 @@ thread_jumps::profitable_jump_thread_path (basic_block bbi, tree name,
So for that case, drastically reduce the number of statements
we are allowed to copy. */
if (!(threaded_through_latch && threaded_multiway_branch)
- && (n_insns * PARAM_VALUE (PARAM_FSM_SCALE_PATH_STMTS)
- >= PARAM_VALUE (PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS)))
+ && (n_insns * param_fsm_scale_path_stmts
+ >= param_max_jump_thread_duplication_stmts))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
@@ -683,7 +683,7 @@ thread_jumps::fsm_find_control_statement_thread_paths (tree name)
if (gimple_code (def_stmt) == GIMPLE_PHI
&& (gimple_phi_num_args (def_stmt)
- >= (unsigned) PARAM_VALUE (PARAM_FSM_MAXIMUM_PHI_ARGUMENTS)))
+ >= (unsigned) param_fsm_maximum_phi_arguments))
return;
if (is_gimple_assign (def_stmt)
@@ -771,7 +771,7 @@ thread_jumps::find_jump_threads_backwards (basic_block bb, bool speed_p)
m_visited_bbs.empty ();
m_seen_loop_phi = false;
m_speed_p = speed_p;
- m_max_threaded_paths = PARAM_VALUE (PARAM_MAX_FSM_THREAD_PATHS);
+ m_max_threaded_paths = param_max_fsm_thread_paths;
fsm_find_control_statement_thread_paths (name);
}
@@ -234,7 +234,7 @@ record_temporary_equivalences_from_stmts_at_dest (edge e,
gimple_stmt_iterator gsi;
int max_stmt_count;
- max_stmt_count = PARAM_VALUE (PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS);
+ max_stmt_count = param_max_jump_thread_duplication_stmts;
/* Walk through each statement in the block recording equivalences
we discover. Note any equivalences we discover are context
@@ -275,7 +275,7 @@ record_temporary_equivalences_from_stmts_at_dest (edge e,
killed due to threading, grow the max count
accordingly. */
if (max_stmt_count
- == PARAM_VALUE (PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS))
+ == param_max_jump_thread_duplication_stmts)
{
max_stmt_count += estimate_threading_killed_stmts (e->dest);
if (dump_file)
@@ -545,7 +545,7 @@ compute_control_dep_chain (basic_block bb, basic_block dep_bb,
bool found_cd_chain = false;
size_t cur_chain_len = 0;
- if (*num_calls > PARAM_VALUE (PARAM_UNINIT_CONTROL_DEP_ATTEMPTS))
+ if (*num_calls > param_uninit_control_dep_attempts)
return false;
++*num_calls;
@@ -194,7 +194,7 @@ switch_conversion::check_range ()
}
if (tree_to_uhwi (m_range_size)
- > ((unsigned) m_count * SWITCH_CONVERSION_BRANCH_RATIO))
+ > ((unsigned) m_count * param_switch_conversion_branch_ratio))
{
m_reason = "the maximum range-branch ratio exceeded";
return false;
@@ -1268,8 +1268,8 @@ jump_table_cluster::can_be_handled (const vec<cluster *> &clusters,
unsigned HOST_WIDE_INT max_ratio
= (optimize_insn_for_size_p ()
- ? PARAM_VALUE (PARAM_JUMP_TABLE_MAX_GROWTH_RATIO_FOR_SIZE)
- : PARAM_VALUE (PARAM_JUMP_TABLE_MAX_GROWTH_RATIO_FOR_SPEED));
+ ? param_jump_table_max_growth_ratio_for_size
+ : param_jump_table_max_growth_ratio_for_speed);
unsigned HOST_WIDE_INT range = get_range (clusters[start]->get_low (),
clusters[end]->get_high ());
/* Check overflow. */
@@ -476,7 +476,7 @@ case_tree_node::case_tree_node ():
unsigned int
jump_table_cluster::case_values_threshold (void)
{
- unsigned int threshold = PARAM_VALUE (PARAM_CASE_VALUES_THRESHOLD);
+ unsigned int threshold = param_case_values_threshold;
if (threshold == 0)
threshold = targetm.case_values_threshold ();
@@ -683,7 +683,7 @@ is changed into:
b_b = PHI <b_6, b_7>
There are further constraints. Specifically, the range of values across all
-case labels must not be bigger than SWITCH_CONVERSION_BRANCH_RATIO (default
+case labels must not be bigger than param_switch_conversion_branch_ratio (default
eight) times the number of the actual switch branches.
This transformation was contributed by Martin Jambor, see this e-mail:
@@ -185,7 +185,7 @@ vect_mark_for_runtime_alias_test (ddr_p ddr, loop_vec_info loop_vinfo)
{
class loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
- if ((unsigned) PARAM_VALUE (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS) == 0)
+ if ((unsigned) param_vect_max_version_for_alias_checks == 0)
return opt_result::failure_at (vect_location,
"will not create alias checks, as"
" --param vect-max-version-for-alias-checks"
@@ -2074,7 +2074,7 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo)
if (do_peeling)
{
unsigned max_allowed_peel
- = PARAM_VALUE (PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT);
+ = param_vect_max_peeling_for_alignment;
if (flag_vect_cost_model == VECT_COST_MODEL_CHEAP)
max_allowed_peel = 0;
if (max_allowed_peel != (unsigned)-1)
@@ -2215,7 +2215,7 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo)
if (known_alignment_for_access_p (dr_info)
|| LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo).length ()
- >= (unsigned) PARAM_VALUE (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS))
+ >= (unsigned) param_vect_max_version_for_alignment_checks)
{
do_versioning = false;
break;
@@ -3644,10 +3644,9 @@ vect_prune_runtime_alias_test_list (loop_vec_info loop_vinfo)
dump_printf_loc (MSG_NOTE, vect_location,
"improved number of alias checks from %d to %d\n",
may_alias_ddrs.length (), count);
- unsigned limit = PARAM_VALUE (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS);
+ unsigned limit = param_vect_max_version_for_alias_checks;
if (flag_simd_cost_model == VECT_COST_MODEL_CHEAP)
- limit = default_param_value
- (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS) * 6 / 10;
+ limit = param_vect_max_version_for_alias_checks * 6 / 10;
if (count > limit)
return opt_result::failure_at
(vect_location,
@@ -1665,7 +1665,7 @@ vect_analyze_loop_costing (loop_vec_info loop_vinfo)
return -1;
}
- int min_scalar_loop_bound = (PARAM_VALUE (PARAM_MIN_VECT_LOOP_BOUND)
+ int min_scalar_loop_bound = (param_min_vect_loop_bound
* assumed_vf);
/* Use the cost model only if it is more conservative than user specified
@@ -1775,7 +1775,7 @@ vect_get_datarefs_in_loop (loop_p loop, basic_block *bbs,
/* If dependence analysis will give up due to the limit on the
number of datarefs stop here and fail fatally. */
if (datarefs->length ()
- > (unsigned)PARAM_VALUE (PARAM_LOOP_MAX_DATAREFS_FOR_DATADEPS))
+ > (unsigned)param_loop_max_datarefs_for_datadeps)
return opt_result::failure_at (stmt, "exceeded param "
"loop-max-datarefs-for-datadeps\n");
}
@@ -2458,7 +2458,7 @@ vect_analyze_loop (class loop *loop, vec_info_shared *shared)
enabled, this is not a simd loop and it is the innermost loop. */
vect_epilogues = (!loop->simdlen
&& loop->inner == NULL
- && PARAM_VALUE (PARAM_VECT_EPILOGUES_NOMASK)
+ && param_vect_epilogues_nomask
&& LOOP_VINFO_PEELING_FOR_NITER (first_loop_vinfo)
/* For now only allow one epilogue loop. */
&& first_loop_vinfo->epilogue_vinfos.is_empty ());
@@ -3289,7 +3289,7 @@ vect_slp_bb (basic_block bb)
gimple_stmt_iterator region_end = gsi;
- if (insns > PARAM_VALUE (PARAM_SLP_MAX_INSNS_IN_BB))
+ if (insns > param_slp_max_insns_in_bb)
{
if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
@@ -489,7 +489,7 @@ public:
/* Threshold of number of iterations below which vectorization will not be
performed. It is calculated from MIN_PROFITABLE_ITERS and
- PARAM_MIN_VECT_LOOP_BOUND. */
+ param_min_vect_loop_bound. */
unsigned int th;
/* When applying loop versioning, the vector form should only be used
@@ -3395,7 +3395,7 @@ find_switch_asserts (basic_block bb, gswitch *last)
/* Now register along the default label assertions that correspond to the
anti-range of each label. */
- int insertion_limit = PARAM_VALUE (PARAM_MAX_VRP_SWITCH_ASSERTIONS);
+ int insertion_limit = param_max_vrp_switch_assertions;
if (insertion_limit == 0)
return;
@@ -4306,7 +4306,7 @@ vrp_prop::check_mem_ref (location_t location, tree ref,
The loop computes the range of the final offset for expressions such
as (A + i0 + ... + iN)[CSTOFF] where i0 through iN are SSA_NAMEs in
some range. */
- const unsigned limit = PARAM_VALUE (PARAM_SSA_NAME_DEF_CHAIN_LIMIT);
+ const unsigned limit = param_ssa_name_def_chain_limit;
for (unsigned n = 0; TREE_CODE (arg) == SSA_NAME && n < limit; ++n)
{
gimple *def = SSA_NAME_DEF_STMT (arg);
@@ -1549,15 +1549,15 @@ wide_int_to_tree_1 (tree type, const wide_int_ref &pcst)
if (TYPE_SIGN (type) == UNSIGNED)
{
/* Cache [0, N). */
- limit = INTEGER_SHARE_LIMIT;
- if (IN_RANGE (hwi, 0, INTEGER_SHARE_LIMIT - 1))
+ limit = param_integer_share_limit;
+ if (IN_RANGE (hwi, 0, param_integer_share_limit - 1))
ix = hwi;
}
else
{
/* Cache [-1, N). */
- limit = INTEGER_SHARE_LIMIT + 1;
- if (IN_RANGE (hwi, -1, INTEGER_SHARE_LIMIT - 1))
+ limit = param_integer_share_limit + 1;
+ if (IN_RANGE (hwi, -1, param_integer_share_limit - 1))
ix = hwi + 1;
}
break;
@@ -1733,23 +1733,23 @@ cache_integer_cst (tree t)
if (TYPE_UNSIGNED (type))
{
/* Cache 0..N */
- limit = INTEGER_SHARE_LIMIT;
+ limit = param_integer_share_limit;
/* This is a little hokie, but if the prec is smaller than
- what is necessary to hold INTEGER_SHARE_LIMIT, then the
+ what is necessary to hold param_integer_share_limit, then the
obvious test will not get the correct answer. */
if (prec < HOST_BITS_PER_WIDE_INT)
{
- if (tree_to_uhwi (t) < (unsigned HOST_WIDE_INT) INTEGER_SHARE_LIMIT)
+ if (tree_to_uhwi (t) < (unsigned HOST_WIDE_INT) param_integer_share_limit)
ix = tree_to_uhwi (t);
}
- else if (wi::ltu_p (wi::to_wide (t), INTEGER_SHARE_LIMIT))
+ else if (wi::ltu_p (wi::to_wide (t), param_integer_share_limit))
ix = tree_to_uhwi (t);
}
else
{
/* Cache -1..N */
- limit = INTEGER_SHARE_LIMIT + 1;
+ limit = param_integer_share_limit + 1;
if (integer_minus_onep (t))
ix = 0;
@@ -1757,10 +1757,10 @@ cache_integer_cst (tree t)
{
if (prec < HOST_BITS_PER_WIDE_INT)
{
- if (tree_to_shwi (t) < INTEGER_SHARE_LIMIT)
+ if (tree_to_shwi (t) < param_integer_share_limit)
ix = tree_to_shwi (t) + 1;
}
- else if (wi::ltu_p (wi::to_wide (t), INTEGER_SHARE_LIMIT))
+ else if (wi::ltu_p (wi::to_wide (t), param_integer_share_limit))
ix = tree_to_shwi (t) + 1;
}
}
@@ -5844,7 +5844,7 @@ add_uses_1 (rtx *x, void *cui)
compile time for ridiculously complex expressions, although they're
seldom useful, and they may often have to be discarded as not
representable anyway. */
-#define EXPR_USE_DEPTH (PARAM_VALUE (PARAM_MAX_VARTRACK_EXPR_DEPTH))
+#define EXPR_USE_DEPTH (param_max_vartrack_expr_depth)
/* Attempt to reverse the EXPR operation in the debug info and record
it in the cselib table. Say for reg1 = reg2 + 6 even when reg2 is
@@ -5904,7 +5904,7 @@ reverse_op (rtx val, const_rtx expr, rtx_insn *insn)
&& (GET_CODE (l->loc) != CONST || !references_value_p (l->loc, 0)))
return;
/* Avoid creating too large locs lists. */
- else if (count == PARAM_VALUE (PARAM_MAX_VARTRACK_REVERSE_OP_SIZE))
+ else if (count == param_max_vartrack_reverse_op_size)
return;
switch (GET_CODE (src))
@@ -7054,7 +7054,7 @@ vt_find_locations (void)
int *rc_order;
int i;
int htabsz = 0;
- int htabmax = PARAM_VALUE (PARAM_MAX_VARTRACK_SIZE);
+ int htabmax = param_max_vartrack_size;
bool success = true;
timevar_push (TV_VAR_TRACKING_DATAFLOW);