mirror of
git://gcc.gnu.org/git/gcc.git
synced 2025-04-06 19:51:51 +08:00
ipa-cp: Better representation of aggregate values we clone for
This patch replaces linked lists of ipa_agg_replacement_value with vectors of similar structures called ipa_argagg_value and simplifies how we compute them in the first place. Having a vector should also result in less overhead when allocating and because we keep it sorted, it leads to logarithmic searches. The slightly obnoxious "argagg" bit in the name can be changed into "agg" after the next patch removes our current ipa_agg_value type. The patch also introduces type ipa_argagg_value_list which serves as a common view into a vector of ipa_argagg_value structures regardless whether they are stored in GC memory (required for IPA-CP transformation summary because we store trees) or in an auto_vec which is hopefully usually only allocated on stack. The calculation of aggreagete costant values for a given subsert of callers is then rewritten to compute known constants for each edge (some pruning to skip obviously not needed is still employed and should not be really worse than what I am replacing) and these vectors are there intersected, which can be done linearly since they are sorted. The patch also removes a lot of heap allocations of small lists of aggregate values and replaces them with stack based auto_vecs. As Richard Sandiford suggested, I use std::lower_bound from <algorithm> rather than re-implementing bsearch for array_slice. The patch depends on the patch which adds the ability to construct array_slices from gc-allocated vectors. gcc/ChangeLog: 2022-10-17 Martin Jambor <mjambor@suse.cz> * ipa-prop.h (IPA_PROP_ARG_INDEX_LIMIT_BITS): New. (ipcp_transformation): Added forward declaration. (ipa_argagg_value): New type. (ipa_argagg_value_list): New type. (ipa_agg_replacement_value): Removed type. (ipcp_transformation): Switch from using ipa_agg_replacement_value to ipa_argagg_value_list. (ipa_get_agg_replacements_for_node): Removed. (ipa_dump_agg_replacement_values): Removed declaration. * ipa-cp.cc: Define INCLUDE_ALGORITHM. (values_equal_for_ipcp_p): Moved up in the file. (ipa_argagg_value_list::dump): New function. (ipa_argagg_value_list::debug): Likewise. (ipa_argagg_value_list::get_elt): Likewise. (ipa_argagg_value_list::get_elt_for_index): Likewise. (ipa_argagg_value_list::get_value): New overloaded functions. (ipa_argagg_value_list::superset_of_p): New function. (new ipa_argagg_value_list::push_adjusted_values): Likewise. (push_agg_values_from_plats): Likewise. (intersect_argaggs_with): Likewise. (get_clone_agg_value): Removed. (ipa_agg_value_from_node): Make last parameter const, use ipa_argagg_value_list to search values coming from clones. (ipa_get_indirect_edge_target_1): Use ipa_argagg_value_list to search values coming from clones. (ipcp_discover_new_direct_edges): Pass around a vector of ipa_argagg_values rather than a link list of replacement values. (cgraph_edge_brings_value_p): Use ipa_argagg_value_list to search values coming from clones. (create_specialized_node): Work with a vector of ipa_argagg_values rather than a link list of replacement values. (self_recursive_agg_pass_through_p): Make the pointer parameters const. (copy_plats_to_inter): Removed. (intersect_with_plats): Likewise. (agg_replacements_to_vector): Likewise. (intersect_with_agg_replacements): Likewise. (intersect_aggregates_with_edge): Likewise. (push_agg_values_for_index_from_edge): Likewise. (push_agg_values_from_edge): Likewise. (find_aggregate_values_for_callers_subset): Rewrite. (cgraph_edge_brings_all_agg_vals_for_node): Likewise. (ipcp_val_agg_replacement_ok_p): Use ipa_argagg_value_list to search aggregate values. (decide_about_value): Work with a vector of ipa_argagg_values rather than a link list of replacement values. (decide_whether_version_node): Likewise. (ipa_analyze_node): Check number of parameters, assert that there are no descriptors when bailing out. * ipa-prop.cc (ipa_set_node_agg_value_chain): Switch to a vector of ipa_argagg_value. (ipa_node_params_t::duplicate): Removed superfluous handling of ipa_agg_replacement_values. Name of src parameter removed because it is no longer used. (ipcp_transformation_t::duplicate): Replaced duplication of ipa_agg_replacement_values with copying vector m_agg_values. (ipa_dump_agg_replacement_values): Removed. (write_ipcp_transformation_info): Stream the new data-structure instead of the old. (read_ipcp_transformation_info): Likewise. (adjust_agg_replacement_values): Work with ipa_argagg_values instead of linked lists of ipa_agg_replacement_values, copy the items and truncate the vector as necessary to keep it sorted instead of marking items as invalid. Return one bool if CFG should be updated. (ipcp_modif_dom_walker): Store ipcp_transformation instead of linked list of ipa_agg_replacement_values. (ipcp_modif_dom_walker::before_dom_children): Use ipa_argagg_value_list instead of walking a list of ipa_agg_replacement_values. (ipcp_transform_function): Switch to the new data structure, adjust dumping. gcc/testsuite/ChangeLog: 2022-08-15 Martin Jambor <mjambor@suse.cz> * gcc.dg/ipa/ipcp-agg-11.c: Adjust dumps. * gcc.dg/ipa/ipcp-agg-8.c: Likewise.
This commit is contained in:
Martin Jambor
parent
e73fe9e162
commit
e0403e9568
1012
gcc/ipa-cp.cc
1012
gcc/ipa-cp.cc
File diff suppressed because it is too large
Load Diff
262
gcc/ipa-prop.cc
262
gcc/ipa-prop.cc
@ -1095,7 +1095,10 @@ parm_ref_data_pass_through_p (struct ipa_func_body_info *fbi, int index,
|
||||
latter can be NULL), STMT is the load statement. If function returns true,
|
||||
*INDEX_P, *OFFSET_P and *BY_REF is filled with the parameter index, offset
|
||||
within the aggregate and whether it is a load from a value passed by
|
||||
reference respectively. */
|
||||
reference respectively.
|
||||
|
||||
Return false if the offset divided by BITS_PER_UNIT would not fit into an
|
||||
unsigned int. */
|
||||
|
||||
bool
|
||||
ipa_load_from_parm_agg (struct ipa_func_body_info *fbi,
|
||||
@ -1109,7 +1112,8 @@ ipa_load_from_parm_agg (struct ipa_func_body_info *fbi,
|
||||
bool reverse;
|
||||
tree base = get_ref_base_and_extent_hwi (op, offset_p, &size, &reverse);
|
||||
|
||||
if (!base)
|
||||
if (!base
|
||||
|| (*offset_p / BITS_PER_UNIT) > UINT_MAX)
|
||||
return false;
|
||||
|
||||
/* We can not propagate across volatile loads. */
|
||||
@ -3057,13 +3061,11 @@ ipa_analyze_node (struct cgraph_node *node)
|
||||
return;
|
||||
info->analysis_done = 1;
|
||||
|
||||
if (ipa_func_spec_opts_forbid_analysis_p (node))
|
||||
if (ipa_func_spec_opts_forbid_analysis_p (node)
|
||||
|| (count_formal_params (node->decl)
|
||||
>= (1 << IPA_PROP_ARG_INDEX_LIMIT_BITS)))
|
||||
{
|
||||
for (int i = 0; i < ipa_get_param_count (info); i++)
|
||||
{
|
||||
ipa_set_param_used (info, i, true);
|
||||
ipa_set_controlled_uses (info, i, IPA_UNDESCRIBED_USE);
|
||||
}
|
||||
gcc_assert (!ipa_get_param_count (info));
|
||||
return;
|
||||
}
|
||||
|
||||
@ -4383,11 +4385,11 @@ ipcp_free_transformation_sum (void)
|
||||
|
||||
void
|
||||
ipa_set_node_agg_value_chain (struct cgraph_node *node,
|
||||
struct ipa_agg_replacement_value *aggvals)
|
||||
vec<ipa_argagg_value, va_gc> *aggs)
|
||||
{
|
||||
ipcp_transformation_initialize ();
|
||||
ipcp_transformation *s = ipcp_transformation_sum->get_create (node);
|
||||
s->agg_values = aggvals;
|
||||
s->m_agg_values = aggs;
|
||||
}
|
||||
|
||||
/* Hook that is called by cgraph.cc when an edge is removed. Adjust reference
|
||||
@ -4532,12 +4534,10 @@ ipa_add_new_function (cgraph_node *node, void *data ATTRIBUTE_UNUSED)
|
||||
/* Hook that is called by summary when a node is duplicated. */
|
||||
|
||||
void
|
||||
ipa_node_params_t::duplicate(cgraph_node *src, cgraph_node *dst,
|
||||
ipa_node_params_t::duplicate(cgraph_node *, cgraph_node *,
|
||||
ipa_node_params *old_info,
|
||||
ipa_node_params *new_info)
|
||||
{
|
||||
ipa_agg_replacement_value *old_av, *new_av;
|
||||
|
||||
new_info->descriptors = vec_safe_copy (old_info->descriptors);
|
||||
new_info->lattices = NULL;
|
||||
new_info->ipcp_orig_node = old_info->ipcp_orig_node;
|
||||
@ -4547,23 +4547,6 @@ ipa_node_params_t::duplicate(cgraph_node *src, cgraph_node *dst,
|
||||
new_info->analysis_done = old_info->analysis_done;
|
||||
new_info->node_enqueued = old_info->node_enqueued;
|
||||
new_info->versionable = old_info->versionable;
|
||||
|
||||
old_av = ipa_get_agg_replacements_for_node (src);
|
||||
if (old_av)
|
||||
{
|
||||
new_av = NULL;
|
||||
while (old_av)
|
||||
{
|
||||
struct ipa_agg_replacement_value *v;
|
||||
|
||||
v = ggc_alloc<ipa_agg_replacement_value> ();
|
||||
memcpy (v, old_av, sizeof (*v));
|
||||
v->next = new_av;
|
||||
new_av = v;
|
||||
old_av = old_av->next;
|
||||
}
|
||||
ipa_set_node_agg_value_chain (dst, new_av);
|
||||
}
|
||||
}
|
||||
|
||||
/* Duplication of ipcp transformation summaries. */
|
||||
@ -4576,17 +4559,9 @@ ipcp_transformation_t::duplicate(cgraph_node *, cgraph_node *dst,
|
||||
/* Avoid redundant work of duplicating vectors we will never use. */
|
||||
if (dst->inlined_to)
|
||||
return;
|
||||
dst_trans->m_agg_values = vec_safe_copy (src_trans->m_agg_values);
|
||||
dst_trans->bits = vec_safe_copy (src_trans->bits);
|
||||
dst_trans->m_vr = vec_safe_copy (src_trans->m_vr);
|
||||
ipa_agg_replacement_value *agg = src_trans->agg_values,
|
||||
**aggptr = &dst_trans->agg_values;
|
||||
while (agg)
|
||||
{
|
||||
*aggptr = ggc_alloc<ipa_agg_replacement_value> ();
|
||||
**aggptr = *agg;
|
||||
agg = agg->next;
|
||||
aggptr = &(*aggptr)->next;
|
||||
}
|
||||
}
|
||||
|
||||
/* Register our cgraph hooks if they are not already there. */
|
||||
@ -4703,23 +4678,6 @@ ipa_print_all_params (FILE * f)
|
||||
ipa_print_node_params (f, node);
|
||||
}
|
||||
|
||||
/* Dump the AV linked list. */
|
||||
|
||||
void
|
||||
ipa_dump_agg_replacement_values (FILE *f, struct ipa_agg_replacement_value *av)
|
||||
{
|
||||
bool comma = false;
|
||||
fprintf (f, " Aggregate replacements:");
|
||||
for (; av; av = av->next)
|
||||
{
|
||||
fprintf (f, "%s %i[" HOST_WIDE_INT_PRINT_DEC "]=", comma ? "," : "",
|
||||
av->index, av->offset);
|
||||
print_generic_expr (f, av->value);
|
||||
comma = true;
|
||||
}
|
||||
fprintf (f, "\n");
|
||||
}
|
||||
|
||||
/* Stream out jump function JUMP_FUNC to OB. */
|
||||
|
||||
static void
|
||||
@ -5356,31 +5314,31 @@ write_ipcp_transformation_info (output_block *ob, cgraph_node *node)
|
||||
int node_ref;
|
||||
unsigned int count = 0;
|
||||
lto_symtab_encoder_t encoder;
|
||||
struct ipa_agg_replacement_value *aggvals, *av;
|
||||
|
||||
aggvals = ipa_get_agg_replacements_for_node (node);
|
||||
encoder = ob->decl_state->symtab_node_encoder;
|
||||
node_ref = lto_symtab_encoder_encode (encoder, node);
|
||||
streamer_write_uhwi (ob, node_ref);
|
||||
|
||||
for (av = aggvals; av; av = av->next)
|
||||
count++;
|
||||
streamer_write_uhwi (ob, count);
|
||||
|
||||
for (av = aggvals; av; av = av->next)
|
||||
{
|
||||
struct bitpack_d bp;
|
||||
|
||||
streamer_write_uhwi (ob, av->offset);
|
||||
streamer_write_uhwi (ob, av->index);
|
||||
stream_write_tree (ob, av->value, true);
|
||||
|
||||
bp = bitpack_create (ob->main_stream);
|
||||
bp_pack_value (&bp, av->by_ref, 1);
|
||||
streamer_write_bitpack (&bp);
|
||||
}
|
||||
|
||||
ipcp_transformation *ts = ipcp_get_transformation_summary (node);
|
||||
if (ts && !vec_safe_is_empty (ts->m_agg_values))
|
||||
{
|
||||
streamer_write_uhwi (ob, ts->m_agg_values->length ());
|
||||
for (const ipa_argagg_value &av : ts->m_agg_values)
|
||||
{
|
||||
struct bitpack_d bp;
|
||||
|
||||
stream_write_tree (ob, av.value, true);
|
||||
streamer_write_uhwi (ob, av.unit_offset);
|
||||
streamer_write_uhwi (ob, av.index);
|
||||
|
||||
bp = bitpack_create (ob->main_stream);
|
||||
bp_pack_value (&bp, av.by_ref, 1);
|
||||
streamer_write_bitpack (&bp);
|
||||
}
|
||||
}
|
||||
else
|
||||
streamer_write_uhwi (ob, 0);
|
||||
|
||||
if (ts && vec_safe_length (ts->m_vr) > 0)
|
||||
{
|
||||
count = ts->m_vr->length ();
|
||||
@ -5432,26 +5390,27 @@ static void
|
||||
read_ipcp_transformation_info (lto_input_block *ib, cgraph_node *node,
|
||||
data_in *data_in)
|
||||
{
|
||||
struct ipa_agg_replacement_value *aggvals = NULL;
|
||||
unsigned int count, i;
|
||||
|
||||
count = streamer_read_uhwi (ib);
|
||||
for (i = 0; i <count; i++)
|
||||
if (count > 0)
|
||||
{
|
||||
struct ipa_agg_replacement_value *av;
|
||||
struct bitpack_d bp;
|
||||
ipcp_transformation_initialize ();
|
||||
ipcp_transformation *ts = ipcp_transformation_sum->get_create (node);
|
||||
vec_safe_grow_cleared (ts->m_agg_values, count, true);
|
||||
for (i = 0; i <count; i++)
|
||||
{
|
||||
ipa_argagg_value *av = &(*ts->m_agg_values)[i];;
|
||||
|
||||
av = ggc_alloc<ipa_agg_replacement_value> ();
|
||||
av->offset = streamer_read_uhwi (ib);
|
||||
av->index = streamer_read_uhwi (ib);
|
||||
av->value = stream_read_tree (ib, data_in);
|
||||
bp = streamer_read_bitpack (ib);
|
||||
av->by_ref = bp_unpack_value (&bp, 1);
|
||||
av->next = aggvals;
|
||||
aggvals = av;
|
||||
av->value = stream_read_tree (ib, data_in);
|
||||
av->unit_offset = streamer_read_uhwi (ib);
|
||||
av->index = streamer_read_uhwi (ib);
|
||||
|
||||
bitpack_d bp = streamer_read_bitpack (ib);
|
||||
av->by_ref = bp_unpack_value (&bp, 1);
|
||||
}
|
||||
}
|
||||
ipa_set_node_agg_value_chain (node, aggvals);
|
||||
|
||||
|
||||
count = streamer_read_uhwi (ib);
|
||||
if (count > 0)
|
||||
{
|
||||
@ -5595,56 +5554,75 @@ ipcp_read_transformation_summaries (void)
|
||||
}
|
||||
}
|
||||
|
||||
/* Adjust the aggregate replacements in AGGVAL to reflect parameters skipped in
|
||||
/* Adjust the aggregate replacements in TS to reflect parameters skipped in
|
||||
NODE but also if any parameter was IPA-SRAed into a scalar go ahead with
|
||||
substitution of the default_definitions of that new param with the
|
||||
appropriate constant.
|
||||
|
||||
Return two bools. the first it true if at least one item in AGGVAL still
|
||||
exists and function body walk should go ahead. The second is true if any
|
||||
values were already substituted for scalarized parameters and update_cfg
|
||||
shuld be run after replace_uses_by. */
|
||||
If after adjustments there are no aggregate replacements left, the
|
||||
m_agg_values will be set to NULL. In other cases, it may be shrunk.
|
||||
|
||||
static std::pair<bool, bool>
|
||||
Return true if any values were already substituted for scalarized parameters
|
||||
and update_cfg shuld be run after replace_uses_by. */
|
||||
|
||||
static bool
|
||||
adjust_agg_replacement_values (cgraph_node *node,
|
||||
ipa_agg_replacement_value *aggval,
|
||||
ipcp_transformation *ts,
|
||||
const vec<ipa_param_descriptor, va_gc>
|
||||
&descriptors)
|
||||
{
|
||||
struct ipa_agg_replacement_value *v;
|
||||
clone_info *cinfo = clone_info::get (node);
|
||||
if (!cinfo || !cinfo->param_adjustments)
|
||||
return std::pair<bool, bool> (true, false);
|
||||
return false;
|
||||
|
||||
bool anything_left = false;
|
||||
bool removed_item = false;
|
||||
bool done_replacement = false;
|
||||
for (v = aggval; v; v = v->next)
|
||||
unsigned dst_index = 0;
|
||||
unsigned count = ts->m_agg_values->length ();
|
||||
for (unsigned i = 0; i < count; i++)
|
||||
{
|
||||
ipa_argagg_value *v = &(*ts->m_agg_values)[i];
|
||||
gcc_checking_assert (v->index >= 0);
|
||||
|
||||
unsigned unit_offset = v->offset / BITS_PER_UNIT;
|
||||
tree cst_type = TREE_TYPE (v->value);
|
||||
int split_idx;
|
||||
int new_idx
|
||||
= cinfo->param_adjustments->get_updated_index_or_split (v->index,
|
||||
unit_offset,
|
||||
v->unit_offset,
|
||||
cst_type,
|
||||
&split_idx);
|
||||
v->index = new_idx;
|
||||
if (new_idx >= 0)
|
||||
anything_left = true;
|
||||
else if (split_idx >= 0)
|
||||
{
|
||||
tree parm = ipa_get_param (descriptors, split_idx);
|
||||
tree ddef = ssa_default_def (cfun, parm);
|
||||
if (ddef)
|
||||
v->index = new_idx;
|
||||
if (removed_item)
|
||||
(*ts->m_agg_values)[dst_index] = *v;
|
||||
dst_index++;
|
||||
}
|
||||
else
|
||||
{
|
||||
removed_item = true;
|
||||
if (split_idx >= 0)
|
||||
{
|
||||
replace_uses_by (ddef, v->value);
|
||||
done_replacement = true;
|
||||
tree parm = ipa_get_param (descriptors, split_idx);
|
||||
tree ddef = ssa_default_def (cfun, parm);
|
||||
if (ddef)
|
||||
{
|
||||
replace_uses_by (ddef, v->value);
|
||||
done_replacement = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return std::pair<bool, bool> (anything_left, done_replacement);
|
||||
|
||||
if (dst_index == 0)
|
||||
{
|
||||
ggc_free (ts->m_agg_values);
|
||||
ts->m_agg_values = NULL;
|
||||
}
|
||||
else if (removed_item)
|
||||
ts->m_agg_values->truncate (dst_index);
|
||||
|
||||
return done_replacement;
|
||||
}
|
||||
|
||||
/* Dominator walker driving the ipcp modification phase. */
|
||||
@ -5654,10 +5632,9 @@ class ipcp_modif_dom_walker : public dom_walker
|
||||
public:
|
||||
ipcp_modif_dom_walker (struct ipa_func_body_info *fbi,
|
||||
vec<ipa_param_descriptor, va_gc> *descs,
|
||||
struct ipa_agg_replacement_value *av,
|
||||
bool *sc)
|
||||
ipcp_transformation *ts, bool *sc)
|
||||
: dom_walker (CDI_DOMINATORS), m_fbi (fbi), m_descriptors (descs),
|
||||
m_aggval (av), m_something_changed (sc) {}
|
||||
m_ts (ts), m_something_changed (sc) {}
|
||||
|
||||
edge before_dom_children (basic_block) final override;
|
||||
bool cleanup_eh ()
|
||||
@ -5666,7 +5643,7 @@ public:
|
||||
private:
|
||||
struct ipa_func_body_info *m_fbi;
|
||||
vec<ipa_param_descriptor, va_gc> *m_descriptors;
|
||||
struct ipa_agg_replacement_value *m_aggval;
|
||||
ipcp_transformation *m_ts;
|
||||
bool *m_something_changed;
|
||||
auto_bitmap m_need_eh_cleanup;
|
||||
};
|
||||
@ -5677,10 +5654,9 @@ ipcp_modif_dom_walker::before_dom_children (basic_block bb)
|
||||
gimple_stmt_iterator gsi;
|
||||
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
||||
{
|
||||
struct ipa_agg_replacement_value *v;
|
||||
gimple *stmt = gsi_stmt (gsi);
|
||||
tree rhs, val, t;
|
||||
HOST_WIDE_INT offset;
|
||||
HOST_WIDE_INT bit_offset;
|
||||
poly_int64 size;
|
||||
int index;
|
||||
bool by_ref, vce;
|
||||
@ -5708,32 +5684,30 @@ ipcp_modif_dom_walker::before_dom_children (basic_block bb)
|
||||
continue;
|
||||
|
||||
if (!ipa_load_from_parm_agg (m_fbi, m_descriptors, stmt, rhs, &index,
|
||||
&offset, &size, &by_ref))
|
||||
&bit_offset, &size, &by_ref))
|
||||
continue;
|
||||
for (v = m_aggval; v; v = v->next)
|
||||
if (v->index == index
|
||||
&& v->offset == offset)
|
||||
break;
|
||||
unsigned unit_offset = bit_offset / BITS_PER_UNIT;
|
||||
ipa_argagg_value_list avl (m_ts);
|
||||
tree v = avl.get_value (index, unit_offset, by_ref);
|
||||
|
||||
if (!v
|
||||
|| v->by_ref != by_ref
|
||||
|| maybe_ne (tree_to_poly_int64 (TYPE_SIZE (TREE_TYPE (v->value))),
|
||||
size))
|
||||
|| maybe_ne (tree_to_poly_int64 (TYPE_SIZE (TREE_TYPE (v))), size))
|
||||
continue;
|
||||
|
||||
gcc_checking_assert (is_gimple_ip_invariant (v->value));
|
||||
if (!useless_type_conversion_p (TREE_TYPE (rhs), TREE_TYPE (v->value)))
|
||||
gcc_checking_assert (is_gimple_ip_invariant (v));
|
||||
if (!useless_type_conversion_p (TREE_TYPE (rhs), TREE_TYPE (v)))
|
||||
{
|
||||
if (fold_convertible_p (TREE_TYPE (rhs), v->value))
|
||||
val = fold_build1 (NOP_EXPR, TREE_TYPE (rhs), v->value);
|
||||
if (fold_convertible_p (TREE_TYPE (rhs), v))
|
||||
val = fold_build1 (NOP_EXPR, TREE_TYPE (rhs), v);
|
||||
else if (TYPE_SIZE (TREE_TYPE (rhs))
|
||||
== TYPE_SIZE (TREE_TYPE (v->value)))
|
||||
val = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (rhs), v->value);
|
||||
== TYPE_SIZE (TREE_TYPE (v)))
|
||||
val = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (rhs), v);
|
||||
else
|
||||
{
|
||||
if (dump_file)
|
||||
{
|
||||
fprintf (dump_file, " const ");
|
||||
print_generic_expr (dump_file, v->value);
|
||||
print_generic_expr (dump_file, v);
|
||||
fprintf (dump_file, " can't be converted to type of ");
|
||||
print_generic_expr (dump_file, rhs);
|
||||
fprintf (dump_file, "\n");
|
||||
@ -5742,7 +5716,7 @@ ipcp_modif_dom_walker::before_dom_children (basic_block bb)
|
||||
}
|
||||
}
|
||||
else
|
||||
val = v->value;
|
||||
val = v;
|
||||
|
||||
if (dump_file && (dump_flags & TDF_DETAILS))
|
||||
{
|
||||
@ -6019,7 +5993,6 @@ ipcp_transform_function (struct cgraph_node *node)
|
||||
{
|
||||
vec<ipa_param_descriptor, va_gc> *descriptors = NULL;
|
||||
struct ipa_func_body_info fbi;
|
||||
struct ipa_agg_replacement_value *aggval;
|
||||
int param_count;
|
||||
|
||||
gcc_checking_assert (cfun);
|
||||
@ -6031,18 +6004,17 @@ ipcp_transform_function (struct cgraph_node *node)
|
||||
|
||||
ipcp_update_bits (node);
|
||||
ipcp_update_vr (node);
|
||||
aggval = ipa_get_agg_replacements_for_node (node);
|
||||
if (!aggval)
|
||||
ipcp_transformation *ts = ipcp_get_transformation_summary (node);
|
||||
if (!ts || vec_safe_is_empty (ts->m_agg_values))
|
||||
return 0;
|
||||
param_count = count_formal_params (node->decl);
|
||||
if (param_count == 0)
|
||||
return 0;
|
||||
vec_safe_grow_cleared (descriptors, param_count, true);
|
||||
ipa_populate_param_decls (node, *descriptors);
|
||||
std::pair<bool, bool> rr
|
||||
= adjust_agg_replacement_values (node, aggval, *descriptors);
|
||||
bool cfg_changed = rr.second;
|
||||
if (!rr.first)
|
||||
|
||||
bool cfg_changed = adjust_agg_replacement_values (node, ts, *descriptors);
|
||||
if (vec_safe_is_empty (ts->m_agg_values))
|
||||
{
|
||||
vec_free (descriptors);
|
||||
if (dump_file)
|
||||
@ -6053,7 +6025,11 @@ ipcp_transform_function (struct cgraph_node *node)
|
||||
return 0;
|
||||
}
|
||||
if (dump_file)
|
||||
ipa_dump_agg_replacement_values (dump_file, aggval);
|
||||
{
|
||||
fprintf (dump_file, " Aggregate replacements:");
|
||||
ipa_argagg_value_list avs (ts);
|
||||
avs.dump (dump_file);
|
||||
}
|
||||
|
||||
fbi.node = node;
|
||||
fbi.info = NULL;
|
||||
@ -6064,7 +6040,7 @@ ipcp_transform_function (struct cgraph_node *node)
|
||||
|
||||
bool modified_mem_access = false;
|
||||
calculate_dominance_info (CDI_DOMINATORS);
|
||||
ipcp_modif_dom_walker walker (&fbi, descriptors, aggval, &modified_mem_access);
|
||||
ipcp_modif_dom_walker walker (&fbi, descriptors, ts, &modified_mem_access);
|
||||
walker.walk (ENTRY_BLOCK_PTR_FOR_FN (cfun));
|
||||
free_dominance_info (CDI_DOMINATORS);
|
||||
cfg_changed |= walker.cleanup_eh ();
|
||||
@ -6076,7 +6052,7 @@ ipcp_transform_function (struct cgraph_node *node)
|
||||
fbi.bb_infos.release ();
|
||||
|
||||
ipcp_transformation *s = ipcp_transformation_sum->get (node);
|
||||
s->agg_values = NULL;
|
||||
s->m_agg_values = NULL;
|
||||
s->bits = NULL;
|
||||
s->m_vr = NULL;
|
||||
|
||||
|
||||
139
gcc/ipa-prop.h
139
gcc/ipa-prop.h
@ -25,6 +25,11 @@ along with GCC; see the file COPYING3. If not see
|
||||
|
||||
#define IPA_UNDESCRIBED_USE -1
|
||||
|
||||
/* Index identifying an actualargument or a formal parameter may have only this
|
||||
many bits. */
|
||||
|
||||
#define IPA_PROP_ARG_INDEX_LIMIT_BITS 16
|
||||
|
||||
/* ipa-prop.cc stuff (ipa-cp, indirect inlining): */
|
||||
|
||||
/* A jump function for a callsite represents the values passed as actual
|
||||
@ -184,6 +189,92 @@ struct GTY(()) ipa_agg_jump_function
|
||||
bool by_ref;
|
||||
};
|
||||
|
||||
class ipcp_transformation;
|
||||
|
||||
/* Element of a vector describing aggregate values for a number of arguments in
|
||||
a particular context, be it a call or the aggregate constants that a node is
|
||||
specialized for. */
|
||||
|
||||
struct GTY(()) ipa_argagg_value
|
||||
{
|
||||
/* The constant value. In the contexts where the list of known values is
|
||||
being pruned, NULL means a variable value. */
|
||||
tree value;
|
||||
/* Unit offset within the aggregate. */
|
||||
unsigned unit_offset;
|
||||
/* Index of the parameter, as it was in the original function (i.e. needs
|
||||
remapping after parameter modification is carried out as part of clone
|
||||
materialization). */
|
||||
unsigned index : IPA_PROP_ARG_INDEX_LIMIT_BITS;
|
||||
/* Whether the value was passed by reference. */
|
||||
unsigned by_ref : 1;
|
||||
};
|
||||
|
||||
/* A view into a sorted list of aggregate values in a particular context, be it
|
||||
a call or the aggregate constants that a node is specialized for. The
|
||||
actual data is stored in the vector this has been constructed from. */
|
||||
|
||||
class ipa_argagg_value_list
|
||||
{
|
||||
public:
|
||||
ipa_argagg_value_list () = delete;
|
||||
ipa_argagg_value_list (const vec<ipa_argagg_value, va_gc> *values)
|
||||
: m_elts (values)
|
||||
{}
|
||||
ipa_argagg_value_list (const vec<ipa_argagg_value> *values)
|
||||
: m_elts (*values)
|
||||
{}
|
||||
ipa_argagg_value_list (const ipcp_transformation *tinfo);
|
||||
|
||||
/* Return the aggregate constant stored for INDEX at UNIT_OFFSET, if it is
|
||||
passed by reference or not according to BY_REF, or NULL_TREE
|
||||
otherwise. */
|
||||
|
||||
tree get_value (int index, unsigned unit_offset, bool by_ref) const;
|
||||
|
||||
/* Return the aggregate constant stored for INDEX at UNIT_OFFSET, not
|
||||
performing any check of whether value is passed by reference. Return
|
||||
NULL_TREE if there is no such constant. */
|
||||
|
||||
tree get_value (int index, unsigned unit_offset) const;
|
||||
|
||||
/* Return the item describing a constant stored for INDEX at UNIT_OFFSET or
|
||||
NULL if there is no such constant. */
|
||||
|
||||
const ipa_argagg_value *get_elt (int index, unsigned unit_offset) const;
|
||||
|
||||
/* Return the first item describing a constant stored for parameter with
|
||||
INDEX, regardless of offset or reference, or NULL if there is no such
|
||||
constant. */
|
||||
|
||||
const ipa_argagg_value *get_elt_for_index (int index) const;
|
||||
|
||||
/* Return true if all elements present in OTHER are also present in this
|
||||
list. */
|
||||
|
||||
bool superset_of_p (const ipa_argagg_value_list &other) const;
|
||||
|
||||
/* Push all items in this list that describe parameter SRC_INDEX into RES as
|
||||
ones describing DST_INDEX while subtracting UNIT_DELTA from their unit
|
||||
offsets but skip those which would end up with a negative offset. */
|
||||
|
||||
void push_adjusted_values (unsigned src_index, unsigned dest_index,
|
||||
unsigned unit_delta,
|
||||
vec<ipa_argagg_value> *res) const;
|
||||
|
||||
/* Dump aggregate constants to FILE. */
|
||||
|
||||
void dump (FILE *f);
|
||||
|
||||
/* Dump aggregate constants to stderr. */
|
||||
|
||||
void DEBUG_FUNCTION debug ();
|
||||
|
||||
/* Array slice pointing to the actual storage. */
|
||||
|
||||
array_slice<const ipa_argagg_value> m_elts;
|
||||
};
|
||||
|
||||
/* An element in an aggregate part describing a known value at a given offset.
|
||||
All unlisted positions are assumed to be unknown and all listed values must
|
||||
fulfill is_gimple_ip_invariant. */
|
||||
@ -882,28 +973,12 @@ ipa_is_param_used_by_polymorphic_call (class ipa_node_params *info, int i)
|
||||
return (*info->descriptors)[i].used_by_polymorphic_call;
|
||||
}
|
||||
|
||||
/* Information about replacements done in aggregates for a given node (each
|
||||
node has its linked list). */
|
||||
struct GTY(()) ipa_agg_replacement_value
|
||||
{
|
||||
/* Next item in the linked list. */
|
||||
struct ipa_agg_replacement_value *next;
|
||||
/* Offset within the aggregate. */
|
||||
HOST_WIDE_INT offset;
|
||||
/* The constant value. */
|
||||
tree value;
|
||||
/* The parameter index. */
|
||||
int index;
|
||||
/* Whether the value was passed by reference. */
|
||||
bool by_ref;
|
||||
};
|
||||
|
||||
/* Structure holding information for the transformation phase of IPA-CP. */
|
||||
|
||||
struct GTY(()) ipcp_transformation
|
||||
{
|
||||
/* Linked list of known aggregate values. */
|
||||
ipa_agg_replacement_value *agg_values;
|
||||
/* Known aggregate values. */
|
||||
vec<ipa_argagg_value, va_gc> *m_agg_values;
|
||||
/* Known bits information. */
|
||||
vec<ipa_bits *, va_gc> *bits;
|
||||
/* Value range information. */
|
||||
@ -911,26 +986,25 @@ struct GTY(()) ipcp_transformation
|
||||
|
||||
/* Default constructor. */
|
||||
ipcp_transformation ()
|
||||
: agg_values (NULL), bits (NULL), m_vr (NULL)
|
||||
: m_agg_values (NULL), bits (NULL), m_vr (NULL)
|
||||
{ }
|
||||
|
||||
/* Default destructor. */
|
||||
~ipcp_transformation ()
|
||||
{
|
||||
ipa_agg_replacement_value *agg = agg_values;
|
||||
while (agg)
|
||||
{
|
||||
ipa_agg_replacement_value *next = agg->next;
|
||||
ggc_free (agg);
|
||||
agg = next;
|
||||
}
|
||||
vec_free (m_agg_values);
|
||||
vec_free (bits);
|
||||
vec_free (m_vr);
|
||||
}
|
||||
};
|
||||
|
||||
inline
|
||||
ipa_argagg_value_list::ipa_argagg_value_list (const ipcp_transformation *tinfo)
|
||||
: m_elts (tinfo->m_agg_values)
|
||||
{}
|
||||
|
||||
void ipa_set_node_agg_value_chain (struct cgraph_node *node,
|
||||
struct ipa_agg_replacement_value *aggvals);
|
||||
vec<ipa_argagg_value, va_gc> *aggs);
|
||||
void ipcp_transformation_initialize (void);
|
||||
void ipcp_free_transformation_sum (void);
|
||||
|
||||
@ -1107,15 +1181,6 @@ ipcp_get_transformation_summary (cgraph_node *node)
|
||||
return ipcp_transformation_sum->get (node);
|
||||
}
|
||||
|
||||
/* Return the aggregate replacements for NODE, if there are any. */
|
||||
|
||||
static inline struct ipa_agg_replacement_value *
|
||||
ipa_get_agg_replacements_for_node (cgraph_node *node)
|
||||
{
|
||||
ipcp_transformation *ts = ipcp_get_transformation_summary (node);
|
||||
return ts ? ts->agg_values : NULL;
|
||||
}
|
||||
|
||||
/* Function formal parameters related computations. */
|
||||
void ipa_initialize_node_params (struct cgraph_node *node);
|
||||
bool ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
|
||||
@ -1171,8 +1236,6 @@ struct ipcp_agg_lattice;
|
||||
|
||||
extern object_allocator<ipcp_agg_lattice> ipcp_agg_lattice_pool;
|
||||
|
||||
void ipa_dump_agg_replacement_values (FILE *f,
|
||||
struct ipa_agg_replacement_value *av);
|
||||
void ipa_prop_write_jump_functions (void);
|
||||
void ipa_prop_read_jump_functions (void);
|
||||
void ipcp_write_transformation_summaries (void);
|
||||
|
||||
@ -73,5 +73,5 @@ entry ()
|
||||
/* { dg-final { scan-ipa-dump "offset: 0, type: int, CONST: 101" "cp" } } */
|
||||
/* { dg-final { scan-ipa-dump "offset: 32, type: int, PASS THROUGH: 0, op trunc_mod_expr 7" "cp" } } */
|
||||
/* { dg-final { scan-ipa-dump "offset: 64, type: int, LOAD AGG: 1 \\\[offset: 0, by reference], op plus_expr 6" "cp" } } */
|
||||
/* { dg-final { scan-ipa-dump "Aggregate replacements: 0\\\[0]=1, 0\\\[32]=105, 0\\\[64]=-18" "cp" } } */
|
||||
/* { dg-final { scan-ipa-dump "Aggregate replacements: 0\\\[0]=101, 0\\\[32]=2, 0\\\[64]=9" "cp" } } */
|
||||
/* { dg-final { scan-ipa-dump "Aggregate replacements: 0\\\[0]=1\\(by_ref\\), 0\\\[4]=105\\(by_ref\\), 0\\\[8]=-18\\(by_ref\\)" "cp" } } */
|
||||
/* { dg-final { scan-ipa-dump "Aggregate replacements: 0\\\[0]=101, 0\\\[4]=2, 0\\\[8]=9" "cp" } } */
|
||||
|
||||
@ -48,5 +48,5 @@ entry (int c)
|
||||
foo (4, i, &s);
|
||||
}
|
||||
}
|
||||
/* { dg-final { scan-ipa-dump "Aggregate replacements: 1\\\[32]=64, 1\\\[64]=32" "cp" } } */
|
||||
/* { dg-final { scan-ipa-dump "Aggregate replacements: 1\\\[32]=0" "cp" } } */
|
||||
/* { dg-final { scan-ipa-dump "Aggregate replacements: 1\\\[4]=64\\(by_ref\\), 1\\\[8]=32\\(by_ref\\)" "cp" } } */
|
||||
/* { dg-final { scan-ipa-dump "Aggregate replacements: 1\\\[4]=0\\(by_ref\\)" "cp" } } */
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user