tree-ssa-structalias.c (struct variable_info): Add is_global_var member.

2009-06-23  Richard Guenther  <rguenther@suse.de>

	* tree-ssa-structalias.c (struct variable_info): Add is_global_var
	member.
	(var_anything, anything_tree, var_nothing, nothing_tree, var_readonly,
	readonly_tree, var_escaped, escaped_tree, var_nonlocal, nonlocal_tree,
	var_callused, callused_tree, var_storedanything, storedanything_tree,
	var_integer, integer_tree): Remove global variables.
	(new_var_info): Do not pass new id, append the new var to the
	global variable vector.
	(do_ds_constraint): Use is_global_var member of the variable-info.
	(new_scalar_tmp_constraint_exp): Adjust.
	(create_function_info_for): Likewise.
	(create_variable_info_for): Likewise.
	(find_what_var_points_to): Remove dead code.
	(init_base_vars): Simplify.
	(compute_points_to_sets): Adjust.

From-SVN: r148841

1 files changed, 57 insertions, 105 deletions

diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c
index ac2c7dc..692a624 100644
--- a/gcc/tree-ssa-structalias.c
+++ b/gcc/tree-ssa-structalias.c
@@ -229,6 +229,9 @@ struct variable_info
   /* True if this field may contain pointers.  */
   unsigned int may_have_pointers : 1;
 
+  /* True if this represents a global variable.  */
+  unsigned int is_global_var : 1;
+
   /* A link to the variable for the next field in this structure.  */
   struct variable_info *next;
 
@@ -284,39 +287,6 @@ enum { nothing_id = 0, anything_id = 1, readonly_id = 2,
        escaped_id = 3, nonlocal_id = 4, callused_id = 5,
        storedanything_id = 6, integer_id = 7 };
 
-/* Variable that represents the unknown pointer.  */
-static varinfo_t var_anything;
-static tree anything_tree;
-
-/* Variable that represents the NULL pointer.  */
-static varinfo_t var_nothing;
-static tree nothing_tree;
-
-/* Variable that represents read only memory.  */
-static varinfo_t var_readonly;
-static tree readonly_tree;
-
-/* Variable that represents escaped memory.  */
-static varinfo_t var_escaped;
-static tree escaped_tree;
-
-/* Variable that represents nonlocal memory.  */
-static varinfo_t var_nonlocal;
-static tree nonlocal_tree;
-
-/* Variable that represents call-used memory.  */
-static varinfo_t var_callused;
-static tree callused_tree;
-
-/* Variable that represents variables that are stored to anything.  */
-static varinfo_t var_storedanything;
-static tree storedanything_tree;
-
-/* Variable that represents integers.  This is used for when people do things
-   like &0->a.b.  */
-static varinfo_t var_integer;
-static tree integer_tree;
-
 /* Lookup a heap var for FROM, and return it if we find one.  */
 
 static tree
@@ -350,25 +320,34 @@ heapvar_insert (tree from, tree to)
 }
 
 /* Return a new variable info structure consisting for a variable
-   named NAME, and using constraint graph node NODE.  */
+   named NAME, and using constraint graph node NODE.  Append it
+   to the vector of variable info structures.  */
 
 static varinfo_t
-new_var_info (tree t, unsigned int id, const char *name)
+new_var_info (tree t, const char *name)
 {
+  unsigned index = VEC_length (varinfo_t, varmap);
   varinfo_t ret = (varinfo_t) pool_alloc (variable_info_pool);
 
-  ret->id = id;
+  ret->id = index;
   ret->name = name;
   ret->decl = t;
-  ret->is_artificial_var = false;
+  /* Vars without decl are artificial and do not have sub-variables.  */
+  ret->is_artificial_var = (t == NULL_TREE);
+  ret->is_full_var = (t == NULL_TREE);
   ret->is_heap_var = false;
   ret->is_special_var = false;
   ret->is_unknown_size_var = false;
-  ret->is_full_var = false;
   ret->may_have_pointers = true;
+  ret->is_global_var = true;
+  if (t && DECL_P (t))
+    ret->is_global_var = is_global_var (t);
   ret->solution = BITMAP_ALLOC (&pta_obstack);
   ret->oldsolution = BITMAP_ALLOC (&oldpta_obstack);
   ret->next = NULL;
+
+  VEC_safe_push (varinfo_t, heap, varmap, ret);
+
   return ret;
 }
 
@@ -1702,7 +1681,7 @@ do_ds_constraint (constraint_t c, bitmap delta)
 		}
 	    }
 	  /* If v is a global variable then this is an escape point.  */
-	  if (is_global_var (v->decl))
+	  if (v->is_global_var)
 	    {
 	      t = find (escaped_id);
 	      if (add_graph_edge (graph, t, rhs)
@@ -2682,15 +2661,13 @@ static struct constraint_expr
 new_scalar_tmp_constraint_exp (const char *name)
 {
   struct constraint_expr tmp;
-  unsigned index = VEC_length (varinfo_t, varmap);
   varinfo_t vi;
 
-  vi = new_var_info (NULL_TREE, index, name);
+  vi = new_var_info (NULL_TREE, name);
   vi->offset = 0;
   vi->size = -1;
   vi->fullsize = -1;
   vi->is_full_var = 1;
-  VEC_safe_push (varinfo_t, heap, varmap, vi);
 
   tmp.var = vi->id;
   tmp.type = SCALAR;
@@ -4263,7 +4240,6 @@ count_num_arguments (tree decl, bool *is_varargs)
 static unsigned int
 create_function_info_for (tree decl, const char *name)
 {
-  unsigned int index = VEC_length (varinfo_t, varmap);
   varinfo_t vi;
   tree arg;
   unsigned int i;
@@ -4271,12 +4247,11 @@ create_function_info_for (tree decl, const char *name)
 
   /* Create the variable info.  */
 
-  vi = new_var_info (decl, index, name);
+  vi = new_var_info (decl, name);
   vi->offset = 0;
   vi->size = 1;
   vi->fullsize = count_num_arguments (decl, &is_varargs) + 1;
   insert_vi_for_tree (vi->decl, vi);
-  VEC_safe_push (varinfo_t, heap, varmap, vi);
 
   stats.total_vars++;
 
@@ -4287,10 +4262,9 @@ create_function_info_for (tree decl, const char *name)
       vi->fullsize = ~0;
       vi->size = ~0;
       vi->is_unknown_size_var = true;
-      return index;
+      return vi->id;
     }
 
-
   arg = DECL_ARGUMENTS (decl);
 
   /* Set up variables for each argument.  */
@@ -4299,19 +4273,16 @@ create_function_info_for (tree decl, const char *name)
       varinfo_t argvi;
       const char *newname;
       char *tempname;
-      unsigned int newindex;
       tree argdecl = decl;
 
       if (arg)
 	argdecl = arg;
 
-      newindex = VEC_length (varinfo_t, varmap);
       asprintf (&tempname, "%s.arg%d", name, i-1);
       newname = ggc_strdup (tempname);
       free (tempname);
 
-      argvi = new_var_info (argdecl, newindex, newname);
-      VEC_safe_push (varinfo_t, heap, varmap, argvi);
+      argvi = new_var_info (argdecl, newname);
       argvi->offset = i;
       argvi->size = 1;
       argvi->is_full_var = true;
@@ -4332,7 +4303,6 @@ create_function_info_for (tree decl, const char *name)
       varinfo_t resultvi;
       const char *newname;
       char *tempname;
-      unsigned int newindex;
       tree resultdecl = decl;
 
       vi->fullsize ++;
@@ -4340,13 +4310,11 @@ create_function_info_for (tree decl, const char *name)
       if (DECL_RESULT (decl))
 	resultdecl = DECL_RESULT (decl);
 
-      newindex = VEC_length (varinfo_t, varmap);
       asprintf (&tempname, "%s.result", name);
       newname = ggc_strdup (tempname);
       free (tempname);
 
-      resultvi = new_var_info (resultdecl, newindex, newname);
-      VEC_safe_push (varinfo_t, heap, varmap, resultvi);
+      resultvi = new_var_info (resultdecl, newname);
       resultvi->offset = i;
       resultvi->size = 1;
       resultvi->fullsize = vi->fullsize;
@@ -4356,7 +4324,8 @@ create_function_info_for (tree decl, const char *name)
       if (DECL_RESULT (decl))
 	insert_vi_for_tree (DECL_RESULT (decl), resultvi);
     }
-  return index;
+
+  return vi->id;
 }
 
 
@@ -4386,7 +4355,6 @@ check_for_overlaps (VEC (fieldoff_s,heap) *fieldstack)
 static unsigned int
 create_variable_info_for (tree decl, const char *name)
 {
-  unsigned int index = VEC_length (varinfo_t, varmap);
   varinfo_t vi;
   tree decl_type = TREE_TYPE (decl);
   tree declsize = DECL_P (decl) ? DECL_SIZE (decl) : TYPE_SIZE (decl_type);
@@ -4406,7 +4374,7 @@ create_variable_info_for (tree decl, const char *name)
   /* If the variable doesn't have subvars, we may end up needing to
      sort the field list and create fake variables for all the
      fields.  */
-  vi = new_var_info (decl, index, name);
+  vi = new_var_info (decl, name);
   vi->offset = 0;
   vi->may_have_pointers = could_have_pointers (decl);
   if (!declsize
@@ -4423,7 +4391,6 @@ create_variable_info_for (tree decl, const char *name)
     }
 
   insert_vi_for_tree (vi->decl, vi);
-  VEC_safe_push (varinfo_t, heap, varmap, vi);
   if (is_global && (!flag_whole_program || !in_ipa_mode)
       && vi->may_have_pointers)
     {
@@ -4441,7 +4408,6 @@ create_variable_info_for (tree decl, const char *name)
       && VEC_length (fieldoff_s, fieldstack) > 1
       && VEC_length (fieldoff_s, fieldstack) <= MAX_FIELDS_FOR_FIELD_SENSITIVE)
     {
-      unsigned int newindex = VEC_length (varinfo_t, varmap);
       fieldoff_s *fo = NULL;
       bool notokay = false;
       unsigned int i;
@@ -4481,7 +4447,7 @@ create_variable_info_for (tree decl, const char *name)
 	  vi->size = ~0;
 	  vi->is_full_var = true;
 	  VEC_free (fieldoff_s, heap, fieldstack);
-	  return index;
+	  return vi->id;
 	}
 
       vi->size = fo->size;
@@ -4495,7 +4461,6 @@ create_variable_info_for (tree decl, const char *name)
 	  const char *newname = "NULL";
 	  char *tempname;
 
-	  newindex = VEC_length (varinfo_t, varmap);
 	  if (dump_file)
 	    {
 	      asprintf (&tempname, "%s." HOST_WIDE_INT_PRINT_DEC
@@ -4504,13 +4469,12 @@ create_variable_info_for (tree decl, const char *name)
 	      newname = ggc_strdup (tempname);
 	      free (tempname);
 	    }
-	  newvi = new_var_info (decl, newindex, newname);
+	  newvi = new_var_info (decl, newname);
 	  newvi->offset = fo->offset;
 	  newvi->size = fo->size;
 	  newvi->fullsize = vi->fullsize;
 	  newvi->may_have_pointers = fo->may_have_pointers;
 	  insert_into_field_list (vi, newvi);
-	  VEC_safe_push (varinfo_t, heap, varmap, newvi);
 	  if (is_global && (!flag_whole_program || !in_ipa_mode)
 	      && newvi->may_have_pointers)
 	    make_copy_constraint (newvi, nonlocal_id);
@@ -4523,7 +4487,7 @@ create_variable_info_for (tree decl, const char *name)
 
   VEC_free (fieldoff_s, heap, fieldstack);
 
-  return index;
+  return vi->id;
 }
 
 /* Print out the points-to solution for VAR to FILE.  */
@@ -4770,7 +4734,6 @@ find_what_var_points_to (varinfo_t vi, struct pt_solution *pt)
   bitmap_iterator bi;
   bitmap finished_solution;
   bitmap result;
-  tree ptr = vi->decl;
 
   memset (pt, 0, sizeof (struct pt_solution));
 
@@ -4813,9 +4776,6 @@ find_what_var_points_to (varinfo_t vi, struct pt_solution *pt)
   finished_solution = BITMAP_GGC_ALLOC ();
   stats.points_to_sets_created++;
 
-  if (TREE_CODE (ptr) == SSA_NAME)
-    ptr = SSA_NAME_VAR (ptr);
-
   set_uids_in_ptset (finished_solution, vi->solution, pt);
   result = shared_bitmap_lookup (finished_solution);
   if (!result)
@@ -5066,24 +5026,29 @@ static void
 init_base_vars (void)
 {
   struct constraint_expr lhs, rhs;
+  varinfo_t var_anything;
+  varinfo_t var_nothing;
+  varinfo_t var_readonly;
+  varinfo_t var_escaped;
+  varinfo_t var_nonlocal;
+  varinfo_t var_callused;
+  varinfo_t var_storedanything;
+  varinfo_t var_integer;
 
   /* Create the NULL variable, used to represent that a variable points
      to NULL.  */
-  nothing_tree = create_tmp_var_raw (void_type_node, "NULL");
-  var_nothing = new_var_info (nothing_tree, nothing_id, "NULL");
-  insert_vi_for_tree (nothing_tree, var_nothing);
+  var_nothing = new_var_info (NULL_TREE, "NULL");
+  gcc_assert (var_nothing->id == nothing_id);
   var_nothing->is_artificial_var = 1;
   var_nothing->offset = 0;
   var_nothing->size = ~0;
   var_nothing->fullsize = ~0;
   var_nothing->is_special_var = 1;
-  VEC_safe_push (varinfo_t, heap, varmap, var_nothing);
 
   /* Create the ANYTHING variable, used to represent that a variable
      points to some unknown piece of memory.  */
-  anything_tree = create_tmp_var_raw (ptr_type_node, "ANYTHING");
-  var_anything = new_var_info (anything_tree, anything_id, "ANYTHING");
-  insert_vi_for_tree (anything_tree, var_anything);
+  var_anything = new_var_info (NULL_TREE, "ANYTHING");
+  gcc_assert (var_anything->id == anything_id);
   var_anything->is_artificial_var = 1;
   var_anything->size = ~0;
   var_anything->offset = 0;
@@ -5094,7 +5059,6 @@ init_base_vars (void)
   /* Anything points to anything.  This makes deref constraints just
      work in the presence of linked list and other p = *p type loops,
      by saying that *ANYTHING = ANYTHING. */
-  VEC_safe_push (varinfo_t, heap, varmap, var_anything);
   lhs.type = SCALAR;
   lhs.var = anything_id;
   lhs.offset = 0;
@@ -5109,16 +5073,14 @@ init_base_vars (void)
 
   /* Create the READONLY variable, used to represent that a variable
      points to readonly memory.  */
-  readonly_tree = create_tmp_var_raw (ptr_type_node, "READONLY");
-  var_readonly = new_var_info (readonly_tree, readonly_id, "READONLY");
+  var_readonly = new_var_info (NULL_TREE, "READONLY");
+  gcc_assert (var_readonly->id == readonly_id);
   var_readonly->is_artificial_var = 1;
   var_readonly->offset = 0;
   var_readonly->size = ~0;
   var_readonly->fullsize = ~0;
   var_readonly->next = NULL;
   var_readonly->is_special_var = 1;
-  insert_vi_for_tree (readonly_tree, var_readonly);
-  VEC_safe_push (varinfo_t, heap, varmap, var_readonly);
 
   /* readonly memory points to anything, in order to make deref
      easier.  In reality, it points to anything the particular
@@ -5134,28 +5096,23 @@ init_base_vars (void)
 
   /* Create the ESCAPED variable, used to represent the set of escaped
      memory.  */
-  escaped_tree = create_tmp_var_raw (ptr_type_node, "ESCAPED");
-  var_escaped = new_var_info (escaped_tree, escaped_id, "ESCAPED");
-  insert_vi_for_tree (escaped_tree, var_escaped);
+  var_escaped = new_var_info (NULL_TREE, "ESCAPED");
+  gcc_assert (var_escaped->id == escaped_id);
   var_escaped->is_artificial_var = 1;
   var_escaped->offset = 0;
   var_escaped->size = ~0;
   var_escaped->fullsize = ~0;
   var_escaped->is_special_var = 0;
-  VEC_safe_push (varinfo_t, heap, varmap, var_escaped);
-  gcc_assert (VEC_index (varinfo_t, varmap, 3) == var_escaped);
 
   /* Create the NONLOCAL variable, used to represent the set of nonlocal
      memory.  */
-  nonlocal_tree = create_tmp_var_raw (ptr_type_node, "NONLOCAL");
-  var_nonlocal = new_var_info (nonlocal_tree, nonlocal_id, "NONLOCAL");
-  insert_vi_for_tree (nonlocal_tree, var_nonlocal);
+  var_nonlocal = new_var_info (NULL_TREE, "NONLOCAL");
+  gcc_assert (var_nonlocal->id == nonlocal_id);
   var_nonlocal->is_artificial_var = 1;
   var_nonlocal->offset = 0;
   var_nonlocal->size = ~0;
   var_nonlocal->fullsize = ~0;
   var_nonlocal->is_special_var = 1;
-  VEC_safe_push (varinfo_t, heap, varmap, var_nonlocal);
 
   /* ESCAPED = *ESCAPED, because escaped is may-deref'd at calls, etc.  */
   lhs.type = SCALAR;
@@ -5203,15 +5160,13 @@ init_base_vars (void)
 
   /* Create the CALLUSED variable, used to represent the set of call-used
      memory.  */
-  callused_tree = create_tmp_var_raw (ptr_type_node, "CALLUSED");
-  var_callused = new_var_info (callused_tree, callused_id, "CALLUSED");
-  insert_vi_for_tree (callused_tree, var_callused);
+  var_callused = new_var_info (NULL_TREE, "CALLUSED");
+  gcc_assert (var_callused->id == callused_id);
   var_callused->is_artificial_var = 1;
   var_callused->offset = 0;
   var_callused->size = ~0;
   var_callused->fullsize = ~0;
   var_callused->is_special_var = 0;
-  VEC_safe_push (varinfo_t, heap, varmap, var_callused);
 
   /* CALLUSED = *CALLUSED, because call-used is may-deref'd at calls, etc.  */
   lhs.type = SCALAR;
@@ -5234,29 +5189,24 @@ init_base_vars (void)
 
   /* Create the STOREDANYTHING variable, used to represent the set of
      variables stored to *ANYTHING.  */
-  storedanything_tree = create_tmp_var_raw (ptr_type_node, "STOREDANYTHING");
-  var_storedanything = new_var_info (storedanything_tree, storedanything_id,
-				     "STOREDANYTHING");
-  insert_vi_for_tree (storedanything_tree, var_storedanything);
+  var_storedanything = new_var_info (NULL_TREE, "STOREDANYTHING");
+  gcc_assert (var_storedanything->id == storedanything_id);
   var_storedanything->is_artificial_var = 1;
   var_storedanything->offset = 0;
   var_storedanything->size = ~0;
   var_storedanything->fullsize = ~0;
   var_storedanything->is_special_var = 0;
-  VEC_safe_push (varinfo_t, heap, varmap, var_storedanything);
 
   /* Create the INTEGER variable, used to represent that a variable points
      to what an INTEGER "points to".  */
-  integer_tree = create_tmp_var_raw (ptr_type_node, "INTEGER");
-  var_integer = new_var_info (integer_tree, integer_id, "INTEGER");
-  insert_vi_for_tree (integer_tree, var_integer);
+  var_integer = new_var_info (NULL_TREE, "INTEGER");
+  gcc_assert (var_integer->id == integer_id);
   var_integer->is_artificial_var = 1;
   var_integer->size = ~0;
   var_integer->fullsize = ~0;
   var_integer->offset = 0;
   var_integer->next = NULL;
   var_integer->is_special_var = 1;
-  VEC_safe_push (varinfo_t, heap, varmap, var_integer);
 
   /* INTEGER = ANYTHING, because we don't know where a dereference of
      a random integer will point to.  */
@@ -5446,8 +5396,10 @@ compute_points_to_sets (void)
 
   /* Compute the points-to sets for ESCAPED and CALLUSED used for
      call-clobber analysis.  */
-  find_what_var_points_to (var_escaped, &cfun->gimple_df->escaped);
-  find_what_var_points_to (var_callused, &cfun->gimple_df->callused);
+  find_what_var_points_to (get_varinfo (escaped_id),
+			   &cfun->gimple_df->escaped);
+  find_what_var_points_to (get_varinfo (callused_id),
+			   &cfun->gimple_df->callused);
 
   /* Make sure the ESCAPED solution (which is used as placeholder in
      other solutions) does not reference itself.  This simplifies