/* Interprocedural constant propagation
- Copyright (C) 2005-2016 Free Software Foundation, Inc.
+ Copyright (C) 2005-2017 Free Software Foundation, Inc.
Contributed by Razya Ladelsky <RAZYA@il.ibm.com> and Martin Jambor
<mjambor@suse.cz>
values:
Pass through - the caller's formal parameter is passed as an actual
- argument, plus an operation on it can be performed.
+ argument, plus an operation on it can be performed.
Constant - a constant is passed as an actual argument.
Unknown - neither of the above.
};
/* Lattice describing potential values of a formal parameter of a function, or
- a part of an aggreagate. TOP is represented by a lattice with zero values
+ a part of an aggregate. TOP is represented by a lattice with zero values
and with contains_variable and bottom flags cleared. BOTTOM is represented
by a lattice with the bottom flag set. In that case, values and
contains_variable flag should be disregarded. */
struct ipcp_agg_lattice *next;
};
-/* Lattice of pointer alignment. Unlike the previous types of lattices, this
- one is only capable of holding one value. */
-
-class ipcp_alignment_lattice
-{
-public:
- /* If bottom and top are both false, these two fields hold values as given by
- ptr_info_def and get_pointer_alignment_1. */
- unsigned align;
- unsigned misalign;
-
- inline bool bottom_p () const;
- inline bool top_p () const;
- inline bool set_to_bottom ();
- bool meet_with (unsigned new_align, unsigned new_misalign);
- bool meet_with (const ipcp_alignment_lattice &other, HOST_WIDE_INT offset);
- void print (FILE * f);
-private:
- /* If set, this lattice is bottom and all other fields should be
- disregarded. */
- bool bottom;
- /* If bottom and not_top are false, the lattice is TOP. If not_top is true,
- the known alignment is stored in the fields align and misalign. The field
- is negated so that memset to zero initializes the lattice to TOP
- state. */
- bool not_top;
-
- bool meet_with_1 (unsigned new_align, unsigned new_misalign);
-};
-
/* Lattice of known bits, only capable of holding one value.
Bitwise constant propagation propagates which bits of a
value are constant.
bool top_p () { return m_lattice_val == IPA_BITS_UNDEFINED; }
bool constant_p () { return m_lattice_val == IPA_BITS_CONSTANT; }
bool set_to_bottom ();
- bool set_to_constant (widest_int, widest_int);
-
+ bool set_to_constant (widest_int, widest_int);
+
widest_int get_value () { return m_value; }
widest_int get_mask () { return m_mask; }
value is known to be constant. */
widest_int m_value, m_mask;
- bool meet_with_1 (widest_int, widest_int, unsigned);
+ bool meet_with_1 (widest_int, widest_int, unsigned);
void get_value_and_mask (tree, widest_int *, widest_int *);
-};
+};
/* Lattice of value ranges. */
ipcp_lattice<ipa_polymorphic_call_context> ctxlat;
/* Lattices describing aggregate parts. */
ipcp_agg_lattice *aggs;
- /* Lattice describing known alignment. */
- ipcp_alignment_lattice alignment;
/* Lattice describing known bits. */
ipcp_bits_lattice bits_lattice;
/* Lattice describing value range. */
print_ipcp_constant_value (FILE * f, tree v)
{
if (TREE_CODE (v) == ADDR_EXPR
- && TREE_CODE (TREE_OPERAND (v, 0)) == CONST_DECL)
+ && TREE_CODE (TREE_OPERAND (v, 0)) == CONST_DECL)
{
fprintf (f, "& ");
print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (v, 0)), 0);
fprintf (f, "\n");
}
-/* Print alignment lattice to F. */
-
-void
-ipcp_alignment_lattice::print (FILE * f)
-{
- if (top_p ())
- fprintf (f, " Alignment unknown (TOP)\n");
- else if (bottom_p ())
- fprintf (f, " Alignment unusable (BOTTOM)\n");
- else
- fprintf (f, " Alignment %u, misalignment %u\n", align, misalign);
-}
-
void
ipcp_bits_lattice::print (FILE *f)
{
plats->itself.print (f, dump_sources, dump_benefits);
fprintf (f, " ctxs: ");
plats->ctxlat.print (f, dump_sources, dump_benefits);
- plats->alignment.print (f);
plats->bits_lattice.print (f);
fprintf (f, " ");
plats->m_value_range.print (f);
decloned constructors, inlining is always better anyway. */
else if (node->comdat_local_p ())
reason = "comdat-local function";
+ else if (node->calls_comdat_local)
+ {
+ /* TODO: call is versionable if we make sure that all
+ callers are inside of a comdat group. */
+ reason = "calls comdat-local function";
+ }
if (reason && dump_file && !node->alias && !node->thunk.thunk_p)
fprintf (dump_file, "Function %s/%i is not versionable, reason: %s.\n",
if (!opt_for_fn (node->decl, flag_ipa_cp_clone))
{
if (dump_file)
- fprintf (dump_file, "Not considering %s for cloning; "
+ fprintf (dump_file, "Not considering %s for cloning; "
"-fipa-cp-clone disabled.\n",
- node->name ());
+ node->name ());
return false;
}
if (node->optimize_for_size_p ())
{
if (dump_file)
- fprintf (dump_file, "Not considering %s for cloning; "
+ fprintf (dump_file, "Not considering %s for cloning; "
"optimizing it for size.\n",
- node->name ());
+ node->name ());
return false;
}
if (inline_summaries->get (node)->self_size < stats.n_calls)
{
if (dump_file)
- fprintf (dump_file, "Considering %s for cloning; code might shrink.\n",
- node->name ());
+ fprintf (dump_file, "Considering %s for cloning; code might shrink.\n",
+ node->name ());
return true;
}
"usually called directly.\n",
node->name ());
return true;
- }
+ }
}
if (!stats.n_hot_calls)
{
return ret;
}
-/* Return true if alignment information in the lattice is yet unknown. */
-
-bool
-ipcp_alignment_lattice::top_p () const
-{
- return !bottom && !not_top;
-}
-
-/* Return true if alignment information in the lattice is known to be
- unusable. */
-
-bool
-ipcp_alignment_lattice::bottom_p () const
-{
- return bottom;
-}
-
-/* Set alignment information in the lattice to bottom. Return true if it
- previously was in a different state. */
-
-bool
-ipcp_alignment_lattice::set_to_bottom ()
-{
- if (bottom_p ())
- return false;
- bottom = true;
- return true;
-}
-
-/* Meet the current value of the lattice with described by OTHER
- lattice. */
-
bool
ipcp_vr_lattice::meet_with (const ipcp_vr_lattice &other)
{
return true;
}
-/* Meet the current value of the lattice with alignment described by NEW_ALIGN
- and NEW_MISALIGN, assuming that we know the current value is neither TOP nor
- BOTTOM. Return true if the value of lattice has changed. */
-
-bool
-ipcp_alignment_lattice::meet_with_1 (unsigned new_align, unsigned new_misalign)
-{
- gcc_checking_assert (new_align != 0);
- if (align == new_align && misalign == new_misalign)
- return false;
-
- bool changed = false;
- if (align > new_align)
- {
- align = new_align;
- misalign = misalign % new_align;
- changed = true;
- }
- if (misalign != (new_misalign % align))
- {
- int diff = abs ((int) misalign - (int) (new_misalign % align));
- align = least_bit_hwi (diff);
- if (align)
- misalign = misalign % align;
- else
- set_to_bottom ();
- changed = true;
- }
- gcc_checking_assert (bottom_p () || align != 0);
- return changed;
-}
-
-/* Meet the current value of the lattice with alignment described by NEW_ALIGN
- and NEW_MISALIGN. Return true if the value of lattice has changed. */
-
-bool
-ipcp_alignment_lattice::meet_with (unsigned new_align, unsigned new_misalign)
-{
- gcc_assert (new_align != 0);
- if (bottom_p ())
- return false;
- if (top_p ())
- {
- not_top = true;
- align = new_align;
- misalign = new_misalign;
- return true;
- }
- return meet_with_1 (new_align, new_misalign);
-}
-
-/* Meet the current value of the lattice with OTHER, taking into account that
- OFFSET has been added to the pointer value. Return true if the value of
- lattice has changed. */
-
-bool
-ipcp_alignment_lattice::meet_with (const ipcp_alignment_lattice &other,
- HOST_WIDE_INT offset)
-{
- if (other.bottom_p ())
- return set_to_bottom ();
- if (bottom_p () || other.top_p ())
- return false;
-
- unsigned adjusted_misalign = (other.misalign + offset) % other.align;
- if (top_p ())
- {
- not_top = true;
- align = other.align;
- misalign = adjusted_misalign;
- return true;
- }
-
- return meet_with_1 (other.align, adjusted_misalign);
-}
-
/* Set lattice value to bottom, if it already isn't the case. */
bool
if (TREE_CODE (operand) == INTEGER_CST)
{
- *valuep = wi::to_widest (operand);
+ *valuep = wi::to_widest (operand);
*maskp = 0;
}
else
unsigned precision)
{
gcc_assert (constant_p ());
-
- widest_int old_mask = m_mask;
+
+ widest_int old_mask = m_mask;
m_mask = (m_mask | mask) | (m_value ^ value);
if (wi::sext (m_mask, precision) == -1)
{
if (wi::sext (mask, precision) == -1)
return set_to_bottom ();
- return set_to_constant (value, mask);
+ return set_to_constant (value, mask);
}
return meet_with_1 (value, mask, precision);
return set_to_bottom ();
}
- else if (code == NOP_EXPR)
- {
- adjusted_value = other.m_value;
- adjusted_mask = other.m_mask;
- }
-
else
return set_to_bottom ();
{
if (wi::sext (adjusted_mask, precision) == -1)
return set_to_bottom ();
- return set_to_constant (adjusted_value, adjusted_mask);
+ return set_to_constant (adjusted_value, adjusted_mask);
}
else
return meet_with_1 (adjusted_value, adjusted_mask, precision);
ret = plats->itself.set_contains_variable ();
ret |= plats->ctxlat.set_contains_variable ();
ret |= set_agg_lats_contain_variable (plats);
- ret |= plats->alignment.set_to_bottom ();
ret |= plats->bits_lattice.set_to_bottom ();
ret |= plats->m_value_range.set_to_bottom ();
return ret;
disable = true;
}
- for (i = 0; i < ipa_get_param_count (info) ; i++)
+ for (i = 0; i < ipa_get_param_count (info); i++)
{
struct ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
plats->m_value_range.init ();
if (disable || variable)
{
- for (i = 0; i < ipa_get_param_count (info) ; i++)
+ for (i = 0; i < ipa_get_param_count (info); i++)
{
struct ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
if (disable)
plats->itself.set_to_bottom ();
plats->ctxlat.set_to_bottom ();
set_agg_lats_to_bottom (plats);
- plats->alignment.set_to_bottom ();
plats->bits_lattice.set_to_bottom ();
plats->m_value_range.set_to_bottom ();
}
for (ie = node->indirect_calls; ie; ie = ie->next_callee)
if (ie->indirect_info->polymorphic
- && ie->indirect_info->param_index >= 0)
+ && ie->indirect_info->param_index >= 0)
{
gcc_checking_assert (ie->indirect_info->param_index >= 0);
ipa_get_parm_lattices (info,
return NULL_TREE;
if (TREE_CODE_CLASS (ipa_get_jf_pass_through_operation (jfunc))
- == tcc_comparison)
- restype = boolean_type_node;
+ == tcc_unary)
+ res = fold_unary (ipa_get_jf_pass_through_operation (jfunc),
+ TREE_TYPE (input), input);
else
- restype = TREE_TYPE (input);
- res = fold_binary (ipa_get_jf_pass_through_operation (jfunc), restype,
- input, ipa_get_jf_pass_through_operand (jfunc));
-
+ {
+ if (TREE_CODE_CLASS (ipa_get_jf_pass_through_operation (jfunc))
+ == tcc_comparison)
+ restype = boolean_type_node;
+ else
+ restype = TREE_TYPE (input);
+ res = fold_binary (ipa_get_jf_pass_through_operation (jfunc), restype,
+ input, ipa_get_jf_pass_through_operand (jfunc));
+ }
if (res && !is_gimple_ip_invariant (res))
return NULL_TREE;
if (ipa_edge_within_scc (cs))
{
ipcp_value_source<valtype> *s;
- for (s = val->sources; s ; s = s->next)
+ for (s = val->sources; s; s = s->next)
if (s->cs == cs)
break;
if (s)
is the index of the source parameter. */
static bool
-propagate_vals_accross_pass_through (cgraph_edge *cs,
- ipa_jump_func *jfunc,
- ipcp_lattice<tree> *src_lat,
- ipcp_lattice<tree> *dest_lat,
- int src_idx)
+propagate_vals_across_pass_through (cgraph_edge *cs, ipa_jump_func *jfunc,
+ ipcp_lattice<tree> *src_lat,
+ ipcp_lattice<tree> *dest_lat, int src_idx)
{
ipcp_value<tree> *src_val;
bool ret = false;
is the index of the source parameter. */
static bool
-propagate_vals_accross_ancestor (struct cgraph_edge *cs,
- struct ipa_jump_func *jfunc,
- ipcp_lattice<tree> *src_lat,
- ipcp_lattice<tree> *dest_lat,
- int src_idx)
+propagate_vals_across_ancestor (struct cgraph_edge *cs,
+ struct ipa_jump_func *jfunc,
+ ipcp_lattice<tree> *src_lat,
+ ipcp_lattice<tree> *dest_lat, int src_idx)
{
ipcp_value<tree> *src_val;
bool ret = false;
edge CS and put the values into DEST_LAT. */
static bool
-propagate_scalar_accross_jump_function (struct cgraph_edge *cs,
- struct ipa_jump_func *jfunc,
- ipcp_lattice<tree> *dest_lat)
+propagate_scalar_across_jump_function (struct cgraph_edge *cs,
+ struct ipa_jump_func *jfunc,
+ ipcp_lattice<tree> *dest_lat)
{
if (dest_lat->bottom)
return false;
return dest_lat->set_contains_variable ();
if (jfunc->type == IPA_JF_PASS_THROUGH)
- ret = propagate_vals_accross_pass_through (cs, jfunc, src_lat,
- dest_lat, src_idx);
+ ret = propagate_vals_across_pass_through (cs, jfunc, src_lat,
+ dest_lat, src_idx);
else
- ret = propagate_vals_accross_ancestor (cs, jfunc, src_lat, dest_lat,
- src_idx);
+ ret = propagate_vals_across_ancestor (cs, jfunc, src_lat, dest_lat,
+ src_idx);
if (src_lat->contains_variable)
ret |= dest_lat->set_contains_variable ();
edge CS and describes argument IDX and put the values into DEST_LAT. */
static bool
-propagate_context_accross_jump_function (cgraph_edge *cs,
+propagate_context_across_jump_function (cgraph_edge *cs,
ipa_jump_func *jfunc, int idx,
ipcp_lattice<ipa_polymorphic_call_context> *dest_lat)
{
return ret;
}
-/* Propagate alignments across jump function JFUNC that is associated with
- edge CS and update DEST_LAT accordingly. */
-
-static bool
-propagate_alignment_accross_jump_function (cgraph_edge *cs,
- ipa_jump_func *jfunc,
- ipcp_alignment_lattice *dest_lat)
-{
- if (dest_lat->bottom_p ())
- return false;
-
- if (jfunc->type == IPA_JF_PASS_THROUGH
- || jfunc->type == IPA_JF_ANCESTOR)
- {
- struct ipa_node_params *caller_info = IPA_NODE_REF (cs->caller);
- HOST_WIDE_INT offset = 0;
- int src_idx;
-
- if (jfunc->type == IPA_JF_PASS_THROUGH)
- {
- enum tree_code op = ipa_get_jf_pass_through_operation (jfunc);
- if (op != NOP_EXPR)
- {
- if (op != POINTER_PLUS_EXPR
- && op != PLUS_EXPR)
- return dest_lat->set_to_bottom ();
- tree operand = ipa_get_jf_pass_through_operand (jfunc);
- if (!tree_fits_shwi_p (operand))
- return dest_lat->set_to_bottom ();
- offset = tree_to_shwi (operand);
- }
- src_idx = ipa_get_jf_pass_through_formal_id (jfunc);
- }
- else
- {
- src_idx = ipa_get_jf_ancestor_formal_id (jfunc);
- offset = ipa_get_jf_ancestor_offset (jfunc) / BITS_PER_UNIT;
- }
-
- struct ipcp_param_lattices *src_lats;
- src_lats = ipa_get_parm_lattices (caller_info, src_idx);
- return dest_lat->meet_with (src_lats->alignment, offset);
- }
- else
- {
- if (jfunc->alignment.known)
- return dest_lat->meet_with (jfunc->alignment.align,
- jfunc->alignment.misalign);
- else
- return dest_lat->set_to_bottom ();
- }
-}
-
/* Propagate bits across jfunc that is associated with
edge cs and update dest_lattice accordingly. */
bool
-propagate_bits_accross_jump_function (cgraph_edge *cs, int idx, ipa_jump_func *jfunc,
- ipcp_bits_lattice *dest_lattice)
+propagate_bits_across_jump_function (cgraph_edge *cs, int idx,
+ ipa_jump_func *jfunc,
+ ipcp_bits_lattice *dest_lattice)
{
if (dest_lattice->bottom_p ())
return false;
unsigned precision = TYPE_PRECISION (parm_type);
signop sgn = TYPE_SIGN (parm_type);
- if (jfunc->type == IPA_JF_PASS_THROUGH)
+ if (jfunc->type == IPA_JF_PASS_THROUGH
+ || jfunc->type == IPA_JF_ANCESTOR)
{
struct ipa_node_params *caller_info = IPA_NODE_REF (cs->caller);
- enum tree_code code = ipa_get_jf_pass_through_operation (jfunc);
tree operand = NULL_TREE;
+ enum tree_code code;
+ unsigned src_idx;
- if (code != NOP_EXPR)
- operand = ipa_get_jf_pass_through_operand (jfunc);
+ if (jfunc->type == IPA_JF_PASS_THROUGH)
+ {
+ code = ipa_get_jf_pass_through_operation (jfunc);
+ src_idx = ipa_get_jf_pass_through_formal_id (jfunc);
+ if (code != NOP_EXPR)
+ operand = ipa_get_jf_pass_through_operand (jfunc);
+ }
+ else
+ {
+ code = POINTER_PLUS_EXPR;
+ src_idx = ipa_get_jf_ancestor_formal_id (jfunc);
+ unsigned HOST_WIDE_INT offset = ipa_get_jf_ancestor_offset (jfunc) / BITS_PER_UNIT;
+ operand = build_int_cstu (size_type_node, offset);
+ }
- int src_idx = ipa_get_jf_pass_through_formal_id (jfunc);
struct ipcp_param_lattices *src_lats
= ipa_get_parm_lattices (caller_info, src_idx);
and we store it in jump function during analysis stage. */
if (src_lats->bits_lattice.bottom_p ()
- && jfunc->bits.known)
- return dest_lattice->meet_with (jfunc->bits.value, jfunc->bits.mask,
+ && jfunc->bits)
+ return dest_lattice->meet_with (jfunc->bits->value, jfunc->bits->mask,
precision);
else
return dest_lattice->meet_with (src_lats->bits_lattice, precision, sgn,
else if (jfunc->type == IPA_JF_ANCESTOR)
return dest_lattice->set_to_bottom ();
-
- else if (jfunc->bits.known)
- return dest_lattice->meet_with (jfunc->bits.value, jfunc->bits.mask, precision);
-
+ else if (jfunc->bits)
+ return dest_lattice->meet_with (jfunc->bits->value, jfunc->bits->mask,
+ precision);
else
return dest_lattice->set_to_bottom ();
}
+/* Emulate effects of unary OPERATION and/or conversion from SRC_TYPE to
+ DST_TYPE on value range in SRC_VR and store it to DST_VR. Return true if
+ the result is a range or an anti-range. */
+
+static bool
+ipa_vr_operation_and_type_effects (value_range *dst_vr, value_range *src_vr,
+ enum tree_code operation,
+ tree dst_type, tree src_type)
+{
+ memset (dst_vr, 0, sizeof (*dst_vr));
+ extract_range_from_unary_expr (dst_vr, operation, dst_type, src_vr, src_type);
+ if (dst_vr->type == VR_RANGE || dst_vr->type == VR_ANTI_RANGE)
+ return true;
+ else
+ return false;
+}
+
/* Propagate value range across jump function JFUNC that is associated with
- edge CS and update DEST_PLATS accordingly. */
+ edge CS with param of callee of PARAM_TYPE and update DEST_PLATS
+ accordingly. */
static bool
-propagate_vr_accross_jump_function (cgraph_edge *cs,
- ipa_jump_func *jfunc,
- struct ipcp_param_lattices *dest_plats)
+propagate_vr_across_jump_function (cgraph_edge *cs, ipa_jump_func *jfunc,
+ struct ipcp_param_lattices *dest_plats,
+ tree param_type)
{
- struct ipcp_param_lattices *src_lats;
ipcp_vr_lattice *dest_lat = &dest_plats->m_value_range;
if (dest_lat->bottom_p ())
return false;
+ if (!param_type
+ || (!INTEGRAL_TYPE_P (param_type)
+ && !POINTER_TYPE_P (param_type)))
+ return dest_lat->set_to_bottom ();
+
if (jfunc->type == IPA_JF_PASS_THROUGH)
{
- struct ipa_node_params *caller_info = IPA_NODE_REF (cs->caller);
- if (dest_lat->bottom_p ())
- return false;
- int src_idx = ipa_get_jf_pass_through_formal_id (jfunc);
- src_lats = ipa_get_parm_lattices (caller_info, src_idx);
+ enum tree_code operation = ipa_get_jf_pass_through_operation (jfunc);
- if (ipa_get_jf_pass_through_operation (jfunc) == NOP_EXPR)
- return dest_lat->meet_with (src_lats->m_value_range);
+ if (TREE_CODE_CLASS (operation) == tcc_unary)
+ {
+ struct ipa_node_params *caller_info = IPA_NODE_REF (cs->caller);
+ int src_idx = ipa_get_jf_pass_through_formal_id (jfunc);
+ tree operand_type = ipa_get_type (caller_info, src_idx);
+ struct ipcp_param_lattices *src_lats
+ = ipa_get_parm_lattices (caller_info, src_idx);
+
+ if (src_lats->m_value_range.bottom_p ())
+ return dest_lat->set_to_bottom ();
+ value_range vr;
+ if (ipa_vr_operation_and_type_effects (&vr,
+ &src_lats->m_value_range.m_vr,
+ operation, param_type,
+ operand_type))
+ return dest_lat->meet_with (&vr);
+ }
}
else if (jfunc->type == IPA_JF_CONST)
{
tree val = ipa_get_jf_constant (jfunc);
if (TREE_CODE (val) == INTEGER_CST)
{
+ val = fold_convert (param_type, val);
if (TREE_OVERFLOW_P (val))
val = drop_tree_overflow (val);
- jfunc->vr_known = true;
- jfunc->m_vr.type = VR_RANGE;
- jfunc->m_vr.min = val;
- jfunc->m_vr.max = val;
- return dest_lat->meet_with (&jfunc->m_vr);
+
+ value_range tmpvr;
+ memset (&tmpvr, 0, sizeof (tmpvr));
+ tmpvr.type = VR_RANGE;
+ tmpvr.min = val;
+ tmpvr.max = val;
+ return dest_lat->meet_with (&tmpvr);
}
}
- if (jfunc->vr_known)
- return dest_lat->meet_with (&jfunc->m_vr);
+ value_range vr;
+ if (jfunc->m_vr
+ && ipa_vr_operation_and_type_effects (&vr, jfunc->m_vr, NOP_EXPR,
+ param_type,
+ TREE_TYPE (jfunc->m_vr->min)))
+ return dest_lat->meet_with (&vr);
else
return dest_lat->set_to_bottom ();
}
if (**aglat && (**aglat)->offset == offset)
{
if ((**aglat)->size != val_size
- || ((**aglat)->next
- && (**aglat)->next->offset < offset + val_size))
+ || ((**aglat)->next
+ && (**aglat)->next->offset < offset + val_size))
{
set_agg_lats_to_bottom (dest_plats);
return false;
edge CS and put the values into DEST_LAT. */
static bool
-propagate_aggs_accross_jump_function (struct cgraph_edge *cs,
- struct ipa_jump_func *jfunc,
- struct ipcp_param_lattices *dest_plats)
+propagate_aggs_across_jump_function (struct cgraph_edge *cs,
+ struct ipa_jump_func *jfunc,
+ struct ipcp_param_lattices *dest_plats)
{
bool ret = false;
caller. */
static bool
-propagate_constants_accross_call (struct cgraph_edge *cs)
+propagate_constants_across_call (struct cgraph_edge *cs)
{
struct ipa_node_params *callee_info;
enum availability availability;
{
struct ipa_jump_func *jump_func = ipa_get_ith_jump_func (args, i);
struct ipcp_param_lattices *dest_plats;
+ tree param_type = ipa_get_type (callee_info, i);
dest_plats = ipa_get_parm_lattices (callee_info, i);
if (availability == AVAIL_INTERPOSABLE)
ret |= set_all_contains_variable (dest_plats);
else
{
- ret |= propagate_scalar_accross_jump_function (cs, jump_func,
- &dest_plats->itself);
- ret |= propagate_context_accross_jump_function (cs, jump_func, i,
- &dest_plats->ctxlat);
- ret |= propagate_alignment_accross_jump_function (cs, jump_func,
- &dest_plats->alignment);
- ret |= propagate_bits_accross_jump_function (cs, i, jump_func,
- &dest_plats->bits_lattice);
- ret |= propagate_aggs_accross_jump_function (cs, jump_func,
- dest_plats);
+ ret |= propagate_scalar_across_jump_function (cs, jump_func,
+ &dest_plats->itself);
+ ret |= propagate_context_across_jump_function (cs, jump_func, i,
+ &dest_plats->ctxlat);
+ ret
+ |= propagate_bits_across_jump_function (cs, i, jump_func,
+ &dest_plats->bits_lattice);
+ ret |= propagate_aggs_across_jump_function (cs, jump_func,
+ dest_plats);
if (opt_for_fn (callee->decl, flag_ipa_vrp))
- ret |= propagate_vr_accross_jump_function (cs,
- jump_func, dest_plats);
+ ret |= propagate_vr_across_jump_function (cs, jump_func,
+ dest_plats, param_type);
else
ret |= dest_plats->m_value_range.set_to_bottom ();
}
else
t = known_csts[param_index];
- if (t &&
- TREE_CODE (t) == ADDR_EXPR
+ if (t
+ && TREE_CODE (t) == ADDR_EXPR
&& TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL)
return TREE_OPERAND (t, 0);
else
if (!t && known_aggs.length () > (unsigned int) param_index
&& !ie->indirect_info->by_ref)
{
- struct ipa_agg_jump_function *agg;
- agg = known_aggs[param_index];
- t = ipa_find_agg_cst_for_param (agg, known_csts[param_index],
- ie->indirect_info->offset,
- true);
+ struct ipa_agg_jump_function *agg;
+ agg = known_aggs[param_index];
+ t = ipa_find_agg_cst_for_param (agg, known_csts[param_index],
+ ie->indirect_info->offset, true);
}
/* If we found the virtual table pointer, lookup the target. */
return NULL;
target = ipa_impossible_devirt_target (ie, target);
}
- *speculative = ie->indirect_info->vptr_changed;
+ *speculative = ie->indirect_info->vptr_changed;
if (!*speculative)
- return target;
+ return target;
}
}
}
if (removable_params_cost)
*removable_params_cost = 0;
- for (i = 0; i < count ; i++)
+ for (i = 0; i < count; i++)
{
struct ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
ipcp_lattice<tree> *lat = &plats->itself;
perform_estimation_of_a_value (cgraph_node *node, vec<tree> known_csts,
vec<ipa_polymorphic_call_context> known_contexts,
vec<ipa_agg_jump_function_p> known_aggs_ptrs,
- int base_time, int removable_params_cost,
+ sreal base_time, int removable_params_cost,
int est_move_cost, ipcp_value_base *val)
{
- int time, size, time_benefit;
+ int size, time_benefit;
+ sreal time;
inline_hints hints;
estimate_ipcp_clone_size_and_time (node, known_csts, known_contexts,
known_aggs_ptrs, &size, &time,
&hints);
- time_benefit = base_time - time
+ base_time -= time;
+ if (base_time > 65535)
+ base_time = 65535;
+ time_benefit = base_time.to_int ()
+ devirtualization_time_bonus (node, known_csts, known_contexts,
known_aggs_ptrs)
+ hint_time_bonus (hints)
vec<ipa_agg_jump_function> known_aggs;
vec<ipa_agg_jump_function_p> known_aggs_ptrs;
bool always_const;
- int base_time = inline_summaries->get (node)->time;
+ sreal base_time = inline_summaries->get (node)->time.to_int ();
int removable_params_cost;
if (!count || !ipcp_versionable_function_p (node))
return;
if (dump_file && (dump_flags & TDF_DETAILS))
- fprintf (dump_file, "\nEstimating effects for %s/%i, base_time: %i.\n",
- node->name (), node->order, base_time);
+ fprintf (dump_file, "\nEstimating effects for %s/%i, base_time: %f.\n",
+ node->name (), node->order, base_time.to_double ());
always_const = gather_context_independent_values (info, &known_csts,
&known_contexts, &known_aggs,
{
struct caller_statistics stats;
inline_hints hints;
- int time, size;
+ sreal time;
+ int size;
init_caller_stats (&stats);
node->call_for_symbol_thunks_and_aliases (gather_caller_stats, &stats,
if (dump_file)
fprintf (dump_file, " - context independent values, size: %i, "
- "time_benefit: %i\n", size, base_time - time);
+ "time_benefit: %f\n", size, (base_time - time).to_double ());
if (size <= 0 || node->local.local)
{
fprintf (dump_file, " Decided to specialize for all "
"known contexts, code not going to grow.\n");
}
- else if (good_cloning_opportunity_p (node, base_time - time,
+ else if (good_cloning_opportunity_p (node, (base_time - time).to_int (),
stats.freq_sum, stats.count_sum,
size))
{
else if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " Not cloning for all contexts because "
"!good_cloning_opportunity_p.\n");
-
+
}
- for (i = 0; i < count ; i++)
+ for (i = 0; i < count; i++)
{
struct ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
ipcp_lattice<tree> *lat = &plats->itself;
known_contexts[i] = ipa_polymorphic_call_context ();
}
- for (i = 0; i < count ; i++)
+ for (i = 0; i < count; i++)
{
struct ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
struct ipa_agg_jump_function *ajf;
fprintf (dump_file, " - estimates for value ");
print_ipcp_constant_value (dump_file, val->value);
fprintf (dump_file, " for ");
- ipa_dump_param (dump_file, info, i);
+ ipa_dump_param (dump_file, info, i);
fprintf (dump_file, "[%soffset: " HOST_WIDE_INT_PRINT_DEC
"]: time_benefit: %i, size: %i\n",
plats->aggs_by_ref ? "ref " : "",
}
}
- for (i = 0; i < count ; i++)
+ for (i = 0; i < count; i++)
vec_free (known_aggs[i].items);
known_csts.release ();
struct ipa_node_params *info = IPA_NODE_REF (node);
int i, count = ipa_get_param_count (info);
- for (i = 0; i < count ; i++)
+ for (i = 0; i < count; i++)
{
struct ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
ipcp_lattice<tree> *lat = &plats->itself;
if (ipa_edge_within_scc (cs))
{
IPA_NODE_REF (v)->node_within_scc = true;
- if (propagate_constants_accross_call (cs))
+ if (propagate_constants_across_call (cs))
push_node_to_stack (topo, cs->callee->function_symbol ());
}
v = pop_node_from_stack (topo);
add_all_node_vals_to_toposort (v, topo);
for (cs = v->callees; cs; cs = cs->next_callee)
if (!ipa_edge_within_scc (cs))
- propagate_constants_accross_call (cs);
+ propagate_constants_across_call (cs);
}
cycle_nodes.release ();
}
if (dump_file)
fprintf (dump_file, "\n Propagating constants:\n\n");
- if (in_lto_p)
- ipa_update_after_lto_read ();
-
-
FOR_EACH_DEFINED_FUNCTION (node)
{
struct ipa_node_params *info = IPA_NODE_REF (node);
- /* In LTO we do not have PARM_DECLs but we would still like to be able to
- look at types of parameters. */
- if (in_lto_p)
- {
- tree t = TYPE_ARG_TYPES (TREE_TYPE (node->decl));
- for (int k = 0; k < ipa_get_param_count (info) && t; k++)
- {
- gcc_assert (t != void_list_node);
- info->descriptors[k].decl_or_type = TREE_VALUE (t);
- t = t ? TREE_CHAIN (t) : NULL;
- }
- }
-
determine_versionability (node, info);
if (node->has_gimple_body_p ())
{
{
fprintf (dump_file, " replacing ");
ipa_dump_param (dump_file, info, parm_num);
-
+
fprintf (dump_file, " with const ");
print_generic_expr (dump_file, value, 0);
fprintf (dump_file, "\n");
fprintf (dump_file, " setting count of the specialized node to "
HOST_WIDE_INT_PRINT_DEC "\n", (HOST_WIDE_INT) new_node->count);
- for (cs = new_node->callees; cs ; cs = cs->next_callee)
+ for (cs = new_node->callees; cs; cs = cs->next_callee)
fprintf (dump_file, " edge to %s has count "
HOST_WIDE_INT_PRINT_DEC "\n",
cs->callee->name (), (HOST_WIDE_INT) cs->count);
fprintf (dump_file, " setting count of the original node to "
HOST_WIDE_INT_PRINT_DEC "\n", (HOST_WIDE_INT) orig_node->count);
- for (cs = orig_node->callees; cs ; cs = cs->next_callee)
+ for (cs = orig_node->callees; cs; cs = cs->next_callee)
fprintf (dump_file, " edge to %s is left with "
HOST_WIDE_INT_PRINT_DEC "\n",
cs->callee->name (), (HOST_WIDE_INT) cs->count);
remainder = orig_node_count - new_sum;
orig_node->count = remainder;
- for (cs = new_node->callees; cs ; cs = cs->next_callee)
+ for (cs = new_node->callees; cs; cs = cs->next_callee)
if (cs->frequency)
cs->count = apply_probability (cs->count,
- GCOV_COMPUTE_SCALE (new_sum,
- orig_node_count));
+ GCOV_COMPUTE_SCALE (new_sum,
+ orig_node_count));
else
cs->count = 0;
- for (cs = orig_node->callees; cs ; cs = cs->next_callee)
+ for (cs = orig_node->callees; cs; cs = cs->next_callee)
cs->count = apply_probability (cs->count,
- GCOV_COMPUTE_SCALE (remainder,
- orig_node_count));
+ GCOV_COMPUTE_SCALE (remainder,
+ orig_node_count));
if (dump_file)
dump_profile_updates (orig_node, new_node);
new_node->count += redirected_sum;
orig_node->count -= redirected_sum;
- for (cs = new_node->callees; cs ; cs = cs->next_callee)
+ for (cs = new_node->callees; cs; cs = cs->next_callee)
if (cs->frequency)
cs->count += apply_probability (cs->count,
- GCOV_COMPUTE_SCALE (redirected_sum,
- new_node_count));
+ GCOV_COMPUTE_SCALE (redirected_sum,
+ new_node_count));
else
cs->count = 0;
- for (cs = orig_node->callees; cs ; cs = cs->next_callee)
+ for (cs = orig_node->callees; cs; cs = cs->next_callee)
{
gcov_type dec = apply_probability (cs->count,
- GCOV_COMPUTE_SCALE (redirected_sum,
- orig_node_count));
+ GCOV_COMPUTE_SCALE (redirected_sum,
+ orig_node_count));
if (dec < cs->count)
cs->count -= dec;
else
fprintf (dump_file, " cannot change function signature\n");
}
- for (i = 0; i < count ; i++)
+ for (i = 0; i < count; i++)
{
tree t = known_csts[i];
if (t)
args_to_skip, "constprop");
ipa_set_node_agg_value_chain (new_node, aggvals);
for (av = aggvals; av; av = av->next)
- new_node->maybe_create_reference (av->value, IPA_REF_ADDR, NULL);
+ new_node->maybe_create_reference (av->value, NULL);
if (dump_file && (dump_flags & TDF_DETAILS))
{
new_node->name (), new_node->order);
if (known_contexts.exists ())
{
- for (i = 0; i < count ; i++)
+ for (i = 0; i < count; i++)
if (!known_contexts[i].useless_p ())
{
fprintf (dump_file, " known ctx %i is ", i);
struct ipa_node_params *info = IPA_NODE_REF (node);
int i, count = ipa_get_param_count (info);
- for (i = 0; i < count ; i++)
+ for (i = 0; i < count; i++)
{
struct cgraph_edge *cs;
tree newval = NULL_TREE;
struct ipa_jump_func *jump_func;
tree t;
- if (i >= ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
+ if (i >= ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
|| (i == 0
&& call_passes_through_thunk_p (cs))
|| (!cs->callee->instrumentation_clone
&& cs->callee->function_symbol ()->instrumentation_clone))
- {
- newval = NULL_TREE;
- break;
- }
+ {
+ newval = NULL_TREE;
+ break;
+ }
jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i);
t = ipa_value_from_jfunc (IPA_NODE_REF (cs->caller), jump_func);
if (!t
ipa_node_params *info = IPA_NODE_REF (node);
int i, count = ipa_get_param_count (info);
- for (i = 0; i < count ; i++)
+ for (i = 0; i < count; i++)
{
cgraph_edge *cs;
}
}
-/* Copy agggregate replacement values of NODE (which is an IPA-CP clone) to the
+/* Copy aggregate replacement values of NODE (which is an IPA-CP clone) to the
vector result while subtracting OFFSET from the individual value offsets. */
static vec<ipa_agg_jf_item>
count = c;
}
- for (i = 0; i < count ; i++)
+ for (i = 0; i < count; i++)
{
struct cgraph_edge *cs;
vec<ipa_agg_jf_item> inter = vNULL;
return res;
}
-/* Turn KNOWN_AGGS into a list of aggreate replacement values. */
+/* Turn KNOWN_AGGS into a list of aggregate replacement values. */
static struct ipa_agg_replacement_value *
known_aggs_to_agg_replacement_list (vec<ipa_agg_jump_function> known_aggs)
info->do_clone_for_all_contexts ? &known_aggs
: NULL, NULL);
- for (i = 0; i < count ;i++)
+ for (i = 0; i < count;i++)
{
struct ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
ipcp_lattice<tree> *lat = &plats->itself;
known_contexts);
}
- info = IPA_NODE_REF (node);
+ info = IPA_NODE_REF (node);
}
if (info->do_clone_for_all_contexts)
info = IPA_NODE_REF (node);
info->do_clone_for_all_contexts = false;
IPA_NODE_REF (clone)->is_all_contexts_clone = true;
- for (i = 0; i < count ; i++)
+ for (i = 0; i < count; i++)
vec_free (known_aggs[i].items);
known_aggs.release ();
ret = true;
static bool
has_undead_caller_from_outside_scc_p (struct cgraph_node *node,
- void *data ATTRIBUTE_UNUSED)
+ void *data ATTRIBUTE_UNUSED)
{
struct cgraph_edge *cs;
identify_dead_nodes (struct cgraph_node *node)
{
struct cgraph_node *v;
- for (v = node; v ; v = ((struct ipa_dfs_info *) v->aux)->next_cycle)
+ for (v = node; v; v = ((struct ipa_dfs_info *) v->aux)->next_cycle)
if (v->local.local
&& !v->call_for_symbol_thunks_and_aliases
(has_undead_caller_from_outside_scc_p, NULL, true))
IPA_NODE_REF (v)->node_dead = 1;
- for (v = node; v ; v = ((struct ipa_dfs_info *) v->aux)->next_cycle)
+ for (v = node; v; v = ((struct ipa_dfs_info *) v->aux)->next_cycle)
if (!IPA_NODE_REF (v)->node_dead)
spread_undeadness (v);
if (dump_file && (dump_flags & TDF_DETAILS))
{
- for (v = node; v ; v = ((struct ipa_dfs_info *) v->aux)->next_cycle)
+ for (v = node; v; v = ((struct ipa_dfs_info *) v->aux)->next_cycle)
if (IPA_NODE_REF (v)->node_dead)
fprintf (dump_file, " Marking node as dead: %s/%i.\n",
v->name (), v->order);
{
struct cgraph_node *v;
iterate = false;
- for (v = node; v ; v = ((struct ipa_dfs_info *) v->aux)->next_cycle)
+ for (v = node; v; v = ((struct ipa_dfs_info *) v->aux)->next_cycle)
if (v->has_gimple_body_p ()
&& ipcp_versionable_function_p (v))
iterate |= decide_whether_version_node (v);
}
}
-/* Look up all alignment information that we have discovered and copy it over
- to the transformation summary. */
-
-static void
-ipcp_store_alignment_results (void)
-{
- cgraph_node *node;
-
- FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
- {
- ipa_node_params *info = IPA_NODE_REF (node);
- bool dumped_sth = false;
- bool found_useful_result = false;
-
- if (!opt_for_fn (node->decl, flag_ipa_cp_alignment))
- {
- if (dump_file)
- fprintf (dump_file, "Not considering %s for alignment discovery "
- "and propagate; -fipa-cp-alignment: disabled.\n",
- node->name ());
- continue;
- }
-
- if (info->ipcp_orig_node)
- info = IPA_NODE_REF (info->ipcp_orig_node);
-
- unsigned count = ipa_get_param_count (info);
- for (unsigned i = 0; i < count ; i++)
- {
- ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
- if (!plats->alignment.bottom_p ()
- && !plats->alignment.top_p ())
- {
- gcc_checking_assert (plats->alignment.align > 0);
- found_useful_result = true;
- break;
- }
- }
- if (!found_useful_result)
- continue;
-
- ipcp_grow_transformations_if_necessary ();
- ipcp_transformation_summary *ts = ipcp_get_transformation_summary (node);
- vec_safe_reserve_exact (ts->alignments, count);
-
- for (unsigned i = 0; i < count ; i++)
- {
- ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
- ipa_alignment al;
-
- if (!plats->alignment.bottom_p ()
- && !plats->alignment.top_p ())
- {
- al.known = true;
- al.align = plats->alignment.align;
- al.misalign = plats->alignment.misalign;
- }
- else
- al.known = false;
-
- ts->alignments->quick_push (al);
- if (!dump_file || !al.known)
- continue;
- if (!dumped_sth)
- {
- fprintf (dump_file, "Propagated alignment info for function %s/%i:\n",
- node->name (), node->order);
- dumped_sth = true;
- }
- fprintf (dump_file, " param %i: align: %u, misalign: %u\n",
- i, al.align, al.misalign);
- }
- }
-}
-
/* Look up all the bits information that we have discovered and copy it over
to the transformation summary. */
}
}
- if (!found_useful_result)
- continue;
+ if (!found_useful_result)
+ continue;
- ipcp_grow_transformations_if_necessary ();
- ipcp_transformation_summary *ts = ipcp_get_transformation_summary (node);
- vec_safe_reserve_exact (ts->bits, count);
+ ipcp_grow_transformations_if_necessary ();
+ ipcp_transformation_summary *ts = ipcp_get_transformation_summary (node);
+ vec_safe_reserve_exact (ts->bits, count);
- for (unsigned i = 0; i < count; i++)
- {
- ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
- ipa_bits bits_jfunc;
+ for (unsigned i = 0; i < count; i++)
+ {
+ ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
+ ipa_bits *jfbits;
- if (plats->bits_lattice.constant_p ())
- {
- bits_jfunc.known = true;
- bits_jfunc.value = plats->bits_lattice.get_value ();
- bits_jfunc.mask = plats->bits_lattice.get_mask ();
- }
- else
- bits_jfunc.known = false;
+ if (plats->bits_lattice.constant_p ())
+ jfbits
+ = ipa_get_ipa_bits_for_value (plats->bits_lattice.get_value (),
+ plats->bits_lattice.get_mask ());
+ else
+ jfbits = NULL;
- ts->bits->quick_push (bits_jfunc);
- if (!dump_file || !bits_jfunc.known)
- continue;
- if (!dumped_sth)
- {
- fprintf (dump_file, "Propagated bits info for function %s/%i:\n",
- node->name (), node->order);
- dumped_sth = true;
- }
- fprintf (dump_file, " param %i: value = ", i);
- print_hex (bits_jfunc.value, dump_file);
- fprintf (dump_file, ", mask = ");
- print_hex (bits_jfunc.mask, dump_file);
- fprintf (dump_file, "\n");
- }
+ ts->bits->quick_push (jfbits);
+ if (!dump_file || !jfbits)
+ continue;
+ if (!dumped_sth)
+ {
+ fprintf (dump_file, "Propagated bits info for function %s/%i:\n",
+ node->name (), node->order);
+ dumped_sth = true;
+ }
+ fprintf (dump_file, " param %i: value = ", i);
+ print_hex (jfbits->value, dump_file);
+ fprintf (dump_file, ", mask = ");
+ print_hex (jfbits->mask, dump_file);
+ fprintf (dump_file, "\n");
+ }
}
}
cgraph_node *node;
FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
- {
- ipa_node_params *info = IPA_NODE_REF (node);
- bool found_useful_result = false;
+ {
+ ipa_node_params *info = IPA_NODE_REF (node);
+ bool found_useful_result = false;
- if (!opt_for_fn (node->decl, flag_ipa_vrp))
- {
- if (dump_file)
- fprintf (dump_file, "Not considering %s for VR discovery "
- "and propagate; -fipa-ipa-vrp: disabled.\n",
- node->name ());
- continue;
- }
+ if (!opt_for_fn (node->decl, flag_ipa_vrp))
+ {
+ if (dump_file)
+ fprintf (dump_file, "Not considering %s for VR discovery "
+ "and propagate; -fipa-ipa-vrp: disabled.\n",
+ node->name ());
+ continue;
+ }
- if (info->ipcp_orig_node)
- info = IPA_NODE_REF (info->ipcp_orig_node);
+ if (info->ipcp_orig_node)
+ info = IPA_NODE_REF (info->ipcp_orig_node);
- unsigned count = ipa_get_param_count (info);
- for (unsigned i = 0; i < count ; i++)
- {
- ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
- if (!plats->m_value_range.bottom_p ()
- && !plats->m_value_range.top_p ())
- {
- found_useful_result = true;
- break;
- }
- }
- if (!found_useful_result)
- continue;
+ unsigned count = ipa_get_param_count (info);
+ for (unsigned i = 0; i < count; i++)
+ {
+ ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
+ if (!plats->m_value_range.bottom_p ()
+ && !plats->m_value_range.top_p ())
+ {
+ found_useful_result = true;
+ break;
+ }
+ }
+ if (!found_useful_result)
+ continue;
- ipcp_grow_transformations_if_necessary ();
- ipcp_transformation_summary *ts = ipcp_get_transformation_summary (node);
- vec_safe_reserve_exact (ts->m_vr, count);
+ ipcp_grow_transformations_if_necessary ();
+ ipcp_transformation_summary *ts = ipcp_get_transformation_summary (node);
+ vec_safe_reserve_exact (ts->m_vr, count);
- for (unsigned i = 0; i < count ; i++)
- {
- ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
- ipa_vr vr;
+ for (unsigned i = 0; i < count; i++)
+ {
+ ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
+ ipa_vr vr;
- if (!plats->m_value_range.bottom_p ()
- && !plats->m_value_range.top_p ())
- {
- vr.known = true;
- vr.type = plats->m_value_range.m_vr.type;
- vr.min = plats->m_value_range.m_vr.min;
- vr.max = plats->m_value_range.m_vr.max;
- }
- else
- {
- vr.known = false;
- vr.type = VR_VARYING;
- vr.min = vr.max = wi::zero (INT_TYPE_SIZE);
- }
- ts->m_vr->quick_push (vr);
- }
- }
+ if (!plats->m_value_range.bottom_p ()
+ && !plats->m_value_range.top_p ())
+ {
+ vr.known = true;
+ vr.type = plats->m_value_range.m_vr.type;
+ vr.min = plats->m_value_range.m_vr.min;
+ vr.max = plats->m_value_range.m_vr.max;
+ }
+ else
+ {
+ vr.known = false;
+ vr.type = VR_VARYING;
+ vr.min = vr.max = wi::zero (INT_TYPE_SIZE);
+ }
+ ts->m_vr->quick_push (vr);
+ }
+ }
}
/* The IPCP driver. */
ipa_check_create_node_params ();
ipa_check_create_edge_args ();
grow_edge_clone_vectors ();
- edge_duplication_hook_holder =
- symtab->add_edge_duplication_hook (&ipcp_edge_duplication_hook, NULL);
- edge_removal_hook_holder =
- symtab->add_edge_removal_hook (&ipcp_edge_removal_hook, NULL);
+ edge_duplication_hook_holder
+ = symtab->add_edge_duplication_hook (&ipcp_edge_duplication_hook, NULL);
+ edge_removal_hook_holder
+ = symtab->add_edge_removal_hook (&ipcp_edge_removal_hook, NULL);
if (dump_file)
{
fprintf (dump_file, "\nIPA structures before propagation:\n");
if (dump_flags & TDF_DETAILS)
- ipa_print_all_params (dump_file);
+ ipa_print_all_params (dump_file);
ipa_print_all_jump_functions (dump_file);
}
ipcp_propagate_stage (&topo);
/* Decide what constant propagation and cloning should be performed. */
ipcp_decision_stage (&topo);
- /* Store results of alignment propagation. */
- ipcp_store_alignment_results ();
/* Store results of bits propagation. */
ipcp_store_bits_results ();
/* Store results of value range propagation. */
projects / gcc.git / blobdiff