path: root/contrib/gcc/ipa-reference.c

/* Callgraph based analysis of static variables.
   Copyright (C) 2004, 2005 Free Software Foundation, Inc.
   Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>

This file is part of GCC.

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
Software Foundation; either version 2, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING.  If not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.  
*/

/* This file gathers information about how variables whose scope is
   confined to the compilation unit are used.  

   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.

   First each function and static variable initialization is analyzed
   to determine which local static variables are either read, written,
   or have their address taken.  Any local static that has its address
   taken is removed from consideration.  Once the local read and
   writes are determined, a transitive closure of this information is
   performed over the call graph to determine the worst case set of
   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.
   
   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"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "tree-flow.h"
#include "tree-inline.h"
#include "tree-pass.h"
#include "langhooks.h"
#include "pointer-set.h"
#include "ggc.h"
#include "ipa-utils.h"
#include "ipa-reference.h"
#include "c-common.h"
#include "tree-gimple.h"
#include "cgraph.h"
#include "output.h"
#include "flags.h"
#include "timevar.h"
#include "diagnostic.h"
#include "langhooks.h"

/* This splay tree contains all of the static variables that are
   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;

static bitmap_obstack ipa_obstack;

enum initialization_status_t
{
  UNINITIALIZED,
  RUNNING,
  FINISHED
};

tree memory_identifier_string;

/* Return the ipa_reference_vars structure starting from the cgraph NODE.  */
static inline ipa_reference_vars_info_t
get_reference_vars_info_from_cgraph (struct cgraph_node * node)
{
  return get_function_ann (node->decl)->reference_vars_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 (tree fn) 
{
  ipa_reference_vars_info_t info = get_function_ann (fn)->reference_vars_info;

  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 (tree fn) 
{
  ipa_reference_vars_info_t info = get_function_ann (fn)->reference_vars_info;

  if (info)
    return info->global;
  else
    /* This phase was not run.  */ 
    return NULL;
}

/* Return a bitmap indexed by VAR_DECL uid for the static variables
   that may be read locally by the execution of the function fn.
   Returns NULL if no data is available.  */

bitmap 
ipa_reference_get_read_local (tree fn)
{
  ipa_reference_local_vars_info_t l = get_local_reference_vars_info (fn);
  if (l) 
    return l->statics_read;
  else
    return NULL;
}

/* Return a bitmap indexed by VAR_DECL uid for the static variables
   that may be written locally by the execution of the function fn.
   Returns NULL if no data is available.  */

bitmap 
ipa_reference_get_written_local (tree fn)
{
  ipa_reference_local_vars_info_t l = get_local_reference_vars_info (fn);
  if (l) 
    return l->statics_written;
  else
    return NULL;
}

/* 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 (tree fn) 
{
  ipa_reference_global_vars_info_t g = get_global_reference_vars_info (fn);
  if (g) 
    return g->statics_read;
  else
    return NULL;
}

/* 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 (tree fn) 
{
  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
   that are not read during the execution of the function FN.  Returns
   NULL if no data is available.  */

bitmap 
ipa_reference_get_not_read_global (tree fn) 
{
  ipa_reference_global_vars_info_t g = get_global_reference_vars_info (fn);
  if (g) 
    return g->statics_not_read;
  else
    return NULL;
}

/* 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 variables written may or may not be read during the function
   call.  Returns NULL if no data is available.  */

bitmap 
ipa_reference_get_not_written_global (tree fn) 
{
  ipa_reference_global_vars_info_t g = get_global_reference_vars_info (fn);
  if (g) 
    return g->statics_not_written;
  else
    return NULL;
}



/* Add VAR to all_module_statics and the two
   reference_vars_to_consider* sets.  */

static inline void 
add_static_var (tree var) 
{
  int uid = DECL_UID (var);
  if (!bitmap_bit_p (all_module_statics, uid))
    {
      splay_tree_insert (reference_vars_to_consider,
			 uid, (splay_tree_value)var);
      bitmap_set_bit (all_module_statics, uid);
    }
}

/* Return true if the variable T is the right kind of static variable to
   perform compilation unit scope escape analysis.  */

static inline bool 
has_proper_scope_for_analysis (tree t)
{
  /* If the variable has the "used" attribute, treat it as if it had a
     been touched by the devil.  */
  if (lookup_attribute ("used", DECL_ATTRIBUTES (t)))
    return false;

  /* Do not want to do anything with volatile except mark any
     function that uses one to be not const or pure.  */
  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;

  if (DECL_EXTERNAL (t) || TREE_PUBLIC (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 (!bitmap_bit_p (all_module_statics, DECL_UID (t)))
    add_static_var (t);

  return true;
}

/* If T is a VAR_DECL for a static that we are interested in, add the
   uid to the bitmap.  */

static void
check_operand (ipa_reference_local_vars_info_t local, 
	       tree t, bool checking_write)
{
  if (!t) return;

  if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == FUNCTION_DECL)
      && (has_proper_scope_for_analysis (t))) 
    {
      if (checking_write)
	{
	  if (local)
	    bitmap_set_bit (local->statics_written, DECL_UID (t));
	  /* Mark the write so we can tell which statics are
	     readonly.  */
	  bitmap_set_bit (module_statics_written, DECL_UID (t));
	}
      else if (local)
	bitmap_set_bit (local->statics_read, DECL_UID (t));
    }
}

/* Examine tree T for references to static variables. All internal
   references like array references or indirect references are added
   to the READ_BM. Direct references are added to either READ_BM or
   WRITE_BM depending on the value of CHECKING_WRITE.   */

static void
check_tree (ipa_reference_local_vars_info_t local, tree t, bool checking_write)
{
  if ((TREE_CODE (t) == EXC_PTR_EXPR) || (TREE_CODE (t) == FILTER_EXPR))
    return;

  while (TREE_CODE (t) == REALPART_EXPR 
	 || TREE_CODE (t) == IMAGPART_EXPR
	 || handled_component_p (t))
    {
      if (TREE_CODE (t) == ARRAY_REF)
	check_operand (local, TREE_OPERAND (t, 1), false);
      t = TREE_OPERAND (t, 0);
    }

  /* The bottom of an indirect reference can only be read, not
     written.  So just recurse and whatever we find, check it against
     the read bitmaps.  */

  /*  if (INDIRECT_REF_P (t) || TREE_CODE (t) == MEM_REF) */
  /* FIXME when we have array_ref's of pointers.  */
  if (INDIRECT_REF_P (t))
    check_tree (local, TREE_OPERAND (t, 0), false);

  if (SSA_VAR_P (t))
    check_operand (local, t, checking_write);
}

/* Scan tree T to see if there are any addresses taken in within T.  */

static void 
look_for_address_of (tree t)
{
  if (TREE_CODE (t) == ADDR_EXPR)
    {
      tree x = get_base_var (t);
      if (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == FUNCTION_DECL) 
	if (has_proper_scope_for_analysis (x))
	  bitmap_set_bit (module_statics_escape, DECL_UID (x));
    }
}

/* Check to see if T is a read or address of operation on a static var
   we are interested in analyzing.  LOCAL is passed in to get access
   to its bit vectors.  Local is NULL if this is called from a static
   initializer.  */

static void
check_rhs_var (ipa_reference_local_vars_info_t local, tree t)
{
  look_for_address_of (t);

  if (local == NULL) 
    return;

  check_tree(local, t, false);
}

/* Check to see if T is an assignment to a static var we are
   interested in analyzing.  LOCAL is passed in to get access to its bit
   vectors.  */

static void
check_lhs_var (ipa_reference_local_vars_info_t local, tree t)
{
  if (local == NULL) 
    return;
   
  check_tree(local, t, true);
}

/* This is a scaled down version of get_asm_expr_operands from
   tree_ssa_operands.c.  The version there runs much later and assumes
   that aliasing information is already available. Here we are just
   trying to find if the set of inputs and outputs contain references
   or address of operations to local static variables.  FN is the
   function being analyzed and STMT is the actual asm statement.  */

static void
get_asm_expr_operands (ipa_reference_local_vars_info_t local, tree stmt)
{
  int noutputs = list_length (ASM_OUTPUTS (stmt));
  const char **oconstraints
    = (const char **) alloca ((noutputs) * sizeof (const char *));
  int i;
  tree link;
  const char *constraint;
  bool allows_mem, allows_reg, is_inout;
  
  for (i=0, link = ASM_OUTPUTS (stmt); link; ++i, link = TREE_CHAIN (link))
    {
      oconstraints[i] = constraint
	= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
      parse_output_constraint (&constraint, i, 0, 0,
			       &allows_mem, &allows_reg, &is_inout);
      
      check_lhs_var (local, TREE_VALUE (link));
    }

  for (link = ASM_INPUTS (stmt); link; link = TREE_CHAIN (link))
    {
      constraint
	= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
      parse_input_constraint (&constraint, 0, 0, noutputs, 0,
			      oconstraints, &allows_mem, &allows_reg);
      
      check_rhs_var (local, TREE_VALUE (link));
    }
  
  for (link = ASM_CLOBBERS (stmt); link; link = TREE_CHAIN (link))
    if (simple_cst_equal(TREE_VALUE (link), memory_identifier_string) == 1) 
      {
	/* Abandon all hope, ye who enter here. */
	local->calls_read_all = true;
	local->calls_write_all = true;
      }      
}

/* Check the parameters of a function call from CALLER to CALL_EXPR to
   see if any of them are static vars.  Also check to see if this is
   either an indirect call, a call outside the compilation unit, or
   has special attributes that effect the clobbers.  The caller
   parameter is the tree node for the caller and the second operand is
   the tree node for the entire call expression.  */

static void
check_call (ipa_reference_local_vars_info_t local, tree call_expr) 
{
  int flags = call_expr_flags (call_expr);
  tree operand_list = TREE_OPERAND (call_expr, 1);
  tree operand;
  tree callee_t = get_callee_fndecl (call_expr);
  enum availability avail = AVAIL_NOT_AVAILABLE;

  for (operand = operand_list;
       operand != NULL_TREE;
       operand = TREE_CHAIN (operand))
    {
      tree argument = TREE_VALUE (operand);
      check_rhs_var (local, argument);
    }

  if (callee_t)
    {
      struct cgraph_node* callee = cgraph_node(callee_t);
      avail = cgraph_function_body_availability (callee);
    }

  if (avail == AVAIL_NOT_AVAILABLE || avail == AVAIL_OVERWRITABLE)
    if (local) 
      {
	if (flags & ECF_PURE) 
	  local->calls_read_all = true;
	else 
	  {
	    local->calls_read_all = true;
	    local->calls_write_all = true;
	  }
      }
}

/* TP is the part of the tree currently under the microscope.
   WALK_SUBTREES is part of the walk_tree api but is unused here.
   DATA is cgraph_node of the function being walked.  */

/* FIXME: When this is converted to run over SSA form, this code
   should be converted to use the operand scanner.  */

static tree
scan_for_static_refs (tree *tp, 
		      int *walk_subtrees, 
		      void *data)
{
  struct cgraph_node *fn = data;
  tree t = *tp;
  ipa_reference_local_vars_info_t local = NULL;
  if (fn)
    local = get_reference_vars_info_from_cgraph (fn)->local;

  switch (TREE_CODE (t))  
    {
    case VAR_DECL:
      if (DECL_INITIAL (t))
	walk_tree (&DECL_INITIAL (t), scan_for_static_refs, fn, visited_nodes);
      *walk_subtrees = 0;
      break;

    case MODIFY_EXPR:
      {
	/* First look on the lhs and see what variable is stored to */
	tree lhs = TREE_OPERAND (t, 0);
	tree rhs = TREE_OPERAND (t, 1);
	check_lhs_var (local, lhs);

	/* For the purposes of figuring out what the cast affects */

	/* Next check the operands on the rhs to see if they are ok. */
	switch (TREE_CODE_CLASS (TREE_CODE (rhs))) 
	  {
	  case tcc_binary:	    
	  case tcc_comparison:	    
 	    {
 	      tree op0 = TREE_OPERAND (rhs, 0);
 	      tree op1 = TREE_OPERAND (rhs, 1);
 	      check_rhs_var (local, op0);
 	      check_rhs_var (local, op1);
	    }
	    break;
	  case tcc_unary:
 	    {
 	      tree op0 = TREE_OPERAND (rhs, 0);
 	      check_rhs_var (local, op0);
 	    }

	    break;
	  case tcc_reference:
	    check_rhs_var (local, rhs);
	    break;
	  case tcc_declaration:
	    check_rhs_var (local, rhs);
	    break;
	  case tcc_expression:
	    switch (TREE_CODE (rhs)) 
	      {
	      case ADDR_EXPR:
		check_rhs_var (local, rhs);
		break;
	      case CALL_EXPR: 
		check_call (local, rhs);
		break;
	      default:
		break;
	      }
	    break;
	  default:
	    break;
	  }
	*walk_subtrees = 0;
      }
      break;

    case ADDR_EXPR:
      /* This case is here to find addresses on rhs of constructors in
	 decl_initial of static variables. */
      check_rhs_var (local, t);
      *walk_subtrees = 0;
      break;

    case LABEL_EXPR:
      if (DECL_NONLOCAL (TREE_OPERAND (t, 0)))
	{
	  /* Target of long jump. */
	  local->calls_read_all = true;
	  local->calls_write_all = true;
	}
      break;

    case CALL_EXPR: 
      check_call (local, t);
      *walk_subtrees = 0;
      break;
      
    case ASM_EXPR:
      get_asm_expr_operands (local, t);
      *walk_subtrees = 0;
      break;
      
    default:
      break;
    }
  return NULL;
}


/* Lookup the tree node for the static variable that has UID.  */
static tree
get_static_decl (int index)
{
  splay_tree_node stn = 
    splay_tree_lookup (reference_vars_to_consider, index);
  if (stn)
    return (tree)stn->value;
  return NULL;
}

/* Lookup the tree node for the static variable that has UID and
   convert the name to a string for debugging.  */

static const char *
get_static_name (int index)
{
  splay_tree_node stn = 
    splay_tree_lookup (reference_vars_to_consider, index);
  if (stn)
    return lang_hooks.decl_printable_name ((tree)(stn->value), 2);
  return NULL;
}

/* Or in all of the bits from every callee into X, the caller's, bit
   vector.  There are several cases to check to avoid the sparse
   bitmap oring.  */

static void
propagate_bits (struct cgraph_node *x)
{
  ipa_reference_vars_info_t x_info = get_reference_vars_info_from_cgraph (x);
  ipa_reference_global_vars_info_t x_global = x_info->global;

  struct cgraph_edge *e;
  for (e = x->callees; e; e = e->next_callee) 
    {
      struct cgraph_node *y = e->callee;

      /* Only look at the master nodes and skip external nodes.  */
      y = cgraph_master_clone (y);
      if (y)
	{
	  if (get_reference_vars_info_from_cgraph (y))
	    {
	      ipa_reference_vars_info_t y_info = get_reference_vars_info_from_cgraph (y);
	      ipa_reference_global_vars_info_t y_global = y_info->global;
	      
	      if (x_global->statics_read
		  != all_module_statics)
		{
		  if (y_global->statics_read 
		      == all_module_statics)
		    {
		      BITMAP_FREE (x_global->statics_read);
		      x_global->statics_read 
			= all_module_statics;
		    }
		  /* Skip bitmaps that are pointer equal to node's bitmap
		     (no reason to spin within the cycle).  */
		  else if (x_global->statics_read 
			   != y_global->statics_read)
		    bitmap_ior_into (x_global->statics_read,
				     y_global->statics_read);
		}
	      
	      if (x_global->statics_written 
		  != all_module_statics)
		{
		  if (y_global->statics_written 
		      == all_module_statics)
		    {
		      BITMAP_FREE (x_global->statics_written);
		      x_global->statics_written 
			= all_module_statics;
		    }
		  /* Skip bitmaps that are pointer equal to node's bitmap
		     (no reason to spin within the cycle).  */
		  else if (x_global->statics_written 
			   != y_global->statics_written)
		    bitmap_ior_into (x_global->statics_written,
				     y_global->statics_written);
		}
	    }
	  else 
	    {
	      gcc_unreachable ();
	    }
	}
    }
}

/* Look at all of the callees of X to see which ones represent inlined
   calls.  For each of these callees, merge their local info into
   TARGET and check their children recursively.  

   This function goes away when Jan changes the inliner and IPA
   analysis so that this is not run between the time when inlining
   decisions are made and when the inlining actually occurs.  */

static void 
merge_callee_local_info (struct cgraph_node *target, 
			 struct cgraph_node *x)
{
  struct cgraph_edge *e;
  ipa_reference_local_vars_info_t x_l = 
    get_reference_vars_info_from_cgraph (target)->local;

  /* Make the world safe for tail recursion.  */
  struct ipa_dfs_info *node_info = x->aux;
  
  if (node_info->aux) 
    return;

  node_info->aux = x;

  for (e = x->callees; e; e = e->next_callee) 
    {
      struct cgraph_node *y = e->callee;
      if (y->global.inlined_to) 
	{
	  ipa_reference_vars_info_t y_info;
	  ipa_reference_local_vars_info_t y_l;
	  struct cgraph_node* orig_y = y;
	 
	  y = cgraph_master_clone (y);
	  if (y)
	    {
	      y_info = get_reference_vars_info_from_cgraph (y);
	      y_l = y_info->local;
	      if (x_l != y_l)
		{
		  bitmap_ior_into (x_l->statics_read,
				   y_l->statics_read);
		  bitmap_ior_into (x_l->statics_written,
				   y_l->statics_written);
		}
	      x_l->calls_read_all |= y_l->calls_read_all;
	      x_l->calls_write_all |= y_l->calls_write_all;
	      merge_callee_local_info (target, y);
	    }
	  else 
	    {
	      fprintf(stderr, "suspect inlining of ");
	      dump_cgraph_node (stderr, orig_y);
	      fprintf(stderr, "\ninto ");
	      dump_cgraph_node (stderr, target);
	      dump_cgraph (stderr);
	      gcc_assert(false);
	    }
	}
    }

  node_info->aux = NULL;
}

/* The init routine for analyzing global static variable usage.  See
   comments at top for description.  */
static void 
ipa_init (void) 
{
  struct cgraph_node *node;
  memory_identifier_string = build_string(7, "memory");

  reference_vars_to_consider =
    splay_tree_new_ggc (splay_tree_compare_ints);

  bitmap_obstack_initialize (&ipa_obstack);
  module_statics_escape = BITMAP_ALLOC (&ipa_obstack);
  module_statics_written = BITMAP_ALLOC (&ipa_obstack);
  all_module_statics = BITMAP_ALLOC (&ipa_obstack);

  /* This will add NODE->DECL to the splay trees.  */
  for (node = cgraph_nodes; node; node = node->next)
    has_proper_scope_for_analysis (node->decl);

  /* 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 ();
}

/* 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 cgraph_varpool_node *vnode)
{
  tree global = vnode->decl;
  if (TREE_CODE (global) == VAR_DECL)
    {
      if (DECL_INITIAL (global)) 
	walk_tree (&DECL_INITIAL (global), scan_for_static_refs, 
		   NULL, visited_nodes);
    } 
  else gcc_unreachable ();
}

/* This is the main routine for finding the reference patterns for
   global variables within a function FN.  */

static void
analyze_function (struct cgraph_node *fn)
{
  ipa_reference_vars_info_t info 
    = xcalloc (1, sizeof (struct ipa_reference_vars_info_d));
  ipa_reference_local_vars_info_t l
    = xcalloc (1, sizeof (struct ipa_reference_local_vars_info_d));
  tree decl = fn->decl;

  /* Add the info to the tree's annotation.  */
  get_function_ann (fn->decl)->reference_vars_info = info;

  info->local = l;
  l->statics_read = BITMAP_ALLOC (&ipa_obstack);
  l->statics_written = BITMAP_ALLOC (&ipa_obstack);

  if (dump_file)
    fprintf (dump_file, "\n local analysis of %s\n", cgraph_node_name (fn));
  
  {
    struct function *this_cfun = DECL_STRUCT_FUNCTION (decl);
    basic_block this_block;

    FOR_EACH_BB_FN (this_block, this_cfun)
      {
	block_stmt_iterator bsi;
	for (bsi = bsi_start (this_block); !bsi_end_p (bsi); bsi_next (&bsi))
	  walk_tree (bsi_stmt_ptr (bsi), scan_for_static_refs, 
		     fn, visited_nodes);
      }
  }

  /* There may be const decls with interesting right hand sides.  */
  if (DECL_STRUCT_FUNCTION (decl))
    {
      tree step;
      for (step = DECL_STRUCT_FUNCTION (decl)->unexpanded_var_list;
	   step;
	   step = TREE_CHAIN (step))
	{
	  tree var = TREE_VALUE (step);
	  if (TREE_CODE (var) == VAR_DECL 
	      && DECL_INITIAL (var)
	      && !TREE_STATIC (var))
	    walk_tree (&DECL_INITIAL (var), scan_for_static_refs, 
		       fn, visited_nodes);
	}
    }
}

/* If FN is avail == AVAIL_OVERWRITABLE, replace the effects bit
   vectors with worst case bit vectors.  We had to analyze it above to
   find out if it took the address of any statics. However, now that
   we know that, we can get rid of all of the other side effects.  */

static void
clean_function (struct cgraph_node *fn)
{
  ipa_reference_vars_info_t info = get_reference_vars_info_from_cgraph (fn);
  ipa_reference_local_vars_info_t l = info->local;
  ipa_reference_global_vars_info_t g = info->global;
  
  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);
    }
  
  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);
    }

  
  free (get_function_ann (fn->decl)->reference_vars_info);
  get_function_ann (fn->decl)->reference_vars_info = NULL;
}


/* Produce the global information by preforming a transitive closure
   on the local information that was produced by ipa_analyze_function
   and ipa_analyze_variable.  */

static unsigned int
static_execute (void)
{
  struct cgraph_node *node;
  struct cgraph_varpool_node *vnode;
  struct cgraph_node *w;
  struct cgraph_node **order =
    xcalloc (cgraph_n_nodes, sizeof (struct cgraph_node *));
  int order_pos = order_pos = ipa_utils_reduced_inorder (order, false, true);
  int i;

  ipa_init ();

  /* Process all of the variables first.  */
  for (vnode = cgraph_varpool_nodes_queue; vnode; vnode = vnode->next_needed)
    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 
	&& (cgraph_is_master_clone (node)
	    || (cgraph_function_body_availability (node) 
		== AVAIL_OVERWRITABLE)))
      analyze_function (node);

  pointer_set_destroy (visited_nodes);
  visited_nodes = NULL;
  if (dump_file) 
    dump_cgraph (dump_file);

  /* Prune out the variables that were found to behave badly
     (i.e. have their address taken).  */
  {
    unsigned int index;
    bitmap_iterator bi;
    bitmap module_statics_readonly = BITMAP_ALLOC (&ipa_obstack);
    bitmap module_statics_const = BITMAP_ALLOC (&ipa_obstack);
    bitmap bm_temp = BITMAP_ALLOC (&ipa_obstack);

    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);

	/* Readonly on a function decl is very different from the
	   variable.  */
	if (TREE_CODE (var) == FUNCTION_DECL)
	  continue;

	/* 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));
	  }
	if (DECL_INITIAL (var)
	    && is_gimple_min_invariant (DECL_INITIAL (var)))
	  {
 	    bitmap_set_bit (module_statics_const, index);
	    if (dump_file)
	      fprintf (dump_file, "read-only constant %s\n",
		       get_static_name (index));
	  }
      }

    BITMAP_FREE(module_statics_escape);
    BITMAP_FREE(module_statics_written);

    if (dump_file)
      EXECUTE_IF_SET_IN_BITMAP (all_module_statics, 0, index, bi)
	{
	  fprintf (dump_file, "\nPromotable global:%s",
		   get_static_name (index));
	}

    for (i = 0; i < order_pos; i++ )
      {
	ipa_reference_local_vars_info_t l;
	node = order[i];
	l = get_reference_vars_info_from_cgraph (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.  */
	bitmap_and_into (l->statics_read, 
		         all_module_statics);
	bitmap_and_into (l->statics_written, 
		         all_module_statics);
      }

    BITMAP_FREE(module_statics_readonly);
    BITMAP_FREE(module_statics_const);
    BITMAP_FREE(bm_temp);
  }

  if (dump_file)
    {
      for (i = 0; i < order_pos; i++ )
	{
	  unsigned int index;
	  ipa_reference_local_vars_info_t l;
	  bitmap_iterator bi;

	  node = order[i];
	  l = get_reference_vars_info_from_cgraph (node)->local;
	  fprintf (dump_file, 
		   "\nFunction name:%s/%i:", 
		   cgraph_node_name (node), node->uid);
	  fprintf (dump_file, "\n  locals read: ");
	  EXECUTE_IF_SET_IN_BITMAP (l->statics_read,
				    0, index, bi)
	    {
	      fprintf (dump_file, "%s ",
		       get_static_name (index));
	    }
	  fprintf (dump_file, "\n  locals written: ");
	  EXECUTE_IF_SET_IN_BITMAP (l->statics_written,
				    0, index, bi)
	    {
	      fprintf(dump_file, "%s ",
		      get_static_name (index));
	    }
	}
    }

  /* 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
     propagation in one pass from the leaves to the roots.  */
  order_pos = ipa_utils_reduced_inorder (order, true, true);
  if (dump_file)
    ipa_utils_print_order(dump_file, "reduced", order, order_pos);

  for (i = 0; i < order_pos; i++ )
    {
      ipa_reference_vars_info_t node_info;
      ipa_reference_global_vars_info_t node_g = 
	xcalloc (1, sizeof (struct ipa_reference_global_vars_info_d));
      ipa_reference_local_vars_info_t node_l;
      
      bool read_all;
      bool write_all;
      struct ipa_dfs_info * w_info;

      node = order[i];
      node_info = get_reference_vars_info_from_cgraph (node);
      if (!node_info) 
	{
	  dump_cgraph_node (stderr, node);
	  dump_cgraph (stderr);
	  gcc_unreachable ();
	}

      node_info->global = node_g;
      node_l = node_info->local;

      read_all = node_l->calls_read_all;
      write_all = node_l->calls_write_all;

      /* If any node in a cycle is calls_read_all or calls_write_all
	 they all are. */
      w_info = node->aux;
      w = w_info->next_cycle;
      while (w)
	{
	  ipa_reference_local_vars_info_t w_l = 
	    get_reference_vars_info_from_cgraph (w)->local;
	  read_all |= w_l->calls_read_all;
	  write_all |= w_l->calls_write_all;

	  w_info = w->aux;
	  w = w_info->next_cycle;
	}

      /* Initialized the bitmaps for the reduced nodes */
      if (read_all) 
	node_g->statics_read = all_module_statics;
      else 
	{
	  node_g->statics_read = BITMAP_ALLOC (&ipa_obstack);
	  bitmap_copy (node_g->statics_read, 
		       node_l->statics_read);
	}

      if (write_all) 
	node_g->statics_written = all_module_statics;
      else
	{
	  node_g->statics_written = BITMAP_ALLOC (&ipa_obstack);
	  bitmap_copy (node_g->statics_written, 
		       node_l->statics_written);
	}

      w_info = node->aux;
      w = w_info->next_cycle;
      while (w)
	{
	  ipa_reference_vars_info_t w_ri = 
	    get_reference_vars_info_from_cgraph (w);
	  ipa_reference_local_vars_info_t w_l = w_ri->local;

	  /* All nodes within a cycle share the same global info bitmaps.  */
	  w_ri->global = node_g;
	  
	  /* These global bitmaps are initialized from the local info
	     of all of the nodes in the region.  However there is no
	     need to do any work if the bitmaps were set to
	     all_module_statics.  */
	  if (!read_all)
	    bitmap_ior_into (node_g->statics_read,
			     w_l->statics_read);
	  if (!write_all)
	    bitmap_ior_into (node_g->statics_written,
			     w_l->statics_written);
	  w_info = w->aux;
	  w = w_info->next_cycle;
	}

      w = node;
      while (w)
	{
	  propagate_bits (w);
	  w_info = w->aux;
	  w = w_info->next_cycle;
	}
    }

  /* Need to fix up the local information sets.  The information that
     has been gathered so far is preinlining.  However, the
     compilation will progress post inlining so the local sets for the
     inlined calls need to be merged into the callers.  Note that the
     local sets are not shared between all of the nodes in a cycle so
     those nodes in the cycle must be processed explicitly.  */
  for (i = 0; i < order_pos; i++ )
    {
      struct ipa_dfs_info * w_info;
      node = order[i];
      merge_callee_local_info (node, node);
      
      w_info = node->aux;
      w = w_info->next_cycle;
      while (w)
	{
	  merge_callee_local_info (w, w);
	  w_info = w->aux;
	  w = w_info->next_cycle;
	}
    }

  if (dump_file)
    {
      for (i = 0; i < order_pos; i++ )
	{
	  ipa_reference_vars_info_t node_info;
	  ipa_reference_global_vars_info_t node_g;
	  ipa_reference_local_vars_info_t node_l;
	  unsigned int index;
	  bitmap_iterator bi;
	  struct ipa_dfs_info * w_info;

	  node = order[i];
	  node_info = get_reference_vars_info_from_cgraph (node);
	  node_g = node_info->global;
	  node_l = node_info->local;
	  fprintf (dump_file, 
		   "\nFunction name:%s/%i:", 
		   cgraph_node_name (node), node->uid);
	  fprintf (dump_file, "\n  locals read: ");
	  EXECUTE_IF_SET_IN_BITMAP (node_l->statics_read,
				    0, index, bi)
	    {
	      fprintf (dump_file, "%s ",
		       get_static_name (index));
	    }
	  fprintf (dump_file, "\n  locals written: ");
	  EXECUTE_IF_SET_IN_BITMAP (node_l->statics_written,
				    0, index, bi)
	    {
	      fprintf(dump_file, "%s ",
		      get_static_name (index));
	    }

	  w_info = node->aux;
	  w = w_info->next_cycle;
	  while (w) 
	    {
	      ipa_reference_vars_info_t w_ri = 
		get_reference_vars_info_from_cgraph (w);
	      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: ");
	      EXECUTE_IF_SET_IN_BITMAP (w_l->statics_read,
					0, index, bi)
		{
		  fprintf (dump_file, "%s ",
			   get_static_name (index));
		}

	      fprintf (dump_file, "\n    locals written: ");
	      EXECUTE_IF_SET_IN_BITMAP (w_l->statics_written,
					0, index, bi)
		{
		  fprintf(dump_file, "%s ",
			  get_static_name (index));
		}
	      

	      w_info = w->aux;
	      w = w_info->next_cycle;
	    }
	  fprintf (dump_file, "\n  globals read: ");
	  EXECUTE_IF_SET_IN_BITMAP (node_g->statics_read,
				    0, index, bi)
	    {
	      fprintf (dump_file, "%s ",
		       get_static_name (index));
	    }
	  fprintf (dump_file, "\n  globals written: ");
	  EXECUTE_IF_SET_IN_BITMAP (node_g->statics_written,
				    0, index, bi)
	    {
	      fprintf (dump_file, "%s ",
		       get_static_name (index));
	    }
	}
    }

  /* Cleanup. */
  for (i = 0; i < order_pos; i++ )
    {
      ipa_reference_vars_info_t node_info;
      ipa_reference_global_vars_info_t node_g;
      node = order[i];
      node_info = get_reference_vars_info_from_cgraph (node);
      node_g = node_info->global;
      
      /* Create the complimentary sets.  These are more useful for
	 certain apis.  */
      node_g->statics_not_read = BITMAP_ALLOC (&ipa_obstack);
      node_g->statics_not_written = BITMAP_ALLOC (&ipa_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);
   }

  free (order);

  for (node = cgraph_nodes; node; node = node->next)
    {
      /* Get rid of the aux information.  */
      
      if (node->aux)
	{
	  free (node->aux);
	  node->aux = NULL;
	}
      
      if (node->analyzed 
	  && (cgraph_function_body_availability (node) == AVAIL_OVERWRITABLE))
	clean_function (node);
    }
  return 0;
}


static bool
gate_reference (void)
{
  return (flag_unit_at_a_time != 0  && flag_ipa_reference
	  /* Don't bother doing anything if the program has errors.  */
	  && !(errorcount || sorrycount));
}

struct tree_opt_pass pass_ipa_reference =
{
  "static-var",				/* name */
  gate_reference,			/* gate */
  static_execute,			/* execute */
  NULL,					/* sub */
  NULL,					/* next */
  0,					/* static_pass_number */
  TV_IPA_REFERENCE,		        /* tv_id */
  0,	                                /* properties_required */
  0,					/* properties_provided */
  0,					/* properties_destroyed */
  0,					/* todo_flags_start */
  0,                                    /* todo_flags_finish */
  0					/* letter */
};

#include "gt-ipa-reference.h"