OSDN Git Service

* cgraph.c (cgraph_remove_node): Kill bodies in other partitoin.
authorhubicka <hubicka@138bc75d-0d04-0410-961f-82ee72b054a4>
Tue, 20 Apr 2010 14:49:18 +0000 (14:49 +0000)
committerMasaki Muranaka <monaka@monami-software.com>
Sun, 23 May 2010 01:07:09 +0000 (10:07 +0900)
(dump_cgraph_node): Dump new flags.
* cgraph.h (struct cgraph_node): Add flags reachable_from_other_partition
and in_other_partition.
(cgraph_can_remove_if_no_direct_calls_p): Functions used by other partition
can not be removed.
* cgraphunit.c (cgraph_mark_functions_to_output): Functions used by the other
partition must be output; silence sanity checking on leaking functions
bodies from other paritition.
* lto-cgraph.c (reachable_from_other_partition_p): New function.
(lto_output_node): Output new flags; do not sanity check that inline
clones are output; drop lto_forced_extern_inline_p code; do not mock
visibility flags at partition boundaries.
(add_node_to): New function.
(output_cgraph): Use it to sort functions so masters appear before
clones.
(input_overwrite_node): Input new flags.
* passes.c (ipa_write_summaries): Do not call
lto_new_extern_inline_states.
* lto-section-out.c (forced_extern_inline, lto_new_extern_inline_states,
lto_delete_extern_inline_states, lto_force_functions_extern_inline,
lto_forced_extern_inline_p): Kill.
* lto-streamer.h (lto_new_extern_inline_states,
* lto_delete_extern_inline_states, lto_force_functions_extern_inline,
lto_forced_extern_inline_p): Kill.

* lto.c (lto_add_inline_clones): Do not track inlined_decls.
(lto_add_all_inlinees): Likewise.
(lto_wpa_write_files): Likewise.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@158563 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/ChangeLog
gcc/cgraph.h
gcc/cgraphunit.c
gcc/lto-cgraph.c
gcc/lto/ChangeLog
gcc/lto/lto.c
gcc/passes.c

index a5b7037..cd74f02 100644 (file)
@@ -1,3 +1,31 @@
+2010-04-20  Jan Hubicka  <jh@suse.cz>
+
+       * cgraph.c (cgraph_remove_node): Kill bodies in other partitoin.
+       (dump_cgraph_node): Dump new flags.
+       * cgraph.h (struct cgraph_node): Add flags reachable_from_other_partition
+       and in_other_partition.
+       (cgraph_can_remove_if_no_direct_calls_p): Functions used by other partition
+       can not be removed.
+       * cgraphunit.c (cgraph_mark_functions_to_output): Functions used by the other
+       partition must be output; silence sanity checking on leaking functions
+       bodies from other paritition.
+       * lto-cgraph.c (reachable_from_other_partition_p): New function.
+       (lto_output_node): Output new flags; do not sanity check that inline
+       clones are output; drop lto_forced_extern_inline_p code; do not mock
+       visibility flags at partition boundaries.
+       (add_node_to): New function.
+       (output_cgraph): Use it to sort functions so masters appear before
+       clones.
+       (input_overwrite_node): Input new flags.
+       * passes.c (ipa_write_summaries): Do not call
+       lto_new_extern_inline_states.
+       * lto-section-out.c (forced_extern_inline, lto_new_extern_inline_states,
+       lto_delete_extern_inline_states, lto_force_functions_extern_inline,
+       lto_forced_extern_inline_p): Kill.
+       * lto-streamer.h (lto_new_extern_inline_states,
+       * lto_delete_extern_inline_states, lto_force_functions_extern_inline,
+       lto_forced_extern_inline_p): Kill.
+
 2010-04-20  Richard Guenther  <rguenther@suse.de>
 
        * tree-ssa-structalias.c (do_sd_constraint): Add edges only
index dc6168a..6bc565a 100644 (file)
@@ -249,11 +249,15 @@ struct GTY((chain_next ("%h.next"), chain_prev ("%h.previous"))) cgraph_node {
      cgraph_remove_unreachable_nodes cgraph still can contain unreachable
      nodes when they are needed for virtual clone instantiation.  */
   unsigned reachable : 1;
+  /* Set when function is reachable by call from other LTRANS partition.  */
+  unsigned reachable_from_other_partition : 1;
   /* Set once the function is lowered (i.e. its CFG is built).  */
   unsigned lowered : 1;
   /* Set once the function has been instantiated and its callee
      lists created.  */
   unsigned analyzed : 1;
+  /* Set when function is available in the other LTO partition.  */
+  unsigned in_other_partition : 1;
   /* Set when function is scheduled to be processed by local passes.  */
   unsigned process : 1;
   /* Set for aliases once they got through assemble_alias.  */
@@ -723,7 +727,7 @@ cgraph_only_called_directly_p (struct cgraph_node *node)
 static inline bool
 cgraph_can_remove_if_no_direct_calls_p (struct cgraph_node *node)
 {
-  return (!node->needed
+  return (!node->needed && !node->reachable_from_other_partition
          && (DECL_COMDAT (node->decl) || !node->local.externally_visible));
 }
 
index afcd660..7d65b04 100644 (file)
@@ -1130,7 +1130,7 @@ cgraph_mark_functions_to_output (void)
         outside the current compilation unit.  */
       if (node->analyzed
          && !node->global.inlined_to
-         && (node->needed
+         && (node->needed || node->reachable_from_other_partition
              || (e && node->reachable))
          && !TREE_ASM_WRITTEN (decl)
          && !DECL_EXTERNAL (decl))
@@ -1157,6 +1157,10 @@ cgraph_mark_functions_to_output (void)
 #ifdef ENABLE_CHECKING
          if (!node->global.inlined_to
              && gimple_has_body_p (decl)
+             /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
+                are inside partition, we can end up not removing the body since we no longer
+                have analyzed node pointing to it.  */
+             && !node->in_other_partition
              && !DECL_EXTERNAL (decl))
            {
              dump_cgraph_node (stderr, node);
@@ -1165,6 +1169,7 @@ cgraph_mark_functions_to_output (void)
 #endif
          gcc_assert (node->global.inlined_to
                      || !gimple_has_body_p (decl)
+                     || node->in_other_partition
                      || DECL_EXTERNAL (decl));
 
        }
@@ -1178,6 +1183,10 @@ cgraph_mark_functions_to_output (void)
          tree decl = node->decl;
          if (!node->global.inlined_to
              && gimple_has_body_p (decl)
+             /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
+                are inside partition, we can end up not removing the body since we no longer
+                have analyzed node pointing to it.  */
+             && !node->in_other_partition
              && !DECL_EXTERNAL (decl))
            {
              dump_cgraph_node (stderr, node);
index f911c3a..309db7f 100644 (file)
@@ -30,6 +30,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "flags.h"
 #include "params.h"
 #include "input.h"
+#include "varray.h"
 #include "hashtab.h"
 #include "langhooks.h"
 #include "basic-block.h"
@@ -46,26 +47,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);
-static void output_cgraph_opt_summary (void);
-static void input_cgraph_opt_summary (VEC (cgraph_node_ptr, heap) * nodes);
-
-
-/* Cgraph streaming is organized as set of record whose type
-   is indicated by a tag.  */
-enum LTO_cgraph_tags
-{
-  /* Must leave 0 for the stopper.  */
-
-  /* Cgraph node without body available.  */
-  LTO_cgraph_unavail_node = 1,
-  /* Cgraph node with function body.  */
-  LTO_cgraph_analyzed_node,
-  /* Cgraph edges.  */
-  LTO_cgraph_edge,
-  LTO_cgraph_indirect_edge
-};
-
 /* Create a new cgraph encoder.  */
 
 lto_cgraph_encoder_t
@@ -74,7 +55,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;
 }
 
@@ -86,7 +66,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);
 }
 
@@ -116,7 +95,6 @@ lto_cgraph_encoder_encode (lto_cgraph_encoder_t encoder,
   return ref;
 }
 
-#define LCC_NOT_FOUND  (-1)
 
 /* Look up NODE in encoder.  Return NODE's reference if it has been encoded
    or LCC_NOT_FOUND if it is not there.  */
@@ -142,123 +120,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)
+lto_cgraph_encoder_size (lto_cgraph_encoder_t encoder)
 {
-  return VEC_length (varpool_node_ptr, encoder->nodes);
+  return VEC_length (cgraph_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)
-{
-  return pointer_set_contains (encoder->initializer, node);
-}
-
-/* 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.  */
 
@@ -270,21 +139,15 @@ lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
   intptr_t ref;
   struct bitpack_d *bp;
 
-  if (edge->indirect_unknown_callee)
-    lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_indirect_edge);
-  else
-    lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_edge);
+  lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_edge);
 
   ref = lto_cgraph_encoder_lookup (encoder, edge->caller);
   gcc_assert (ref != LCC_NOT_FOUND);
   lto_output_sleb128_stream (ob->main_stream, ref);
 
-  if (!edge->indirect_unknown_callee)
-    {
-      ref = lto_cgraph_encoder_lookup (encoder, edge->callee);
-      gcc_assert (ref != LCC_NOT_FOUND);
-      lto_output_sleb128_stream (ob->main_stream, ref);
-    }
+  ref = lto_cgraph_encoder_lookup (encoder, edge->callee);
+  gcc_assert (ref != LCC_NOT_FOUND);
+  lto_output_sleb128_stream (ob->main_stream, ref);
 
   lto_output_sleb128_stream (ob->main_stream, edge->count);
 
@@ -294,59 +157,21 @@ lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
   bp_pack_value (bp, edge->inline_failed, HOST_BITS_PER_INT);
   bp_pack_value (bp, edge->frequency, HOST_BITS_PER_INT);
   bp_pack_value (bp, edge->loop_nest, 30);
-  bp_pack_value (bp, edge->indirect_inlining_edge, 1);
+  bp_pack_value (bp, edge->indirect_call, 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)
@@ -357,47 +182,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
@@ -409,24 +193,47 @@ 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;
+  unsigned local, externally_visible, inlinable, analyzed;
+  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;
-  else
+  switch (cgraph_function_body_availability (node))
+    {
+    case AVAIL_NOT_AVAILABLE:
+      tag = LTO_cgraph_unavail_node;
+      break;
+
+    case AVAIL_AVAILABLE:
+    case AVAIL_LOCAL:
+      tag = LTO_cgraph_avail_node;
+      break;
+
+    case AVAIL_OVERWRITABLE:
+      tag = LTO_cgraph_overwritable_node;
+      break;
+
+    default:
+      gcc_unreachable ();
+    }
+
+  if (boundary_p)
     tag = LTO_cgraph_unavail_node;
 
   lto_output_uleb128_stream (ob->main_stream, tag);
 
+  local = node->local.local;
+  externally_visible = node->local.externally_visible;
+  inlinable = node->local.inlinable;
+  analyzed = node->analyzed;
+
   /* In WPA mode, we only output part of the call-graph.  Also, we
      fake cgraph node attributes.  There are two cases that we care.
 
@@ -437,7 +244,7 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
      Cherry-picked nodes:  These are nodes we pulled from other
      translation units into SET during IPA-inlining.  We make them as
      local static nodes to prevent clashes with other local statics.  */
-  if (boundary_p && node->analyzed)
+  if (boundary_p)
     {
       /* Inline clones can not be part of boundary.  
          gcc_assert (!node->global.inlined_to);  
@@ -448,49 +255,41 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
         needs a bit extra work and will be promplty done by cgraph_remove_node
         after reading back.  */
       in_other_partition = 1;
+      analyzed = 0;
     }
 
-  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);
 
   bp = bitpack_create ();
-  bp_pack_value (bp, node->local.local, 1);
-  bp_pack_value (bp, node->local.externally_visible, 1);
+  bp_pack_value (bp, local, 1);
+  bp_pack_value (bp, externally_visible, 1);
   bp_pack_value (bp, node->local.finalized, 1);
-  bp_pack_value (bp, node->local.inlinable, 1);
-  bp_pack_value (bp, node->local.versionable, 1);
+  bp_pack_value (bp, inlinable, 1);
   bp_pack_value (bp, node->local.disregard_inline_limits, 1);
   bp_pack_value (bp, node->local.redefined_extern_inline, 1);
+  bp_pack_value (bp, node->local.for_functions_valid, 1);
   bp_pack_value (bp, node->local.vtable_method, 1);
   bp_pack_value (bp, node->needed, 1);
   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);
+  bp_pack_value (bp, node->reachable, 1);
+  bp_pack_value (bp, analyzed && reachable_from_other_partition_p (node, set), 1);
   bp_pack_value (bp, node->lowered, 1);
+  bp_pack_value (bp, analyzed, 1);
   bp_pack_value (bp, in_other_partition, 1);
+  bp_pack_value (bp, node->process, 1);
   bp_pack_value (bp, node->alias, 1);
   bp_pack_value (bp, node->finalized_by_frontend, 1);
-  bp_pack_value (bp, node->frequency, 2);
   lto_output_bitpack (ob->main_stream, bp);
   bitpack_delete (bp);
 
-  if (tag == LTO_cgraph_analyzed_node)
+  if (tag != LTO_cgraph_unavail_node)
     {
       lto_output_sleb128_stream (ob->main_stream,
                                 node->local.inline_summary.estimated_self_stack_size);
@@ -502,18 +301,30 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
                                 node->local.inline_summary.self_time);
       lto_output_sleb128_stream (ob->main_stream,
                                 node->local.inline_summary.time_inlining_benefit);
-      if (node->global.inlined_to)
-       {
-         ref = lto_cgraph_encoder_lookup (encoder, node->global.inlined_to);
-         gcc_assert (ref != LCC_NOT_FOUND);
-       }
-      else
-       ref = LCC_NOT_FOUND;
+    }
 
-      lto_output_sleb128_stream (ob->main_stream, ref);
+  /* FIXME lto: Outputting global info is not neccesary until after
+     inliner was run.  Global structure holds results of propagation
+     done by inliner.  */
+  lto_output_sleb128_stream (ob->main_stream,
+                            node->global.estimated_stack_size);
+  lto_output_sleb128_stream (ob->main_stream,
+                            node->global.stack_frame_offset);
+  if (node->global.inlined_to && !boundary_p)
+    {
+      ref = lto_cgraph_encoder_lookup (encoder, node->global.inlined_to);
+      gcc_assert (ref != LCC_NOT_FOUND);
     }
+  else
+    ref = LCC_NOT_FOUND;
+  lto_output_sleb128_stream (ob->main_stream, ref);
 
-  if (node->same_comdat_group && !boundary_p)
+  lto_output_sleb128_stream (ob->main_stream, node->global.time);
+  lto_output_sleb128_stream (ob->main_stream, node->global.size);
+  lto_output_sleb128_stream (ob->main_stream,
+                            node->global.estimated_growth);
+  lto_output_uleb128_stream (ob->main_stream, node->global.inlined);
+  if (node->same_comdat_group)
     {
       ref = lto_cgraph_encoder_lookup (encoder, node->same_comdat_group);
       gcc_assert (ref != LCC_NOT_FOUND);
@@ -560,95 +371,6 @@ 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,
-                        lto_varpool_encoder_t varpool_encoder,
-                        cgraph_node_set set, varpool_node_set vset)
-{
-  bool boundary_p = !varpool_node_in_set_p (node, vset) && node->analyzed;
-  struct bitpack_d *bp;
-  struct varpool_node *alias;
-  int count = 0;
-  int ref;
-
-  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);
-  bp_pack_value (bp, node->alias, 1);
-  gcc_assert (!node->alias || !node->extra_name);
-  gcc_assert (node->finalized || !node->analyzed);
-  gcc_assert (node->needed);
-  /* 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.  */
-  if (DECL_IN_CONSTANT_POOL (node->decl))
-    {
-      bp_pack_value (bp, 0, 1);  /* used_from_other_parition.  */
-      bp_pack_value (bp, 0, 1);  /* in_other_partition.  */
-    }
-  else
-    {
-      bp_pack_value (bp, node->analyzed
-                    && referenced_from_other_partition_p (&node->ref_list,
-                                                          set, vset), 1);
-      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 (node->same_comdat_group && !boundary_p)
-    {
-      ref = lto_varpool_encoder_lookup (varpool_encoder, node->same_comdat_group);
-      gcc_assert (ref != LCC_NOT_FOUND);
-    }
-  else
-    ref = LCC_NOT_FOUND;
-  lto_output_sleb128_stream (ob->main_stream, ref);
-
-  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);
-    }
-}
-
-/* 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
@@ -669,157 +391,47 @@ 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.  */
-
-static void
-output_outgoing_cgraph_edges (struct cgraph_edge *edge,
-                             struct lto_simple_output_block *ob,
-                             lto_cgraph_encoder_t encoder)
-{
-  if (!edge)
-    return;
-
-  /* Output edges in backward direction, so the reconstructed callgraph match
-     and it is easy to associate call sites in the IPA pass summaries.  */
-  while (edge->next_callee)
-    edge = edge->next_callee;
-  for (; edge; edge = edge->prev_callee)
-    lto_output_edge (ob, edge, encoder);
-}
-
 /* 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;
 
-  encoder = state->cgraph_node_encoder = lto_cgraph_encoder_new ();
-  varpool_encoder = state->varpool_node_encoder = lto_varpool_encoder_new ();
+  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);
+  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
@@ -834,38 +446,32 @@ 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);
+             /* Also with each included function include all other functions
+                in the same comdat group.  */
+             if (callee->same_comdat_group)
+               {
+                 struct cgraph_node *next;
+                 for (next = callee->same_comdat_group;
+                      next != callee;
+                      next = next->same_comdat_group)
+                   if (!cgraph_node_in_set_p (next, set))
+                     add_node_to (encoder, next);
+               }
            }
        }
+      /* Also with each included function include all other functions
+        in the same comdat group.  */
+      if (node->same_comdat_group)
+       {
+         struct cgraph_node *next;
+         for (next = node->same_comdat_group;
+              next != node;
+              next = next->same_comdat_group)
+           if (!cgraph_node_in_set_p (next, set))
+             add_node_to (encoder, next);
+       }
     }
-}
-
-/* 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;
-
-  if (flag_wpa)
-    output_cgraph_opt_summary ();
-
-  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
@@ -874,15 +480,25 @@ 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))
     {
       node = csi_node (csi);
-      output_outgoing_cgraph_edges (node->callees, ob, encoder);
-      output_outgoing_cgraph_edges (node->indirect_calls, ob, encoder);
+      if (node->callees)
+        {
+         /* Output edges in backward direction, so the reconstructed callgraph
+            match and it is easy to associate call sites in the IPA pass summaries.  */
+         edge = node->callees;
+         while (edge->next_callee)
+           edge = edge->next_callee;
+         for (; edge; edge = edge->prev_callee)
+           lto_output_edge (ob, edge, encoder);
+       }
     }
 
   lto_output_uleb128_stream (ob->main_stream, 0);
@@ -900,10 +516,9 @@ 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,
    STACK_SIZE, SELF_TIME and SELF_SIZE.  This is called either to initialize
    NODE or to replace the values in it, for instance because the first
@@ -930,53 +545,29 @@ input_overwrite_node (struct lto_file_decl_data *file_data,
   node->local.inline_summary.size_inlining_benefit = size_inlining_benefit;
   node->global.time = self_time;
   node->global.size = self_size;
-  node->global.estimated_stack_size = stack_size;
-  node->global.estimated_growth = INT_MIN;
   node->local.lto_file_data = file_data;
 
   node->local.local = bp_unpack_value (bp, 1);
   node->local.externally_visible = bp_unpack_value (bp, 1);
   node->local.finalized = bp_unpack_value (bp, 1);
   node->local.inlinable = bp_unpack_value (bp, 1);
-  node->local.versionable = bp_unpack_value (bp, 1);
   node->local.disregard_inline_limits = bp_unpack_value (bp, 1);
   node->local.redefined_extern_inline = bp_unpack_value (bp, 1);
+  node->local.for_functions_valid = bp_unpack_value (bp, 1);
   node->local.vtable_method = bp_unpack_value (bp, 1);
   node->needed = bp_unpack_value (bp, 1);
   node->address_taken = bp_unpack_value (bp, 1);
   node->abstract_and_needed = bp_unpack_value (bp, 1);
+  node->reachable = bp_unpack_value (bp, 1);
   node->reachable_from_other_partition = bp_unpack_value (bp, 1);
   node->lowered = bp_unpack_value (bp, 1);
-  node->analyzed = tag == LTO_cgraph_analyzed_node;
+  node->analyzed = bp_unpack_value (bp, 1);
   node->in_other_partition = bp_unpack_value (bp, 1);
+  node->process = bp_unpack_value (bp, 1);
   node->alias = bp_unpack_value (bp, 1);
   node->finalized_by_frontend = bp_unpack_value (bp, 1);
-  node->frequency = (enum node_frequency)bp_unpack_value (bp, 2);
 }
 
-/* Output the part of the cgraph in SET.  */
-
-static void
-output_varpool (cgraph_node_set set, varpool_node_set vset)
-{
-  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;
-
-  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),
-                              varpool_encoder,
-                              set, vset);
-    }
-
-  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.  */
@@ -984,49 +575,58 @@ 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 estimated_stack_size = 0;
+  int stack_frame_offset = 0;
   int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
+  int estimated_growth = 0;
+  int time = 0;
+  int size = 0;
   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;
+  bool inlined = false;
 
-  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);
 
   node->count = lto_input_sleb128 (ib);
   bp = lto_input_bitpack (ib);
 
-  if (tag == LTO_cgraph_analyzed_node)
+  if (tag != LTO_cgraph_unavail_node)
     {
       stack_size = lto_input_sleb128 (ib);
       self_size = lto_input_sleb128 (ib);
       size_inlining_benefit = lto_input_sleb128 (ib);
       self_time = lto_input_sleb128 (ib);
       time_inlining_benefit = lto_input_sleb128 (ib);
-
-      ref = lto_input_sleb128 (ib);
     }
 
+  estimated_stack_size = lto_input_sleb128 (ib);
+  stack_frame_offset = lto_input_sleb128 (ib);
+  ref = lto_input_sleb128 (ib);
+  time = lto_input_sleb128 (ib);
+  size = lto_input_sleb128 (ib);
+  estimated_growth = lto_input_sleb128 (ib);
+  inlined = lto_input_uleb128 (ib);
   ref2 = lto_input_sleb128 (ib);
   same_body_count = lto_input_uleb128 (ib);
 
@@ -1043,9 +643,17 @@ input_node (struct lto_file_decl_data *file_data,
                        size_inlining_benefit);
   bitpack_delete (bp);
 
+  node->global.estimated_stack_size = estimated_stack_size;
+  node->global.stack_frame_offset = stack_frame_offset;
+  node->global.time = time;
+  node->global.size = size;
+
   /* Store a reference for now, and fix up later to be a pointer.  */
   node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
 
+  node->global.estimated_growth = estimated_growth;
+  node->global.inlined = inlined;
+
   /* Store a reference for now, and fix up later to be a pointer.  */
   node->same_comdat_group = (cgraph_node_ptr) (intptr_t) ref2;
 
@@ -1079,89 +687,12 @@ 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;
-  int ref = LCC_NOT_FOUND;
-
-  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->alias = bp_unpack_value (bp, 1);
-  node->analyzed = node->finalized; 
-  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);
-  ref = lto_input_sleb128 (ib);
-  /* Store a reference for now, and fix up later to be a pointer.  */
-  node->same_comdat_group = (struct varpool_node *) (intptr_t) ref;
-  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 a node from input_block IB.  TAG is the node's tag just read.
-   Return the node read or overwriten.  */
+/* 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.  */
 
 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
-   edge being read is indirect (in the sense that it has
-   indirect_unknown_callee set).  */
-
-static void
-input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes,
-           bool indirect)
+input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes)
 {
   struct cgraph_node *caller, *callee;
   struct cgraph_edge *edge;
@@ -1172,20 +703,14 @@ 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)
     internal_error ("bytecode stream: no caller found while reading edge");
 
-  if (!indirect)
-    {
-      callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
-      if (callee == NULL || callee->decl == NULL_TREE)
-       internal_error ("bytecode stream: no callee found while reading edge");
-    }
-  else
-    callee = NULL;
+  callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
+  if (callee == NULL || callee->decl == NULL_TREE)
+    internal_error ("bytecode stream: no callee found while reading edge");
 
   count = (gcov_type) lto_input_sleb128 (ib);
 
@@ -1203,39 +728,19 @@ input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes,
       || caller_resolution == LDPR_PREEMPTED_IR)
     return;
 
-  if (indirect)
-    edge = cgraph_create_indirect_edge (caller, NULL, 0, count, freq, nest);
-  else
-    edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
-
-  edge->indirect_inlining_edge = bp_unpack_value (bp, 1);
+  edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
   edge->lto_stmt_uid = stmt_id;
   edge->inline_failed = inline_failed;
+  edge->indirect_call = bp_unpack_value (bp, 1);
   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)
 {
@@ -1249,12 +754,10 @@ input_cgraph_1 (struct lto_file_decl_data *file_data,
   while (tag)
     {
       if (tag == LTO_cgraph_edge)
-        input_edge (ib, nodes, false);
-      else if (tag == LTO_cgraph_indirect_edge)
-        input_edge (ib, nodes, true);
+        input_edge (ib, nodes);
       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);
@@ -1295,79 +798,10 @@ input_cgraph_1 (struct lto_file_decl_data *file_data,
       else
        node->same_comdat_group = NULL;
     }
-  return nodes;
-}
-
-/* Read a varpool from IB using the info in FILE_DATA.  */
 
-static VEC(varpool_node_ptr, heap) *
-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;
-  int i;
-  struct varpool_node *node;
-
-  len = lto_input_uleb128 (ib);
-  while (len)
-    {
-      VEC_safe_push (varpool_node_ptr, heap, varpool,
-                    input_varpool_node (file_data, ib));
-      len--;
-    }
-  for (i = 0; VEC_iterate (varpool_node_ptr, varpool, i, node); i++)
-    {
-      int ref = (int) (intptr_t) node->same_comdat_group;
-
-      /* Fixup same_comdat_group from reference to pointer.  */
-      if (ref != LCC_NOT_FOUND)
-       node->same_comdat_group = VEC_index (varpool_node_ptr, varpool, ref);
-      else
-       node->same_comdat_group = NULL;
-    }
-  return varpool;
+  VEC_free (cgraph_node_ptr, heap, nodes);
 }
 
-/* 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.  */
@@ -1414,32 +848,18 @@ 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);
-      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);
-      if (flag_ltrans)
-       input_cgraph_opt_summary (nodes);
-      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
@@ -1455,197 +875,3 @@ input_cgraph (void)
        node->aux = NULL;
     }
 }
-
-/* True when we need optimization summary for NODE.  */
-
-static int
-output_cgraph_opt_summary_p (struct cgraph_node *node)
-{
-  if (!node->clone_of)
-    return false;
-  return (node->clone.tree_map
-          || node->clone.args_to_skip
-          || node->clone.combined_args_to_skip);
-}
-
-/* Output optimization summary for NODE to OB.  */
-
-static void
-output_node_opt_summary (struct output_block *ob,
-                        struct cgraph_node *node)
-{
-  unsigned int index;
-  bitmap_iterator bi;
-  struct ipa_replace_map *map;
-  struct bitpack_d *bp;
-  int i;
-
-  lto_output_uleb128_stream (ob->main_stream,
-                            bitmap_count_bits (node->clone.args_to_skip));
-  EXECUTE_IF_SET_IN_BITMAP (node->clone.args_to_skip, 0, index, bi)
-    lto_output_uleb128_stream (ob->main_stream, index);
-  lto_output_uleb128_stream (ob->main_stream,
-                            bitmap_count_bits (node->clone.combined_args_to_skip));
-  EXECUTE_IF_SET_IN_BITMAP (node->clone.combined_args_to_skip, 0, index, bi)
-    lto_output_uleb128_stream (ob->main_stream, index);
-  lto_output_uleb128_stream (ob->main_stream,
-                            VEC_length (ipa_replace_map_p, node->clone.tree_map));
-  for (i = 0; VEC_iterate (ipa_replace_map_p, node->clone.tree_map, i, map); i++)
-    {
-      int parm_num;
-      tree parm;
-
-      for (parm_num = 0, parm = DECL_ARGUMENTS (node->decl); parm;
-          parm = TREE_CHAIN (parm), parm_num++)
-       if (map->old_tree == parm)
-         break;
-      /* At the moment we assume all old trees to be PARM_DECLs, because we have no
-         mechanism to store function local declarations into summaries.  */
-      gcc_assert (parm);
-      lto_output_uleb128_stream (ob->main_stream, parm_num);
-      lto_output_tree (ob, map->new_tree, true);
-      bp = bitpack_create ();
-      bp_pack_value (bp, map->replace_p, 1);
-      bp_pack_value (bp, map->ref_p, 1);
-      lto_output_bitpack (ob->main_stream, bp);
-      bitpack_delete (bp);
-    }
-}
-
-/* Output optimization summaries stored in callgraph.
-   At the moment it is the clone info structure.  */
-
-static void
-output_cgraph_opt_summary (void)
-{
-  struct cgraph_node *node;
-  int i, n_nodes;
-  lto_cgraph_encoder_t encoder;
-  struct output_block *ob = create_output_block (LTO_section_cgraph_opt_sum);
-  unsigned count = 0;
-
-  ob->cgraph_node = NULL;
-  encoder = ob->decl_state->cgraph_node_encoder;
-  n_nodes = lto_cgraph_encoder_size (encoder);
-  for (i = 0; i < n_nodes; i++)
-    if (output_cgraph_opt_summary_p (lto_cgraph_encoder_deref (encoder, i)))
-      count++;
-  lto_output_uleb128_stream (ob->main_stream, count);
-  for (i = 0; i < n_nodes; i++)
-    {
-      node = lto_cgraph_encoder_deref (encoder, i);
-      if (output_cgraph_opt_summary_p (node))
-       {
-         lto_output_uleb128_stream (ob->main_stream, i);
-         output_node_opt_summary (ob, node);
-       }
-    }
-  produce_asm (ob, NULL);
-  destroy_output_block (ob);
-}
-
-/* Input optimiation summary of NODE.  */
-
-static void
-input_node_opt_summary (struct cgraph_node *node,
-                       struct lto_input_block *ib_main,
-                       struct data_in *data_in)
-{
-  int i;
-  int count;
-  int bit;
-  struct bitpack_d *bp;
-
-  count = lto_input_uleb128 (ib_main);
-  if (count)
-    node->clone.args_to_skip = BITMAP_GGC_ALLOC ();
-  for (i = 0; i < count; i++)
-    {
-      bit = lto_input_uleb128 (ib_main);
-      bitmap_set_bit (node->clone.args_to_skip, bit);
-    }
-  count = lto_input_uleb128 (ib_main);
-  if (count)
-    node->clone.combined_args_to_skip = BITMAP_GGC_ALLOC ();
-  for (i = 0; i < count; i++)
-    {
-      bit = lto_input_uleb128 (ib_main);
-      bitmap_set_bit (node->clone.combined_args_to_skip, bit);
-    }
-  count = lto_input_uleb128 (ib_main);
-  for (i = 0; i < count; i++)
-    {
-      int parm_num;
-      tree parm;
-      struct ipa_replace_map *map = GGC_NEW (struct ipa_replace_map);
-
-      VEC_safe_push (ipa_replace_map_p, gc, node->clone.tree_map, map);
-      for (parm_num = 0, parm = DECL_ARGUMENTS (node->decl); parm_num;
-          parm = TREE_CHAIN (parm))
-       parm_num --;
-      map->parm_num = lto_input_uleb128 (ib_main);
-      map->old_tree = NULL;
-      map->new_tree = lto_input_tree (ib_main, data_in);
-      bp = lto_input_bitpack (ib_main);
-      map->replace_p = bp_unpack_value (bp, 1);
-      map->ref_p = bp_unpack_value (bp, 1);
-      bitpack_delete (bp);
-    }
-}
-
-/* Read section in file FILE_DATA of length LEN with data DATA.  */
-
-static void
-input_cgraph_opt_section (struct lto_file_decl_data *file_data,
-                         const char *data, size_t len, VEC (cgraph_node_ptr,
-                                                            heap) * nodes)
-{
-  const struct lto_function_header *header =
-    (const struct lto_function_header *) data;
-  const int32_t cfg_offset = sizeof (struct lto_function_header);
-  const int32_t main_offset = cfg_offset + header->cfg_size;
-  const int32_t 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, NULL);
-  count = lto_input_uleb128 (&ib_main);
-
-  for (i = 0; i < count; i++)
-    {
-      int ref = lto_input_uleb128 (&ib_main);
-      input_node_opt_summary (VEC_index (cgraph_node_ptr, nodes, ref),
-                             &ib_main, data_in);
-    }
-  lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
-                        len);
-  lto_data_in_delete (data_in);
-}
-
-/* Input optimization summary of cgraph.  */
-
-static void
-input_cgraph_opt_summary (VEC (cgraph_node_ptr, heap) * nodes)
-{
-  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_cgraph_opt_sum, NULL,
-                             &len);
-
-      if (data)
-       input_cgraph_opt_section (file_data, data, len, nodes);
-    }
-}
index 464a2ef..9118e00 100644 (file)
@@ -1,3 +1,9 @@
+2010-04-20  Jan Hubicka  <jh@suse.cz>
+
+       * lto.c (lto_add_inline_clones): Do not track inlined_decls.
+       (lto_add_all_inlinees): Likewise.
+       (lto_wpa_write_files): Likewise.
+
 2010-04-18  Eric Botcazou  <ebotcazou@adacore.com>
 
        * lto-lang.c (lto_init): Remove second argument in call to
index dc6ccb5..1544f05 100644 (file)
@@ -593,22 +593,19 @@ finish:
 
 static void
 lto_add_inline_clones (cgraph_node_set set, struct cgraph_node *node,
-                      bitmap original_decls, bitmap inlined_decls)
+                      bitmap original_decls)
 {
    struct cgraph_node *callee;
    struct cgraph_edge *edge;
 
    cgraph_node_set_add (set, node);
 
-   if (!bitmap_bit_p (original_decls, DECL_UID (node->decl)))
-     bitmap_set_bit (inlined_decls, DECL_UID (node->decl));
-
    /* Check to see if NODE has any inlined callee.  */
    for (edge = node->callees; edge != NULL; edge = edge->next_callee)
      {
        callee = edge->callee;
        if (callee->global.inlined_to != NULL)
-         lto_add_inline_clones (set, callee, original_decls, inlined_decls);
+         lto_add_inline_clones (set, callee, original_decls);
      }
 }
 
@@ -616,14 +613,13 @@ lto_add_inline_clones (cgraph_node_set set, struct cgraph_node *node,
    information in the callgraph.  Returns a bitmap of decls that have
    been inlined into SET indexed by UID.  */
 
-static bitmap
+static void
 lto_add_all_inlinees (cgraph_node_set set)
 {
   cgraph_node_set_iterator csi;
   struct cgraph_node *node;
   bitmap original_nodes = lto_bitmap_alloc ();
   bitmap original_decls = lto_bitmap_alloc ();
-  bitmap inlined_decls = lto_bitmap_alloc ();
   bool changed;
 
   /* We are going to iterate SET while adding to it, mark all original
@@ -663,19 +659,17 @@ lto_add_all_inlinees (cgraph_node_set set)
     }
   while (changed);
 
 /* Transitively add to SET all the inline clones for every node that
-     has been inlined.  */
 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
-    {
-      node = csi_node (csi);
-      if (bitmap_bit_p (original_nodes, node->uid))
-       lto_add_inline_clones (set, node, original_decls, inlined_decls);
-    }
+ /* Transitively add to SET all the inline clones for every node that
+    has been inlined.  */
+ for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
+   {
+     node = csi_node (csi);
+     if (bitmap_bit_p (original_nodes, node->uid))
+      lto_add_inline_clones (set, node, original_decls);
+   }
 
   lto_bitmap_free (original_nodes);
   lto_bitmap_free (original_decls);
-
-  return inlined_decls;
 }
 
 /* Owing to inlining, we may need to promote a file-scope variable
@@ -1004,8 +998,6 @@ lto_wpa_write_files (void)
   unsigned i, n_sets, last_out_file_ix, num_out_files;
   lto_file *file;
   cgraph_node_set set;
-  bitmap decls;
-  VEC(bitmap,heap) *inlined_decls = NULL;
 
   timevar_push (TV_WHOPR_WPA);
 
@@ -1015,8 +1007,7 @@ lto_wpa_write_files (void)
      compiled by LTRANS.  */
   for (i = 0; VEC_iterate (cgraph_node_set, lto_cgraph_node_sets, i, set); i++)
     {
-      decls = lto_add_all_inlinees (set);
-      VEC_safe_push (bitmap, heap, inlined_decls, decls);
+      lto_add_all_inlinees (set);
       lto_stats.num_output_cgraph_nodes += VEC_length (cgraph_node_ptr,
                                                       set->nodes);
     }
@@ -1053,13 +1044,8 @@ lto_wpa_write_files (void)
            fatal_error ("lto_elf_file_open() failed");
 
          lto_set_current_out_file (file);
-         lto_new_extern_inline_states ();
-
-         decls = VEC_index (bitmap, inlined_decls, i);
-         lto_force_functions_extern_inline (decls);
 
          ipa_write_summaries_of_cgraph_node_set (set);
-         lto_delete_extern_inline_states ();
 
          lto_set_current_out_file (NULL);
          lto_elf_file_close (file);
@@ -1072,10 +1058,6 @@ lto_wpa_write_files (void)
 
   output_files[last_out_file_ix] = NULL;
 
-  for (i = 0; VEC_iterate (bitmap, inlined_decls, i, decls); i++)
-    lto_bitmap_free (decls);
-  VEC_free (bitmap, heap, inlined_decls);
-
   timevar_pop (TV_WHOPR_WPA_IO);
 
   return output_files;
index cbd605f..6437ab7 100644 (file)
@@ -1695,7 +1695,6 @@ ipa_write_summaries (void)
   if (!flag_generate_lto || errorcount || sorrycount)
     return;
 
-  lto_new_extern_inline_states ();
   set = cgraph_node_set_new ();
 
   /* Create the callgraph set in the same order used in
@@ -1726,7 +1725,6 @@ ipa_write_summaries (void)
     }
 
   ipa_write_summaries_1 (set);
-  lto_delete_extern_inline_states ();
 
   free (order);
   ggc_free (set);