OSDN Git Service

* tree-pass.h (ipa_opt_pass_d): Rename function_read_summary;
authorhubicka <hubicka@138bc75d-0d04-0410-961f-82ee72b054a4>
Wed, 21 Apr 2010 17:44:03 +0000 (17:44 +0000)
committerMasaki Muranaka <monaka@monami-software.com>
Sun, 23 May 2010 05:34:47 +0000 (14:34 +0900)
add write_optimization_summary, read_optimization_summary.
(ipa_write_summaries_of_cgraph_node_set): Remove.
(ipa_write_optimization_summaries): Declare.
(ipa_read_optimization_summaries): Declare.
* ipa-cp.c (pass_ipa_cp): Update.
* ipa-reference.c (pass_ipa_reference): Update.
* ipa-pure-const.c (pass_ipa_pure_const): Update.
* lto-streamer-out.c (pass_ipa_lto_gimple, pass_ipa_lto_finish):
Update.
* ipa-inline.c (pass_ipa_inline): Update.
* ipa.c (pass_ipa_whole_program): Update.
* lto-wpa-fixup.c (pass_ipa_lto_wpa_fixup): Update.
* passes.c (ipa_write_summaries_1): Do not test wpa.
(ipa_write_optimization_summaries_1): New.
(ipa_write_optimization_summaries): New.
(ipa_read_summaries): Do not test ltrans.
(ipa_read_optimization_summaries_1): New.
(ipa_read_optimization_summaries): New.

* lto.c (lto_wpa_write_files): Update.
(read_cgraph_and_symbols): Be more verbose.
(materialize_cgraph): Likewise.
(do_whole_program_analysis): Likewise.

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

gcc/ChangeLog
gcc/ipa-cp.c
gcc/ipa-inline.c
gcc/ipa-reference.c
gcc/ipa.c
gcc/lto/ChangeLog
gcc/lto/lto.c
gcc/passes.c
gcc/tree-pass.h

index 9b379bd..155c5fc 100644 (file)
@@ -1,5 +1,27 @@
 2010-04-21  Jan Hubicka  <jh@suse.cz>
 
+       * tree-pass.h (ipa_opt_pass_d): Rename function_read_summary;
+       add write_optimization_summary, read_optimization_summary.
+       (ipa_write_summaries_of_cgraph_node_set): Remove.
+       (ipa_write_optimization_summaries): Declare.
+       (ipa_read_optimization_summaries): Declare.
+       * ipa-cp.c (pass_ipa_cp): Update.
+       * ipa-reference.c (pass_ipa_reference): Update.
+       * ipa-pure-const.c (pass_ipa_pure_const): Update.
+       * lto-streamer-out.c (pass_ipa_lto_gimple, pass_ipa_lto_finish):
+       Update.
+       * ipa-inline.c (pass_ipa_inline): Update.
+       * ipa.c (pass_ipa_whole_program): Update.
+       * lto-wpa-fixup.c (pass_ipa_lto_wpa_fixup): Update.
+       * passes.c (ipa_write_summaries_1): Do not test wpa.
+       (ipa_write_optimization_summaries_1): New.
+       (ipa_write_optimization_summaries): New.
+       (ipa_read_summaries): Do not test ltrans.
+       (ipa_read_optimization_summaries_1): New.
+       (ipa_read_optimization_summaries): New.
+
+2010-04-21  Jan Hubicka  <jh@suse.cz>
+
        * lto-cgraph.c (lto_output_node): Do not output comdat groups
        for boundary nodes.
        (output_cgraph): Do not arrange comdat groups for boundary nodes.
index f4aab5d..ca7c0e6 100644 (file)
@@ -183,7 +183,6 @@ ipcp_analyze_node (struct cgraph_node *node)
   /* Unreachable nodes should have been eliminated before ipcp.  */
   gcc_assert (node->needed || node->reachable);
 
-  node->local.versionable = tree_versionable_function_p (node->decl);
   ipa_initialize_node_params (node);
   ipa_detect_param_modifications (node);
 }
@@ -416,21 +415,35 @@ ipcp_print_all_lattices (FILE * f)
 static bool
 ipcp_versionable_function_p (struct cgraph_node *node)
 {
-  struct cgraph_edge *edge;
+  tree decl = node->decl;
+  basic_block bb;
 
   /* There are a number of generic reasons functions cannot be versioned.  */
-  if (!node->local.versionable)
+  if (!tree_versionable_function_p (decl))
     return false;
 
-  /* Removing arguments doesn't work if the function takes varargs
-     or use __builtin_apply_args. */
-  for (edge = node->callees; edge; edge = edge->next_callee)
+  /* Removing arguments doesn't work if the function takes varargs.  */
+  if (DECL_STRUCT_FUNCTION (decl)->stdarg)
+    return false;
+
+  /* Removing arguments doesn't work if we use __builtin_apply_args.  */
+  FOR_EACH_BB_FN (bb, DECL_STRUCT_FUNCTION (decl))
     {
-      tree t = edge->callee->decl;
-      if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
-         && (DECL_FUNCTION_CODE (t) == BUILT_IN_APPLY_ARGS
-            || DECL_FUNCTION_CODE (t) == BUILT_IN_VA_START))
-       return false;
+      gimple_stmt_iterator gsi;
+      for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+       {
+         const_gimple stmt = gsi_stmt (gsi);
+         tree t;
+
+         if (!is_gimple_call (stmt))
+           continue;
+         t = gimple_call_fndecl (stmt);
+         if (t == NULL_TREE)
+           continue;
+         if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
+             && DECL_FUNCTION_CODE (t) == BUILT_IN_APPLY_ARGS)
+           return false;
+       }
     }
 
   return true;
@@ -917,9 +930,12 @@ ipcp_update_callgraph (void)
        for (i = 0; i < count; i++)
          {
            struct ipcp_lattice *lat = ipcp_get_lattice (info, i);
+           tree parm_tree = ipa_get_param (info, i);
 
            /* We can proactively remove obviously unused arguments.  */
-           if (!ipa_is_param_used (info, i))
+           if (is_gimple_reg (parm_tree)
+               && !gimple_default_def (DECL_STRUCT_FUNCTION (orig_node->decl),
+                                       parm_tree))
              {
                bitmap_set_bit (args_to_skip, i);
                continue;
@@ -992,9 +1008,12 @@ ipcp_estimate_growth (struct cgraph_node *node)
   for (i = 0; i < count; i++)
     {
       struct ipcp_lattice *lat = ipcp_get_lattice (info, i);
+      tree parm_tree = ipa_get_param (info, i);
 
       /* We can proactively remove obviously unused arguments.  */
-      if (!ipa_is_param_used (info, i))
+      if (is_gimple_reg (parm_tree)
+         && !gimple_default_def (DECL_STRUCT_FUNCTION (node->decl),
+                                 parm_tree))
        removable_args++;
 
       if (lat->type == IPA_CONST_VALUE)
@@ -1062,9 +1081,12 @@ ipcp_const_param_count (struct cgraph_node *node)
   for (i = 0; i < count; i++)
     {
       struct ipcp_lattice *lat = ipcp_get_lattice (info, i);
+      tree parm_tree = ipa_get_param (info, i);
       if (ipcp_lat_is_insertable (lat)
          /* Do not count obviously unused arguments.  */
-          && ipa_is_param_used (info, i))
+         && (!is_gimple_reg (parm_tree)
+             || gimple_default_def (DECL_STRUCT_FUNCTION (node->decl),
+                                    parm_tree)))
        const_param++;
     }
   return const_param;
@@ -1168,7 +1190,9 @@ ipcp_insert_stage (void)
          parm_tree = ipa_get_param (info, i);
 
          /* We can proactively remove obviously unused arguments.  */
-          if (!ipa_is_param_used (info, i))
+         if (is_gimple_reg (parm_tree)
+             && !gimple_default_def (DECL_STRUCT_FUNCTION (node->decl),
+                                     parm_tree))
            {
              bitmap_set_bit (args_to_skip, i);
              continue;
@@ -1258,7 +1282,7 @@ ipcp_driver (void)
       ipcp_print_profile_data (dump_file);
     }
   /* Free all IPCP structures.  */
-  ipa_free_all_structures_after_ipa_cp ();
+  free_all_ipa_structures_after_ipa_cp ();
   if (dump_file)
     fprintf (dump_file, "\nIPA constant propagation end\n");
   return 0;
@@ -1280,8 +1304,7 @@ ipcp_generate_summary (void)
 
 /* Write ipcp summary for nodes in SET.  */
 static void
-ipcp_write_summary (cgraph_node_set set,
-                   varpool_node_set vset ATTRIBUTE_UNUSED)
+ipcp_write_summary (cgraph_node_set set)
 {
   ipa_prop_write_jump_functions (set);
 }
@@ -1316,14 +1339,14 @@ struct ipa_opt_pass_d pass_ipa_cp =
   0,                           /* properties_destroyed */
   0,                           /* todo_flags_start */
   TODO_dump_cgraph | TODO_dump_func |
-  TODO_remove_functions | TODO_ggc_collect /* todo_flags_finish */
+  TODO_remove_functions /* todo_flags_finish */
  },
  ipcp_generate_summary,                        /* generate_summary */
  ipcp_write_summary,                   /* write_summary */
  ipcp_read_summary,                    /* read_summary */
  NULL,                                 /* write_optimization_summary */
  NULL,                                 /* read_optimization_summary */
NULL,                                 /* stmt_fixup */
lto_ipa_fixup_call_notes,             /* stmt_fixup */
  0,                                    /* TODOs */
  NULL,                                 /* function_transform */
  NULL,                                 /* variable_transform */
index d9f207c..fbd695d 100644 (file)
@@ -268,8 +268,7 @@ cgraph_clone_inlined_nodes (struct cgraph_edge *e, bool duplicate,
       else
        {
          struct cgraph_node *n;
-         n = cgraph_clone_node (e->callee, e->callee->decl,
-                                e->count, e->frequency, e->loop_nest,
+         n = cgraph_clone_node (e->callee, e->count, e->frequency, e->loop_nest,
                                 update_original, NULL);
          cgraph_redirect_edge_callee (e, n);
        }
@@ -286,7 +285,6 @@ cgraph_clone_inlined_nodes (struct cgraph_edge *e, bool duplicate,
       + inline_summary (e->callee)->estimated_self_stack_size;
   if (e->callee->global.inlined_to->global.estimated_stack_size < peak)
     e->callee->global.inlined_to->global.estimated_stack_size = peak;
-  cgraph_propagate_frequency (e->callee);
 
   /* Recursively clone all bodies.  */
   for (e = e->callee->callees; e; e = e->next_callee)
@@ -311,7 +309,6 @@ cgraph_mark_inline_edge (struct cgraph_edge *e, bool update_original,
 
   gcc_assert (e->inline_failed);
   e->inline_failed = CIF_OK;
-  DECL_POSSIBLY_INLINED (e->callee->decl) = true;
 
   if (!e->callee->global.inlined)
     DECL_POSSIBLY_INLINED (e->callee->decl) = true;
@@ -669,7 +666,7 @@ update_caller_keys (fibheap_t heap, struct cgraph_node *node,
   struct cgraph_edge *edge;
   cgraph_inline_failed_t failed_reason;
 
-  if (!node->local.inlinable
+  if (!node->local.inlinable || node->local.disregard_inline_limits
       || node->global.inlined_to)
     return;
   if (bitmap_bit_p (updated_nodes, node->uid))
@@ -810,8 +807,7 @@ cgraph_decide_recursive_inlining (struct cgraph_node *node,
             cgraph_node_name (node));
 
   /* We need original clone to copy around.  */
-  master_clone = cgraph_clone_node (node, node->decl,
-                                   node->count, CGRAPH_FREQ_BASE, 1,
+  master_clone = cgraph_clone_node (node, node->count, CGRAPH_FREQ_BASE, 1,
                                    false, NULL);
   master_clone->needed = true;
   for (e = master_clone->callees; e; e = e->next_callee)
@@ -1074,14 +1070,12 @@ cgraph_decide_inlining_of_small_functions (void)
            }
        }
 
-      if (edge->callee->local.disregard_inline_limits)
-       ;
-      else if (!cgraph_maybe_hot_edge_p (edge))
+      if (!cgraph_maybe_hot_edge_p (edge))
        not_good = CIF_UNLIKELY_CALL;
-      else if (!flag_inline_functions
+      if (!flag_inline_functions
          && !DECL_DECLARED_INLINE_P (edge->callee->decl))
        not_good = CIF_NOT_DECLARED_INLINED;
-      else if (optimize_function_for_size_p (DECL_STRUCT_FUNCTION(edge->caller->decl)))
+      if (optimize_function_for_size_p (DECL_STRUCT_FUNCTION(edge->caller->decl)))
        not_good = CIF_OPTIMIZING_FOR_SIZE;
       if (not_good && growth > 0 && cgraph_estimate_growth (edge->callee) > 0)
        {
@@ -1327,8 +1321,6 @@ cgraph_decide_inlining (void)
   cgraph_remove_function_insertion_hook (function_insertion_hook_holder);
   if (in_lto_p && flag_indirect_inlining)
     ipa_update_after_lto_read ();
-  if (flag_indirect_inlining)
-    ipa_create_all_structures_for_iinln ();
 
   max_count = 0;
   max_benefit = 0;
@@ -1449,7 +1441,7 @@ cgraph_decide_inlining (void)
 
   /* Free ipa-prop structures if they are no longer needed.  */
   if (flag_indirect_inlining)
-    ipa_free_all_structures_after_iinln ();
+    free_all_ipa_structures_after_iinln ();
 
   if (dump_file)
     fprintf (dump_file,
@@ -2102,8 +2094,7 @@ inline_read_summary (void)
    active, we don't need to write them twice.  */
 
 static void
-inline_write_summary (cgraph_node_set set,
-                     varpool_node_set vset ATTRIBUTE_UNUSED)
+inline_write_summary (cgraph_node_set set)
 {
   if (flag_indirect_inlining && !flag_ipa_cp)
     ipa_prop_write_jump_functions (set);
@@ -2139,14 +2130,14 @@ struct ipa_opt_pass_d pass_ipa_inline =
   0,                                   /* properties_destroyed */
   TODO_remove_functions,               /* todo_flags_finish */
   TODO_dump_cgraph | TODO_dump_func
-  | TODO_remove_functions | TODO_ggc_collect   /* todo_flags_finish */
+  | TODO_remove_functions              /* todo_flags_finish */
  },
  inline_generate_summary,              /* generate_summary */
  inline_write_summary,                 /* write_summary */
  inline_read_summary,                  /* read_summary */
  NULL,                                 /* write_optimization_summary */
  NULL,                                 /* read_optimization_summary */
NULL,                                 /* stmt_fixup */
lto_ipa_fixup_call_notes,             /* stmt_fixup */
  0,                                    /* TODOs */
  inline_transform,                     /* function_transform */
  NULL,                                 /* variable_transform */
index f1946d8..7183e65 100644 (file)
@@ -22,7 +22,13 @@ along with GCC; see the file COPYING3.  If not see
 /* This file gathers information about how variables whose scope is
    confined to the compilation unit are used.
 
-   The transitive call site specific clobber effects are computed
+   There are two categories of information produced by this pass:
+
+   1) The addressable (TREE_ADDRESSABLE) bit and readonly
+   (TREE_READONLY) bit associated with these variables is properly set
+   based on scanning all of the code withing the compilation unit.
+
+   2) The transitive call site specific clobber effects are computed
    for the variables whose scope is contained within this compilation
    unit.
 
@@ -35,7 +41,12 @@ along with GCC; see the file COPYING3.  If not see
    side effects of each call.  In later parts of the compiler, these
    local and global sets are examined to make the call clobbering less
    traumatic, promote some statics to registers, and improve aliasing
-   information.  */
+   information.
+
+   Currently must be run after inlining decisions have been made since
+   otherwise, the local sets will not contain information that is
+   consistent with post inlined state.  The global sets are not prone
+   to this problem since they are by definition transitive.  */
 
 #include "config.h"
 #include "system.h"
@@ -59,8 +70,9 @@ along with GCC; see the file COPYING3.  If not see
 #include "diagnostic.h"
 #include "langhooks.h"
 #include "lto-streamer.h"
-#include "toplev.h"
 
+static void add_new_function (struct cgraph_node *node,
+                             void *data ATTRIBUTE_UNUSED);
 static void remove_node_data (struct cgraph_node *node,
                              void *data ATTRIBUTE_UNUSED);
 static void duplicate_node_data (struct cgraph_node *src,
@@ -87,113 +99,157 @@ struct ipa_reference_local_vars_info_d
 /* Statics that are read and written by some set of functions. The
    local ones are based on the loads and stores local to the function.
    The global ones are based on the local info as well as the
-   transitive closure of the functions that are called. */
+   transitive closure of the functions that are called.  The
+   structures are separated to allow the global structures to be
+   shared between several functions since every function within a
+   strongly connected component will have the same information.  This
+   sharing saves both time and space in the computation of the vectors
+   as well as their translation from decl_uid form to ann_uid
+   form.  */
 
 struct ipa_reference_global_vars_info_d
 {
   bitmap statics_read;
   bitmap statics_written;
-};
-
-/* Information we save about every function after ipa-reference is completted.  */
-
-struct ipa_reference_optimization_summary_d
-{
   bitmap statics_not_read;
   bitmap statics_not_written;
 };
 
 typedef struct ipa_reference_local_vars_info_d *ipa_reference_local_vars_info_t;
 typedef struct ipa_reference_global_vars_info_d *ipa_reference_global_vars_info_t;
-typedef struct ipa_reference_optimization_summary_d *ipa_reference_optimization_summary_t;
-
 struct ipa_reference_vars_info_d
 {
-  struct ipa_reference_local_vars_info_d local;
-  struct ipa_reference_global_vars_info_d global;
+  ipa_reference_local_vars_info_t local;
+  ipa_reference_global_vars_info_t global;
 };
 
 typedef struct ipa_reference_vars_info_d *ipa_reference_vars_info_t;
 
 /* This splay tree contains all of the static variables that are
-   being considered by the compilation level alias analysis.  */
-static splay_tree reference_vars_to_consider;
+   being considered by the compilation level alias analysis.  For
+   module_at_a_time compilation, this is the set of static but not
+   public variables.  Any variables that either have their address
+   taken or participate in otherwise unsavory operations are deleted
+   from this list.  */
+static GTY((param1_is(int), param2_is(tree)))
+     splay_tree reference_vars_to_consider;
+
+/* This bitmap is used to knock out the module static variables whose
+   addresses have been taken and passed around.  */
+static bitmap module_statics_escape;
+
+/* This bitmap is used to knock out the module static variables that
+   are not readonly.  */
+static bitmap module_statics_written;
 
 /* A bit is set for every module static we are considering.  This is
    ored into the local info when asm code is found that clobbers all
    memory. */
 static bitmap all_module_statics;
 
+static struct pointer_set_t *visited_nodes;
+
 /* Obstack holding bitmaps of local analysis (live from analysis to
    propagation)  */
 static bitmap_obstack local_info_obstack;
 /* Obstack holding global analysis live forever.  */
-static bitmap_obstack optimization_summary_obstack;
+static bitmap_obstack global_info_obstack;
 
 /* Holders of ipa cgraph hooks: */
+static struct cgraph_node_hook_list *function_insertion_hook_holder;
 static struct cgraph_2node_hook_list *node_duplication_hook_holder;
 static struct cgraph_node_hook_list *node_removal_hook_holder;
 
+enum initialization_status_t
+{
+  UNINITIALIZED,
+  RUNNING,
+  FINISHED
+};
+
+tree memory_identifier_string;
+
 /* Vector where the reference var infos are actually stored. */
 DEF_VEC_P (ipa_reference_vars_info_t);
 DEF_VEC_ALLOC_P (ipa_reference_vars_info_t, heap);
 static VEC (ipa_reference_vars_info_t, heap) *ipa_reference_vars_vector;
-DEF_VEC_P (ipa_reference_optimization_summary_t);
-DEF_VEC_ALLOC_P (ipa_reference_optimization_summary_t, heap);
-static VEC (ipa_reference_optimization_summary_t, heap) *ipa_reference_opt_sum_vector;
 
 /* Return the ipa_reference_vars structure starting from the cgraph NODE.  */
 static inline ipa_reference_vars_info_t
 get_reference_vars_info (struct cgraph_node *node)
 {
   if (!ipa_reference_vars_vector
-      || VEC_length (ipa_reference_vars_info_t,
-                    ipa_reference_vars_vector) <= (unsigned int) node->uid)
+      || VEC_length (ipa_reference_vars_info_t, ipa_reference_vars_vector) <= (unsigned int)node->uid)
     return NULL;
-  return VEC_index (ipa_reference_vars_info_t, ipa_reference_vars_vector,
-                   node->uid);
+  return VEC_index (ipa_reference_vars_info_t, ipa_reference_vars_vector, node->uid);
 }
 
 /* Return the ipa_reference_vars structure starting from the cgraph NODE.  */
-static inline ipa_reference_optimization_summary_t
-get_reference_optimization_summary (struct cgraph_node *node)
+static inline void
+set_reference_vars_info (struct cgraph_node *node, ipa_reference_vars_info_t info)
+{
+  if (!ipa_reference_vars_vector
+      || VEC_length (ipa_reference_vars_info_t, ipa_reference_vars_vector) <= (unsigned int)node->uid)
+     VEC_safe_grow_cleared (ipa_reference_vars_info_t, heap, ipa_reference_vars_vector, node->uid + 1);
+  VEC_replace (ipa_reference_vars_info_t, ipa_reference_vars_vector, node->uid, info);
+}
+
+/* Get a bitmap that contains all of the locally referenced static
+   variables for function FN.  */
+static ipa_reference_local_vars_info_t
+get_local_reference_vars_info (struct cgraph_node *fn)
+{
+  ipa_reference_vars_info_t info = get_reference_vars_info (fn);
+
+  if (info)
+    return info->local;
+  else
+    /* This phase was not run.  */
+    return NULL;
+}
+
+/* Get a bitmap that contains all of the globally referenced static
+   variables for function FN.  */
+
+static ipa_reference_global_vars_info_t
+get_global_reference_vars_info (struct cgraph_node *fn)
 {
-  if (!ipa_reference_opt_sum_vector
-      || (VEC_length (ipa_reference_optimization_summary_t,
-                    ipa_reference_opt_sum_vector)
-         <= (unsigned int) node->uid))
+  ipa_reference_vars_info_t info = get_reference_vars_info (fn);
+
+  if (info)
+    return info->global;
+  else
+    /* This phase was not run.  */
     return NULL;
-  return VEC_index (ipa_reference_optimization_summary_t, ipa_reference_opt_sum_vector,
-                   node->uid);
 }
 
-/* Return the ipa_reference_vars structure starting from the cgraph NODE.  */
-static inline void
-set_reference_vars_info (struct cgraph_node *node,
-                        ipa_reference_vars_info_t info)
+/* Return a bitmap indexed by VAR_DECL uid for the static variables
+   that are read during the execution of the function FN.  Returns
+   NULL if no data is available.  */
+
+bitmap
+ipa_reference_get_read_global (struct cgraph_node *fn)
 {
-  if (!ipa_reference_vars_vector
-      || VEC_length (ipa_reference_vars_info_t,
-                    ipa_reference_vars_vector) <= (unsigned int) node->uid)
-    VEC_safe_grow_cleared (ipa_reference_vars_info_t, heap,
-                          ipa_reference_vars_vector, node->uid + 1);
-  VEC_replace (ipa_reference_vars_info_t, ipa_reference_vars_vector,
-              node->uid, info);
+  ipa_reference_global_vars_info_t g = get_global_reference_vars_info (fn);
+  if (g)
+    return g->statics_read;
+  else
+    return NULL;
 }
 
-/* Return the ipa_reference_vars structure starting from the cgraph NODE.  */
-static inline void
-set_reference_optimization_summary (struct cgraph_node *node,
-                                   ipa_reference_optimization_summary_t info)
+/* Return a bitmap indexed by VAR_DECL uid for the static variables
+   that are written during the execution of the function FN.  Note
+   that variables written may or may not be read during the function
+   call.  Returns NULL if no data is available.  */
+
+bitmap
+ipa_reference_get_written_global (struct cgraph_node *fn)
 {
-  if (!ipa_reference_opt_sum_vector
-      || (VEC_length (ipa_reference_optimization_summary_t,
-                     ipa_reference_opt_sum_vector)
-         <= (unsigned int) node->uid))
-    VEC_safe_grow_cleared (ipa_reference_optimization_summary_t,
-                          heap, ipa_reference_opt_sum_vector, node->uid + 1);
-  VEC_replace (ipa_reference_optimization_summary_t,
-              ipa_reference_opt_sum_vector, node->uid, info);
+  ipa_reference_global_vars_info_t g = get_global_reference_vars_info (fn);
+  if (g)
+    return g->statics_written;
+  else
+    return NULL;
 }
 
 /* Return a bitmap indexed by_DECL_UID uid for the static variables
@@ -203,11 +259,9 @@ set_reference_optimization_summary (struct cgraph_node *node,
 bitmap
 ipa_reference_get_not_read_global (struct cgraph_node *fn)
 {
-  ipa_reference_optimization_summary_t info;
-
-  info = get_reference_optimization_summary (fn);
-  if (info)
-    return info->statics_not_read;
+  ipa_reference_global_vars_info_t g = get_global_reference_vars_info (fn);
+  if (g)
+    return g->statics_not_read;
   else
     return NULL;
 }
@@ -220,11 +274,9 @@ ipa_reference_get_not_read_global (struct cgraph_node *fn)
 bitmap
 ipa_reference_get_not_written_global (struct cgraph_node *fn)
 {
-  ipa_reference_optimization_summary_t info;
-
-  info = get_reference_optimization_summary (fn);
-  if (info)
-    return info->statics_not_written;
+  ipa_reference_global_vars_info_t g = get_global_reference_vars_info (fn);
+  if (g)
+    return g->statics_not_written;
   else
     return NULL;
 }
@@ -241,9 +293,8 @@ add_static_var (tree var)
   gcc_assert (TREE_CODE (var) == VAR_DECL);
   if (!bitmap_bit_p (all_module_statics, uid))
     {
-      if (dump_file)
-       splay_tree_insert (reference_vars_to_consider,
-                          uid, (splay_tree_value)var);
+      splay_tree_insert (reference_vars_to_consider,
+                        uid, (splay_tree_value)var);
       bitmap_set_bit (all_module_statics, uid);
     }
 }
@@ -252,11 +303,8 @@ add_static_var (tree var)
    perform compilation unit scope escape analysis.  */
 
 static inline bool
-is_proper_for_analysis (tree t)
+has_proper_scope_for_analysis (tree t)
 {
-  /* We handle only variables whose address is never taken.  */
-  if (TREE_ADDRESSABLE (t))
-    return false;
   /* If the variable has the "used" attribute, treat it as if it had a
      been touched by the devil.  */
   if (DECL_PRESERVE_P (t))
@@ -267,14 +315,22 @@ is_proper_for_analysis (tree t)
   if (TREE_THIS_VOLATILE (t))
     return false;
 
+  /* Do not care about a local automatic that is not static.  */
+  if (!TREE_STATIC (t) && !DECL_EXTERNAL (t))
+    return false;
+
+  /* FIXME: for LTO we should include PUBLIC vars too.  This is bit difficult
+     as summarie would need unsharing.  */
+  if (DECL_EXTERNAL (t) || TREE_PUBLIC (t))
+    return false;
+
   /* We cannot touch decls where the type needs constructing.  */
   if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (t)))
     return false;
 
   /* This is a variable we care about.  Check if we have seen it
      before, and if not add it the set of variables we care about.  */
-  if (all_module_statics
-      && !bitmap_bit_p (all_module_statics, DECL_UID (t)))
+  if (!bitmap_bit_p (all_module_statics, DECL_UID (t)))
     add_static_var (t);
 
   return true;
@@ -477,10 +533,10 @@ propagate_bits (ipa_reference_global_vars_info_t x_global, struct cgraph_node *x
            {
              ipa_reference_vars_info_t y_info
                = get_reference_vars_info (y);
-             ipa_reference_global_vars_info_t y_global = &y_info->global;
+             ipa_reference_global_vars_info_t y_global = y_info->global;
 
              /* Calls in current cycle do not have global computed yet.  */
-             if (!y_global->statics_read)
+             if (!y_info->global)
                continue;
 
              if (x_global->statics_read
@@ -537,19 +593,49 @@ ipa_init (void)
 
   init_p = true;
 
-  if (dump_file)
-    reference_vars_to_consider = splay_tree_new (splay_tree_compare_ints, 0, 0);
+  memory_identifier_string = build_string(7, "memory");
 
-  bitmap_obstack_initialize (&local_info_obstack);
-  bitmap_obstack_initialize (&optimization_summary_obstack);
-  all_module_statics = BITMAP_ALLOC (&local_info_obstack);
+  reference_vars_to_consider =
+    splay_tree_new_ggc (splay_tree_compare_ints);
 
+  bitmap_obstack_initialize (&local_info_obstack);
+  bitmap_obstack_initialize (&global_info_obstack);
+  module_statics_escape = BITMAP_ALLOC (&local_info_obstack);
+  module_statics_written = BITMAP_ALLOC (&local_info_obstack);
+  all_module_statics = BITMAP_ALLOC (&global_info_obstack);
+
+  /* There are some shared nodes, in particular the initializers on
+     static declarations.  We do not need to scan them more than once
+     since all we would be interested in are the addressof
+     operations.  */
+  visited_nodes = pointer_set_create ();
+
+  function_insertion_hook_holder =
+      cgraph_add_function_insertion_hook (&add_new_function, NULL);
   node_removal_hook_holder =
       cgraph_add_node_removal_hook (&remove_node_data, NULL);
   node_duplication_hook_holder =
       cgraph_add_node_duplication_hook (&duplicate_node_data, NULL);
 }
 
+/* Check out the rhs of a static or global initialization VNODE to see
+   if any of them contain addressof operations.  Note that some of
+   these variables may  not even be referenced in the code in this
+   compilation unit but their right hand sides may contain references
+   to variables defined within this unit.  */
+
+static void
+analyze_variable (struct varpool_node *vnode)
+{
+  struct walk_stmt_info wi;
+  tree global = vnode->decl;
+
+  memset (&wi, 0, sizeof (wi));
+  wi.pset = visited_nodes;
+  walk_tree (&DECL_INITIAL (global), scan_initializer_for_static_refs,
+             &wi, wi.pset);
+}
+
 
 /* Set up the persistent info for FN.  */
 
@@ -558,14 +644,17 @@ init_function_info (struct cgraph_node *fn)
 {
   ipa_reference_vars_info_t info
     = XCNEW (struct ipa_reference_vars_info_d);
+  ipa_reference_local_vars_info_t l
+    = XCNEW (struct ipa_reference_local_vars_info_d);
 
   /* Add the info to the tree's annotation.  */
   set_reference_vars_info (fn, info);
 
-  info->local.statics_read = BITMAP_ALLOC (&local_info_obstack);
-  info->local.statics_written = BITMAP_ALLOC (&local_info_obstack);
+  info->local = l;
+  l->statics_read = BITMAP_ALLOC (&local_info_obstack);
+  l->statics_written = BITMAP_ALLOC (&local_info_obstack);
 
-  return &info->local;
+  return l;
 }
 
 
@@ -575,47 +664,49 @@ init_function_info (struct cgraph_node *fn)
 static void
 analyze_function (struct cgraph_node *fn)
 {
+  tree decl = fn->decl;
+  struct function *this_cfun = DECL_STRUCT_FUNCTION (decl);
+  basic_block this_block;
+#ifdef ENABLE_CHECKING
+  tree step;
+#endif
   ipa_reference_local_vars_info_t local;
-  struct ipa_ref *ref;
-  int i;
-  tree var;
-  struct cgraph_edge *ie;
 
-  local = init_function_info (fn);
-  /* Process indirect calls.  All direct calles are handled at propagation
-     time.  */
-  for (ie = fn->indirect_calls; ie; ie = ie->next_callee)
-    if (!(ie->indirect_info->ecf_flags & ECF_CONST))
-      {
-        local->calls_read_all = true;
-        if (!(ie->indirect_info->ecf_flags & ECF_PURE)
-           && ((ie->indirect_info->ecf_flags & (ECF_NOTHROW | ECF_NORETURN))
-               !=  (ECF_NOTHROW | ECF_NORETURN)))
-         local->calls_write_all = true;
-      }
-  for (i = 0; ipa_ref_list_reference_iterate (&fn->ref_list, i, ref); i++)
+  if (dump_file)
+    fprintf (dump_file, "\n local analysis of %s\n", cgraph_node_name (fn));
+
+  push_cfun (DECL_STRUCT_FUNCTION (decl));
+  current_function_decl = decl;
+
+  init_function_info (fn);
+  FOR_EACH_BB_FN (this_block, this_cfun)
     {
-      if (ref->refered_type != IPA_REF_VARPOOL)
-       continue;
-      var = ipa_ref_varpool_node (ref)->decl;
-      if (ipa_ref_varpool_node (ref)->externally_visible
-         || !ipa_ref_varpool_node (ref)->analyzed
-         || !is_proper_for_analysis (var))
-       continue;
-      switch (ref->use)
+      gimple_stmt_iterator gsi;
+      gimple phi;
+      tree op;
+      use_operand_p use;
+      ssa_op_iter iter;
+
+      /* Find the addresses taken in phi node arguments.  */
+      for (gsi = gsi_start_phis (this_block);
+          !gsi_end_p (gsi);
+          gsi_next (&gsi))
        {
-       case IPA_REF_LOAD:
-          bitmap_set_bit (local->statics_read, DECL_UID (var));
-         break;
-       case IPA_REF_STORE:
-          bitmap_set_bit (local->statics_written, DECL_UID (var));
-         break;
-       case IPA_REF_ADDR:
-         break;
+         phi = gsi_stmt (gsi);
+         FOR_EACH_PHI_ARG (use, phi, iter, SSA_OP_USE)
+           {
+             op = USE_FROM_PTR (use);
+             if (TREE_CODE (op) == ADDR_EXPR)
+               mark_address_taken (get_base_var (op));
+           }
        }
+
+      for (gsi = gsi_start_bb (this_block); !gsi_end_p (gsi); gsi_next (&gsi))
+       scan_stmt_for_static_refs (&gsi, fn);
     }
 
-  if ((flags_from_decl_or_type (fn->decl) & (ECF_NOTHROW | ECF_NORETURN))
+  local = get_reference_vars_info (fn)->local;
+  if ((flags_from_decl_or_type (decl) & (ECF_NOTHROW | ECF_NORETURN))
       == (ECF_NOTHROW | ECF_NORETURN))
     {
       local->calls_write_all = false;
@@ -627,19 +718,115 @@ analyze_function (struct cgraph_node *fn)
     BITMAP_FREE (local->statics_written);
   if (local->calls_read_all)
     BITMAP_FREE (local->statics_read);
+
+
+#ifdef ENABLE_CHECKING
+  /* Verify that all local initializers was expanded by gimplifier.  */
+  for (step = DECL_STRUCT_FUNCTION (decl)->local_decls;
+       step;
+       step = TREE_CHAIN (step))
+    {
+      tree var = TREE_VALUE (step);
+      if (TREE_CODE (var) == VAR_DECL
+         && DECL_INITIAL (var)
+         && !TREE_STATIC (var))
+       gcc_unreachable ();
+    }
+#endif
+  pop_cfun ();
+  current_function_decl = NULL;
+}
+
+/* Remove local data associated with function FN.  */
+static void
+clean_function_local_data (struct cgraph_node *fn)
+{
+  ipa_reference_vars_info_t info = get_reference_vars_info (fn);
+  ipa_reference_local_vars_info_t l = info->local;
+  if (l)
+    {
+      if (l->statics_read
+         && l->statics_read != all_module_statics)
+       BITMAP_FREE (l->statics_read);
+      if (l->statics_written
+         &&l->statics_written != all_module_statics)
+       BITMAP_FREE (l->statics_written);
+      free (l);
+      info->local = NULL;
+    }
+}
+
+/* Remove all data associated with function FN.  */
+
+static void
+clean_function (struct cgraph_node *fn)
+{
+  ipa_reference_vars_info_t info = get_reference_vars_info (fn);
+  ipa_reference_global_vars_info_t g = info->global;
+
+  clean_function_local_data (fn);
+  if (g)
+    {
+      if (g->statics_read
+         && g->statics_read != all_module_statics)
+       BITMAP_FREE (g->statics_read);
+
+      if (g->statics_written
+         && g->statics_written != all_module_statics)
+       BITMAP_FREE (g->statics_written);
+
+      if (g->statics_not_read
+         && g->statics_not_read != all_module_statics)
+       BITMAP_FREE (g->statics_not_read);
+
+      if (g->statics_not_written
+         && g->statics_not_written != all_module_statics)
+       BITMAP_FREE (g->statics_not_written);
+      free (g);
+      info->global = NULL;
+    }
+
+  free (get_reference_vars_info (fn));
+  set_reference_vars_info (fn, NULL);
+}
+
+/* Called when new function is inserted to callgraph late.  */
+static void
+add_new_function (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
+{
+  /* There are some shared nodes, in particular the initializers on
+     static declarations.  We do not need to scan them more than once
+     since all we would be interested in are the addressof
+     operations.  */
+  analyze_function (node);
+  visited_nodes = NULL;
 }
 
 static bitmap
-copy_global_bitmap (bitmap src)
+copy_local_bitmap (bitmap src)
 {
   bitmap dst;
   if (!src)
     return NULL;
-  dst = BITMAP_ALLOC (&optimization_summary_obstack);
+  if (src == all_module_statics)
+    return all_module_statics;
+  dst = BITMAP_ALLOC (&local_info_obstack);
   bitmap_copy (dst, src);
   return dst;
 }
 
+static bitmap
+copy_global_bitmap (bitmap src)
+{
+  bitmap dst;
+  if (!src)
+    return NULL;
+  if (src == all_module_statics)
+    return all_module_statics;
+  dst = BITMAP_ALLOC (&global_info_obstack);
+  bitmap_copy (dst, src);
+  return dst;
+}
 
 /* Called when new clone is inserted to callgraph late.  */
 
@@ -647,16 +834,33 @@ static void
 duplicate_node_data (struct cgraph_node *src, struct cgraph_node *dst,
                     void *data ATTRIBUTE_UNUSED)
 {
-  ipa_reference_optimization_summary_t ginfo;
-  ipa_reference_optimization_summary_t dst_ginfo;
-
-  ginfo = get_reference_optimization_summary (src);
-  if (!ginfo)
+  ipa_reference_global_vars_info_t ginfo;
+  ipa_reference_local_vars_info_t linfo;
+  ipa_reference_global_vars_info_t dst_ginfo;
+  ipa_reference_local_vars_info_t dst_linfo;
+
+  ginfo = get_global_reference_vars_info (src);
+  linfo = get_local_reference_vars_info (src);
+  if (!linfo && !ginfo)
     return;
-  dst_ginfo = XCNEW (struct ipa_reference_optimization_summary_d);
-  set_reference_optimization_summary (dst, dst_ginfo);
-  dst_ginfo->statics_not_read = copy_global_bitmap (ginfo->statics_not_read);
-  dst_ginfo->statics_not_written = copy_global_bitmap (ginfo->statics_not_written);
+  init_function_info (dst);
+  if (linfo)
+    {
+      dst_linfo = get_local_reference_vars_info (dst);
+      dst_linfo->statics_read = copy_local_bitmap (linfo->statics_read);
+      dst_linfo->statics_written = copy_local_bitmap (linfo->statics_written);
+      dst_linfo->calls_read_all = linfo->calls_read_all;
+      dst_linfo->calls_write_all = linfo->calls_write_all;
+    }
+  if (ginfo)
+    {
+      get_reference_vars_info (dst)->global = XCNEW (struct ipa_reference_global_vars_info_d);
+      dst_ginfo = get_global_reference_vars_info (dst);
+      dst_ginfo->statics_read = copy_global_bitmap (ginfo->statics_read);
+      dst_ginfo->statics_written = copy_global_bitmap (ginfo->statics_written);
+      dst_ginfo->statics_not_read = copy_global_bitmap (ginfo->statics_not_read);
+      dst_ginfo->statics_not_written = copy_global_bitmap (ginfo->statics_not_written);
+    }
 }
 
 /* Called when node is removed.  */
@@ -664,20 +868,8 @@ duplicate_node_data (struct cgraph_node *src, struct cgraph_node *dst,
 static void
 remove_node_data (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
 {
-  ipa_reference_optimization_summary_t ginfo;
-  ginfo = get_reference_optimization_summary (node);
-  if (ginfo)
-    {
-      if (ginfo->statics_not_read
-         && ginfo->statics_not_read != all_module_statics)
-       BITMAP_FREE (ginfo->statics_not_read);
-
-      if (ginfo->statics_not_written
-         && ginfo->statics_not_written != all_module_statics)
-       BITMAP_FREE (ginfo->statics_not_written);
-      free (ginfo);
-      set_reference_optimization_summary (node, NULL);
-    }
+  if (get_reference_vars_info (node))
+    clean_function (node);
 }
 
 /* Analyze each function in the cgraph to see which global or statics
@@ -687,18 +879,89 @@ static void
 generate_summary (void)
 {
   struct cgraph_node *node;
+  struct varpool_node *vnode;
   unsigned int index;
   bitmap_iterator bi;
+  bitmap module_statics_readonly;
   bitmap bm_temp;
 
   ipa_init ();
+  module_statics_readonly = BITMAP_ALLOC (&local_info_obstack);
   bm_temp = BITMAP_ALLOC (&local_info_obstack);
 
-  /* Process all of the functions next.  */
+  /* Process all of the variables first.  */
+  FOR_EACH_STATIC_INITIALIZER (vnode)
+    analyze_variable (vnode);
+
+  /* Process all of the functions next.
+
+     We do not want to process any of the clones so we check that this
+     is a master clone.  However, we do need to process any
+     AVAIL_OVERWRITABLE functions (these are never clones) because
+     they may cause a static variable to escape.  The code that can
+     overwrite such a function cannot access the statics because it
+     would not be in the same compilation unit.  When the analysis is
+     finished, the computed information of these AVAIL_OVERWRITABLE is
+     replaced with worst case info.
+  */
   for (node = cgraph_nodes; node; node = node->next)
-    if (node->analyzed)
+    if (cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
       analyze_function (node);
 
+  pointer_set_destroy (visited_nodes);
+  visited_nodes = NULL;
+
+  /* Prune out the variables that were found to behave badly
+     (i.e. have their address taken).  */
+  EXECUTE_IF_SET_IN_BITMAP (module_statics_escape, 0, index, bi)
+    {
+      splay_tree_remove (reference_vars_to_consider, index);
+    }
+
+  bitmap_and_compl_into (all_module_statics,
+                        module_statics_escape);
+
+  bitmap_and_compl (module_statics_readonly, all_module_statics,
+                   module_statics_written);
+
+  /* If the address is not taken, we can unset the addressable bit
+     on this variable.  */
+  EXECUTE_IF_SET_IN_BITMAP (all_module_statics, 0, index, bi)
+    {
+      tree var = get_static_decl (index);
+      TREE_ADDRESSABLE (var) = 0;
+      if (dump_file)
+       fprintf (dump_file, "Not TREE_ADDRESSABLE var %s\n",
+                get_static_name (index));
+    }
+
+  /* If the variable is never written, we can set the TREE_READONLY
+     flag.  Additionally if it has a DECL_INITIAL that is made up of
+     constants we can treat the entire global as a constant.  */
+
+  bitmap_and_compl (module_statics_readonly, all_module_statics,
+                   module_statics_written);
+  EXECUTE_IF_SET_IN_BITMAP (module_statics_readonly, 0, index, bi)
+    {
+      tree var = get_static_decl (index);
+
+      /* Ignore variables in named sections - changing TREE_READONLY
+        changes the section flags, potentially causing conflicts with
+        other variables in the same named section.  */
+      if (DECL_SECTION_NAME (var) == NULL_TREE)
+       {
+         TREE_READONLY (var) = 1;
+         if (dump_file)
+           fprintf (dump_file, "read-only var %s\n",
+                    get_static_name (index));
+       }
+    }
+
+  BITMAP_FREE(module_statics_escape);
+  BITMAP_FREE(module_statics_written);
+  module_statics_escape = NULL;
+  module_statics_written = NULL;
+
   if (dump_file)
     EXECUTE_IF_SET_IN_BITMAP (all_module_statics, 0, index, bi)
       {
@@ -706,6 +969,25 @@ generate_summary (void)
                 get_static_name (index));
       }
 
+  for (node = cgraph_nodes; node; node = node->next)
+    if (cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
+      {
+       ipa_reference_local_vars_info_t l;
+       l = get_reference_vars_info (node)->local;
+
+       /* Any variables that are not in all_module_statics are
+          removed from the local maps.  This will include all of the
+          variables that were found to escape in the function
+          scanning.  */
+       if (l->statics_read)
+         bitmap_and_into (l->statics_read,
+                          all_module_statics);
+       if (l->statics_written)
+         bitmap_and_into (l->statics_written,
+                          all_module_statics);
+      }
+
+  BITMAP_FREE(module_statics_readonly);
   BITMAP_FREE(bm_temp);
 
   if (dump_file)
@@ -716,7 +998,7 @@ generate_summary (void)
          unsigned int index;
          bitmap_iterator bi;
 
-         l = &get_reference_vars_info (node)->local;
+         l = get_reference_vars_info (node)->local;
          fprintf (dump_file,
                   "\nFunction name:%s/%i:",
                   cgraph_node_name (node), node->uid);
@@ -742,9 +1024,159 @@ generate_summary (void)
             fprintf (dump_file, "\n  calls read all: ");
        }
 }
+
+
+/* Return true if we need to write summary of NODE. */
+
+static bool
+write_node_summary_p (struct cgraph_node *node)
+{
+  gcc_assert (node->global.inlined_to == NULL);
+  return (node->analyzed
+         && cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE
+         && get_reference_vars_info (node) != NULL);
+}
+
+/* Serialize the ipa info for lto.  */
+
+static void
+ipa_reference_write_summary (cgraph_node_set set)
+{
+  struct cgraph_node *node;
+  struct lto_simple_output_block *ob
+    = lto_create_simple_output_block (LTO_section_ipa_reference);
+  unsigned int count = 0;
+  cgraph_node_set_iterator csi;
+
+  for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
+    if (write_node_summary_p (csi_node (csi)))
+       count++;
+
+  lto_output_uleb128_stream (ob->main_stream, count);
+
+  /* Process all of the functions.  */
+  for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
+    {
+      node = csi_node (csi);
+      if (write_node_summary_p (node))
+       {
+         ipa_reference_local_vars_info_t l
+           = get_reference_vars_info (node)->local;
+         unsigned int index;
+         bitmap_iterator bi;
+         lto_cgraph_encoder_t encoder;
+         int node_ref;
+
+         encoder = ob->decl_state->cgraph_node_encoder;
+         node_ref = lto_cgraph_encoder_encode (encoder, node);
+         lto_output_uleb128_stream (ob->main_stream, node_ref);
+
+         /* Stream out the statics read.  */
+         if (l->calls_read_all)
+           lto_output_sleb128_stream (ob->main_stream, -1);
+         else
+           {
+             lto_output_sleb128_stream (ob->main_stream,
+                                        bitmap_count_bits (l->statics_read));
+             EXECUTE_IF_SET_IN_BITMAP (l->statics_read, 0, index, bi)
+               lto_output_var_decl_index(ob->decl_state, ob->main_stream,
+                                         get_static_decl (index));
+           }
+
+         /* Stream out the statics written.  */
+         if (l->calls_write_all)
+           lto_output_sleb128_stream (ob->main_stream, -1);
+         else
+           {
+             lto_output_sleb128_stream (ob->main_stream,
+                                        bitmap_count_bits (l->statics_written));
+             EXECUTE_IF_SET_IN_BITMAP (l->statics_written, 0, index, bi)
+               lto_output_var_decl_index(ob->decl_state, ob->main_stream,
+                                         get_static_decl (index));
+           }
+       }
+    }
+  lto_destroy_simple_output_block (ob);
+}
+
+
+/* Deserialize the ipa info for lto.  */
+
+static void
+ipa_reference_read_summary (void)
+{
+  struct lto_file_decl_data ** file_data_vec
+    = lto_get_file_decl_data ();
+  struct lto_file_decl_data * file_data;
+  unsigned int j = 0;
+
+  ipa_init ();
+
+  while ((file_data = file_data_vec[j++]))
+    {
+      const char *data;
+      size_t len;
+      struct lto_input_block *ib
+       = lto_create_simple_input_block (file_data,
+                                        LTO_section_ipa_reference,
+                                        &data, &len);
+      if (ib)
+       {
+         unsigned int i;
+         unsigned int f_count = lto_input_uleb128 (ib);
+
+         for (i = 0; i < f_count; i++)
+           {
+             unsigned int j, index;
+             struct cgraph_node *node;
+             ipa_reference_local_vars_info_t l;
+             int v_count;
+             lto_cgraph_encoder_t encoder;
+
+             index = lto_input_uleb128 (ib);
+             encoder = file_data->cgraph_node_encoder;
+             node = lto_cgraph_encoder_deref (encoder, index);
+             l = init_function_info (node);
+
+             /* Set the statics read.  */
+             v_count = lto_input_sleb128 (ib);
+             if (v_count == -1)
+               l->calls_read_all = true;
+             else
+               for (j = 0; j < (unsigned int)v_count; j++)
+                 {
+                   unsigned int var_index = lto_input_uleb128 (ib);
+                   tree v_decl = lto_file_decl_data_get_var_decl (file_data,
+                                                                  var_index);
+                   add_static_var (v_decl);
+                   bitmap_set_bit (l->statics_read, DECL_UID (v_decl));
+                 }
+
+             /* Set the statics written.  */
+             v_count = lto_input_sleb128 (ib);
+             if (v_count == -1)
+               l->calls_write_all = true;
+             else
+               for (j = 0; j < (unsigned int)v_count; j++)
+                 {
+                   unsigned int var_index = lto_input_uleb128 (ib);
+                   tree v_decl = lto_file_decl_data_get_var_decl (file_data,
+                                                                  var_index);
+                   add_static_var (v_decl);
+                   bitmap_set_bit (l->statics_written, DECL_UID (v_decl));
+                 }
+           }
+
+         lto_destroy_simple_input_block (file_data,
+                                         LTO_section_ipa_reference,
+                                         ib, data, len);
+       }
+    }
+}
+
+
 \f
 /* Set READ_ALL/WRITE_ALL based on DECL flags.  */
-
 static void
 read_write_all_from_decl (tree decl, bool * read_all, bool * write_all)
 {
@@ -756,9 +1188,11 @@ read_write_all_from_decl (tree decl, bool * read_all, bool * write_all)
   else
     {
        /* TODO: To be able to produce sane results, we should also handle
-         common builtins, in particular throw.  */
+         common builtins, in particular throw.
+         Indirect calls hsould be only counted and as inliner is replacing them
+         by direct calls, we can conclude if any indirect calls are left in body */
       *read_all = true;
-      /* When function does not return, it is safe to ignore anythign it writes
+      /* When function does not reutrn, it is safe to ignore anythign it writes
         to, because the effect will never happen.  */
       if ((flags & (ECF_NOTHROW | ECF_NORETURN))
          != (ECF_NOTHROW | ECF_NORETURN))
@@ -767,7 +1201,8 @@ read_write_all_from_decl (tree decl, bool * read_all, bool * write_all)
 }
 
 /* Produce the global information by preforming a transitive closure
-   on the local information that was produced by ipa_analyze_function */
+   on the local information that was produced by ipa_analyze_function
+   and ipa_analyze_variable.  */
 
 static unsigned int
 propagate (void)
@@ -779,12 +1214,10 @@ propagate (void)
   int order_pos = ipa_utils_reduced_inorder (order, false, true, NULL);
   int i;
 
+  cgraph_remove_function_insertion_hook (function_insertion_hook_holder);
   if (dump_file)
     dump_cgraph (dump_file);
 
-  ipa_discover_readonly_nonaddressable_vars ();
-  generate_summary ();
-
   /* Propagate the local information thru the call graph to produce
      the global information.  All the nodes within a cycle will have
      the same info so we collapse cycles first.  Then we can do the
@@ -796,7 +1229,8 @@ propagate (void)
   for (i = 0; i < order_pos; i++ )
     {
       ipa_reference_vars_info_t node_info;
-      ipa_reference_global_vars_info_t node_g;
+      ipa_reference_global_vars_info_t node_g =
+       XCNEW (struct ipa_reference_global_vars_info_d);
       ipa_reference_local_vars_info_t node_l;
       struct cgraph_edge *e;
 
@@ -813,8 +1247,8 @@ propagate (void)
          gcc_unreachable ();
        }
 
-      node_l = &node_info->local;
-      node_g = &node_info->global;
+      gcc_assert (!node_info->global);
+      node_l = node_info->local;
 
       read_all = node_l->calls_read_all;
       write_all = node_l->calls_write_all;
@@ -835,7 +1269,7 @@ propagate (void)
       while (w)
        {
          ipa_reference_local_vars_info_t w_l =
-           &get_reference_vars_info (w)->local;
+           get_reference_vars_info (w)->local;
 
          /* When function is overwrittable, we can not assume anything.  */
          if (cgraph_function_body_availability (w) <= AVAIL_OVERWRITABLE)
@@ -858,7 +1292,7 @@ propagate (void)
        node_g->statics_read = all_module_statics;
       else
        {
-         node_g->statics_read = BITMAP_ALLOC (&local_info_obstack);
+         node_g->statics_read = BITMAP_ALLOC (&global_info_obstack);
          bitmap_copy (node_g->statics_read,
                       node_l->statics_read);
        }
@@ -866,7 +1300,7 @@ propagate (void)
        node_g->statics_written = all_module_statics;
       else
        {
-         node_g->statics_written = BITMAP_ALLOC (&local_info_obstack);
+         node_g->statics_written = BITMAP_ALLOC (&global_info_obstack);
          bitmap_copy (node_g->statics_written,
                       node_l->statics_written);
        }
@@ -878,7 +1312,7 @@ propagate (void)
        {
          ipa_reference_vars_info_t w_ri =
            get_reference_vars_info (w);
-         ipa_reference_local_vars_info_t w_l = &w_ri->local;
+         ipa_reference_local_vars_info_t w_l = w_ri->local;
 
          /* These global bitmaps are initialized from the local info
             of all of the nodes in the region.  However there is no
@@ -896,7 +1330,7 @@ propagate (void)
        }
 
       /* All nodes within a cycle have the same global info bitmaps.  */
-      node_info->global = *node_g;
+      node_info->global = node_g;
       w_info = (struct ipa_dfs_info *) node->aux;
       w = w_info->next_cycle;
       while (w)
@@ -904,7 +1338,10 @@ propagate (void)
          ipa_reference_vars_info_t w_ri =
            get_reference_vars_info (w);
 
-          w_ri->global = *node_g;
+         gcc_assert (!w_ri->global);
+          w_ri->global = XCNEW (struct ipa_reference_global_vars_info_d);
+         w_ri->global->statics_read = copy_global_bitmap (node_g->statics_read);
+         w_ri->global->statics_written = copy_global_bitmap (node_g->statics_written);
 
          w_info = (struct ipa_dfs_info *) w->aux;
          w = w_info->next_cycle;
@@ -924,8 +1361,8 @@ propagate (void)
 
          node = order[i];
          node_info = get_reference_vars_info (node);
-         node_g = &node_info->global;
-         node_l = &node_info->local;
+         node_g = node_info->global;
+         node_l = node_info->local;
          fprintf (dump_file,
                   "\nFunction name:%s/%i:",
                   cgraph_node_name (node), node->uid);
@@ -952,7 +1389,7 @@ propagate (void)
            {
              ipa_reference_vars_info_t w_ri =
                get_reference_vars_info (w);
-             ipa_reference_local_vars_info_t w_l = &w_ri->local;
+             ipa_reference_local_vars_info_t w_l = w_ri->local;
              fprintf (dump_file, "\n  next cycle: %s/%i ",
                       cgraph_node_name (w), w->uid);
              fprintf (dump_file, "\n    locals read: ");
@@ -1000,261 +1437,54 @@ propagate (void)
     }
 
   /* Cleanup. */
-  for (node = cgraph_nodes; node; node = node->next)
+  for (i = 0; i < order_pos; i++ )
     {
       ipa_reference_vars_info_t node_info;
       ipa_reference_global_vars_info_t node_g;
-      ipa_reference_optimization_summary_t opt;
-
-      if (!node->analyzed)
-        continue;
-
+      node = order[i];
       node_info = get_reference_vars_info (node);
-      if (cgraph_function_body_availability (node) > AVAIL_OVERWRITABLE)
-       {
-         node_g = &node_info->global;
-
-         opt = XCNEW (struct ipa_reference_optimization_summary_d);
-         set_reference_optimization_summary (node, opt);
+      node_g = node_info->global;
+
+      /* Create the complimentary sets.  These are more useful for
+        certain apis.  */
+      node_g->statics_not_read = BITMAP_ALLOC (&global_info_obstack);
+      node_g->statics_not_written = BITMAP_ALLOC (&global_info_obstack);
+
+      if (node_g->statics_read != all_module_statics)
+       bitmap_and_compl (node_g->statics_not_read,
+                         all_module_statics,
+                         node_g->statics_read);
+
+      if (node_g->statics_written
+         != all_module_statics)
+       bitmap_and_compl (node_g->statics_not_written,
+                         all_module_statics,
+                         node_g->statics_written);
+   }
 
-         /* Create the complimentary sets.  */
-         opt->statics_not_read = BITMAP_ALLOC (&optimization_summary_obstack);
-         opt->statics_not_written = BITMAP_ALLOC (&optimization_summary_obstack);
+  free (order);
 
-         if (node_g->statics_read != all_module_statics)
-           bitmap_and_compl (opt->statics_not_read,
-                             all_module_statics,
-                             node_g->statics_read);
+  for (node = cgraph_nodes; node; node = node->next)
+    {
+      ipa_reference_vars_info_t node_info;
+      node_info = get_reference_vars_info (node);
+      /* Get rid of the aux information.  */
 
-         if (node_g->statics_written
-             != all_module_statics)
-           bitmap_and_compl (opt->statics_not_written,
-                             all_module_statics,
-                             node_g->statics_written);
-       }
-      if (node_info)
-       free (node_info);
       if (node->aux)
        {
          free (node->aux);
          node->aux = NULL;
        }
-   }
-
-  free (order);
 
+      if (cgraph_function_body_availability (node) == AVAIL_OVERWRITABLE)
+       clean_function (node);
+      else if (node_info)
+       clean_function_local_data (node);
+    }
   bitmap_obstack_release (&local_info_obstack);
-  VEC_free (ipa_reference_vars_info_t, heap, ipa_reference_vars_vector);
-  ipa_reference_vars_vector = NULL;
-  if (dump_file)
-    splay_tree_delete (reference_vars_to_consider);
-  reference_vars_to_consider = NULL;
-  all_module_statics = NULL;
   return 0;
 }
 
-/* Return true if we need to write summary of NODE. */
-
-static bool
-write_node_summary_p (struct cgraph_node *node,
-                     cgraph_node_set set,
-                     varpool_node_set vset,
-                     bitmap ltrans_statics)
-{
-  ipa_reference_optimization_summary_t info;
-
-  /* See if we have (non-empty) info.  */
-  if (!node->analyzed || node->global.inlined_to)
-    return false;
-  info = get_reference_optimization_summary (node);
-  if (!info || (bitmap_empty_p (info->statics_not_read)
-               && bitmap_empty_p (info->statics_not_written)))
-    return false;
-
-  /* See if we want to encode it.
-     Encode also referenced functions since constant folding might turn it into
-     a direct call.
-
-     In future we might also want to include summaries of functions references
-     by initializers of constant variables references in current unit.  */
-  if (!reachable_from_this_partition_p (node, set)
-      && !referenced_from_this_partition_p (&node->ref_list, set, vset))
-    return false;
-
-  /* See if the info has non-empty intersections with vars we want to encode.  */
-  if (!bitmap_intersect_p (info->statics_not_read, ltrans_statics)
-      && !bitmap_intersect_p (info->statics_not_written, ltrans_statics))
-    return false;
-  return true;
-}
-
-/* Stream out BITS&LTRANS_STATICS as list of decls to OB.  */
-
-static void
-stream_out_bitmap (struct lto_simple_output_block *ob,
-                  bitmap bits, bitmap ltrans_statics)
-{
-  unsigned int count = 0;
-  unsigned int index;
-  bitmap_iterator bi;
-  EXECUTE_IF_AND_IN_BITMAP (bits, ltrans_statics, 0, index, bi)
-    count ++;
-  lto_output_uleb128_stream (ob->main_stream, count);
-  if (!count)
-    return;
-  EXECUTE_IF_AND_IN_BITMAP (bits, ltrans_statics, 0, index, bi)
-    {
-      tree decl = (tree)splay_tree_lookup (reference_vars_to_consider, index)->value;
-      lto_output_var_decl_index(ob->decl_state, ob->main_stream, decl);
-    }
-}
-
-/* Serialize the ipa info for lto.  */
-
-static void
-ipa_reference_write_optimization_summary (cgraph_node_set set,
-                                         varpool_node_set vset)
-{
-  struct cgraph_node *node;
-  struct varpool_node *vnode;
-  struct lto_simple_output_block *ob
-    = lto_create_simple_output_block (LTO_section_ipa_reference);
-  unsigned int count = 0;
-  lto_cgraph_encoder_t encoder = ob->decl_state->cgraph_node_encoder;
-  bitmap ltrans_statics = BITMAP_ALLOC (NULL);
-
-  reference_vars_to_consider = splay_tree_new (splay_tree_compare_ints, 0, 0);
-
-  /* See what variables we are interested in.  */
-  for (vnode = varpool_nodes; vnode; vnode = vnode->next)
-    if (referenced_from_this_partition_p (&vnode->ref_list, set, vset))
-      {
-       tree decl = vnode->decl;
-       if (is_proper_for_analysis (decl))
-         {
-           bitmap_set_bit (ltrans_statics, DECL_UID (decl));
-           splay_tree_insert (reference_vars_to_consider,
-                              DECL_UID (decl), (splay_tree_value)decl);
-         }
-      }
-
-  for (node = cgraph_nodes; node; node = node->next)
-    if (write_node_summary_p (node, set, vset, ltrans_statics))
-       count++;
-
-  lto_output_uleb128_stream (ob->main_stream, count);
-
-  /* Process all of the functions.  */
-  for (node = cgraph_nodes; node; node = node->next)
-    if (write_node_summary_p (node, set, vset, ltrans_statics))
-      {
-       ipa_reference_optimization_summary_t info;
-       int node_ref;
-
-       info = get_reference_optimization_summary (node);
-       node_ref = lto_cgraph_encoder_encode (encoder, node);
-       lto_output_uleb128_stream (ob->main_stream, node_ref);
-
-       stream_out_bitmap (ob, info->statics_not_read, ltrans_statics);
-       stream_out_bitmap (ob, info->statics_not_written, ltrans_statics);
-      }
-  BITMAP_FREE (ltrans_statics);
-  lto_destroy_simple_output_block (ob);
-  splay_tree_delete (reference_vars_to_consider);
-}
-
-/* Deserialize the ipa info for lto.  */
-
-static void
-ipa_reference_read_optimization_summary (void)
-{
-  struct lto_file_decl_data ** file_data_vec
-    = lto_get_file_decl_data ();
-  struct lto_file_decl_data * file_data;
-  unsigned int j = 0;
-  bitmap_obstack_initialize (&optimization_summary_obstack);
-
-  node_removal_hook_holder =
-      cgraph_add_node_removal_hook (&remove_node_data, NULL);
-  node_duplication_hook_holder =
-      cgraph_add_node_duplication_hook (&duplicate_node_data, NULL);
-
-  while ((file_data = file_data_vec[j++]))
-    {
-      const char *data;
-      size_t len;
-      struct lto_input_block *ib
-       = lto_create_simple_input_block (file_data,
-                                        LTO_section_ipa_reference,
-                                        &data, &len);
-      if (ib)
-       {
-         unsigned int i;
-         unsigned int f_count = lto_input_uleb128 (ib);
-
-         for (i = 0; i < f_count; i++)
-           {
-             unsigned int j, index;
-             struct cgraph_node *node;
-             ipa_reference_optimization_summary_t info;
-             int v_count;
-             lto_cgraph_encoder_t encoder;
-
-             index = lto_input_uleb128 (ib);
-             encoder = file_data->cgraph_node_encoder;
-             node = lto_cgraph_encoder_deref (encoder, index);
-             info = XCNEW (struct ipa_reference_optimization_summary_d);
-             set_reference_optimization_summary (node, info);
-             info->statics_not_read = BITMAP_ALLOC (&optimization_summary_obstack);
-             info->statics_not_written = BITMAP_ALLOC (&optimization_summary_obstack);
-             if (dump_file)
-               fprintf (dump_file,
-                        "\nFunction name:%s/%i:\n  static not read:",
-                        cgraph_node_name (node), node->uid);
-
-             /* Set the statics not read.  */
-             v_count = lto_input_uleb128 (ib);
-             for (j = 0; j < (unsigned int)v_count; j++)
-               {
-                 unsigned int var_index = lto_input_uleb128 (ib);
-                 tree v_decl = lto_file_decl_data_get_var_decl (file_data,
-                                                                var_index);
-                 bitmap_set_bit (info->statics_not_read, DECL_UID (v_decl));
-                 if (dump_file)
-                   fprintf (dump_file, " %s",
-                            lang_hooks.decl_printable_name (v_decl, 2));
-               }
-
-             if (dump_file)
-               fprintf (dump_file,
-                        "\n  static not written:");
-             /* Set the statics not written.  */
-             v_count = lto_input_uleb128 (ib);
-             for (j = 0; j < (unsigned int)v_count; j++)
-               {
-                 unsigned int var_index = lto_input_uleb128 (ib);
-                 tree v_decl = lto_file_decl_data_get_var_decl (file_data,
-                                                                var_index);
-                 bitmap_set_bit (info->statics_not_written, DECL_UID (v_decl));
-                 if (dump_file)
-                   fprintf (dump_file, " %s",
-                            lang_hooks.decl_printable_name (v_decl, 2));
-               }
-             if (dump_file)
-               fprintf (dump_file, "\n");
-           }
-
-         lto_destroy_simple_input_block (file_data,
-                                         LTO_section_ipa_reference,
-                                         ib, data, len);
-       }
-      else
-       /* Fatal error here.  We do not want to support compiling ltrans units with
-          different version of compiler or different flags than the WPA unit, so
-          this should never happen.  */
-       fatal_error ("ipa reference summary is missing in ltrans unit");
-    }
-}
 
 static bool
 gate_reference (void)
@@ -1281,13 +1511,15 @@ struct ipa_opt_pass_d pass_ipa_reference =
   0,                                   /* todo_flags_start */
   0                                     /* todo_flags_finish */
  },
NULL,                                 /* generate_summary */
NULL,                                 /* write_summary */
NULL,                                 /* read_summary */
ipa_reference_write_optimization_summary,/* write_optimization_summary */
ipa_reference_read_optimization_summary,/* read_optimization_summary */
generate_summary,                     /* generate_summary */
ipa_reference_write_summary,          /* write_summary */
ipa_reference_read_summary,           /* read_summary */
NULL,                                 /* write_optimization_summary */
NULL,                                 /* read_optimization_summary */
  NULL,                                 /* stmt_fixup */
  0,                                    /* TODOs */
  NULL,                                 /* function_transform */
  NULL                                  /* variable_transform */
 };
+
+#include "gt-ipa-reference.h"
index 01beca7..abe5c9e 100644 (file)
--- a/gcc/ipa.c
+++ b/gcc/ipa.c
@@ -388,6 +388,8 @@ cgraph_remove_unreachable_nodes (bool before_inlining_p, FILE *file)
                      node->analyzed = false;
                      node->local.inlinable = false;
                    }
+                 else
+                   gcc_assert (!clone->in_other_partition);
                  cgraph_node_remove_callees (node);
                  if (node->prev_sibling_clone)
                    node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
index a97314c..74e0650 100644 (file)
@@ -1,5 +1,12 @@
 2010-04-21  Jan Hubicka  <jh@suse.cz>
 
+       * lto.c (lto_wpa_write_files): Update.
+       (read_cgraph_and_symbols): Be more verbose.
+       (materialize_cgraph): Likewise.
+       (do_whole_program_analysis): Likewise.
+
+2010-04-21  Jan Hubicka  <jh@suse.cz>
+
        * lto.c (globalize_cross_file_statics): When function has address taken,
        it needs to be public.
 
index ea8f03a..12475f1 100644 (file)
@@ -1046,7 +1046,7 @@ lto_wpa_write_files (void)
 
          lto_set_current_out_file (file);
 
-         ipa_write_summaries_of_cgraph_node_set (set);
+         ipa_write_optimization_summaries (set);
 
          lto_set_current_out_file (NULL);
          lto_elf_file_close (file);
@@ -1822,10 +1822,18 @@ read_cgraph_and_symbols (unsigned nfiles, const char **fnames)
       gcc_assert (num_objects == nfiles);
     }
 
+  if (!quiet_flag)
+    fprintf (stderr, "Reading object files:");
+
   /* Read all of the object files specified on the command line.  */
   for (i = 0, last_file_ix = 0; i < nfiles; ++i)
     {
       struct lto_file_decl_data *file_data = NULL;
+      if (!quiet_flag)
+       {
+         fprintf (stderr, " %s", fnames[i]);
+         fflush (stderr);
+       }
 
       current_lto_file = lto_elf_file_open (fnames[i], false);
       if (!current_lto_file)
@@ -1852,9 +1860,15 @@ read_cgraph_and_symbols (unsigned nfiles, const char **fnames)
   /* Each pass will set the appropriate timer.  */
   timevar_pop (TV_IPA_LTO_DECL_IO);
 
+  if (!quiet_flag)
+    fprintf (stderr, "\nReading the callgraph\n");
+
   /* Read the callgraph.  */
   input_cgraph ();
 
+  if (!quiet_flag)
+    fprintf (stderr, "Merging declarations\n");
+
   /* Merge global decls.  */
   lto_symtab_merge_decls ();
 
@@ -1862,8 +1876,14 @@ read_cgraph_and_symbols (unsigned nfiles, const char **fnames)
   lto_fixup_decls (all_file_decl_data);
   free_gimple_type_tables ();
 
+  if (!quiet_flag)
+    fprintf (stderr, "Reading summaries\n");
+
   /* Read the IPA summary data.  */
-  ipa_read_summaries ();
+  if (flag_ltrans)
+    ipa_read_optimization_summaries ();
+  else
+    ipa_read_summaries ();
 
   /* Finally merge the cgraph according to the decl merging decisions.  */
   lto_symtab_merge_cgraph_nodes ();
@@ -1909,6 +1929,11 @@ materialize_cgraph (void)
   unsigned i;
   timevar_id_t lto_timer;
 
+  if (!quiet_flag)
+    fprintf (stderr,
+            flag_wpa ? "Materializing decls:" : "Reading function bodies:");
+
+
   /* Now that we have input the cgraph, we need to clear all of the aux
      nodes and read the functions if we are not running in WPA mode.  */
   timevar_push (TV_IPA_LTO_GIMPLE_IO);
@@ -1927,6 +1952,7 @@ materialize_cgraph (void)
       if (node->local.lto_file_data
           && !DECL_IS_BUILTIN (node->decl))
        {
+         announce_function (node->decl);
          lto_materialize_function (node);
          lto_stats.num_input_cgraph_nodes++;
        }
@@ -1950,6 +1976,8 @@ materialize_cgraph (void)
 
   /* Fix up any calls to DECLs that have become not exception throwing.  */
   lto_fixup_nothrow_decls ();
+  if (!quiet_flag)
+    fprintf (stderr, "\n");
 
   timevar_pop (lto_timer);
 }
@@ -1987,7 +2015,14 @@ do_whole_program_analysis (void)
 
   lto_1_to_1_map ();
 
+  if (!quiet_flag)
+    {
+      fprintf (stderr, "\nStreaming out");
+      fflush (stderr);
+    }
   output_files = lto_wpa_write_files ();
+  if (!quiet_flag)
+    fprintf (stderr, "\n");
 
   /* Show the LTO report before launching LTRANS.  */
   if (flag_lto_report)
index 6437ab7..d9bf3cc 100644 (file)
@@ -1674,8 +1674,8 @@ ipa_write_summaries_1 (cgraph_node_set set)
   struct lto_out_decl_state *state = lto_new_out_decl_state ();
   lto_push_out_decl_state (state);
 
-  if (!flag_wpa)
-    ipa_write_summaries_2 (all_regular_ipa_passes, set, state);
+  gcc_assert (!flag_wpa);
+  ipa_write_summaries_2 (all_regular_ipa_passes, set, state);
   ipa_write_summaries_2 (all_lto_gen_passes, set, state);
 
   gcc_assert (lto_get_out_decl_state () == state);
@@ -1730,15 +1730,58 @@ ipa_write_summaries (void)
   ggc_free (set);
 }
 
+/* Same as execute_pass_list but assume that subpasses of IPA passes
+   are local passes. If SET is not NULL, write out optimization summaries of
+   only those node in SET. */
 
-/* Write all the summaries for the cgraph nodes in SET.  If SET is
+static void
+ipa_write_optimization_summaries_1 (struct opt_pass *pass, cgraph_node_set set,
+                      struct lto_out_decl_state *state)
+{
+  while (pass)
+    {
+      struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *)pass;
+      gcc_assert (!current_function_decl);
+      gcc_assert (!cfun);
+      gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
+      if (pass->type == IPA_PASS
+         && ipa_pass->write_optimization_summary
+         && (!pass->gate || pass->gate ()))
+       {
+         /* If a timevar is present, start it.  */
+         if (pass->tv_id)
+           timevar_push (pass->tv_id);
+
+         ipa_pass->write_optimization_summary (set);
+
+         /* If a timevar is present, start it.  */
+         if (pass->tv_id)
+           timevar_pop (pass->tv_id);
+       }
+
+      if (pass->sub && pass->sub->type != GIMPLE_PASS)
+       ipa_write_optimization_summaries_1 (pass->sub, set, state);
+
+      pass = pass->next;
+    }
+}
+
+/* Write all the optimization summaries for the cgraph nodes in SET.  If SET is
    NULL, write out all summaries of all nodes. */
 
 void
-ipa_write_summaries_of_cgraph_node_set (cgraph_node_set set)
+ipa_write_optimization_summaries (cgraph_node_set set)
 {
-  if (flag_generate_lto && !(errorcount || sorrycount))
-    ipa_write_summaries_1 (set);
+  struct lto_out_decl_state *state = lto_new_out_decl_state ();
+  lto_push_out_decl_state (state);
+
+  gcc_assert (flag_wpa);
+  ipa_write_optimization_summaries_1 (all_regular_ipa_passes, set, state);
+  ipa_write_optimization_summaries_1 (all_lto_gen_passes, set, state);
+
+  gcc_assert (lto_get_out_decl_state () == state);
+  lto_pop_out_decl_state ();
+  lto_delete_out_decl_state (state);
 }
 
 /* Same as execute_pass_list but assume that subpasses of IPA passes
@@ -1783,13 +1826,57 @@ ipa_read_summaries_1 (struct opt_pass *pass)
 void
 ipa_read_summaries (void)
 {
-  if (!flag_ltrans)
-    ipa_read_summaries_1 (all_regular_ipa_passes);
+  ipa_read_summaries_1 (all_regular_ipa_passes);
   ipa_read_summaries_1 (all_lto_gen_passes);
 }
 
 /* Same as execute_pass_list but assume that subpasses of IPA passes
    are local passes.  */
+
+static void
+ipa_read_optimization_summaries_1 (struct opt_pass *pass)
+{
+  while (pass)
+    {
+      struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass;
+
+      gcc_assert (!current_function_decl);
+      gcc_assert (!cfun);
+      gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
+
+      if (pass->gate == NULL || pass->gate ())
+       {
+         if (pass->type == IPA_PASS && ipa_pass->read_optimization_summary)
+           {
+             /* If a timevar is present, start it.  */
+             if (pass->tv_id)
+               timevar_push (pass->tv_id);
+
+             ipa_pass->read_optimization_summary ();
+
+             /* Stop timevar.  */
+             if (pass->tv_id)
+               timevar_pop (pass->tv_id);
+           }
+
+         if (pass->sub && pass->sub->type != GIMPLE_PASS)
+           ipa_read_optimization_summaries_1 (pass->sub);
+       }
+      pass = pass->next;
+    }
+}
+
+/* Read all the summaries for all_regular_ipa_passes and all_lto_gen_passes.  */
+
+void
+ipa_read_optimization_summaries (void)
+{
+  ipa_read_optimization_summaries_1 (all_regular_ipa_passes);
+  ipa_read_optimization_summaries_1 (all_lto_gen_passes);
+}
+
+/* Same as execute_pass_list but assume that subpasses of IPA passes
+   are local passes.  */
 void
 execute_ipa_pass_list (struct opt_pass *pass)
 {
index 5ed86b4..42ef8b2 100644 (file)
@@ -168,7 +168,6 @@ struct rtl_opt_pass
 struct varpool_node;
 struct cgraph_node;
 struct cgraph_node_set_def;
-struct varpool_node_set_def;
 
 /* Description of IPA pass with generate summary, write, execute, read and
    transform stages.  */
@@ -181,15 +180,13 @@ struct ipa_opt_pass_d
   void (*generate_summary) (void);
 
   /* This hook is used to serialize IPA summaries on disk.  */
-  void (*write_summary) (struct cgraph_node_set_def *,
-                        struct varpool_node_set_def *);
+  void (*write_summary) (struct cgraph_node_set_def *);
 
   /* This hook is used to deserialize IPA summaries from disk.  */
   void (*read_summary) (void);
 
   /* This hook is used to serialize IPA optimization summaries on disk.  */
-  void (*write_optimization_summary) (struct cgraph_node_set_def *,
-                                     struct varpool_node_set_def *);
+  void (*write_optimization_summary) (struct cgraph_node_set_def *);
 
   /* This hook is used to deserialize IPA summaries from disk.  */
   void (*read_optimization_summary) (void);
@@ -414,7 +411,6 @@ extern struct gimple_opt_pass pass_late_warn_uninitialized;
 extern struct gimple_opt_pass pass_cse_reciprocals;
 extern struct gimple_opt_pass pass_cse_sincos;
 extern struct gimple_opt_pass pass_optimize_bswap;
-extern struct gimple_opt_pass pass_optimize_widening_mul;
 extern struct gimple_opt_pass pass_warn_function_return;
 extern struct gimple_opt_pass pass_warn_function_noreturn;
 extern struct gimple_opt_pass pass_cselim;
@@ -462,7 +458,6 @@ extern struct simple_ipa_opt_pass pass_ipa_pta;
 extern struct simple_ipa_opt_pass pass_ipa_struct_reorg;
 extern struct ipa_opt_pass_d pass_ipa_lto_wpa_fixup;
 extern struct ipa_opt_pass_d pass_ipa_lto_finish_out;
-extern struct ipa_opt_pass_d pass_ipa_profile;
 
 extern struct gimple_opt_pass pass_all_optimizations;
 extern struct gimple_opt_pass pass_cleanup_cfg_post_optimizing;
@@ -515,7 +510,6 @@ extern struct rtl_opt_pass pass_stack_ptr_mod;
 extern struct rtl_opt_pass pass_initialize_regs;
 extern struct rtl_opt_pass pass_combine;
 extern struct rtl_opt_pass pass_if_after_combine;
-extern struct rtl_opt_pass pass_implicit_zee;
 extern struct rtl_opt_pass pass_partition_blocks;
 extern struct rtl_opt_pass pass_match_asm_constraints;
 extern struct rtl_opt_pass pass_regmove;
@@ -611,8 +605,7 @@ extern const char *get_current_pass_name (void);
 extern void print_current_pass (FILE *);
 extern void debug_pass (void);
 extern void ipa_write_summaries (void);
-extern void ipa_write_optimization_summaries (struct cgraph_node_set_def *,
-                                             struct varpool_node_set_def *);
+extern void ipa_write_optimization_summaries (struct cgraph_node_set_def *);
 extern void ipa_read_summaries (void);
 extern void ipa_read_optimization_summaries (void);
 extern void register_one_dump_file (struct opt_pass *);