+void
+write_agg_replacement_chain (struct output_block *ob, struct 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, (symtab_node) 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)
+ {
+ streamer_write_uhwi (ob, av->offset);
+ streamer_write_uhwi (ob, av->index);
+ stream_write_tree (ob, av->value, true);
+ }
+}
+
+/* Stream in the aggregate value replacement chain for NODE from IB. */
+
+static void
+read_agg_replacement_chain (struct lto_input_block *ib,
+ struct cgraph_node *node,
+ struct 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++)
+ {
+ struct ipa_agg_replacement_value *av;
+
+ 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);
+ av->next = aggvals;
+ aggvals = av;
+ }
+ ipa_set_node_agg_value_chain (node, aggvals);
+}
+
+/* Write all aggregate replacement for nodes in set. */
+
+void
+ipa_prop_write_all_agg_replacement (void)
+{
+ struct cgraph_node *node;
+ struct output_block *ob;
+ unsigned int count = 0;
+ lto_symtab_encoder_iterator lsei;
+ lto_symtab_encoder_t encoder;
+
+ if (!ipa_node_agg_replacements)
+ return;
+
+ ob = create_output_block (LTO_section_ipcp_transform);
+ encoder = ob->decl_state->symtab_node_encoder;
+ ob->cgraph_node = NULL;
+ for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
+ lsei_next_function_in_partition (&lsei))
+ {
+ node = lsei_cgraph_node (lsei);
+ if (cgraph_function_with_gimple_body_p (node)
+ && ipa_get_agg_replacements_for_node (node) != NULL)
+ count++;
+ }
+
+ streamer_write_uhwi (ob, count);
+
+ for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
+ lsei_next_function_in_partition (&lsei))
+ {
+ node = lsei_cgraph_node (lsei);
+ if (cgraph_function_with_gimple_body_p (node)
+ && ipa_get_agg_replacements_for_node (node) != NULL)
+ write_agg_replacement_chain (ob, node);
+ }
+ streamer_write_char_stream (ob->main_stream, 0);
+ produce_asm (ob, NULL);
+ destroy_output_block (ob);
+}
+
+/* Read replacements section in file FILE_DATA of length LEN with data
+ DATA. */
+
+static void
+read_replacements_section (struct lto_file_decl_data *file_data,
+ const char *data,
+ size_t len)
+{
+ const struct lto_function_header *header =
+ (const struct lto_function_header *) data;
+ const int cfg_offset = sizeof (struct lto_function_header);
+ const int main_offset = cfg_offset + header->cfg_size;
+ const int string_offset = main_offset + header->main_size;
+ struct data_in *data_in;
+ struct lto_input_block ib_main;
+ unsigned int i;
+ unsigned int count;
+
+ LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
+ header->main_size);
+
+ data_in = lto_data_in_create (file_data, (const char *) data + string_offset,
+ header->string_size, vNULL);
+ count = streamer_read_uhwi (&ib_main);
+
+ for (i = 0; i < count; i++)
+ {
+ unsigned int index;
+ struct cgraph_node *node;
+ lto_symtab_encoder_t encoder;
+
+ index = streamer_read_uhwi (&ib_main);
+ encoder = file_data->symtab_node_encoder;
+ node = cgraph (lto_symtab_encoder_deref (encoder, index));
+ gcc_assert (node->analyzed);
+ read_agg_replacement_chain (&ib_main, node, data_in);
+ }
+ lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
+ len);
+ lto_data_in_delete (data_in);
+}
+
+/* Read IPA-CP aggregate replacements. */
+
+void
+ipa_prop_read_all_agg_replacement (void)
+{
+ struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
+ struct lto_file_decl_data *file_data;
+ unsigned int j = 0;
+
+ while ((file_data = file_data_vec[j++]))
+ {
+ size_t len;
+ const char *data = lto_get_section_data (file_data,
+ LTO_section_ipcp_transform,
+ NULL, &len);
+ if (data)
+ read_replacements_section (file_data, data, len);
+ }
+}
+
+/* Adjust the aggregate replacements in AGGVAL to reflect parameters skipped in
+ NODE. */
+
+static void
+adjust_agg_replacement_values (struct cgraph_node *node,
+ struct ipa_agg_replacement_value *aggval)
+{
+ struct ipa_agg_replacement_value *v;
+ int i, c = 0, d = 0, *adj;
+
+ if (!node->clone.combined_args_to_skip)
+ return;
+
+ for (v = aggval; v; v = v->next)
+ {
+ gcc_assert (v->index >= 0);
+ if (c < v->index)
+ c = v->index;
+ }
+ c++;
+
+ adj = XALLOCAVEC (int, c);
+ for (i = 0; i < c; i++)
+ if (bitmap_bit_p (node->clone.combined_args_to_skip, i))
+ {
+ adj[i] = -1;
+ d++;
+ }
+ else
+ adj[i] = i - d;
+
+ for (v = aggval; v; v = v->next)
+ v->index = adj[v->index];
+}
+
+
+/* Function body transformation phase. */
+
+unsigned int
+ipcp_transform_function (struct cgraph_node *node)
+{
+ vec<ipa_param_descriptor_t> descriptors = vNULL;
+ struct param_analysis_info *parms_ainfo;
+ struct ipa_agg_replacement_value *aggval;
+ gimple_stmt_iterator gsi;
+ basic_block bb;
+ int param_count;
+ bool cfg_changed = false, something_changed = false;
+
+ gcc_checking_assert (cfun);
+ gcc_checking_assert (current_function_decl);
+
+ if (dump_file)
+ fprintf (dump_file, "Modification phase of node %s/%i\n",
+ cgraph_node_name (node), node->uid);
+
+ aggval = ipa_get_agg_replacements_for_node (node);
+ if (!aggval)
+ return 0;
+ param_count = count_formal_params (node->symbol.decl);
+ if (param_count == 0)
+ return 0;
+ adjust_agg_replacement_values (node, aggval);
+ if (dump_file)
+ ipa_dump_agg_replacement_values (dump_file, aggval);
+ parms_ainfo = XALLOCAVEC (struct param_analysis_info, param_count);
+ memset (parms_ainfo, 0, sizeof (struct param_analysis_info) * param_count);
+ descriptors.safe_grow_cleared (param_count);
+ ipa_populate_param_decls (node, descriptors);
+
+ FOR_EACH_BB (bb)
+ 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;
+ int index;
+ bool by_ref, vce;
+
+ if (!gimple_assign_load_p (stmt))
+ continue;
+ rhs = gimple_assign_rhs1 (stmt);
+ if (!is_gimple_reg_type (TREE_TYPE (rhs)))
+ continue;
+
+ vce = false;
+ t = rhs;
+ while (handled_component_p (t))
+ {
+ /* V_C_E can do things like convert an array of integers to one
+ bigger integer and similar things we do not handle below. */
+ if (TREE_CODE (rhs) == VIEW_CONVERT_EXPR)
+ {
+ vce = true;
+ break;
+ }
+ t = TREE_OPERAND (t, 0);
+ }
+ if (vce)
+ continue;
+
+ if (!ipa_load_from_parm_agg_1 (descriptors, parms_ainfo, stmt,
+ rhs, &index, &offset, &by_ref))
+ continue;
+ for (v = aggval; v; v = v->next)
+ if (v->index == index
+ && v->offset == offset)
+ break;
+ if (!v)
+ continue;
+
+ gcc_checking_assert (is_gimple_ip_invariant (v->value));
+ if (!useless_type_conversion_p (TREE_TYPE (rhs), TREE_TYPE (v->value)))
+ {
+ if (fold_convertible_p (TREE_TYPE (rhs), v->value))
+ val = fold_build1 (NOP_EXPR, TREE_TYPE (rhs), v->value);
+ else if (TYPE_SIZE (TREE_TYPE (rhs))
+ == TYPE_SIZE (TREE_TYPE (v->value)))
+ val = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (rhs), v->value);
+ else
+ {
+ if (dump_file)
+ {
+ fprintf (dump_file, " const ");
+ print_generic_expr (dump_file, v->value, 0);
+ fprintf (dump_file, " can't be converted to type of ");
+ print_generic_expr (dump_file, rhs, 0);
+ fprintf (dump_file, "\n");
+ }
+ continue;
+ }
+ }
+ else
+ val = v->value;
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "Modifying stmt:\n ");
+ print_gimple_stmt (dump_file, stmt, 0, 0);
+ }
+ gimple_assign_set_rhs_from_tree (&gsi, val);
+ update_stmt (stmt);
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "into:\n ");
+ print_gimple_stmt (dump_file, stmt, 0, 0);
+ fprintf (dump_file, "\n");
+ }
+
+ something_changed = true;
+ if (maybe_clean_eh_stmt (stmt)
+ && gimple_purge_dead_eh_edges (gimple_bb (stmt)))
+ cfg_changed = true;
+ }
+
+ (*ipa_node_agg_replacements)[node->uid] = NULL;
+ free_parms_ainfo (parms_ainfo, param_count);
+ descriptors.release ();
+
+ if (!something_changed)
+ return 0;
+ else if (cfg_changed)
+ return TODO_update_ssa_only_virtuals | TODO_cleanup_cfg;
+ else
+ return TODO_update_ssa_only_virtuals;
projects / gcc.git / blobdiff