X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Flto-cgraph.c;h=8a8855a70c14803a7eed3d9c7009e4537634cd74;hb=b5dfd6f18ca7f4a01da8ed9cc67c6d2e59b7ecf1;hp=c6ef21f6338333f37ac1263e466ee56ca6327bbc;hpb=02b2818cfeffc3709b01ae5a2475d6f94eacb056;p=pf3gnuchains%2Fgcc-fork.git

diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c
index c6ef21f6338..8a8855a70c1 100644
--- a/gcc/lto-cgraph.c
+++ b/gcc/lto-cgraph.c
@@ -46,8 +46,6 @@ along with GCC; see the file COPYING3.  If not see
 #include "lto-streamer.h"
 #include "gcov-io.h"
 
-static void output_varpool (cgraph_node_set, varpool_node_set);
-
 /* Cgraph streaming is organized as set of record whose type
    is indicated by a tag.  */
 enum LTO_cgraph_tags
@@ -71,7 +69,6 @@ lto_cgraph_encoder_new (void)
   lto_cgraph_encoder_t encoder = XCNEW (struct lto_cgraph_encoder_d);
   encoder->map = pointer_map_create ();
   encoder->nodes = NULL;
-  encoder->body = pointer_set_create ();
   return encoder;
 }
 
@@ -83,7 +80,6 @@ lto_cgraph_encoder_delete (lto_cgraph_encoder_t encoder)
 {
    VEC_free (cgraph_node_ptr, heap, encoder->nodes);
    pointer_map_destroy (encoder->map);
-   pointer_set_destroy (encoder->body);
    free (encoder);
 }
 
@@ -139,123 +135,14 @@ lto_cgraph_encoder_deref (lto_cgraph_encoder_t encoder, int ref)
 }
 
 
-/* Return TRUE if we should encode initializer of NODE (if any).  */
-
-bool
-lto_cgraph_encoder_encode_body_p (lto_cgraph_encoder_t encoder,
-				  struct cgraph_node *node)
-{
-  return pointer_set_contains (encoder->body, node);
-}
-
-/* Return TRUE if we should encode body of NODE (if any).  */
-
-static void
-lto_set_cgraph_encoder_encode_body (lto_cgraph_encoder_t encoder,
-				    struct cgraph_node *node)
-{
-  pointer_set_insert (encoder->body, node);
-}
-
-/* Create a new varpool encoder.  */
-
-lto_varpool_encoder_t
-lto_varpool_encoder_new (void)
-{
-  lto_varpool_encoder_t encoder = XCNEW (struct lto_varpool_encoder_d);
-  encoder->map = pointer_map_create ();
-  encoder->initializer = pointer_set_create ();
-  encoder->nodes = NULL;
-  return encoder;
-}
-
-
-/* Delete ENCODER and its components.  */
-
-void
-lto_varpool_encoder_delete (lto_varpool_encoder_t encoder)
-{
-   VEC_free (varpool_node_ptr, heap, encoder->nodes);
-   pointer_map_destroy (encoder->map);
-   pointer_set_destroy (encoder->initializer);
-   free (encoder);
-}
-
-
-/* Return the existing reference number of NODE in the varpool encoder in
-   output block OB.  Assign a new reference if this is the first time
-   NODE is encoded.  */
-
-int
-lto_varpool_encoder_encode (lto_varpool_encoder_t encoder,
-			   struct varpool_node *node)
-{
-  int ref;
-  void **slot;
-
-  slot = pointer_map_contains (encoder->map, node);
-  if (!slot)
-    {
-      ref = VEC_length (varpool_node_ptr, encoder->nodes);
-      slot = pointer_map_insert (encoder->map, node);
-      *slot = (void *) (intptr_t) ref;
-      VEC_safe_push (varpool_node_ptr, heap, encoder->nodes, node);
-    }
-  else
-    ref = (int) (intptr_t) *slot;
-
-  return ref;
-}
-
-/* Look up NODE in encoder.  Return NODE's reference if it has been encoded
-   or LCC_NOT_FOUND if it is not there.  */
-
-int
-lto_varpool_encoder_lookup (lto_varpool_encoder_t encoder,
-			   struct varpool_node *node)
-{
-  void **slot = pointer_map_contains (encoder->map, node);
-  return (slot ? (int) (intptr_t) *slot : LCC_NOT_FOUND);
-}
-
-
-/* Return the varpool node corresponding to REF using ENCODER.  */
-
-struct varpool_node *
-lto_varpool_encoder_deref (lto_varpool_encoder_t encoder, int ref)
-{
-  if (ref == LCC_NOT_FOUND)
-    return NULL;
-
-  return VEC_index (varpool_node_ptr, encoder->nodes, ref);
-}
-
-
 /* Return number of encoded nodes in ENCODER.  */
 
 static int
-lto_varpool_encoder_size (lto_varpool_encoder_t encoder)
-{
-  return VEC_length (varpool_node_ptr, encoder->nodes);
-}
-
-/* Return TRUE if we should encode initializer of NODE (if any).  */
-
-bool
-lto_varpool_encoder_encode_initializer_p (lto_varpool_encoder_t encoder,
-					  struct varpool_node *node)
+lto_cgraph_encoder_size (lto_cgraph_encoder_t encoder)
 {
-  return pointer_set_contains (encoder->initializer, node);
+  return VEC_length (cgraph_node_ptr, encoder->nodes);
 }
 
-/* Return TRUE if we should encode initializer of NODE (if any).  */
-
-static void
-lto_set_varpool_encoder_encode_initializer (lto_varpool_encoder_t encoder,
-					    struct varpool_node *node)
-{
-  pointer_set_insert (encoder->initializer, node);
-}
 
 /* Output the cgraph EDGE to OB using ENCODER.  */
 
@@ -294,56 +181,18 @@ lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
   bp_pack_value (bp, edge->indirect_inlining_edge, 1);
   bp_pack_value (bp, edge->call_stmt_cannot_inline_p, 1);
   bp_pack_value (bp, edge->can_throw_external, 1);
-  if (edge->indirect_unknown_callee)
-    {
-      int flags = edge->indirect_info->ecf_flags;
-      bp_pack_value (bp, (flags & ECF_CONST) != 0, 1);
-      bp_pack_value (bp, (flags & ECF_PURE) != 0, 1);
-      bp_pack_value (bp, (flags & ECF_NORETURN) != 0, 1);
-      bp_pack_value (bp, (flags & ECF_MALLOC) != 0, 1);
-      bp_pack_value (bp, (flags & ECF_NOTHROW) != 0, 1);
-      bp_pack_value (bp, (flags & ECF_RETURNS_TWICE) != 0, 1);
-      /* Flags that should not appear on indirect calls.  */
-      gcc_assert (!(flags & (ECF_LOOPING_CONST_OR_PURE
-			     | ECF_MAY_BE_ALLOCA
-			     | ECF_SIBCALL
-			     | ECF_NOVOPS)));
-    }
   lto_output_bitpack (ob->main_stream, bp);
   bitpack_delete (bp);
 }
 
-/* Return if LIST contain references from other partitions.  */
-
-bool
-referenced_from_other_partition_p (struct ipa_ref_list *list, cgraph_node_set set,
-				   varpool_node_set vset)
-{
-  int i;
-  struct ipa_ref *ref;
-  for (i = 0; ipa_ref_list_refering_iterate (list, i, ref); i++)
-    {
-      if (ref->refering_type == IPA_REF_CGRAPH)
-	{
-	  if (!cgraph_node_in_set_p (ipa_ref_refering_node (ref), set))
-	    return true;
-	}
-      else
-	{
-	  if (!varpool_node_in_set_p (ipa_ref_refering_varpool_node (ref),
-				      vset))
-	    return true;
-	}
-    }
-  return false;
-}
-
 /* Return true when node is reachable from other partition.  */
 
-bool
+static bool
 reachable_from_other_partition_p (struct cgraph_node *node, cgraph_node_set set)
 {
   struct cgraph_edge *e;
+  if (node->needed)
+    return true;
   if (!node->analyzed)
     return false;
   if (node->global.inlined_to)
@@ -354,47 +203,6 @@ reachable_from_other_partition_p (struct cgraph_node *node, cgraph_node_set set)
   return false;
 }
 
-/* Return if LIST contain references from other partitions.  */
-
-bool
-referenced_from_this_partition_p (struct ipa_ref_list *list, cgraph_node_set set,
-				  varpool_node_set vset)
-{
-  int i;
-  struct ipa_ref *ref;
-  for (i = 0; ipa_ref_list_refering_iterate (list, i, ref); i++)
-    {
-      if (ref->refering_type == IPA_REF_CGRAPH)
-	{
-	  if (cgraph_node_in_set_p (ipa_ref_refering_node (ref), set))
-	    return true;
-	}
-      else
-	{
-	  if (varpool_node_in_set_p (ipa_ref_refering_varpool_node (ref),
-				     vset))
-	    return true;
-	}
-    }
-  return false;
-}
-
-/* Return true when node is reachable from other partition.  */
-
-bool
-reachable_from_this_partition_p (struct cgraph_node *node, cgraph_node_set set)
-{
-  struct cgraph_edge *e;
-  if (!node->analyzed)
-    return false;
-  if (node->global.inlined_to)
-    return false;
-  for (e = node->callers; e; e = e->next_caller)
-    if (cgraph_node_in_set_p (e->caller, set))
-      return true;
-  return false;
-}
-
 /* Output the cgraph NODE to OB.  ENCODER is used to find the
    reference number of NODE->inlined_to.  SET is the set of nodes we
    are writing to the current file.  If NODE is not in SET, then NODE
@@ -406,16 +214,16 @@ reachable_from_this_partition_p (struct cgraph_node *node, cgraph_node_set set)
 static void
 lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
 		 lto_cgraph_encoder_t encoder, cgraph_node_set set,
-		 varpool_node_set vset)
+		 bitmap written_decls)
 {
   unsigned int tag;
   struct bitpack_d *bp;
-  bool boundary_p;
+  bool boundary_p, wrote_decl_p;
   intptr_t ref;
   bool in_other_partition = false;
-  struct cgraph_node *clone_of;
 
   boundary_p = !cgraph_node_in_set_p (node, set);
+  wrote_decl_p = bitmap_bit_p (written_decls, DECL_UID (node->decl));
 
   if (node->analyzed && !boundary_p)
     tag = LTO_cgraph_analyzed_node;
@@ -447,18 +255,10 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
       in_other_partition = 1;
     }
 
-  clone_of = node->clone_of;
-  while (clone_of
-	 && (ref = lto_cgraph_encoder_lookup (encoder, node->clone_of)) == LCC_NOT_FOUND)
-    if (clone_of->prev_sibling_clone)
-      clone_of = clone_of->prev_sibling_clone;
-    else
-      clone_of = clone_of->clone_of;
-  if (!clone_of)
-    lto_output_sleb128_stream (ob->main_stream, LCC_NOT_FOUND);
-  else
-    lto_output_sleb128_stream (ob->main_stream, ref);
+  lto_output_uleb128_stream (ob->main_stream, wrote_decl_p);
 
+  if (!wrote_decl_p)
+    bitmap_set_bit (written_decls, DECL_UID (node->decl));
 
   lto_output_fn_decl_index (ob->decl_state, ob->main_stream, node->decl);
   lto_output_sleb128_stream (ob->main_stream, node->count);
@@ -475,9 +275,7 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
   bp_pack_value (bp, node->address_taken, 1);
   bp_pack_value (bp, node->abstract_and_needed, 1);
   bp_pack_value (bp, tag == LTO_cgraph_analyzed_node
-		 && !DECL_EXTERNAL (node->decl)
-		 && (reachable_from_other_partition_p (node, set)
-		     || referenced_from_other_partition_p (&node->ref_list, set, vset)), 1);
+		 && reachable_from_other_partition_p (node, set), 1);
   bp_pack_value (bp, node->lowered, 1);
   bp_pack_value (bp, in_other_partition, 1);
   bp_pack_value (bp, node->alias, 1);
@@ -561,9 +359,9 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
 
 static void
 lto_output_varpool_node (struct lto_simple_output_block *ob, struct varpool_node *node,
-		         cgraph_node_set set, varpool_node_set vset)
+		         varpool_node_set set)
 {
-  bool boundary_p = !varpool_node_in_set_p (node, vset) && node->analyzed;
+  bool boundary_p = !varpool_node_in_set_p (node, set) && node->analyzed;
   struct bitpack_d *bp;
   struct varpool_node *alias;
   int count = 0;
@@ -573,10 +371,9 @@ lto_output_varpool_node (struct lto_simple_output_block *ob, struct varpool_node
   bp_pack_value (bp, node->externally_visible, 1);
   bp_pack_value (bp, node->force_output, 1);
   bp_pack_value (bp, node->finalized, 1);
-  bp_pack_value (bp, node->alias, 1);
-  gcc_assert (!node->alias || !node->extra_name);
   gcc_assert (node->finalized || !node->analyzed);
   gcc_assert (node->needed);
+  gcc_assert (!node->alias);
   /* Constant pool initializers can be de-unified into individual ltrans units.
      FIXME: Alternatively at -Os we may want to avoid generating for them the local
      labels and share them across LTRANS partitions.  */
@@ -587,9 +384,9 @@ lto_output_varpool_node (struct lto_simple_output_block *ob, struct varpool_node
     }
   else
     {
-      bp_pack_value (bp, node->analyzed
-		     && referenced_from_other_partition_p (&node->ref_list,
-							   set, vset), 1);
+      /* 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.  */
@@ -607,34 +404,6 @@ lto_output_varpool_node (struct lto_simple_output_block *ob, struct varpool_node
     }
 }
 
-/* Output the varpool NODE to OB. 
-   If NODE is not in SET, then NODE is a boundary.  */
-
-static void
-lto_output_ref (struct lto_simple_output_block *ob, struct ipa_ref *ref,
-		lto_cgraph_encoder_t encoder,
-		lto_varpool_encoder_t varpool_encoder)
-{
-  struct bitpack_d *bp = bitpack_create ();
-  bp_pack_value (bp, ref->refered_type, 1);
-  bp_pack_value (bp, ref->use, 2);
-  lto_output_bitpack (ob->main_stream, bp);
-  bitpack_delete (bp);
-  if (ref->refered_type == IPA_REF_CGRAPH)
-    {
-      int nref = lto_cgraph_encoder_lookup (encoder, ipa_ref_node (ref));
-      gcc_assert (nref != LCC_NOT_FOUND);
-      lto_output_sleb128_stream (ob->main_stream, nref);
-    }
-  else
-    {
-      int nref = lto_varpool_encoder_lookup (varpool_encoder,
-				             ipa_ref_varpool_node (ref));
-      gcc_assert (nref != LCC_NOT_FOUND);
-      lto_output_sleb128_stream (ob->main_stream, nref);
-    }
-}
-
 /* Stream out profile_summary to OB.  */
 
 static void
@@ -655,37 +424,14 @@ output_profile_summary (struct lto_simple_output_block *ob)
 
 /* Add NODE into encoder as well as nodes it is cloned from.
    Do it in a way so clones appear first.  */
-
 static void
-add_node_to (lto_cgraph_encoder_t encoder, struct cgraph_node *node,
-	     bool include_body)
+add_node_to (lto_cgraph_encoder_t encoder, struct cgraph_node *node)
 {
   if (node->clone_of)
-    add_node_to (encoder, node->clone_of, include_body);
-  else if (include_body)
-    lto_set_cgraph_encoder_encode_body (encoder, node);
+    add_node_to (encoder, node->clone_of);
   lto_cgraph_encoder_encode (encoder, node);
 }
 
-/* Add all references in LIST to encoders.  */
-
-static void
-add_references (lto_cgraph_encoder_t encoder,
-		lto_varpool_encoder_t varpool_encoder,
-		struct ipa_ref_list *list)
-{
-  int i;
-  struct ipa_ref *ref;
-  for (i = 0; ipa_ref_list_reference_iterate (list, i, ref); i++)
-    if (ref->refered_type == IPA_REF_CGRAPH)
-      add_node_to (encoder, ipa_ref_node (ref), false);
-    else
-      {
-	struct varpool_node *vnode = ipa_ref_varpool_node (ref);
-        lto_varpool_encoder_encode (varpool_encoder, vnode);
-      }
-}
-
 /* Output all callees or indirect outgoing edges.  EDGE must be the first such
    edge.  */
 
@@ -707,105 +453,37 @@ output_outgoing_cgraph_edges (struct cgraph_edge *edge,
 
 /* Output the part of the cgraph in SET.  */
 
-static void
-output_refs (cgraph_node_set set, varpool_node_set vset,
-	     lto_cgraph_encoder_t encoder,
-	     lto_varpool_encoder_t varpool_encoder)
-{
-  cgraph_node_set_iterator csi;
-  varpool_node_set_iterator vsi;
-  struct lto_simple_output_block *ob;
-  int count;
-  struct ipa_ref *ref;
-  int i;
-
-  ob = lto_create_simple_output_block (LTO_section_refs);
-
-  for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
-    {
-      struct cgraph_node *node = csi_node (csi);
-
-      count = ipa_ref_list_nreferences (&node->ref_list);
-      if (count)
-	{
-	  lto_output_uleb128_stream (ob->main_stream, count);
-	  lto_output_uleb128_stream (ob->main_stream,
-				     lto_cgraph_encoder_lookup (encoder, node));
-	  for (i = 0; ipa_ref_list_reference_iterate (&node->ref_list, i, ref); i++)
-	    lto_output_ref (ob, ref, encoder, varpool_encoder);
-	}
-    }
-
-  lto_output_uleb128_stream (ob->main_stream, 0);
-
-  for (vsi = vsi_start (vset); !vsi_end_p (vsi); vsi_next (&vsi))
-    {
-      struct varpool_node *node = vsi_node (vsi);
-
-      count = ipa_ref_list_nreferences (&node->ref_list);
-      if (count)
-	{
-	  lto_output_uleb128_stream (ob->main_stream, count);
-	  lto_output_uleb128_stream (ob->main_stream,
-				     lto_varpool_encoder_lookup (varpool_encoder,
-								 node));
-	  for (i = 0; ipa_ref_list_reference_iterate (&node->ref_list, i, ref); i++)
-	    lto_output_ref (ob, ref, encoder, varpool_encoder);
-	}
-    }
-
-  lto_output_uleb128_stream (ob->main_stream, 0);
-
-  lto_destroy_simple_output_block (ob);
-}
-
-/* Find out all cgraph and varpool nodes we want to encode in current unit
-   and insert them to encoders.  */
 void
-compute_ltrans_boundary (struct lto_out_decl_state *state,
-			 cgraph_node_set set, varpool_node_set vset)
+output_cgraph (cgraph_node_set set)
 {
   struct cgraph_node *node;
+  struct lto_simple_output_block *ob;
   cgraph_node_set_iterator csi;
-  varpool_node_set_iterator vsi;
   struct cgraph_edge *edge;
-  int i;
+  int i, n_nodes;
+  bitmap written_decls;
   lto_cgraph_encoder_t encoder;
-  lto_varpool_encoder_t varpool_encoder;
+  struct cgraph_asm_node *can;
+
+  ob = lto_create_simple_output_block (LTO_section_cgraph);
 
-  encoder = state->cgraph_node_encoder = lto_cgraph_encoder_new ();
-  varpool_encoder = state->varpool_node_encoder = lto_varpool_encoder_new ();
+  output_profile_summary (ob);
+
+  /* An encoder for cgraph nodes should have been created by
+     ipa_write_summaries_1.  */
+  gcc_assert (ob->decl_state->cgraph_node_encoder);
+  encoder = ob->decl_state->cgraph_node_encoder;
+
+  /* The FUNCTION_DECLs for which we have written a node.  The first
+     node found is written as the "original" node, the remaining nodes
+     are considered its clones.  */
+  written_decls = lto_bitmap_alloc ();
 
   /* Go over all the nodes in SET and assign references.  */
   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
     {
       node = csi_node (csi);
-      add_node_to (encoder, node, true);
-      add_references (encoder, varpool_encoder, &node->ref_list);
-    }
-  for (vsi = vsi_start (vset); !vsi_end_p (vsi); vsi_next (&vsi))
-    {
-      struct varpool_node *vnode = vsi_node (vsi);
-      gcc_assert (!vnode->alias);
-      lto_varpool_encoder_encode (varpool_encoder, vnode);
-      lto_set_varpool_encoder_encode_initializer (varpool_encoder, vnode);
-      add_references (encoder, varpool_encoder, &vnode->ref_list);
-    }
-  /* Pickle in also the initializer of all referenced readonly variables
-     to help folding.  Constant pool variables are not shared, so we must
-     pickle those too.  */
-  for (i = 0; i < lto_varpool_encoder_size (varpool_encoder); i++)
-    {
-      struct varpool_node *vnode = lto_varpool_encoder_deref (varpool_encoder, i);
-      if (DECL_INITIAL (vnode->decl)
-	  && !lto_varpool_encoder_encode_initializer_p (varpool_encoder,
-						        vnode)
-	  && (DECL_IN_CONSTANT_POOL (vnode->decl)
-	      ||  TREE_READONLY (vnode->decl)))
-	{
-	  lto_set_varpool_encoder_encode_initializer (varpool_encoder, vnode);
-	  add_references (encoder, varpool_encoder, &vnode->ref_list);
-	}
+      add_node_to (encoder, node);
     }
 
   /* Go over all the nodes again to include callees that are not in
@@ -820,35 +498,10 @@ compute_ltrans_boundary (struct lto_out_decl_state *state,
 	    {
 	      /* We should have moved all the inlines.  */
 	      gcc_assert (!callee->global.inlined_to);
-	      add_node_to (encoder, callee, false);
+	      add_node_to (encoder, callee);
 	    }
 	}
     }
-}
-
-/* Output the part of the cgraph in SET.  */
-
-void
-output_cgraph (cgraph_node_set set, varpool_node_set vset)
-{
-  struct cgraph_node *node;
-  struct lto_simple_output_block *ob;
-  cgraph_node_set_iterator csi;
-  int i, n_nodes;
-  lto_cgraph_encoder_t encoder;
-  lto_varpool_encoder_t varpool_encoder;
-  struct cgraph_asm_node *can;
-
-  ob = lto_create_simple_output_block (LTO_section_cgraph);
-
-  output_profile_summary (ob);
-
-  /* An encoder for cgraph nodes should have been created by
-     ipa_write_summaries_1.  */
-  gcc_assert (ob->decl_state->cgraph_node_encoder);
-  gcc_assert (ob->decl_state->varpool_node_encoder);
-  encoder = ob->decl_state->cgraph_node_encoder;
-  varpool_encoder = ob->decl_state->varpool_node_encoder;
 
   /* 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
@@ -857,9 +510,11 @@ output_cgraph (cgraph_node_set set, varpool_node_set vset)
   for (i = 0; i < n_nodes; i++)
     {
       node = lto_cgraph_encoder_deref (encoder, i);
-      lto_output_node (ob, node, encoder, set, vset);
+      lto_output_node (ob, node, encoder, set, written_decls);
     }
 
+  lto_bitmap_free (written_decls);
+
   /* Go over the nodes in SET again to write edges.  */
   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
     {
@@ -883,8 +538,6 @@ output_cgraph (cgraph_node_set set, varpool_node_set vset)
   lto_output_uleb128_stream (ob->main_stream, 0);
 
   lto_destroy_simple_output_block (ob);
-  output_varpool (set, vset);
-  output_refs (set, vset, encoder, varpool_encoder);
 }
 
 /* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
@@ -938,23 +591,27 @@ input_overwrite_node (struct lto_file_decl_data *file_data,
 
 /* Output the part of the cgraph in SET.  */
 
-static void
-output_varpool (cgraph_node_set set, varpool_node_set vset)
+void
+output_varpool (varpool_node_set set)
 {
-  struct lto_simple_output_block *ob = lto_create_simple_output_block (LTO_section_varpool);
-  lto_varpool_encoder_t varpool_encoder = ob->decl_state->varpool_node_encoder;
-  int len = lto_varpool_encoder_size (varpool_encoder), i;
+  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 (i = 0; i < len; i++)
-    {
-      lto_output_varpool_node (ob, lto_varpool_encoder_deref (varpool_encoder, i),
-			       set, vset);
-    }
+  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);
 }
@@ -965,32 +622,30 @@ output_varpool (cgraph_node_set set, varpool_node_set vset)
 static struct cgraph_node *
 input_node (struct lto_file_decl_data *file_data,
 	    struct lto_input_block *ib,
-	    enum LTO_cgraph_tags tag,
-	    VEC(cgraph_node_ptr, heap) *nodes)
+	    enum LTO_cgraph_tags tag)
 {
   tree fn_decl;
   struct cgraph_node *node;
   struct bitpack_d *bp;
   int stack_size = 0;
   unsigned decl_index;
+  bool clone_p;
   int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
   int self_time = 0;
   int self_size = 0;
   int time_inlining_benefit = 0;
   int size_inlining_benefit = 0;
   unsigned long same_body_count = 0;
-  int clone_ref;
 
-  clone_ref = lto_input_sleb128 (ib);
+  clone_p = (lto_input_uleb128 (ib) != 0);
 
   decl_index = lto_input_uleb128 (ib);
   fn_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
 
-  if (clone_ref != LCC_NOT_FOUND)
-    {
-      node = cgraph_clone_node (VEC_index (cgraph_node_ptr, nodes, clone_ref), fn_decl,
-				0, CGRAPH_FREQ_BASE, 0, false, NULL);
-    }
+  if (clone_p)
+    node = cgraph_clone_node (cgraph_node (fn_decl), 0,
+			      CGRAPH_FREQ_BASE, 0, false, NULL);
+
   else
     node = cgraph_node (fn_decl);
 
@@ -1082,8 +737,7 @@ input_varpool_node (struct lto_file_decl_data *file_data,
   node->externally_visible = bp_unpack_value (bp, 1);
   node->force_output = bp_unpack_value (bp, 1);
   node->finalized = bp_unpack_value (bp, 1);
-  node->alias = bp_unpack_value (bp, 1);
-  node->analyzed = node->finalized; 
+  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);
@@ -1103,33 +757,6 @@ input_varpool_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 void
-input_ref (struct lto_input_block *ib,
-	   struct cgraph_node *refering_node,
-	   struct varpool_node *refering_varpool_node,
-	   VEC(cgraph_node_ptr, heap) *nodes,
-	   VEC(varpool_node_ptr, heap) *varpool_nodes)
-{
-  struct cgraph_node *node = NULL;
-  struct varpool_node *varpool_node = NULL;
-  struct bitpack_d *bp;
-  enum ipa_ref_type type;
-  enum ipa_ref_use use;
-
-  bp = lto_input_bitpack (ib);
-  type = (enum ipa_ref_type) bp_unpack_value (bp, 1);
-  use = (enum ipa_ref_use) bp_unpack_value (bp, 2);
-  bitpack_delete (bp);
-  if (type == IPA_REF_CGRAPH)
-    node = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
-  else
-    varpool_node = VEC_index (varpool_node_ptr, varpool_nodes, lto_input_sleb128 (ib));
-  ipa_record_reference (refering_node, refering_varpool_node,
-		        node, varpool_node, use, NULL);
-}
 
 /* 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
@@ -1149,7 +776,6 @@ input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes,
   cgraph_inline_failed_t inline_failed;
   struct bitpack_d *bp;
   enum ld_plugin_symbol_resolution caller_resolution;
-  int ecf_flags = 0;
 
   caller = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
   if (caller == NULL || caller->decl == NULL_TREE)
@@ -1181,7 +807,7 @@ input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes,
     return;
 
   if (indirect)
-    edge = cgraph_create_indirect_edge (caller, NULL, 0, count, freq, nest);
+    edge = cgraph_create_indirect_edge (caller, NULL, count, freq, nest);
   else
     edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
 
@@ -1190,29 +816,13 @@ input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes,
   edge->inline_failed = inline_failed;
   edge->call_stmt_cannot_inline_p = bp_unpack_value (bp, 1);
   edge->can_throw_external = bp_unpack_value (bp, 1);
-  if (indirect)
-    {
-      if (bp_unpack_value (bp, 1))
-	ecf_flags |= ECF_CONST;
-      if (bp_unpack_value (bp, 1))
-	ecf_flags |= ECF_PURE;
-      if (bp_unpack_value (bp, 1))
-	ecf_flags |= ECF_NORETURN;
-      if (bp_unpack_value (bp, 1))
-	ecf_flags |= ECF_MALLOC;
-      if (bp_unpack_value (bp, 1))
-	ecf_flags |= ECF_NOTHROW;
-      if (bp_unpack_value (bp, 1))
-	ecf_flags |= ECF_RETURNS_TWICE;
-      edge->indirect_info->ecf_flags = ecf_flags;
-    }
   bitpack_delete (bp);
 }
 
 
 /* Read a cgraph from IB using the info in FILE_DATA.  */
 
-static VEC(cgraph_node_ptr, heap) *
+static void
 input_cgraph_1 (struct lto_file_decl_data *file_data,
 		struct lto_input_block *ib)
 {
@@ -1231,7 +841,7 @@ input_cgraph_1 (struct lto_file_decl_data *file_data,
         input_edge (ib, nodes, true);
       else
 	{
-	  node = input_node (file_data, ib, tag,nodes);
+	  node = input_node (file_data, ib, tag);
 	  if (node == NULL || node->decl == NULL_TREE)
 	    internal_error ("bytecode stream: found empty cgraph node");
 	  VEC_safe_push (cgraph_node_ptr, heap, nodes, node);
@@ -1272,67 +882,26 @@ input_cgraph_1 (struct lto_file_decl_data *file_data,
       else
 	node->same_comdat_group = NULL;
     }
-  return nodes;
+
+  VEC_free (cgraph_node_ptr, heap, nodes);
 }
 
 /* Read a varpool from IB using the info in FILE_DATA.  */
 
-static VEC(varpool_node_ptr, heap) *
+static void
 input_varpool_1 (struct lto_file_decl_data *file_data,
 		struct lto_input_block *ib)
 {
   unsigned HOST_WIDE_INT len;
-  VEC(varpool_node_ptr, heap) *varpool = NULL;
 
   len = lto_input_uleb128 (ib);
   while (len)
     {
-      VEC_safe_push (varpool_node_ptr, heap, varpool,
-		     input_varpool_node (file_data, ib));
+      input_varpool_node (file_data, ib);
       len--;
     }
-  return varpool;
 }
 
-/* Input ipa_refs.  */
-
-static void
-input_refs (struct lto_input_block *ib,
-	    VEC(cgraph_node_ptr, heap) *nodes,
-	    VEC(varpool_node_ptr, heap) *varpool)
-{
-  int count;
-  int idx;
-  while (true)
-    {
-      struct cgraph_node *node;
-      count = lto_input_uleb128 (ib);
-      if (!count)
-	break;
-      idx = lto_input_uleb128 (ib);
-      node = VEC_index (cgraph_node_ptr, nodes, idx);
-      while (count)
-	{
-	  input_ref (ib, node, NULL, nodes, varpool);
-	  count--;
-	}
-    }
-  while (true)
-    {
-      struct varpool_node *node;
-      count = lto_input_uleb128 (ib);
-      if (!count)
-	break;
-      node = VEC_index (varpool_node_ptr, varpool, lto_input_uleb128 (ib));
-      while (count)
-	{
-	  input_ref (ib, NULL, node, nodes, varpool);
-	  count--;
-	}
-    }
-}
-	    
-
 static struct gcov_ctr_summary lto_gcov_summary;
 
 /* Input profile_info from IB.  */
@@ -1379,30 +948,24 @@ input_cgraph (void)
       const char *data;
       size_t len;
       struct lto_input_block *ib;
-      VEC(cgraph_node_ptr, heap) *nodes;
-      VEC(varpool_node_ptr, heap) *varpool;
 
       ib = lto_create_simple_input_block (file_data, LTO_section_cgraph,
 					  &data, &len);
       input_profile_summary (ib);
       file_data->cgraph_node_encoder = lto_cgraph_encoder_new ();
-      nodes = input_cgraph_1 (file_data, ib);
+      input_cgraph_1 (file_data, ib);
       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);
-      varpool = input_varpool_1 (file_data, ib);
+      input_varpool_1 (file_data, ib);
       lto_destroy_simple_input_block (file_data, LTO_section_varpool,
 				      ib, data, len);
 
-      ib = lto_create_simple_input_block (file_data, LTO_section_refs,
-					  &data, &len);
-      input_refs (ib, nodes, varpool);
-      lto_destroy_simple_input_block (file_data, LTO_section_refs,
-				      ib, data, len);
-      VEC_free (cgraph_node_ptr, heap, nodes);
-      VEC_free (varpool_node_ptr, heap, varpool);
+      /* Assume that every file read needs to be processed by LTRANS.  */
+      if (flag_wpa)
+	lto_mark_file_for_ltrans (file_data);
     }
 
   /* Clear out the aux field that was used to store enough state to