* lto-symtab.c (lto_symtab_entry_def) Add vnode.

	(lto_varpool_replace_node): New.
	(lto_symtab_resolve_symbols): Resolve varpool nodes.
	(lto_symtab_merge_decls_1): Prefer decls with varpool node.
	(lto_symtab_merge_cgraph_nodes_1): Merge varpools.
	* cgraph.h (varpool_node_ptr): New type.
	(varpool_node_ptr): New vector.
	(varpool_node_set_def): New structure.
	(varpool_node_set): New type.
	(varpool_node_set): New vector.
	(varpool_node_set_element_def): New structure.
	(varpool_node_set_element, const_varpool_node_set_element): New types.
	(varpool_node_set_iterator): New type.
	(varpool_node): Add prev pointers, add used_from_other_partition,
	in_other_partition.
	(varpool_node_set_new, varpool_node_set_find, varpool_node_set_add,
	varpool_node_set_remove, dump_varpool_node_set, debug_varpool_node_set,
	varpool_get_node, varpool_remove_node): Declare.
	(vsi_end_p, vsi_next, vsi_node, vsi_start, varpool_node_in_set_p,
	varpool_node_set_size): New inlines.
	* cgraph.c (dump_cgraph_node): Dump asm names of aliases.
	* tree-pass.h (varpool_node_set_def): Forward declare.
	(ipa_opt_pass_d): Summary writting takes vnode sets too.
	(ipa_write_optimization_summaries): Update prototype.
	* ipa-cp.c (ipcp_write_summary): Update.
	* ipa-reference.c (ipa_reference_write_summary): Update.
	* lto-cgraph.c (lto_output_varpool_node): New static function.
	(output_varpool): New function.
	(input_varpool_node): New static function.
	(input_varpool_1): New function.
	(input_cgraph): Input varpool.
	* ipa-pure-const.c (pure_const_write_summary): Update.
	* lto-streamer-out.c (lto_output): Update, output varpool too.
	(write_global_stream): Kill WPA hack.
	(produce_asm_for_decls): Update.
	(output_alias_pair_p): Handle variables.
	(output_unreferenced_globals): Output only needed partition of varpool.
	* ipa-inline.c (inline_write_summary): Update.
	* lto-streamer-in.c (lto_input_tree_ref, lto_input_tree): Do not build cgraph.
	* lto-section-in.c (lto_section_name): Add varpool and jump funcs.
	* ipa.c (hash_varpool_node_set_element, eq_varpool_node_set_element,
	varpool_node_set_new, varpool_node_set_add,
	varpool_node_set_remove, varpool_node_set_find, dump_varpool_node_set,
	debug_varpool_node_set): New functions.
	* passes.c (rest_of_decl_compilation): when in LTO do not finalize.
	(execute_one_pass): Process new decls too.
	(ipa_write_summaries_2): Pass around vsets.
	(ipa_write_summaries_1): Likewise.
	(ipa_write_summaries): Build vset; be more selective about cgraph nodes
	to add.
	(ipa_write_optimization_summaries_1): Pass around vsets.
	(ipa_write_optimization_summaries): Likewise.
	* varpool.c (varpool_get_node): New.
	(varpool_node): Update doubly linked lists.
	(varpool_remove_node): New.
	(dump_varpool_node): More dumping.
	(varpool_enqueue_needed_node): Update doubly linked lists.
	(decide_is_variable_needed): Kill ltrans hack.
	(varpool_finalize_decl): Kill lto hack.
	(varpool_assemble_decl): Skip decls in other partitions.
	(varpool_assemble_pending_decls): Update doubly linkes lists.
	(varpool_empty_needed_queue): Likewise.
	(varpool_extra_name_alias): Likewise.
	* lto-streamer.c (lto_get_section_name): Add vars section.
	* lto-streamer.h (lto_section_type): Update.
	(output_varpool, input_varpool): Declare.

	* lto.c (lto_varpool_node_sets): New.
	(lto_1_to_1_map): Partition varpool too.
	(globalize_context_t, globalize_cross_file_statics,
	lto_scan_statics_in_ref_table, lto_scan_statics_in_cgraph_node,
	lto_scan_statics_in_remaining_global_vars): Remove.
	(lto_promote_cross_file_statics): Rewrite.
	(get_filename_for_set): Take vset argument.
	(lto_wpa_write_files): Pass around vsets.

From-SVN: r158854

1 files changed, 129 insertions, 0 deletions

diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c
index b805768..6405432 100644
--- a/gcc/lto-cgraph.c
+++ b/gcc/lto-cgraph.c
@@ -378,6 +378,45 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
     lto_output_uleb128_stream (ob->main_stream, 0);
 }
 
+/* Output the varpool NODE to OB. 
+   If NODE is not in SET, then NODE is a boundary.  */
+
+static void
+lto_output_varpool_node (struct lto_simple_output_block *ob, struct varpool_node *node,
+		         varpool_node_set set)
+{
+  bool boundary_p = !varpool_node_in_set_p (node, set) && node->analyzed;
+  struct bitpack_d *bp;
+  struct varpool_node *alias;
+  int count = 0;
+
+  lto_output_var_decl_index (ob->decl_state, ob->main_stream, node->decl);
+  bp = bitpack_create ();
+  bp_pack_value (bp, node->externally_visible, 1);
+  bp_pack_value (bp, node->force_output, 1);
+  bp_pack_value (bp, node->finalized, 1);
+  gcc_assert (node->finalized || !node->analyzed);
+  gcc_assert (node->needed);
+  gcc_assert (!node->alias);
+  /* FIXME: We have no idea how we move references around.  For moment assume that
+     everything is used externally.  */
+  bp_pack_value (bp, flag_wpa, 1);  /* used_from_other_parition.  */
+  bp_pack_value (bp, boundary_p, 1);  /* in_other_partition.  */
+  /* Also emit any extra name aliases.  */
+  for (alias = node->extra_name; alias; alias = alias->next)
+    count++;
+  bp_pack_value (bp, count != 0, 1);
+  lto_output_bitpack (ob->main_stream, bp);
+  bitpack_delete (bp);
+
+  if (count)
+    {
+      lto_output_uleb128_stream (ob->main_stream, count);
+      for (alias = node->extra_name; alias; alias = alias->next)
+	lto_output_var_decl_index (ob->decl_state, ob->main_stream, alias->decl);
+    }
+}
+
 /* Stream out profile_summary to OB.  */
 
 static void
@@ -564,6 +603,32 @@ input_overwrite_node (struct lto_file_decl_data *file_data,
   node->frequency = (enum node_frequency)bp_unpack_value (bp, 2);
 }
 
+/* Output the part of the cgraph in SET.  */
+
+void
+output_varpool (varpool_node_set set)
+{
+  struct varpool_node *node;
+  struct lto_simple_output_block *ob;
+  int len = 0;
+
+  ob = lto_create_simple_output_block (LTO_section_varpool);
+
+  for (node = varpool_nodes; node; node = node->next)
+    if (node->needed && node->analyzed)
+      len++;
+
+  lto_output_uleb128_stream (ob->main_stream, len);
+
+  /* Write out the nodes.  We must first output a node and then its clones,
+     otherwise at a time reading back the node there would be nothing to clone
+     from.  */
+  for (node = varpool_nodes; node; node = node->next)
+    if (node->needed && node->analyzed)
+      lto_output_varpool_node (ob, node, set);
+
+  lto_destroy_simple_output_block (ob);
+}
 
 /* Read a node from input_block IB.  TAG is the node's tag just read.
    Return the node read or overwriten.  */
@@ -683,6 +748,48 @@ input_node (struct lto_file_decl_data *file_data,
   return node;
 }
 
+/* Read a node from input_block IB.  TAG is the node's tag just read.
+   Return the node read or overwriten.  */
+
+static struct varpool_node *
+input_varpool_node (struct lto_file_decl_data *file_data,
+		    struct lto_input_block *ib)
+{
+  int decl_index;
+  tree var_decl;
+  struct varpool_node *node;
+  struct bitpack_d *bp;
+  bool aliases_p;
+  int count;
+
+  decl_index = lto_input_uleb128 (ib);
+  var_decl = lto_file_decl_data_get_var_decl (file_data, decl_index);
+  node = varpool_node (var_decl);
+
+  bp = lto_input_bitpack (ib);
+  node->externally_visible = bp_unpack_value (bp, 1);
+  node->force_output = bp_unpack_value (bp, 1);
+  node->finalized = bp_unpack_value (bp, 1);
+  node->analyzed = 1; 
+  node->used_from_other_partition = bp_unpack_value (bp, 1);
+  node->in_other_partition = bp_unpack_value (bp, 1);
+  aliases_p = bp_unpack_value (bp, 1);
+  if (node->finalized)
+    varpool_mark_needed_node (node);
+  bitpack_delete (bp);
+  if (aliases_p)
+    {
+      count = lto_input_uleb128 (ib);
+      for (; count > 0; count --)
+	{
+	  tree decl = lto_file_decl_data_get_var_decl (file_data,
+						       lto_input_uleb128 (ib));
+	  varpool_extra_name_alias (decl, var_decl);
+	}
+    }
+  return node;
+}
+
 
 /* Read an edge from IB.  NODES points to a vector of previously read nodes for
    decoding caller and callee of the edge to be read.  If INDIRECT is true, the
@@ -812,6 +919,22 @@ input_cgraph_1 (struct lto_file_decl_data *file_data,
   VEC_free (cgraph_node_ptr, heap, nodes);
 }
 
+/* Read a varpool from IB using the info in FILE_DATA.  */
+
+static void
+input_varpool_1 (struct lto_file_decl_data *file_data,
+		struct lto_input_block *ib)
+{
+  unsigned HOST_WIDE_INT len;
+
+  len = lto_input_uleb128 (ib);
+  while (len)
+    {
+      input_varpool_node (file_data, ib);
+      len--;
+    }
+}
+
 static struct gcov_ctr_summary lto_gcov_summary;
 
 /* Input profile_info from IB.  */
@@ -867,6 +990,12 @@ input_cgraph (void)
       lto_destroy_simple_input_block (file_data, LTO_section_cgraph,
 				      ib, data, len);
 
+      ib = lto_create_simple_input_block (file_data, LTO_section_varpool,
+					  &data, &len);
+      input_varpool_1 (file_data, ib);
+      lto_destroy_simple_input_block (file_data, LTO_section_varpool,
+				      ib, data, len);
+
       /* Assume that every file read needs to be processed by LTRANS.  */
       if (flag_wpa)
 	lto_mark_file_for_ltrans (file_data);