* cgraph.h (cgraph_local_info): Remove for_functions_valid.

[pf3gnuchains/gcc-fork.git] / gcc / lto-cgraph.c

diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c
index 6405432..1982185 100644 (file)
--- a/gcc/lto-cgraph.c
+++ b/gcc/lto-cgraph.c
@@ -47,6 +47,21 @@ along with GCC; see the file COPYING3.  If not see
 #include "lto-streamer.h"
 #include "gcov-io.h"
 
 #include "lto-streamer.h"
 #include "gcov-io.h"
 

+/* 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
 /* Create a new cgraph encoder.  */
 
 lto_cgraph_encoder_t


@@ -95,6 +110,7 @@ lto_cgraph_encoder_encode (lto_cgraph_encoder_t encoder,
   return ref;
 }
 
   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.  */
 
 /* Look up NODE in encoder.  Return NODE's reference if it has been encoded
    or LCC_NOT_FOUND if it is not there.  */


@@ -203,7 +219,6 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
 {
   unsigned int tag;
   struct bitpack_d *bp;
 {
   unsigned int tag;
   struct bitpack_d *bp;

-  unsigned local, externally_visible, inlinable, analyzed;

   bool boundary_p, wrote_decl_p;
   intptr_t ref;
   bool in_other_partition = false;
   bool boundary_p, wrote_decl_p;
   intptr_t ref;
   bool in_other_partition = false;


@@ -211,35 +226,13 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
   boundary_p = !cgraph_node_in_set_p (node, set);
   wrote_decl_p = bitmap_bit_p (written_decls, DECL_UID (node->decl));
 
   boundary_p = !cgraph_node_in_set_p (node, set);
   wrote_decl_p = bitmap_bit_p (written_decls, DECL_UID (node->decl));
 

-  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)
+  if (node->analyzed && !boundary_p)
+    tag = LTO_cgraph_analyzed_node;
+  else

     tag = LTO_cgraph_unavail_node;
 
   lto_output_uleb128_stream (ob->main_stream, tag);
 
     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.
 
   /* In WPA mode, we only output part of the call-graph.  Also, we
      fake cgraph node attributes.  There are two cases that we care.
 


@@ -250,7 +243,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.  */
      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)
+  if (boundary_p && node->analyzed)

     {
       /* Inline clones can not be part of boundary.  
          gcc_assert (!node->global.inlined_to);  
     {
       /* Inline clones can not be part of boundary.  
          gcc_assert (!node->global.inlined_to);  


@@ -261,7 +254,6 @@ 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;
         needs a bit extra work and will be promplty done by cgraph_remove_node
         after reading back.  */
       in_other_partition = 1;

-      analyzed = 0;

     }
 
   lto_output_uleb128_stream (ob->main_stream, wrote_decl_p);
     }
 
   lto_output_uleb128_stream (ob->main_stream, wrote_decl_p);


@@ -273,30 +265,27 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
   lto_output_sleb128_stream (ob->main_stream, node->count);
 
   bp = bitpack_create ();
   lto_output_sleb128_stream (ob->main_stream, node->count);
 
   bp = bitpack_create ();

-  bp_pack_value (bp, local, 1);
-  bp_pack_value (bp, externally_visible, 1);
+  bp_pack_value (bp, node->local.local, 1);
+  bp_pack_value (bp, node->local.externally_visible, 1);

   bp_pack_value (bp, node->local.finalized, 1);
   bp_pack_value (bp, node->local.finalized, 1);

-  bp_pack_value (bp, inlinable, 1);
+  bp_pack_value (bp, node->local.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.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, 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, node->reachable, 1);
-  bp_pack_value (bp, analyzed && reachable_from_other_partition_p (node, set), 1);
+  bp_pack_value (bp, tag == LTO_cgraph_analyzed_node
+                && reachable_from_other_partition_p (node, set), 1);

   bp_pack_value (bp, node->lowered, 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, 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);
 
   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_unavail_node)
+  if (tag == LTO_cgraph_analyzed_node)

     {
       lto_output_sleb128_stream (ob->main_stream,
                                 node->local.inline_summary.estimated_self_stack_size);
     {
       lto_output_sleb128_stream (ob->main_stream,
                                 node->local.inline_summary.estimated_self_stack_size);


@@ -308,29 +297,17 @@ 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);
                                 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;

 
 

-  /* 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);
+      lto_output_sleb128_stream (ob->main_stream, ref);

     }
     }

-  else
-    ref = LCC_NOT_FOUND;
-  lto_output_sleb128_stream (ob->main_stream, ref);

 
 

-  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 && !boundary_p)
     {
       ref = lto_cgraph_encoder_lookup (encoder, node->same_comdat_group);
   if (node->same_comdat_group && !boundary_p)
     {
       ref = lto_cgraph_encoder_lookup (encoder, node->same_comdat_group);


@@ -579,6 +556,8 @@ 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->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.lto_file_data = file_data;
 
   node->local.local = bp_unpack_value (bp, 1);


@@ -587,17 +566,14 @@ input_overwrite_node (struct lto_file_decl_data *file_data,
   node->local.inlinable = 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.inlinable = 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->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->reachable_from_other_partition = bp_unpack_value (bp, 1);
   node->lowered = bp_unpack_value (bp, 1);

-  node->analyzed = bp_unpack_value (bp, 1);
+  node->analyzed = tag == LTO_cgraph_analyzed_node;

   node->in_other_partition = 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);
   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);


@@ -644,18 +620,12 @@ input_node (struct lto_file_decl_data *file_data,
   int stack_size = 0;
   unsigned decl_index;
   bool clone_p;
   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 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 self_time = 0;
   int self_size = 0;
   int time_inlining_benefit = 0;
   int size_inlining_benefit = 0;
   unsigned long same_body_count = 0;

-  bool inlined = false;

 
   clone_p = (lto_input_uleb128 (ib) != 0);
 
 
   clone_p = (lto_input_uleb128 (ib) != 0);
 


@@ -672,22 +642,17 @@ input_node (struct lto_file_decl_data *file_data,
   node->count = lto_input_sleb128 (ib);
   bp = lto_input_bitpack (ib);
 
   node->count = lto_input_sleb128 (ib);
   bp = lto_input_bitpack (ib);
 

-  if (tag != LTO_cgraph_unavail_node)
+  if (tag == LTO_cgraph_analyzed_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);
     {
       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);
 
   ref2 = lto_input_sleb128 (ib);
   same_body_count = lto_input_uleb128 (ib);
 


@@ -704,17 +669,9 @@ input_node (struct lto_file_decl_data *file_data,
                        size_inlining_benefit);
   bitpack_delete (bp);
 
                        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;
 
   /* 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;
 
   /* Store a reference for now, and fix up later to be a pointer.  */
   node->same_comdat_group = (cgraph_node_ptr) (intptr_t) ref2;