OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [tags/] [gnu-dev/] [fsf-gcc-snapshot-1-mar-12/] [or1k-gcc/] [gcc/] [ipa-reference.c] - Diff between revs 684 and 783

Only display areas with differences | Details | Blame | View Log

Rev 684 Rev 783
/* Callgraph based analysis of static variables.
/* Callgraph based analysis of static variables.
   Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010
   Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010
   Free Software Foundation, Inc.
   Free Software Foundation, Inc.
   Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
   Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
 
 
This file is part of GCC.
This file is part of GCC.
 
 
GCC is free software; you can redistribute it and/or modify it under
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
Software Foundation; either version 3, or (at your option) any later
version.
version.
 
 
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.
for more details.
 
 
You should have received a copy of the GNU General Public License
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */
<http://www.gnu.org/licenses/>.  */
 
 
/* This file gathers information about how variables whose scope is
/* This file gathers information about how variables whose scope is
   confined to the compilation unit are used.
   confined to the compilation unit are used.
 
 
   The transitive call site specific clobber effects are computed
   The transitive call site specific clobber effects are computed
   for the variables whose scope is contained within this compilation
   for the variables whose scope is contained within this compilation
   unit.
   unit.
 
 
   First each function and static variable initialization is analyzed
   First each function and static variable initialization is analyzed
   to determine which local static variables are either read, written,
   to determine which local static variables are either read, written,
   or have their address taken.  Any local static that has its address
   or have their address taken.  Any local static that has its address
   taken is removed from consideration.  Once the local read and
   taken is removed from consideration.  Once the local read and
   writes are determined, a transitive closure of this information is
   writes are determined, a transitive closure of this information is
   performed over the call graph to determine the worst case set of
   performed over the call graph to determine the worst case set of
   side effects of each call.  In later parts of the compiler, these
   side effects of each call.  In later parts of the compiler, these
   local and global sets are examined to make the call clobbering less
   local and global sets are examined to make the call clobbering less
   traumatic, promote some statics to registers, and improve aliasing
   traumatic, promote some statics to registers, and improve aliasing
   information.  */
   information.  */
 
 
#include "config.h"
#include "config.h"
#include "system.h"
#include "system.h"
#include "coretypes.h"
#include "coretypes.h"
#include "tm.h"
#include "tm.h"
#include "tree.h"
#include "tree.h"
#include "tree-flow.h"
#include "tree-flow.h"
#include "tree-inline.h"
#include "tree-inline.h"
#include "tree-pass.h"
#include "tree-pass.h"
#include "langhooks.h"
#include "langhooks.h"
#include "pointer-set.h"
#include "pointer-set.h"
#include "splay-tree.h"
#include "splay-tree.h"
#include "ggc.h"
#include "ggc.h"
#include "ipa-utils.h"
#include "ipa-utils.h"
#include "ipa-reference.h"
#include "ipa-reference.h"
#include "gimple.h"
#include "gimple.h"
#include "cgraph.h"
#include "cgraph.h"
#include "output.h"
#include "output.h"
#include "flags.h"
#include "flags.h"
#include "timevar.h"
#include "timevar.h"
#include "diagnostic.h"
#include "diagnostic.h"
#include "langhooks.h"
#include "langhooks.h"
#include "data-streamer.h"
#include "data-streamer.h"
#include "lto-streamer.h"
#include "lto-streamer.h"
 
 
static void remove_node_data (struct cgraph_node *node,
static void remove_node_data (struct cgraph_node *node,
                              void *data ATTRIBUTE_UNUSED);
                              void *data ATTRIBUTE_UNUSED);
static void duplicate_node_data (struct cgraph_node *src,
static void duplicate_node_data (struct cgraph_node *src,
                                 struct cgraph_node *dst,
                                 struct cgraph_node *dst,
                                 void *data ATTRIBUTE_UNUSED);
                                 void *data ATTRIBUTE_UNUSED);
 
 
/* The static variables defined within the compilation unit that are
/* The static variables defined within the compilation unit that are
   loaded or stored directly by function that owns this structure.  */
   loaded or stored directly by function that owns this structure.  */
 
 
struct ipa_reference_local_vars_info_d
struct ipa_reference_local_vars_info_d
{
{
  bitmap statics_read;
  bitmap statics_read;
  bitmap statics_written;
  bitmap statics_written;
};
};
 
 
/* Statics that are read and written by some set of functions. The
/* 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.
   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
   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. */
 
 
struct ipa_reference_global_vars_info_d
struct ipa_reference_global_vars_info_d
{
{
  bitmap statics_read;
  bitmap statics_read;
  bitmap statics_written;
  bitmap statics_written;
};
};
 
 
/* Information we save about every function after ipa-reference is completed.  */
/* Information we save about every function after ipa-reference is completed.  */
 
 
struct ipa_reference_optimization_summary_d
struct ipa_reference_optimization_summary_d
{
{
  bitmap statics_not_read;
  bitmap statics_not_read;
  bitmap statics_not_written;
  bitmap statics_not_written;
};
};
 
 
typedef struct ipa_reference_local_vars_info_d *ipa_reference_local_vars_info_t;
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_global_vars_info_d *ipa_reference_global_vars_info_t;
typedef struct ipa_reference_optimization_summary_d *ipa_reference_optimization_summary_t;
typedef struct ipa_reference_optimization_summary_d *ipa_reference_optimization_summary_t;
 
 
struct ipa_reference_vars_info_d
struct ipa_reference_vars_info_d
{
{
  struct ipa_reference_local_vars_info_d local;
  struct ipa_reference_local_vars_info_d local;
  struct ipa_reference_global_vars_info_d global;
  struct ipa_reference_global_vars_info_d global;
};
};
 
 
typedef struct ipa_reference_vars_info_d *ipa_reference_vars_info_t;
typedef struct ipa_reference_vars_info_d *ipa_reference_vars_info_t;
 
 
/* This splay tree contains all of the static variables that are
/* This splay tree contains all of the static variables that are
   being considered by the compilation level alias analysis.  */
   being considered by the compilation level alias analysis.  */
static splay_tree reference_vars_to_consider;
static splay_tree reference_vars_to_consider;
 
 
/* A bit is set for every module static we are considering.  This is
/* 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
   ored into the local info when asm code is found that clobbers all
   memory. */
   memory. */
static bitmap all_module_statics;
static bitmap all_module_statics;
 
 
/* Obstack holding bitmaps of local analysis (live from analysis to
/* Obstack holding bitmaps of local analysis (live from analysis to
   propagation)  */
   propagation)  */
static bitmap_obstack local_info_obstack;
static bitmap_obstack local_info_obstack;
/* Obstack holding global analysis live forever.  */
/* Obstack holding global analysis live forever.  */
static bitmap_obstack optimization_summary_obstack;
static bitmap_obstack optimization_summary_obstack;
 
 
/* Holders of ipa cgraph hooks: */
/* Holders of ipa cgraph hooks: */
static struct cgraph_2node_hook_list *node_duplication_hook_holder;
static struct cgraph_2node_hook_list *node_duplication_hook_holder;
static struct cgraph_node_hook_list *node_removal_hook_holder;
static struct cgraph_node_hook_list *node_removal_hook_holder;
 
 
/* Vector where the reference var infos are actually stored. */
/* Vector where the reference var infos are actually stored. */
DEF_VEC_P (ipa_reference_vars_info_t);
DEF_VEC_P (ipa_reference_vars_info_t);
DEF_VEC_ALLOC_P (ipa_reference_vars_info_t, heap);
DEF_VEC_ALLOC_P (ipa_reference_vars_info_t, heap);
static VEC (ipa_reference_vars_info_t, heap) *ipa_reference_vars_vector;
static VEC (ipa_reference_vars_info_t, heap) *ipa_reference_vars_vector;
DEF_VEC_P (ipa_reference_optimization_summary_t);
DEF_VEC_P (ipa_reference_optimization_summary_t);
DEF_VEC_ALLOC_P (ipa_reference_optimization_summary_t, heap);
DEF_VEC_ALLOC_P (ipa_reference_optimization_summary_t, heap);
static VEC (ipa_reference_optimization_summary_t, heap) *ipa_reference_opt_sum_vector;
static VEC (ipa_reference_optimization_summary_t, heap) *ipa_reference_opt_sum_vector;
 
 
/* Return the ipa_reference_vars structure starting from the cgraph NODE.  */
/* Return the ipa_reference_vars structure starting from the cgraph NODE.  */
static inline ipa_reference_vars_info_t
static inline ipa_reference_vars_info_t
get_reference_vars_info (struct cgraph_node *node)
get_reference_vars_info (struct cgraph_node *node)
{
{
  if (!ipa_reference_vars_vector
  if (!ipa_reference_vars_vector
      || VEC_length (ipa_reference_vars_info_t,
      || VEC_length (ipa_reference_vars_info_t,
                     ipa_reference_vars_vector) <= (unsigned int) node->uid)
                     ipa_reference_vars_vector) <= (unsigned int) node->uid)
    return NULL;
    return NULL;
  return VEC_index (ipa_reference_vars_info_t, ipa_reference_vars_vector,
  return VEC_index (ipa_reference_vars_info_t, ipa_reference_vars_vector,
                    node->uid);
                    node->uid);
}
}
 
 
/* Return the ipa_reference_vars structure starting from the cgraph NODE.  */
/* Return the ipa_reference_vars structure starting from the cgraph NODE.  */
static inline ipa_reference_optimization_summary_t
static inline ipa_reference_optimization_summary_t
get_reference_optimization_summary (struct cgraph_node *node)
get_reference_optimization_summary (struct cgraph_node *node)
{
{
  if (!ipa_reference_opt_sum_vector
  if (!ipa_reference_opt_sum_vector
      || (VEC_length (ipa_reference_optimization_summary_t,
      || (VEC_length (ipa_reference_optimization_summary_t,
                      ipa_reference_opt_sum_vector)
                      ipa_reference_opt_sum_vector)
          <= (unsigned int) node->uid))
          <= (unsigned int) node->uid))
    return NULL;
    return NULL;
  return VEC_index (ipa_reference_optimization_summary_t, ipa_reference_opt_sum_vector,
  return VEC_index (ipa_reference_optimization_summary_t, ipa_reference_opt_sum_vector,
                    node->uid);
                    node->uid);
}
}
 
 
/* Return the ipa_reference_vars structure starting from the cgraph NODE.  */
/* Return the ipa_reference_vars structure starting from the cgraph NODE.  */
static inline void
static inline void
set_reference_vars_info (struct cgraph_node *node,
set_reference_vars_info (struct cgraph_node *node,
                         ipa_reference_vars_info_t info)
                         ipa_reference_vars_info_t info)
{
{
  if (!ipa_reference_vars_vector
  if (!ipa_reference_vars_vector
      || VEC_length (ipa_reference_vars_info_t,
      || VEC_length (ipa_reference_vars_info_t,
                     ipa_reference_vars_vector) <= (unsigned int) node->uid)
                     ipa_reference_vars_vector) <= (unsigned int) node->uid)
    VEC_safe_grow_cleared (ipa_reference_vars_info_t, heap,
    VEC_safe_grow_cleared (ipa_reference_vars_info_t, heap,
                           ipa_reference_vars_vector, node->uid + 1);
                           ipa_reference_vars_vector, node->uid + 1);
  VEC_replace (ipa_reference_vars_info_t, ipa_reference_vars_vector,
  VEC_replace (ipa_reference_vars_info_t, ipa_reference_vars_vector,
               node->uid, info);
               node->uid, info);
}
}
 
 
/* Return the ipa_reference_vars structure starting from the cgraph NODE.  */
/* Return the ipa_reference_vars structure starting from the cgraph NODE.  */
static inline void
static inline void
set_reference_optimization_summary (struct cgraph_node *node,
set_reference_optimization_summary (struct cgraph_node *node,
                                    ipa_reference_optimization_summary_t info)
                                    ipa_reference_optimization_summary_t info)
{
{
  if (!ipa_reference_opt_sum_vector
  if (!ipa_reference_opt_sum_vector
      || (VEC_length (ipa_reference_optimization_summary_t,
      || (VEC_length (ipa_reference_optimization_summary_t,
                      ipa_reference_opt_sum_vector)
                      ipa_reference_opt_sum_vector)
          <= (unsigned int) node->uid))
          <= (unsigned int) node->uid))
    VEC_safe_grow_cleared (ipa_reference_optimization_summary_t,
    VEC_safe_grow_cleared (ipa_reference_optimization_summary_t,
                           heap, ipa_reference_opt_sum_vector, node->uid + 1);
                           heap, ipa_reference_opt_sum_vector, node->uid + 1);
  VEC_replace (ipa_reference_optimization_summary_t,
  VEC_replace (ipa_reference_optimization_summary_t,
               ipa_reference_opt_sum_vector, node->uid, info);
               ipa_reference_opt_sum_vector, node->uid, info);
}
}
 
 
/* Return a bitmap indexed by_DECL_UID uid for the static variables
/* Return a bitmap indexed by_DECL_UID uid for the static variables
   that are not read during the execution of the function FN.  Returns
   that are not read during the execution of the function FN.  Returns
   NULL if no data is available.  */
   NULL if no data is available.  */
 
 
bitmap
bitmap
ipa_reference_get_not_read_global (struct cgraph_node *fn)
ipa_reference_get_not_read_global (struct cgraph_node *fn)
{
{
  ipa_reference_optimization_summary_t info;
  ipa_reference_optimization_summary_t info;
 
 
  info = get_reference_optimization_summary (cgraph_function_node (fn, NULL));
  info = get_reference_optimization_summary (cgraph_function_node (fn, NULL));
  if (info)
  if (info)
    return info->statics_not_read;
    return info->statics_not_read;
  else if (flags_from_decl_or_type (fn->decl) & ECF_LEAF)
  else if (flags_from_decl_or_type (fn->decl) & ECF_LEAF)
    return all_module_statics;
    return all_module_statics;
  else
  else
    return NULL;
    return NULL;
}
}
 
 
/* Return a bitmap indexed by DECL_UID uid for the static variables
/* Return a bitmap indexed by DECL_UID uid for the static variables
   that are not written during the execution of the function FN.  Note
   that are not written during the execution of the function FN.  Note
   that variables written may or may not be read during the function
   that variables written may or may not be read during the function
   call.  Returns NULL if no data is available.  */
   call.  Returns NULL if no data is available.  */
 
 
bitmap
bitmap
ipa_reference_get_not_written_global (struct cgraph_node *fn)
ipa_reference_get_not_written_global (struct cgraph_node *fn)
{
{
  ipa_reference_optimization_summary_t info;
  ipa_reference_optimization_summary_t info;
 
 
  info = get_reference_optimization_summary (fn);
  info = get_reference_optimization_summary (fn);
  if (info)
  if (info)
    return info->statics_not_written;
    return info->statics_not_written;
  else if (flags_from_decl_or_type (fn->decl) & ECF_LEAF)
  else if (flags_from_decl_or_type (fn->decl) & ECF_LEAF)
    return all_module_statics;
    return all_module_statics;
  else
  else
    return NULL;
    return NULL;
}
}
 
 


 
 
/* Add VAR to all_module_statics and the two
/* Add VAR to all_module_statics and the two
   reference_vars_to_consider* sets.  */
   reference_vars_to_consider* sets.  */
 
 
static inline void
static inline void
add_static_var (tree var)
add_static_var (tree var)
{
{
  int uid = DECL_UID (var);
  int uid = DECL_UID (var);
  gcc_assert (TREE_CODE (var) == VAR_DECL);
  gcc_assert (TREE_CODE (var) == VAR_DECL);
  if (dump_file)
  if (dump_file)
    splay_tree_insert (reference_vars_to_consider,
    splay_tree_insert (reference_vars_to_consider,
                       uid, (splay_tree_value)var);
                       uid, (splay_tree_value)var);
  bitmap_set_bit (all_module_statics, uid);
  bitmap_set_bit (all_module_statics, uid);
}
}
 
 
/* Return true if the variable T is the right kind of static variable to
/* Return true if the variable T is the right kind of static variable to
   perform compilation unit scope escape analysis.  */
   perform compilation unit scope escape analysis.  */
 
 
static inline bool
static inline bool
is_proper_for_analysis (tree t)
is_proper_for_analysis (tree t)
{
{
  /* We handle only variables whose address is never taken.  */
  /* We handle only variables whose address is never taken.  */
  if (TREE_ADDRESSABLE (t))
  if (TREE_ADDRESSABLE (t))
    return false;
    return false;
 
 
  /* If the variable has the "used" attribute, treat it as if it had a
  /* If the variable has the "used" attribute, treat it as if it had a
     been touched by the devil.  */
     been touched by the devil.  */
  if (DECL_PRESERVE_P (t))
  if (DECL_PRESERVE_P (t))
    return false;
    return false;
 
 
  /* Do not want to do anything with volatile except mark any
  /* Do not want to do anything with volatile except mark any
     function that uses one to be not const or pure.  */
     function that uses one to be not const or pure.  */
  if (TREE_THIS_VOLATILE (t))
  if (TREE_THIS_VOLATILE (t))
    return false;
    return false;
 
 
  /* We do not need to analyze readonly vars, we already know they do not
  /* We do not need to analyze readonly vars, we already know they do not
     alias.  */
     alias.  */
  if (TREE_READONLY (t))
  if (TREE_READONLY (t))
    return false;
    return false;
 
 
  /* We cannot touch decls where the type needs constructing.  */
  /* We cannot touch decls where the type needs constructing.  */
  if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (t)))
  if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (t)))
    return false;
    return false;
 
 
  /* This is a variable we care about.  Check if we have seen it
  /* 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.  */
     before, and if not add it the set of variables we care about.  */
  if (all_module_statics
  if (all_module_statics
      && !bitmap_bit_p (all_module_statics, DECL_UID (t)))
      && !bitmap_bit_p (all_module_statics, DECL_UID (t)))
    add_static_var (t);
    add_static_var (t);
 
 
  return true;
  return true;
}
}
 
 
/* Lookup the tree node for the static variable that has UID and
/* Lookup the tree node for the static variable that has UID and
   convert the name to a string for debugging.  */
   convert the name to a string for debugging.  */
 
 
static const char *
static const char *
get_static_name (int index)
get_static_name (int index)
{
{
  splay_tree_node stn =
  splay_tree_node stn =
    splay_tree_lookup (reference_vars_to_consider, index);
    splay_tree_lookup (reference_vars_to_consider, index);
  if (stn)
  if (stn)
    return lang_hooks.decl_printable_name ((tree)(stn->value), 2);
    return lang_hooks.decl_printable_name ((tree)(stn->value), 2);
  return NULL;
  return NULL;
}
}
 
 
/* Or in all of the bits from every callee of X into X_GLOBAL, the caller's cycle,
/* Or in all of the bits from every callee of X into X_GLOBAL, the caller's cycle,
   bit vector.  There are several cases to check to avoid the sparse
   bit vector.  There are several cases to check to avoid the sparse
   bitmap oring.  */
   bitmap oring.  */
 
 
static void
static void
propagate_bits (ipa_reference_global_vars_info_t x_global, struct cgraph_node *x)
propagate_bits (ipa_reference_global_vars_info_t x_global, struct cgraph_node *x)
{
{
  struct cgraph_edge *e;
  struct cgraph_edge *e;
  for (e = x->callees; e; e = e->next_callee)
  for (e = x->callees; e; e = e->next_callee)
    {
    {
      enum availability avail;
      enum availability avail;
      struct cgraph_node *y = cgraph_function_node (e->callee, &avail);
      struct cgraph_node *y = cgraph_function_node (e->callee, &avail);
 
 
      if (!y)
      if (!y)
        continue;
        continue;
      /* Only look into nodes we can propagate something.  */
      /* Only look into nodes we can propagate something.  */
      if (avail > AVAIL_OVERWRITABLE
      if (avail > AVAIL_OVERWRITABLE
          || (avail == AVAIL_OVERWRITABLE
          || (avail == AVAIL_OVERWRITABLE
              && (flags_from_decl_or_type (y->decl) & ECF_LEAF)))
              && (flags_from_decl_or_type (y->decl) & ECF_LEAF)))
        {
        {
          int flags = flags_from_decl_or_type (y->decl);
          int flags = flags_from_decl_or_type (y->decl);
          if (get_reference_vars_info (y))
          if (get_reference_vars_info (y))
            {
            {
              ipa_reference_vars_info_t y_info
              ipa_reference_vars_info_t y_info
                = get_reference_vars_info (y);
                = 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.  */
              /* Calls in current cycle do not have global computed yet.  */
              if (!y_global->statics_read)
              if (!y_global->statics_read)
                continue;
                continue;
 
 
              /* If function is declared const, it reads no memory even if it
              /* If function is declared const, it reads no memory even if it
                 seems so to local analysis.  */
                 seems so to local analysis.  */
              if (flags & ECF_CONST)
              if (flags & ECF_CONST)
                continue;
                continue;
 
 
              if (x_global->statics_read
              if (x_global->statics_read
                  != all_module_statics)
                  != all_module_statics)
                {
                {
                  if (y_global->statics_read
                  if (y_global->statics_read
                      == all_module_statics)
                      == all_module_statics)
                    {
                    {
                      BITMAP_FREE (x_global->statics_read);
                      BITMAP_FREE (x_global->statics_read);
                      x_global->statics_read
                      x_global->statics_read
                        = all_module_statics;
                        = all_module_statics;
                    }
                    }
                  /* Skip bitmaps that are pointer equal to node's bitmap
                  /* Skip bitmaps that are pointer equal to node's bitmap
                     (no reason to spin within the cycle).  */
                     (no reason to spin within the cycle).  */
                  else if (x_global->statics_read
                  else if (x_global->statics_read
                           != y_global->statics_read)
                           != y_global->statics_read)
                    bitmap_ior_into (x_global->statics_read,
                    bitmap_ior_into (x_global->statics_read,
                                     y_global->statics_read);
                                     y_global->statics_read);
                }
                }
 
 
              /* If function is declared pure, it has no stores even if it
              /* If function is declared pure, it has no stores even if it
                 seems so to local analysis; If we can not return from here,
                 seems so to local analysis; If we can not return from here,
                 we can safely ignore the call.  */
                 we can safely ignore the call.  */
              if ((flags & ECF_PURE)
              if ((flags & ECF_PURE)
                  || cgraph_edge_cannot_lead_to_return (e))
                  || cgraph_edge_cannot_lead_to_return (e))
                continue;
                continue;
 
 
              if (x_global->statics_written
              if (x_global->statics_written
                  != all_module_statics)
                  != all_module_statics)
                {
                {
                  if (y_global->statics_written
                  if (y_global->statics_written
                      == all_module_statics)
                      == all_module_statics)
                    {
                    {
                      BITMAP_FREE (x_global->statics_written);
                      BITMAP_FREE (x_global->statics_written);
                      x_global->statics_written
                      x_global->statics_written
                        = all_module_statics;
                        = all_module_statics;
                    }
                    }
                  /* Skip bitmaps that are pointer equal to node's bitmap
                  /* Skip bitmaps that are pointer equal to node's bitmap
                     (no reason to spin within the cycle).  */
                     (no reason to spin within the cycle).  */
                  else if (x_global->statics_written
                  else if (x_global->statics_written
                           != y_global->statics_written)
                           != y_global->statics_written)
                    bitmap_ior_into (x_global->statics_written,
                    bitmap_ior_into (x_global->statics_written,
                                     y_global->statics_written);
                                     y_global->statics_written);
                }
                }
            }
            }
          else
          else
            gcc_unreachable ();
            gcc_unreachable ();
        }
        }
    }
    }
}
}
 
 
/* The init routine for analyzing global static variable usage.  See
/* The init routine for analyzing global static variable usage.  See
   comments at top for description.  */
   comments at top for description.  */
static void
static void
ipa_init (void)
ipa_init (void)
{
{
  static bool init_p = false;
  static bool init_p = false;
 
 
  if (init_p)
  if (init_p)
    return;
    return;
 
 
  init_p = true;
  init_p = true;
 
 
  if (dump_file)
  if (dump_file)
    reference_vars_to_consider = splay_tree_new (splay_tree_compare_ints, 0, 0);
    reference_vars_to_consider = splay_tree_new (splay_tree_compare_ints, 0, 0);
 
 
  bitmap_obstack_initialize (&local_info_obstack);
  bitmap_obstack_initialize (&local_info_obstack);
  bitmap_obstack_initialize (&optimization_summary_obstack);
  bitmap_obstack_initialize (&optimization_summary_obstack);
  all_module_statics = BITMAP_ALLOC (&optimization_summary_obstack);
  all_module_statics = BITMAP_ALLOC (&optimization_summary_obstack);
 
 
  node_removal_hook_holder =
  node_removal_hook_holder =
      cgraph_add_node_removal_hook (&remove_node_data, NULL);
      cgraph_add_node_removal_hook (&remove_node_data, NULL);
  node_duplication_hook_holder =
  node_duplication_hook_holder =
      cgraph_add_node_duplication_hook (&duplicate_node_data, NULL);
      cgraph_add_node_duplication_hook (&duplicate_node_data, NULL);
}
}
 
 
 
 
/* Set up the persistent info for FN.  */
/* Set up the persistent info for FN.  */
 
 
static ipa_reference_local_vars_info_t
static ipa_reference_local_vars_info_t
init_function_info (struct cgraph_node *fn)
init_function_info (struct cgraph_node *fn)
{
{
  ipa_reference_vars_info_t info
  ipa_reference_vars_info_t info
    = XCNEW (struct ipa_reference_vars_info_d);
    = XCNEW (struct ipa_reference_vars_info_d);
 
 
  /* Add the info to the tree's annotation.  */
  /* Add the info to the tree's annotation.  */
  set_reference_vars_info (fn, info);
  set_reference_vars_info (fn, info);
 
 
  info->local.statics_read = BITMAP_ALLOC (&local_info_obstack);
  info->local.statics_read = BITMAP_ALLOC (&local_info_obstack);
  info->local.statics_written = BITMAP_ALLOC (&local_info_obstack);
  info->local.statics_written = BITMAP_ALLOC (&local_info_obstack);
 
 
  return &info->local;
  return &info->local;
}
}
 
 
 
 
/* This is the main routine for finding the reference patterns for
/* This is the main routine for finding the reference patterns for
   global variables within a function FN.  */
   global variables within a function FN.  */
 
 
static void
static void
analyze_function (struct cgraph_node *fn)
analyze_function (struct cgraph_node *fn)
{
{
  ipa_reference_local_vars_info_t local;
  ipa_reference_local_vars_info_t local;
  struct ipa_ref *ref;
  struct ipa_ref *ref;
  int i;
  int i;
  tree var;
  tree var;
 
 
  local = init_function_info (fn);
  local = init_function_info (fn);
  for (i = 0; ipa_ref_list_reference_iterate (&fn->ref_list, i, ref); i++)
  for (i = 0; ipa_ref_list_reference_iterate (&fn->ref_list, i, ref); i++)
    {
    {
      if (ref->refered_type != IPA_REF_VARPOOL)
      if (ref->refered_type != IPA_REF_VARPOOL)
        continue;
        continue;
      var = ipa_ref_varpool_node (ref)->decl;
      var = ipa_ref_varpool_node (ref)->decl;
      if (ipa_ref_varpool_node (ref)->externally_visible
      if (ipa_ref_varpool_node (ref)->externally_visible
          || !ipa_ref_varpool_node (ref)->analyzed
          || !ipa_ref_varpool_node (ref)->analyzed
          || !is_proper_for_analysis (var))
          || !is_proper_for_analysis (var))
        continue;
        continue;
      switch (ref->use)
      switch (ref->use)
        {
        {
        case IPA_REF_LOAD:
        case IPA_REF_LOAD:
          bitmap_set_bit (local->statics_read, DECL_UID (var));
          bitmap_set_bit (local->statics_read, DECL_UID (var));
          break;
          break;
        case IPA_REF_STORE:
        case IPA_REF_STORE:
          if (ipa_ref_cannot_lead_to_return (ref))
          if (ipa_ref_cannot_lead_to_return (ref))
            break;
            break;
          bitmap_set_bit (local->statics_written, DECL_UID (var));
          bitmap_set_bit (local->statics_written, DECL_UID (var));
          break;
          break;
        case IPA_REF_ADDR:
        case IPA_REF_ADDR:
          gcc_unreachable ();
          gcc_unreachable ();
          break;
          break;
        }
        }
    }
    }
 
 
  if (cgraph_node_cannot_return (fn))
  if (cgraph_node_cannot_return (fn))
    bitmap_clear (local->statics_written);
    bitmap_clear (local->statics_written);
}
}
 
 
static bitmap
static bitmap
copy_global_bitmap (bitmap src)
copy_global_bitmap (bitmap src)
{
{
  bitmap dst;
  bitmap dst;
  if (!src)
  if (!src)
    return NULL;
    return NULL;
  if (src == all_module_statics)
  if (src == all_module_statics)
    return all_module_statics;
    return all_module_statics;
  dst = BITMAP_ALLOC (&optimization_summary_obstack);
  dst = BITMAP_ALLOC (&optimization_summary_obstack);
  bitmap_copy (dst, src);
  bitmap_copy (dst, src);
  return dst;
  return dst;
}
}
 
 
 
 
/* Called when new clone is inserted to callgraph late.  */
/* Called when new clone is inserted to callgraph late.  */
 
 
static void
static void
duplicate_node_data (struct cgraph_node *src, struct cgraph_node *dst,
duplicate_node_data (struct cgraph_node *src, struct cgraph_node *dst,
                     void *data ATTRIBUTE_UNUSED)
                     void *data ATTRIBUTE_UNUSED)
{
{
  ipa_reference_optimization_summary_t ginfo;
  ipa_reference_optimization_summary_t ginfo;
  ipa_reference_optimization_summary_t dst_ginfo;
  ipa_reference_optimization_summary_t dst_ginfo;
 
 
  ginfo = get_reference_optimization_summary (src);
  ginfo = get_reference_optimization_summary (src);
  if (!ginfo)
  if (!ginfo)
    return;
    return;
  dst_ginfo = XCNEW (struct ipa_reference_optimization_summary_d);
  dst_ginfo = XCNEW (struct ipa_reference_optimization_summary_d);
  set_reference_optimization_summary (dst, dst_ginfo);
  set_reference_optimization_summary (dst, dst_ginfo);
  dst_ginfo->statics_not_read = copy_global_bitmap (ginfo->statics_not_read);
  dst_ginfo->statics_not_read = copy_global_bitmap (ginfo->statics_not_read);
  dst_ginfo->statics_not_written = copy_global_bitmap (ginfo->statics_not_written);
  dst_ginfo->statics_not_written = copy_global_bitmap (ginfo->statics_not_written);
}
}
 
 
/* Called when node is removed.  */
/* Called when node is removed.  */
 
 
static void
static void
remove_node_data (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
remove_node_data (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
{
{
  ipa_reference_optimization_summary_t ginfo;
  ipa_reference_optimization_summary_t ginfo;
  ginfo = get_reference_optimization_summary (node);
  ginfo = get_reference_optimization_summary (node);
  if (ginfo)
  if (ginfo)
    {
    {
      if (ginfo->statics_not_read
      if (ginfo->statics_not_read
          && ginfo->statics_not_read != all_module_statics)
          && ginfo->statics_not_read != all_module_statics)
        BITMAP_FREE (ginfo->statics_not_read);
        BITMAP_FREE (ginfo->statics_not_read);
 
 
      if (ginfo->statics_not_written
      if (ginfo->statics_not_written
          && ginfo->statics_not_written != all_module_statics)
          && ginfo->statics_not_written != all_module_statics)
        BITMAP_FREE (ginfo->statics_not_written);
        BITMAP_FREE (ginfo->statics_not_written);
      free (ginfo);
      free (ginfo);
      set_reference_optimization_summary (node, NULL);
      set_reference_optimization_summary (node, NULL);
    }
    }
}
}
 
 
/* Analyze each function in the cgraph to see which global or statics
/* Analyze each function in the cgraph to see which global or statics
   are read or written.  */
   are read or written.  */
 
 
static void
static void
generate_summary (void)
generate_summary (void)
{
{
  struct cgraph_node *node;
  struct cgraph_node *node;
  unsigned int index;
  unsigned int index;
  bitmap_iterator bi;
  bitmap_iterator bi;
  bitmap bm_temp;
  bitmap bm_temp;
 
 
  ipa_init ();
  ipa_init ();
  bm_temp = BITMAP_ALLOC (&local_info_obstack);
  bm_temp = BITMAP_ALLOC (&local_info_obstack);
 
 
  /* Process all of the functions next.  */
  /* Process all of the functions next.  */
  for (node = cgraph_nodes; node; node = node->next)
  for (node = cgraph_nodes; node; node = node->next)
    if (node->analyzed)
    if (node->analyzed)
      analyze_function (node);
      analyze_function (node);
 
 
  if (dump_file)
  if (dump_file)
    EXECUTE_IF_SET_IN_BITMAP (all_module_statics, 0, index, bi)
    EXECUTE_IF_SET_IN_BITMAP (all_module_statics, 0, index, bi)
      {
      {
        fprintf (dump_file, "\nPromotable global:%s",
        fprintf (dump_file, "\nPromotable global:%s",
                 get_static_name (index));
                 get_static_name (index));
      }
      }
 
 
  BITMAP_FREE(bm_temp);
  BITMAP_FREE(bm_temp);
 
 
  if (dump_file)
  if (dump_file)
    for (node = cgraph_nodes; node; node = node->next)
    for (node = cgraph_nodes; node; node = node->next)
      if (cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
      if (cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
        {
        {
          ipa_reference_local_vars_info_t l;
          ipa_reference_local_vars_info_t l;
          unsigned int index;
          unsigned int index;
          bitmap_iterator bi;
          bitmap_iterator bi;
 
 
          l = &get_reference_vars_info (node)->local;
          l = &get_reference_vars_info (node)->local;
          fprintf (dump_file,
          fprintf (dump_file,
                   "\nFunction name:%s/%i:",
                   "\nFunction name:%s/%i:",
                   cgraph_node_name (node), node->uid);
                   cgraph_node_name (node), node->uid);
          fprintf (dump_file, "\n  locals read: ");
          fprintf (dump_file, "\n  locals read: ");
          if (l->statics_read)
          if (l->statics_read)
            EXECUTE_IF_SET_IN_BITMAP (l->statics_read,
            EXECUTE_IF_SET_IN_BITMAP (l->statics_read,
                                      0, index, bi)
                                      0, index, bi)
              {
              {
                fprintf (dump_file, "%s ",
                fprintf (dump_file, "%s ",
                         get_static_name (index));
                         get_static_name (index));
              }
              }
          fprintf (dump_file, "\n  locals written: ");
          fprintf (dump_file, "\n  locals written: ");
          if (l->statics_written)
          if (l->statics_written)
            EXECUTE_IF_SET_IN_BITMAP (l->statics_written,
            EXECUTE_IF_SET_IN_BITMAP (l->statics_written,
                                      0, index, bi)
                                      0, index, bi)
              {
              {
                fprintf(dump_file, "%s ",
                fprintf(dump_file, "%s ",
                        get_static_name (index));
                        get_static_name (index));
              }
              }
        }
        }
}
}


/* Set READ_ALL/WRITE_ALL based on decl flags of NODE.  */
/* Set READ_ALL/WRITE_ALL based on decl flags of NODE.  */
 
 
static void
static void
read_write_all_from_decl (struct cgraph_node *node, bool * read_all,
read_write_all_from_decl (struct cgraph_node *node, bool * read_all,
                          bool * write_all)
                          bool * write_all)
{
{
  tree decl = node->decl;
  tree decl = node->decl;
  int flags = flags_from_decl_or_type (decl);
  int flags = flags_from_decl_or_type (decl);
  if ((flags & ECF_LEAF)
  if ((flags & ECF_LEAF)
      && cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE)
      && cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE)
    ;
    ;
  else if (flags & ECF_CONST)
  else if (flags & ECF_CONST)
    ;
    ;
  else if ((flags & ECF_PURE)
  else if ((flags & ECF_PURE)
           || cgraph_node_cannot_return (node))
           || cgraph_node_cannot_return (node))
    {
    {
      *read_all = true;
      *read_all = true;
      if (dump_file && (dump_flags & TDF_DETAILS))
      if (dump_file && (dump_flags & TDF_DETAILS))
         fprintf (dump_file, "   %s/%i -> read all\n",
         fprintf (dump_file, "   %s/%i -> read all\n",
                  cgraph_node_name (node), node->uid);
                  cgraph_node_name (node), node->uid);
    }
    }
  else
  else
    {
    {
       /* TODO: To be able to produce sane results, we should also handle
       /* TODO: To be able to produce sane results, we should also handle
          common builtins, in particular throw.  */
          common builtins, in particular throw.  */
      *read_all = true;
      *read_all = true;
      *write_all = true;
      *write_all = true;
      if (dump_file && (dump_flags & TDF_DETAILS))
      if (dump_file && (dump_flags & TDF_DETAILS))
         fprintf (dump_file, "   %s/%i -> read all, write all\n",
         fprintf (dump_file, "   %s/%i -> read all, write all\n",
                  cgraph_node_name (node), node->uid);
                  cgraph_node_name (node), node->uid);
    }
    }
}
}
 
 
/* Produce the global information by preforming a transitive closure
/* 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 */
 
 
static unsigned int
static unsigned int
propagate (void)
propagate (void)
{
{
  struct cgraph_node *node;
  struct cgraph_node *node;
  struct cgraph_node *w;
  struct cgraph_node *w;
  struct cgraph_node **order =
  struct cgraph_node **order =
    XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
    XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
  int order_pos;
  int order_pos;
  int i;
  int i;
 
 
  if (dump_file)
  if (dump_file)
    dump_cgraph (dump_file);
    dump_cgraph (dump_file);
 
 
  ipa_discover_readonly_nonaddressable_vars ();
  ipa_discover_readonly_nonaddressable_vars ();
  generate_summary ();
  generate_summary ();
 
 
  /* Propagate the local information thru the call graph to produce
  /* Propagate the local information thru the call graph to produce
     the global information.  All the nodes within a cycle will have
     the global information.  All the nodes within a cycle will have
     the same info so we collapse cycles first.  Then we can do the
     the same info so we collapse cycles first.  Then we can do the
     propagation in one pass from the leaves to the roots.  */
     propagation in one pass from the leaves to the roots.  */
  order_pos = ipa_reduced_postorder (order, true, true, NULL);
  order_pos = ipa_reduced_postorder (order, true, true, NULL);
  if (dump_file)
  if (dump_file)
    ipa_print_order (dump_file, "reduced", order, order_pos);
    ipa_print_order (dump_file, "reduced", order, order_pos);
 
 
  for (i = 0; i < order_pos; i++ )
  for (i = 0; i < order_pos; i++ )
    {
    {
      ipa_reference_vars_info_t node_info;
      ipa_reference_vars_info_t node_info;
      ipa_reference_global_vars_info_t node_g;
      ipa_reference_global_vars_info_t node_g;
      ipa_reference_local_vars_info_t node_l;
      ipa_reference_local_vars_info_t node_l;
      struct cgraph_edge *e, *ie;
      struct cgraph_edge *e, *ie;
 
 
      bool read_all;
      bool read_all;
      bool write_all;
      bool write_all;
      struct ipa_dfs_info * w_info;
      struct ipa_dfs_info * w_info;
 
 
      node = order[i];
      node = order[i];
      if (node->alias)
      if (node->alias)
        continue;
        continue;
      node_info = get_reference_vars_info (node);
      node_info = get_reference_vars_info (node);
      gcc_assert (node_info);
      gcc_assert (node_info);
 
 
 
 
      if (dump_file && (dump_flags & TDF_DETAILS))
      if (dump_file && (dump_flags & TDF_DETAILS))
        fprintf (dump_file, "Starting cycle with %s/%i\n",
        fprintf (dump_file, "Starting cycle with %s/%i\n",
                  cgraph_node_name (node), node->uid);
                  cgraph_node_name (node), node->uid);
 
 
      node_l = &node_info->local;
      node_l = &node_info->local;
      node_g = &node_info->global;
      node_g = &node_info->global;
 
 
      read_all = false;
      read_all = false;
      write_all = false;
      write_all = false;
 
 
      /* When function is overwritable, we can not assume anything.  */
      /* When function is overwritable, we can not assume anything.  */
      if (cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE)
      if (cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE)
        read_write_all_from_decl (node, &read_all, &write_all);
        read_write_all_from_decl (node, &read_all, &write_all);
 
 
      for (e = node->callees; e; e = e->next_callee)
      for (e = node->callees; e; e = e->next_callee)
        {
        {
          enum availability avail;
          enum availability avail;
          struct cgraph_node *callee = cgraph_function_node (e->callee, &avail);
          struct cgraph_node *callee = cgraph_function_node (e->callee, &avail);
          if (!callee || avail <= AVAIL_OVERWRITABLE)
          if (!callee || avail <= AVAIL_OVERWRITABLE)
            read_write_all_from_decl (callee, &read_all, &write_all);
            read_write_all_from_decl (callee, &read_all, &write_all);
        }
        }
 
 
      for (ie = node->indirect_calls; ie; ie = ie->next_callee)
      for (ie = node->indirect_calls; ie; ie = ie->next_callee)
        if (!(ie->indirect_info->ecf_flags & ECF_CONST))
        if (!(ie->indirect_info->ecf_flags & ECF_CONST))
          {
          {
            read_all = true;
            read_all = true;
            if (dump_file && (dump_flags & TDF_DETAILS))
            if (dump_file && (dump_flags & TDF_DETAILS))
               fprintf (dump_file, "   indirect call -> read all\n");
               fprintf (dump_file, "   indirect call -> read all\n");
            if (!cgraph_edge_cannot_lead_to_return (ie)
            if (!cgraph_edge_cannot_lead_to_return (ie)
                && !(ie->indirect_info->ecf_flags & ECF_PURE))
                && !(ie->indirect_info->ecf_flags & ECF_PURE))
              {
              {
                if (dump_file && (dump_flags & TDF_DETAILS))
                if (dump_file && (dump_flags & TDF_DETAILS))
                   fprintf (dump_file, "   indirect call -> write all\n");
                   fprintf (dump_file, "   indirect call -> write all\n");
                write_all = true;
                write_all = true;
              }
              }
          }
          }
 
 
 
 
      /* If any node in a cycle is read_all or write_all
      /* If any node in a cycle is read_all or write_all
         they all are. */
         they all are. */
      w_info = (struct ipa_dfs_info *) node->aux;
      w_info = (struct ipa_dfs_info *) node->aux;
      w = w_info->next_cycle;
      w = w_info->next_cycle;
      while (w && (!read_all || !write_all))
      while (w && (!read_all || !write_all))
        {
        {
          if (dump_file && (dump_flags & TDF_DETAILS))
          if (dump_file && (dump_flags & TDF_DETAILS))
            fprintf (dump_file, "  Visiting %s/%i\n",
            fprintf (dump_file, "  Visiting %s/%i\n",
                      cgraph_node_name (w), w->uid);
                      cgraph_node_name (w), w->uid);
          /* When function is overwritable, we can not assume anything.  */
          /* When function is overwritable, we can not assume anything.  */
          if (cgraph_function_body_availability (w) <= AVAIL_OVERWRITABLE)
          if (cgraph_function_body_availability (w) <= AVAIL_OVERWRITABLE)
            read_write_all_from_decl (w, &read_all, &write_all);
            read_write_all_from_decl (w, &read_all, &write_all);
 
 
          for (e = w->callees; e; e = e->next_callee)
          for (e = w->callees; e; e = e->next_callee)
            {
            {
              enum availability avail;
              enum availability avail;
              struct cgraph_node *callee = cgraph_function_node (e->callee, &avail);
              struct cgraph_node *callee = cgraph_function_node (e->callee, &avail);
 
 
              if (avail <= AVAIL_OVERWRITABLE)
              if (avail <= AVAIL_OVERWRITABLE)
                read_write_all_from_decl (callee, &read_all, &write_all);
                read_write_all_from_decl (callee, &read_all, &write_all);
            }
            }
 
 
          for (ie = w->indirect_calls; ie; ie = ie->next_callee)
          for (ie = w->indirect_calls; ie; ie = ie->next_callee)
            if (!(ie->indirect_info->ecf_flags & ECF_CONST))
            if (!(ie->indirect_info->ecf_flags & ECF_CONST))
              {
              {
                read_all = true;
                read_all = true;
                if (dump_file && (dump_flags & TDF_DETAILS))
                if (dump_file && (dump_flags & TDF_DETAILS))
                   fprintf (dump_file, "   indirect call -> read all\n");
                   fprintf (dump_file, "   indirect call -> read all\n");
                if (!cgraph_edge_cannot_lead_to_return (ie)
                if (!cgraph_edge_cannot_lead_to_return (ie)
                    && !(ie->indirect_info->ecf_flags & ECF_PURE))
                    && !(ie->indirect_info->ecf_flags & ECF_PURE))
                  {
                  {
                    write_all = true;
                    write_all = true;
                    if (dump_file && (dump_flags & TDF_DETAILS))
                    if (dump_file && (dump_flags & TDF_DETAILS))
                       fprintf (dump_file, "   indirect call -> write all\n");
                       fprintf (dump_file, "   indirect call -> write all\n");
                  }
                  }
              }
              }
 
 
          w_info = (struct ipa_dfs_info *) w->aux;
          w_info = (struct ipa_dfs_info *) w->aux;
          w = w_info->next_cycle;
          w = w_info->next_cycle;
        }
        }
 
 
 
 
      /* Initialized the bitmaps for the reduced nodes */
      /* Initialized the bitmaps for the reduced nodes */
      if (read_all)
      if (read_all)
        node_g->statics_read = all_module_statics;
        node_g->statics_read = all_module_statics;
      else
      else
        {
        {
          node_g->statics_read = BITMAP_ALLOC (&local_info_obstack);
          node_g->statics_read = BITMAP_ALLOC (&local_info_obstack);
          bitmap_copy (node_g->statics_read,
          bitmap_copy (node_g->statics_read,
                       node_l->statics_read);
                       node_l->statics_read);
        }
        }
      if (write_all)
      if (write_all)
        node_g->statics_written = all_module_statics;
        node_g->statics_written = all_module_statics;
      else
      else
        {
        {
          node_g->statics_written = BITMAP_ALLOC (&local_info_obstack);
          node_g->statics_written = BITMAP_ALLOC (&local_info_obstack);
          bitmap_copy (node_g->statics_written,
          bitmap_copy (node_g->statics_written,
                       node_l->statics_written);
                       node_l->statics_written);
        }
        }
 
 
      propagate_bits (node_g, node);
      propagate_bits (node_g, node);
      w_info = (struct ipa_dfs_info *) node->aux;
      w_info = (struct ipa_dfs_info *) node->aux;
      w = w_info->next_cycle;
      w = w_info->next_cycle;
      while (w && (!read_all || !write_all))
      while (w && (!read_all || !write_all))
        {
        {
          ipa_reference_vars_info_t w_ri =
          ipa_reference_vars_info_t w_ri =
            get_reference_vars_info (w);
            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;
          int flags = flags_from_decl_or_type (w->decl);
          int flags = flags_from_decl_or_type (w->decl);
 
 
          /* These global bitmaps are initialized from the local info
          /* These global bitmaps are initialized from the local info
             of all of the nodes in the region.  However there is no
             of all of the nodes in the region.  However there is no
             need to do any work if the bitmaps were set to
             need to do any work if the bitmaps were set to
             all_module_statics.  */
             all_module_statics.  */
          if (!read_all && !(flags & ECF_CONST))
          if (!read_all && !(flags & ECF_CONST))
            bitmap_ior_into (node_g->statics_read,
            bitmap_ior_into (node_g->statics_read,
                             w_l->statics_read);
                             w_l->statics_read);
          if (!write_all
          if (!write_all
              && !(flags & ECF_PURE)
              && !(flags & ECF_PURE)
              && !cgraph_node_cannot_return (w))
              && !cgraph_node_cannot_return (w))
            bitmap_ior_into (node_g->statics_written,
            bitmap_ior_into (node_g->statics_written,
                             w_l->statics_written);
                             w_l->statics_written);
          propagate_bits (node_g, w);
          propagate_bits (node_g, w);
          w_info = (struct ipa_dfs_info *) w->aux;
          w_info = (struct ipa_dfs_info *) w->aux;
          w = w_info->next_cycle;
          w = w_info->next_cycle;
        }
        }
 
 
      /* All nodes within a cycle have the same global info bitmaps.  */
      /* 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_info = (struct ipa_dfs_info *) node->aux;
      w = w_info->next_cycle;
      w = w_info->next_cycle;
      while (w)
      while (w)
        {
        {
          ipa_reference_vars_info_t w_ri =
          ipa_reference_vars_info_t w_ri =
            get_reference_vars_info (w);
            get_reference_vars_info (w);
 
 
          w_ri->global = *node_g;
          w_ri->global = *node_g;
 
 
          w_info = (struct ipa_dfs_info *) w->aux;
          w_info = (struct ipa_dfs_info *) w->aux;
          w = w_info->next_cycle;
          w = w_info->next_cycle;
        }
        }
    }
    }
 
 
  if (dump_file)
  if (dump_file)
    {
    {
      for (i = 0; i < order_pos; i++ )
      for (i = 0; i < order_pos; i++ )
        {
        {
          ipa_reference_vars_info_t node_info;
          ipa_reference_vars_info_t node_info;
          ipa_reference_global_vars_info_t node_g;
          ipa_reference_global_vars_info_t node_g;
          ipa_reference_local_vars_info_t node_l;
          ipa_reference_local_vars_info_t node_l;
          unsigned int index;
          unsigned int index;
          bitmap_iterator bi;
          bitmap_iterator bi;
          struct ipa_dfs_info * w_info;
          struct ipa_dfs_info * w_info;
 
 
          node = order[i];
          node = order[i];
          if (node->alias)
          if (node->alias)
            continue;
            continue;
          node_info = get_reference_vars_info (node);
          node_info = get_reference_vars_info (node);
          node_g = &node_info->global;
          node_g = &node_info->global;
          node_l = &node_info->local;
          node_l = &node_info->local;
          fprintf (dump_file,
          fprintf (dump_file,
                   "\nFunction name:%s/%i:",
                   "\nFunction name:%s/%i:",
                   cgraph_node_name (node), node->uid);
                   cgraph_node_name (node), node->uid);
          fprintf (dump_file, "\n  locals read: ");
          fprintf (dump_file, "\n  locals read: ");
          if (node_l->statics_read)
          if (node_l->statics_read)
            EXECUTE_IF_SET_IN_BITMAP (node_l->statics_read,
            EXECUTE_IF_SET_IN_BITMAP (node_l->statics_read,
                                      0, index, bi)
                                      0, index, bi)
              {
              {
                fprintf (dump_file, "%s ",
                fprintf (dump_file, "%s ",
                         get_static_name (index));
                         get_static_name (index));
              }
              }
          fprintf (dump_file, "\n  locals written: ");
          fprintf (dump_file, "\n  locals written: ");
          if (node_l->statics_written)
          if (node_l->statics_written)
            EXECUTE_IF_SET_IN_BITMAP (node_l->statics_written,
            EXECUTE_IF_SET_IN_BITMAP (node_l->statics_written,
                                      0, index, bi)
                                      0, index, bi)
              {
              {
                fprintf(dump_file, "%s ",
                fprintf(dump_file, "%s ",
                        get_static_name (index));
                        get_static_name (index));
              }
              }
 
 
          w_info = (struct ipa_dfs_info *) node->aux;
          w_info = (struct ipa_dfs_info *) node->aux;
          w = w_info->next_cycle;
          w = w_info->next_cycle;
          while (w)
          while (w)
            {
            {
              ipa_reference_vars_info_t w_ri =
              ipa_reference_vars_info_t w_ri =
                get_reference_vars_info (w);
                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 ",
              fprintf (dump_file, "\n  next cycle: %s/%i ",
                       cgraph_node_name (w), w->uid);
                       cgraph_node_name (w), w->uid);
              fprintf (dump_file, "\n    locals read: ");
              fprintf (dump_file, "\n    locals read: ");
              if (w_l->statics_read)
              if (w_l->statics_read)
                EXECUTE_IF_SET_IN_BITMAP (w_l->statics_read,
                EXECUTE_IF_SET_IN_BITMAP (w_l->statics_read,
                                          0, index, bi)
                                          0, index, bi)
                  {
                  {
                    fprintf (dump_file, "%s ",
                    fprintf (dump_file, "%s ",
                             get_static_name (index));
                             get_static_name (index));
                  }
                  }
 
 
              fprintf (dump_file, "\n    locals written: ");
              fprintf (dump_file, "\n    locals written: ");
              if (w_l->statics_written)
              if (w_l->statics_written)
                EXECUTE_IF_SET_IN_BITMAP (w_l->statics_written,
                EXECUTE_IF_SET_IN_BITMAP (w_l->statics_written,
                                          0, index, bi)
                                          0, index, bi)
                  {
                  {
                    fprintf (dump_file, "%s ",
                    fprintf (dump_file, "%s ",
                             get_static_name (index));
                             get_static_name (index));
                  }
                  }
 
 
              w_info = (struct ipa_dfs_info *) w->aux;
              w_info = (struct ipa_dfs_info *) w->aux;
              w = w_info->next_cycle;
              w = w_info->next_cycle;
            }
            }
          fprintf (dump_file, "\n  globals read: ");
          fprintf (dump_file, "\n  globals read: ");
          if (node_g->statics_read == all_module_statics)
          if (node_g->statics_read == all_module_statics)
            fprintf (dump_file, "ALL");
            fprintf (dump_file, "ALL");
          else
          else
            EXECUTE_IF_SET_IN_BITMAP (node_g->statics_read,
            EXECUTE_IF_SET_IN_BITMAP (node_g->statics_read,
                                      0, index, bi)
                                      0, index, bi)
              {
              {
                fprintf (dump_file, "%s ",
                fprintf (dump_file, "%s ",
                         get_static_name (index));
                         get_static_name (index));
              }
              }
          fprintf (dump_file, "\n  globals written: ");
          fprintf (dump_file, "\n  globals written: ");
          if (node_g->statics_written == all_module_statics)
          if (node_g->statics_written == all_module_statics)
            fprintf (dump_file, "ALL");
            fprintf (dump_file, "ALL");
          else
          else
            EXECUTE_IF_SET_IN_BITMAP (node_g->statics_written,
            EXECUTE_IF_SET_IN_BITMAP (node_g->statics_written,
                                      0, index, bi)
                                      0, index, bi)
              {
              {
                fprintf (dump_file, "%s ",
                fprintf (dump_file, "%s ",
                         get_static_name (index));
                         get_static_name (index));
              }
              }
        }
        }
    }
    }
 
 
  /* Cleanup. */
  /* Cleanup. */
  for (node = cgraph_nodes; node; node = node->next)
  for (node = cgraph_nodes; node; node = node->next)
    {
    {
      ipa_reference_vars_info_t node_info;
      ipa_reference_vars_info_t node_info;
      ipa_reference_global_vars_info_t node_g;
      ipa_reference_global_vars_info_t node_g;
      ipa_reference_optimization_summary_t opt;
      ipa_reference_optimization_summary_t opt;
 
 
      if (!node->analyzed || node->alias)
      if (!node->analyzed || node->alias)
        continue;
        continue;
 
 
      node_info = get_reference_vars_info (node);
      node_info = get_reference_vars_info (node);
      if (cgraph_function_body_availability (node) > AVAIL_OVERWRITABLE
      if (cgraph_function_body_availability (node) > AVAIL_OVERWRITABLE
          || (flags_from_decl_or_type (node->decl) & ECF_LEAF))
          || (flags_from_decl_or_type (node->decl) & ECF_LEAF))
        {
        {
          node_g = &node_info->global;
          node_g = &node_info->global;
 
 
          opt = XCNEW (struct ipa_reference_optimization_summary_d);
          opt = XCNEW (struct ipa_reference_optimization_summary_d);
          set_reference_optimization_summary (node, opt);
          set_reference_optimization_summary (node, opt);
 
 
          /* Create the complimentary sets.  */
          /* Create the complimentary sets.  */
 
 
          if (bitmap_empty_p (node_g->statics_read))
          if (bitmap_empty_p (node_g->statics_read))
            opt->statics_not_read = all_module_statics;
            opt->statics_not_read = all_module_statics;
          else
          else
            {
            {
              opt->statics_not_read
              opt->statics_not_read
                 = BITMAP_ALLOC (&optimization_summary_obstack);
                 = BITMAP_ALLOC (&optimization_summary_obstack);
              if (node_g->statics_read != all_module_statics)
              if (node_g->statics_read != all_module_statics)
                bitmap_and_compl (opt->statics_not_read,
                bitmap_and_compl (opt->statics_not_read,
                                  all_module_statics,
                                  all_module_statics,
                                  node_g->statics_read);
                                  node_g->statics_read);
            }
            }
 
 
          if (bitmap_empty_p (node_g->statics_written))
          if (bitmap_empty_p (node_g->statics_written))
            opt->statics_not_written = all_module_statics;
            opt->statics_not_written = all_module_statics;
          else
          else
            {
            {
              opt->statics_not_written
              opt->statics_not_written
                = BITMAP_ALLOC (&optimization_summary_obstack);
                = BITMAP_ALLOC (&optimization_summary_obstack);
              if (node_g->statics_written != all_module_statics)
              if (node_g->statics_written != all_module_statics)
                bitmap_and_compl (opt->statics_not_written,
                bitmap_and_compl (opt->statics_not_written,
                                  all_module_statics,
                                  all_module_statics,
                                  node_g->statics_written);
                                  node_g->statics_written);
            }
            }
        }
        }
      free (node_info);
      free (node_info);
   }
   }
 
 
  ipa_free_postorder_info ();
  ipa_free_postorder_info ();
  free (order);
  free (order);
 
 
  bitmap_obstack_release (&local_info_obstack);
  bitmap_obstack_release (&local_info_obstack);
  VEC_free (ipa_reference_vars_info_t, heap, ipa_reference_vars_vector);
  VEC_free (ipa_reference_vars_info_t, heap, ipa_reference_vars_vector);
  ipa_reference_vars_vector = NULL;
  ipa_reference_vars_vector = NULL;
  if (dump_file)
  if (dump_file)
    splay_tree_delete (reference_vars_to_consider);
    splay_tree_delete (reference_vars_to_consider);
  reference_vars_to_consider = NULL;
  reference_vars_to_consider = NULL;
  return 0;
  return 0;
}
}
 
 
/* Return true if we need to write summary of NODE. */
/* Return true if we need to write summary of NODE. */
 
 
static bool
static bool
write_node_summary_p (struct cgraph_node *node,
write_node_summary_p (struct cgraph_node *node,
                      cgraph_node_set set,
                      cgraph_node_set set,
                      varpool_node_set vset,
                      varpool_node_set vset,
                      bitmap ltrans_statics)
                      bitmap ltrans_statics)
{
{
  ipa_reference_optimization_summary_t info;
  ipa_reference_optimization_summary_t info;
 
 
  /* See if we have (non-empty) info.  */
  /* See if we have (non-empty) info.  */
  if (!node->analyzed || node->global.inlined_to)
  if (!node->analyzed || node->global.inlined_to)
    return false;
    return false;
  info = get_reference_optimization_summary (node);
  info = get_reference_optimization_summary (node);
  if (!info || (bitmap_empty_p (info->statics_not_read)
  if (!info || (bitmap_empty_p (info->statics_not_read)
                && bitmap_empty_p (info->statics_not_written)))
                && bitmap_empty_p (info->statics_not_written)))
    return false;
    return false;
 
 
  /* See if we want to encode it.
  /* See if we want to encode it.
     Encode also referenced functions since constant folding might turn it into
     Encode also referenced functions since constant folding might turn it into
     a direct call.
     a direct call.
 
 
     In future we might also want to include summaries of functions references
     In future we might also want to include summaries of functions references
     by initializers of constant variables references in current unit.  */
     by initializers of constant variables references in current unit.  */
  if (!reachable_from_this_partition_p (node, set)
  if (!reachable_from_this_partition_p (node, set)
      && !referenced_from_this_partition_p (&node->ref_list, set, vset))
      && !referenced_from_this_partition_p (&node->ref_list, set, vset))
    return false;
    return false;
 
 
  /* See if the info has non-empty intersections with vars we want to encode.  */
  /* See if the info has non-empty intersections with vars we want to encode.  */
  if (!bitmap_intersect_p (info->statics_not_read, ltrans_statics)
  if (!bitmap_intersect_p (info->statics_not_read, ltrans_statics)
      && !bitmap_intersect_p (info->statics_not_written, ltrans_statics))
      && !bitmap_intersect_p (info->statics_not_written, ltrans_statics))
    return false;
    return false;
  return true;
  return true;
}
}
 
 
/* Stream out BITS&LTRANS_STATICS as list of decls to OB.
/* Stream out BITS&LTRANS_STATICS as list of decls to OB.
   LTRANS_STATICS_BITCOUNT specify number of bits in LTRANS_STATICS
   LTRANS_STATICS_BITCOUNT specify number of bits in LTRANS_STATICS
   or -1.  When it is positive, just output -1 when
   or -1.  When it is positive, just output -1 when
   BITS&LTRANS_STATICS == BITS&LTRANS_STATICS.  */
   BITS&LTRANS_STATICS == BITS&LTRANS_STATICS.  */
 
 
static void
static void
stream_out_bitmap (struct lto_simple_output_block *ob,
stream_out_bitmap (struct lto_simple_output_block *ob,
                   bitmap bits, bitmap ltrans_statics,
                   bitmap bits, bitmap ltrans_statics,
                   int ltrans_statics_bitcount)
                   int ltrans_statics_bitcount)
{
{
  int count = 0;
  int count = 0;
  unsigned int index;
  unsigned int index;
  bitmap_iterator bi;
  bitmap_iterator bi;
  if (bits == all_module_statics)
  if (bits == all_module_statics)
    {
    {
      streamer_write_hwi_stream (ob->main_stream, -1);
      streamer_write_hwi_stream (ob->main_stream, -1);
      return;
      return;
    }
    }
  EXECUTE_IF_AND_IN_BITMAP (bits, ltrans_statics, 0, index, bi)
  EXECUTE_IF_AND_IN_BITMAP (bits, ltrans_statics, 0, index, bi)
    count ++;
    count ++;
  if (count == ltrans_statics_bitcount)
  if (count == ltrans_statics_bitcount)
    {
    {
      streamer_write_hwi_stream (ob->main_stream, -1);
      streamer_write_hwi_stream (ob->main_stream, -1);
      return;
      return;
    }
    }
  streamer_write_hwi_stream (ob->main_stream, count);
  streamer_write_hwi_stream (ob->main_stream, count);
  if (!count)
  if (!count)
    return;
    return;
  EXECUTE_IF_AND_IN_BITMAP (bits, ltrans_statics, 0, index, bi)
  EXECUTE_IF_AND_IN_BITMAP (bits, ltrans_statics, 0, index, bi)
    {
    {
      tree decl = (tree)splay_tree_lookup (reference_vars_to_consider, index)->value;
      tree decl = (tree)splay_tree_lookup (reference_vars_to_consider, index)->value;
      lto_output_var_decl_index(ob->decl_state, ob->main_stream, decl);
      lto_output_var_decl_index(ob->decl_state, ob->main_stream, decl);
    }
    }
}
}
 
 
/* Serialize the ipa info for lto.  */
/* Serialize the ipa info for lto.  */
 
 
static void
static void
ipa_reference_write_optimization_summary (cgraph_node_set set,
ipa_reference_write_optimization_summary (cgraph_node_set set,
                                          varpool_node_set vset)
                                          varpool_node_set vset)
{
{
  struct cgraph_node *node;
  struct cgraph_node *node;
  struct lto_simple_output_block *ob
  struct lto_simple_output_block *ob
    = lto_create_simple_output_block (LTO_section_ipa_reference);
    = lto_create_simple_output_block (LTO_section_ipa_reference);
  unsigned int count = 0;
  unsigned int count = 0;
  int ltrans_statics_bitcount = 0;
  int ltrans_statics_bitcount = 0;
  lto_cgraph_encoder_t encoder = ob->decl_state->cgraph_node_encoder;
  lto_cgraph_encoder_t encoder = ob->decl_state->cgraph_node_encoder;
  lto_varpool_encoder_t varpool_encoder = ob->decl_state->varpool_node_encoder;
  lto_varpool_encoder_t varpool_encoder = ob->decl_state->varpool_node_encoder;
  bitmap ltrans_statics = BITMAP_ALLOC (NULL);
  bitmap ltrans_statics = BITMAP_ALLOC (NULL);
  int i;
  int i;
 
 
  reference_vars_to_consider = splay_tree_new (splay_tree_compare_ints, 0, 0);
  reference_vars_to_consider = splay_tree_new (splay_tree_compare_ints, 0, 0);
 
 
  /* See what variables we are interested in.  */
  /* See what variables we are interested in.  */
  for (i = 0; i < lto_varpool_encoder_size (varpool_encoder); i++)
  for (i = 0; i < lto_varpool_encoder_size (varpool_encoder); i++)
    {
    {
      struct varpool_node *vnode = lto_varpool_encoder_deref (varpool_encoder, i);
      struct varpool_node *vnode = lto_varpool_encoder_deref (varpool_encoder, i);
      if (!vnode->externally_visible
      if (!vnode->externally_visible
          && vnode->analyzed
          && vnode->analyzed
          && bitmap_bit_p (all_module_statics, DECL_UID (vnode->decl))
          && bitmap_bit_p (all_module_statics, DECL_UID (vnode->decl))
          && referenced_from_this_partition_p (&vnode->ref_list, set, vset))
          && referenced_from_this_partition_p (&vnode->ref_list, set, vset))
        {
        {
          tree decl = vnode->decl;
          tree decl = vnode->decl;
          bitmap_set_bit (ltrans_statics, DECL_UID (decl));
          bitmap_set_bit (ltrans_statics, DECL_UID (decl));
          splay_tree_insert (reference_vars_to_consider,
          splay_tree_insert (reference_vars_to_consider,
                             DECL_UID (decl), (splay_tree_value)decl);
                             DECL_UID (decl), (splay_tree_value)decl);
          ltrans_statics_bitcount ++;
          ltrans_statics_bitcount ++;
        }
        }
    }
    }
 
 
 
 
  if (ltrans_statics_bitcount)
  if (ltrans_statics_bitcount)
    for (i = 0; i < lto_cgraph_encoder_size (encoder); i++)
    for (i = 0; i < lto_cgraph_encoder_size (encoder); i++)
      if (write_node_summary_p (lto_cgraph_encoder_deref (encoder, i),
      if (write_node_summary_p (lto_cgraph_encoder_deref (encoder, i),
                                set, vset, ltrans_statics))
                                set, vset, ltrans_statics))
          count++;
          count++;
 
 
  streamer_write_uhwi_stream (ob->main_stream, count);
  streamer_write_uhwi_stream (ob->main_stream, count);
  if (count)
  if (count)
    stream_out_bitmap (ob, ltrans_statics, ltrans_statics,
    stream_out_bitmap (ob, ltrans_statics, ltrans_statics,
                       -1);
                       -1);
 
 
  /* Process all of the functions.  */
  /* Process all of the functions.  */
  if (ltrans_statics_bitcount)
  if (ltrans_statics_bitcount)
    for (i = 0; i < lto_cgraph_encoder_size (encoder); i++)
    for (i = 0; i < lto_cgraph_encoder_size (encoder); i++)
      {
      {
        node = lto_cgraph_encoder_deref (encoder, i);
        node = lto_cgraph_encoder_deref (encoder, i);
        if (write_node_summary_p (node, set, vset, ltrans_statics))
        if (write_node_summary_p (node, set, vset, ltrans_statics))
          {
          {
            ipa_reference_optimization_summary_t info;
            ipa_reference_optimization_summary_t info;
            int node_ref;
            int node_ref;
 
 
            info = get_reference_optimization_summary (node);
            info = get_reference_optimization_summary (node);
            node_ref = lto_cgraph_encoder_encode (encoder, node);
            node_ref = lto_cgraph_encoder_encode (encoder, node);
            streamer_write_uhwi_stream (ob->main_stream, node_ref);
            streamer_write_uhwi_stream (ob->main_stream, node_ref);
 
 
            stream_out_bitmap (ob, info->statics_not_read, ltrans_statics,
            stream_out_bitmap (ob, info->statics_not_read, ltrans_statics,
                               ltrans_statics_bitcount);
                               ltrans_statics_bitcount);
            stream_out_bitmap (ob, info->statics_not_written, ltrans_statics,
            stream_out_bitmap (ob, info->statics_not_written, ltrans_statics,
                               ltrans_statics_bitcount);
                               ltrans_statics_bitcount);
          }
          }
      }
      }
  BITMAP_FREE (ltrans_statics);
  BITMAP_FREE (ltrans_statics);
  lto_destroy_simple_output_block (ob);
  lto_destroy_simple_output_block (ob);
  splay_tree_delete (reference_vars_to_consider);
  splay_tree_delete (reference_vars_to_consider);
}
}
 
 
/* Deserialize the ipa info for lto.  */
/* Deserialize the ipa info for lto.  */
 
 
static void
static void
ipa_reference_read_optimization_summary (void)
ipa_reference_read_optimization_summary (void)
{
{
  struct lto_file_decl_data ** file_data_vec
  struct lto_file_decl_data ** file_data_vec
    = lto_get_file_decl_data ();
    = lto_get_file_decl_data ();
  struct lto_file_decl_data * file_data;
  struct lto_file_decl_data * file_data;
  unsigned int j = 0;
  unsigned int j = 0;
  bitmap_obstack_initialize (&optimization_summary_obstack);
  bitmap_obstack_initialize (&optimization_summary_obstack);
 
 
  node_removal_hook_holder =
  node_removal_hook_holder =
      cgraph_add_node_removal_hook (&remove_node_data, NULL);
      cgraph_add_node_removal_hook (&remove_node_data, NULL);
  node_duplication_hook_holder =
  node_duplication_hook_holder =
      cgraph_add_node_duplication_hook (&duplicate_node_data, NULL);
      cgraph_add_node_duplication_hook (&duplicate_node_data, NULL);
  all_module_statics = BITMAP_ALLOC (&optimization_summary_obstack);
  all_module_statics = BITMAP_ALLOC (&optimization_summary_obstack);
 
 
  while ((file_data = file_data_vec[j++]))
  while ((file_data = file_data_vec[j++]))
    {
    {
      const char *data;
      const char *data;
      size_t len;
      size_t len;
      struct lto_input_block *ib
      struct lto_input_block *ib
        = lto_create_simple_input_block (file_data,
        = lto_create_simple_input_block (file_data,
                                         LTO_section_ipa_reference,
                                         LTO_section_ipa_reference,
                                         &data, &len);
                                         &data, &len);
      if (ib)
      if (ib)
        {
        {
          unsigned int i;
          unsigned int i;
          unsigned int f_count = streamer_read_uhwi (ib);
          unsigned int f_count = streamer_read_uhwi (ib);
          int b_count;
          int b_count;
          if (!f_count)
          if (!f_count)
            continue;
            continue;
          b_count = streamer_read_hwi (ib);
          b_count = streamer_read_hwi (ib);
          if (dump_file)
          if (dump_file)
            fprintf (dump_file, "all module statics:");
            fprintf (dump_file, "all module statics:");
          for (i = 0; i < (unsigned int)b_count; i++)
          for (i = 0; i < (unsigned int)b_count; i++)
            {
            {
              unsigned int var_index = streamer_read_uhwi (ib);
              unsigned int var_index = streamer_read_uhwi (ib);
              tree v_decl = lto_file_decl_data_get_var_decl (file_data,
              tree v_decl = lto_file_decl_data_get_var_decl (file_data,
                                                             var_index);
                                                             var_index);
              bitmap_set_bit (all_module_statics, DECL_UID (v_decl));
              bitmap_set_bit (all_module_statics, DECL_UID (v_decl));
              if (dump_file)
              if (dump_file)
                fprintf (dump_file, " %s",
                fprintf (dump_file, " %s",
                         lang_hooks.decl_printable_name (v_decl, 2));
                         lang_hooks.decl_printable_name (v_decl, 2));
            }
            }
 
 
          for (i = 0; i < f_count; i++)
          for (i = 0; i < f_count; i++)
            {
            {
              unsigned int j, index;
              unsigned int j, index;
              struct cgraph_node *node;
              struct cgraph_node *node;
              ipa_reference_optimization_summary_t info;
              ipa_reference_optimization_summary_t info;
              int v_count;
              int v_count;
              lto_cgraph_encoder_t encoder;
              lto_cgraph_encoder_t encoder;
 
 
              index = streamer_read_uhwi (ib);
              index = streamer_read_uhwi (ib);
              encoder = file_data->cgraph_node_encoder;
              encoder = file_data->cgraph_node_encoder;
              node = lto_cgraph_encoder_deref (encoder, index);
              node = lto_cgraph_encoder_deref (encoder, index);
              info = XCNEW (struct ipa_reference_optimization_summary_d);
              info = XCNEW (struct ipa_reference_optimization_summary_d);
              set_reference_optimization_summary (node, info);
              set_reference_optimization_summary (node, info);
              info->statics_not_read = BITMAP_ALLOC (&optimization_summary_obstack);
              info->statics_not_read = BITMAP_ALLOC (&optimization_summary_obstack);
              info->statics_not_written = BITMAP_ALLOC (&optimization_summary_obstack);
              info->statics_not_written = BITMAP_ALLOC (&optimization_summary_obstack);
              if (dump_file)
              if (dump_file)
                fprintf (dump_file,
                fprintf (dump_file,
                         "\nFunction name:%s/%i:\n  static not read:",
                         "\nFunction name:%s/%i:\n  static not read:",
                         cgraph_node_name (node), node->uid);
                         cgraph_node_name (node), node->uid);
 
 
              /* Set the statics not read.  */
              /* Set the statics not read.  */
              v_count = streamer_read_hwi (ib);
              v_count = streamer_read_hwi (ib);
              if (v_count == -1)
              if (v_count == -1)
                {
                {
                  info->statics_not_read = all_module_statics;
                  info->statics_not_read = all_module_statics;
                  if (dump_file)
                  if (dump_file)
                    fprintf (dump_file, " all module statics");
                    fprintf (dump_file, " all module statics");
                }
                }
              else
              else
                for (j = 0; j < (unsigned int)v_count; j++)
                for (j = 0; j < (unsigned int)v_count; j++)
                  {
                  {
                    unsigned int var_index = streamer_read_uhwi (ib);
                    unsigned int var_index = streamer_read_uhwi (ib);
                    tree v_decl = lto_file_decl_data_get_var_decl (file_data,
                    tree v_decl = lto_file_decl_data_get_var_decl (file_data,
                                                                   var_index);
                                                                   var_index);
                    bitmap_set_bit (info->statics_not_read, DECL_UID (v_decl));
                    bitmap_set_bit (info->statics_not_read, DECL_UID (v_decl));
                    if (dump_file)
                    if (dump_file)
                      fprintf (dump_file, " %s",
                      fprintf (dump_file, " %s",
                               lang_hooks.decl_printable_name (v_decl, 2));
                               lang_hooks.decl_printable_name (v_decl, 2));
                  }
                  }
 
 
              if (dump_file)
              if (dump_file)
                fprintf (dump_file,
                fprintf (dump_file,
                         "\n  static not written:");
                         "\n  static not written:");
              /* Set the statics not written.  */
              /* Set the statics not written.  */
              v_count = streamer_read_hwi (ib);
              v_count = streamer_read_hwi (ib);
              if (v_count == -1)
              if (v_count == -1)
                {
                {
                  info->statics_not_written = all_module_statics;
                  info->statics_not_written = all_module_statics;
                  if (dump_file)
                  if (dump_file)
                    fprintf (dump_file, " all module statics");
                    fprintf (dump_file, " all module statics");
                }
                }
              else
              else
                for (j = 0; j < (unsigned int)v_count; j++)
                for (j = 0; j < (unsigned int)v_count; j++)
                  {
                  {
                    unsigned int var_index = streamer_read_uhwi (ib);
                    unsigned int var_index = streamer_read_uhwi (ib);
                    tree v_decl = lto_file_decl_data_get_var_decl (file_data,
                    tree v_decl = lto_file_decl_data_get_var_decl (file_data,
                                                                   var_index);
                                                                   var_index);
                    bitmap_set_bit (info->statics_not_written, DECL_UID (v_decl));
                    bitmap_set_bit (info->statics_not_written, DECL_UID (v_decl));
                    if (dump_file)
                    if (dump_file)
                      fprintf (dump_file, " %s",
                      fprintf (dump_file, " %s",
                               lang_hooks.decl_printable_name (v_decl, 2));
                               lang_hooks.decl_printable_name (v_decl, 2));
                  }
                  }
              if (dump_file)
              if (dump_file)
                fprintf (dump_file, "\n");
                fprintf (dump_file, "\n");
            }
            }
 
 
          lto_destroy_simple_input_block (file_data,
          lto_destroy_simple_input_block (file_data,
                                          LTO_section_ipa_reference,
                                          LTO_section_ipa_reference,
                                          ib, data, len);
                                          ib, data, len);
        }
        }
      else
      else
        /* Fatal error here.  We do not want to support compiling ltrans units with
        /* 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
           different version of compiler or different flags than the WPA unit, so
           this should never happen.  */
           this should never happen.  */
        fatal_error ("ipa reference summary is missing in ltrans unit");
        fatal_error ("ipa reference summary is missing in ltrans unit");
    }
    }
}
}
 
 
static bool
static bool
gate_reference (void)
gate_reference (void)
{
{
  return (flag_ipa_reference
  return (flag_ipa_reference
          /* Don't bother doing anything if the program has errors.  */
          /* Don't bother doing anything if the program has errors.  */
          && !seen_error ());
          && !seen_error ());
}
}
 
 
struct ipa_opt_pass_d pass_ipa_reference =
struct ipa_opt_pass_d pass_ipa_reference =
{
{
 {
 {
  IPA_PASS,
  IPA_PASS,
  "static-var",                         /* name */
  "static-var",                         /* name */
  gate_reference,                       /* gate */
  gate_reference,                       /* gate */
  propagate,                            /* execute */
  propagate,                            /* execute */
  NULL,                                 /* sub */
  NULL,                                 /* sub */
  NULL,                                 /* next */
  NULL,                                 /* next */
  0,                                     /* static_pass_number */
  0,                                     /* static_pass_number */
  TV_IPA_REFERENCE,                     /* tv_id */
  TV_IPA_REFERENCE,                     /* tv_id */
  0,                                     /* properties_required */
  0,                                     /* properties_required */
  0,                                     /* properties_provided */
  0,                                     /* properties_provided */
  0,                                     /* properties_destroyed */
  0,                                     /* properties_destroyed */
  0,                                     /* todo_flags_start */
  0,                                     /* todo_flags_start */
  0                                     /* todo_flags_finish */
  0                                     /* todo_flags_finish */
 },
 },
 NULL,                                  /* generate_summary */
 NULL,                                  /* generate_summary */
 NULL,                                  /* write_summary */
 NULL,                                  /* write_summary */
 NULL,                                  /* read_summary */
 NULL,                                  /* read_summary */
 ipa_reference_write_optimization_summary,/* write_optimization_summary */
 ipa_reference_write_optimization_summary,/* write_optimization_summary */
 ipa_reference_read_optimization_summary,/* read_optimization_summary */
 ipa_reference_read_optimization_summary,/* read_optimization_summary */
 NULL,                                  /* stmt_fixup */
 NULL,                                  /* stmt_fixup */
 0,                                      /* TODOs */
 0,                                      /* TODOs */
 NULL,                                  /* function_transform */
 NULL,                                  /* function_transform */
 NULL                                   /* variable_transform */
 NULL                                   /* variable_transform */
};
};
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.