revert: tree-flow.h (uid_decl_map_hash, [...]): Move ...

2008-02-25  Richard Guenther  <rguenther@suse.de>

	Revert:
	2008-02-25  Richard Guenther  <rguenther@suse.de>

	* tree-flow.h (uid_decl_map_hash, uid_decl_map_eq): Move ...
	* tree.h (uid_decl_map_hash, uid_decl_map_eq): ... here.
	(lookup_decl_from_uid): Declare.
	* tree-ssa.c (uid_decl_map_eq, uid_decl_map_hash): Move ...
	* tree.c (uid_decl_map_eq, uid_decl_map_hash): ... here.
	(decl_for_uid_map): New global hashtable mapping DECL_UID
	to the decl tree.
	(init_ttree): Allocate it.
	(insert_decl_to_uid_decl_map): New helper function.
	(make_node_stat): Insert new decls into the map.
	(copy_node_stat): Likewise.
	(lookup_decl_from_uid): New function.
	(print_decl_for_uid_map_statistics): New helper.
	(dump_tree_statistics): Call it.

	* tree-flow.h (struct gimple_df): Make referenced_vars a bitmap.
	(referenced_var_iterator): Adjust.
	(FOR_EACH_REFERENCED_VAR): Adjust.
	(FOR_EACH_REFERENCED_VAR_IN_BITMAP): New iterator.
	(num_referenced_vars): Adjust.
	* tree-flow-inline.h (gimple_referenced_vars): Adjust.
	(first_referenced_var): Remove.
	(end_referenced_vars_p): Likewise.
	(next_referenced_var): Likewise.
	(referenced_var_iterator_set): New helper function.
	* tree-dfa.c (referenced_var_lookup): Adjust.
	(referenced_var_check_and_insert): Likewise.
	(remove_referenced_var): Likewise.
	* tree-ssa.c (verify_flow_insensitive_alias_info): Use
	FOR_EACH_REFERENCED_VAR_IN_BITMAP.
	(verify_call_clobbering): Likewise.
	(verify_memory_partitions): Likewise.
	(init_tree_ssa): Allocate bitmap instead of hashtable for
	referenced_vars.
	(delete_tree_ssa): Adjust.
	* tree-ssa-alias.c (mark_aliases_call_clobbered): Use
	FOR_EACH_REFERENCED_VAR_IN_BITMAP.
	(compute_tag_properties): Likewise.
	(set_initial_properties): Likewise.
	(find_partition_for): Likewise.
	(update_reference_counts): Likewise.
	(dump_may_aliases_for): Likewise.
	* tree-ssa-operands.c (add_virtual_operand): Likewise.
	(add_call_clobber_ops): Likewise.
	(add_call_read_ops): Likewise.
	(get_asm_expr_operands): Likewise.
	* tree-into-ssa.c (dump_decl_set): Likewise.
	(update_ssa): Likewise.
	* tree-sra.c (scan_function): Likewise.
	(decide_instantiations): Likewise.
	(scalarize_parms): Likewise.
	* tree-ssa-alias-warnings.c (build_reference_table): Likewise.
	(dsa_named_for): Likewise.
	* tree-ssa-structalias.c (update_alias_info): Likewise.
	(merge_smts_into): Likewise.

From-SVN: r132643

gcc/ChangeLog

+2008-02-25  Richard Guenther  <rguenther@suse.de>
+
+	Revert:
+	2008-02-25  Richard Guenther  <rguenther@suse.de>
+
+	* tree-flow.h (uid_decl_map_hash, uid_decl_map_eq): Move ...
+	* tree.h (uid_decl_map_hash, uid_decl_map_eq): ... here.
+	(lookup_decl_from_uid): Declare.
+	* tree-ssa.c (uid_decl_map_eq, uid_decl_map_hash): Move ...
+	* tree.c (uid_decl_map_eq, uid_decl_map_hash): ... here.
+	(decl_for_uid_map): New global hashtable mapping DECL_UID
+	to the decl tree.
+	(init_ttree): Allocate it.
+	(insert_decl_to_uid_decl_map): New helper function.
+	(make_node_stat): Insert new decls into the map.
+	(copy_node_stat): Likewise.
+	(lookup_decl_from_uid): New function.
+	(print_decl_for_uid_map_statistics): New helper.
+	(dump_tree_statistics): Call it.
+
+	* tree-flow.h (struct gimple_df): Make referenced_vars a bitmap.
+	(referenced_var_iterator): Adjust.
+	(FOR_EACH_REFERENCED_VAR): Adjust.
+	(FOR_EACH_REFERENCED_VAR_IN_BITMAP): New iterator.
+	(num_referenced_vars): Adjust.
+	* tree-flow-inline.h (gimple_referenced_vars): Adjust.
+	(first_referenced_var): Remove.
+	(end_referenced_vars_p): Likewise.
+	(next_referenced_var): Likewise.
+	(referenced_var_iterator_set): New helper function.
+	* tree-dfa.c (referenced_var_lookup): Adjust.
+	(referenced_var_check_and_insert): Likewise.
+	(remove_referenced_var): Likewise.
+	* tree-ssa.c (verify_flow_insensitive_alias_info): Use
+	FOR_EACH_REFERENCED_VAR_IN_BITMAP.
+	(verify_call_clobbering): Likewise.
+	(verify_memory_partitions): Likewise.
+	(init_tree_ssa): Allocate bitmap instead of hashtable for
+	referenced_vars.
+	(delete_tree_ssa): Adjust.
+	* tree-ssa-alias.c (mark_aliases_call_clobbered): Use
+	FOR_EACH_REFERENCED_VAR_IN_BITMAP.
+	(compute_tag_properties): Likewise.
+	(set_initial_properties): Likewise.
+	(find_partition_for): Likewise.
+	(update_reference_counts): Likewise.
+	(dump_may_aliases_for): Likewise.
+	* tree-ssa-operands.c (add_virtual_operand): Likewise.
+	(add_call_clobber_ops): Likewise.
+	(add_call_read_ops): Likewise.
+	(get_asm_expr_operands): Likewise.
+	* tree-into-ssa.c (dump_decl_set): Likewise.
+	(update_ssa): Likewise.
+	* tree-sra.c (scan_function): Likewise.
+	(decide_instantiations): Likewise.
+	(scalarize_parms): Likewise.
+	* tree-ssa-alias-warnings.c (build_reference_table): Likewise.
+	(dsa_named_for): Likewise.
+	* tree-ssa-structalias.c (update_alias_info): Likewise.
+	(merge_smts_into): Likewise.
+
 2008-02-25  Janne Blomqvist  <jb@gcc.gnu.org>
 
 	PR fortran/29549

gcc/tree-dfa.c

@@ -641,16 +641,12 @@ find_vars_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
 tree 
 referenced_var_lookup (unsigned int uid)
 {
-  tree var;
-
-  gcc_assert (bitmap_bit_p (gimple_referenced_vars (cfun), uid));
-
-  /* For now also assert that the variable is really referenced.
-     Otherwise callers need to deal with the result from this function
-     being NULL.  */
-  var = lookup_decl_from_uid (uid);
-  gcc_assert (var);
-  return var;
+  tree h;
+  struct tree_decl_minimal in;
+  in.uid = uid;
+  h = (tree) htab_find_with_hash (gimple_referenced_vars (cfun), &in, uid);
+  gcc_assert (h || uid == 0);
+  return h;
 }
 
 /* Check if TO is in the referenced_vars hash table and insert it if not.  
@@ -659,13 +655,23 @@ referenced_var_lookup (unsigned int uid)
 bool
 referenced_var_check_and_insert (tree to)
 { 
+  tree h, *loc;
+  struct tree_decl_minimal in;
   unsigned int uid = DECL_UID (to);
 
-  if (bitmap_bit_p (gimple_referenced_vars (cfun), uid))
-    return false;
-
-  bitmap_set_bit (gimple_referenced_vars (cfun), uid);
+  in.uid = uid;
+  h = (tree) htab_find_with_hash (gimple_referenced_vars (cfun), &in, uid);
+  if (h)
+    {
+      /* DECL_UID has already been entered in the table.  Verify that it is
+	 the same entry as TO.  See PR 27793.  */
+      gcc_assert (h == to);
+      return false;
+    }
 
+  loc = (tree *) htab_find_slot_with_hash (gimple_referenced_vars (cfun),
+					   &in, uid, INSERT);
+  *loc = to;
   return true;
 }
 
@@ -755,6 +761,8 @@ void
 remove_referenced_var (tree var)
 {
   var_ann_t v_ann;
+  struct tree_decl_minimal in;
+  void **loc;
   unsigned int uid = DECL_UID (var);
   subvar_t sv;
 
@@ -774,7 +782,10 @@ remove_referenced_var (tree var)
     ggc_free (v_ann);
   var->base.ann = NULL;
   gcc_assert (DECL_P (var));
-  bitmap_clear_bit (gimple_referenced_vars (cfun), uid);
+  in.uid = uid;
+  loc = htab_find_slot_with_hash (gimple_referenced_vars (cfun), &in, uid,
+				  NO_INSERT);
+  htab_clear_slot (gimple_referenced_vars (cfun), loc);
 }
 
 

gcc/tree-flow-inline.h

@@ -66,7 +66,7 @@ gimple_call_clobbered_vars (const struct function *fun)
 }
 
 /* Array of all variables referenced in the function.  */
-static inline bitmap
+static inline htab_t
 gimple_referenced_vars (const struct function *fun)
 {
   if (!fun->gimple_df)
@@ -145,23 +145,34 @@ next_htab_element (htab_iterator *hti)
   return NULL;
 }
 
-/* Helper for FOR_EACH_REFERENCED_VAR.  Needed unless iterator
-   bodies deal with NULL elements.  */
+/* Initialize ITER to point to the first referenced variable in the
+   referenced_vars hashtable, and return that variable.  */
+
+static inline tree
+first_referenced_var (referenced_var_iterator *iter)
+{
+  return (tree) first_htab_element (&iter->hti,
+				    gimple_referenced_vars (cfun));
+}
+
+/* Return true if we have hit the end of the referenced variables ITER is
+   iterating through.  */
 
 static inline bool
-referenced_var_iterator_set (referenced_var_iterator *ri, tree *var)
+end_referenced_vars_p (const referenced_var_iterator *iter)
 {
-  while (1)
-    {
-      if (!bmp_iter_set (&ri->bi, &ri->i))
-	return false;
-      *var = lookup_decl_from_uid (ri->i);
-      if (*var)
-	return true;
-      bmp_iter_next (&ri->bi, &ri->i);
-    }
+  return end_htab_p (&iter->hti);
 }
 
+/* Make ITER point to the next referenced_var in the referenced_var hashtable,
+   and return that variable.  */
+
+static inline tree
+next_referenced_var (referenced_var_iterator *iter)
+{
+  return (tree) next_htab_element (&iter->hti);
+} 
+
 /* Fill up VEC with the variables in the referenced vars hashtable.  */
 
 static inline void

gcc/tree-flow.h

@@ -138,8 +138,8 @@ struct mem_ref_stats_d GTY(())
    fields should have gimple_set accessor.  */
 struct gimple_df GTY(())
 {
-  /* Bitmap of all variables referenced in the function.  */
-  bitmap referenced_vars;
+  /* Array of all variables referenced in the function.  */
+  htab_t GTY((param_is (union tree_node))) referenced_vars;
 
   /* A list of all the noreturn calls passed to modify_stmt.
      cleanup_control_flow uses it to detect cases where a mid-block
@@ -569,29 +569,25 @@ struct int_tree_map GTY(())
 extern unsigned int int_tree_map_hash (const void *);
 extern int int_tree_map_eq (const void *, const void *);
 
+extern unsigned int uid_decl_map_hash (const void *);
+extern int uid_decl_map_eq (const void *, const void *);
+
 typedef struct 
 {
-  bitmap_iterator bi;
-  unsigned int i;
+  htab_iterator hti;
 } referenced_var_iterator;
 
+
 /* This macro loops over all the referenced vars, one at a time, putting the
-   current var in VAR.  Note:  It is undefined whether referenced variables
-   you add or remove during the iteration show up or not.  */
+   current var in VAR.  Note:  You are not allowed to add referenced variables
+   to the hashtable while using this macro.  Doing so may cause it to behave
+   erratically.  */
 
 #define FOR_EACH_REFERENCED_VAR(VAR, ITER) \
-  for (bmp_iter_set_init (&(ITER).bi, gimple_referenced_vars (cfun), 0, &(ITER).i); \
-       referenced_var_iterator_set (&(ITER), &(VAR)); \
-       bmp_iter_next (&(ITER).bi, &(ITER).i))
-
-/* Iterate over all variables whose UID is set in the bitmap BM, putting the
-   current var in VAR.  Note: It is undefined whether variables you add or
-   remove during the iteration show up or not.  */
+  for ((VAR) = first_referenced_var (&(ITER)); \
+       !end_referenced_vars_p (&(ITER)); \
+       (VAR) = next_referenced_var (&(ITER))) 
 
-#define FOR_EACH_REFERENCED_VAR_IN_BITMAP(BM, VAR, ITER) \
-  for (bmp_iter_set_init (&(ITER).bi, (BM), 0, &(ITER).i); \
-       referenced_var_iterator_set (&(ITER), &(VAR)); \
-       bmp_iter_next (&(ITER).bi, &(ITER).i))
 
 typedef struct
 {
@@ -613,7 +609,7 @@ typedef struct
 
 extern tree referenced_var_lookup (unsigned int);
 extern bool referenced_var_check_and_insert (tree);
-#define num_referenced_vars bitmap_count_bits (gimple_referenced_vars (cfun))
+#define num_referenced_vars htab_elements (gimple_referenced_vars (cfun))
 #define referenced_var(i) referenced_var_lookup (i)
 
 #define num_ssa_names (VEC_length (tree, cfun->gimple_df->ssa_names))

gcc/tree-into-ssa.c

@@ -1463,14 +1463,14 @@ dump_decl_set (FILE *file, bitmap set)
 {
   if (set)
     {
-      referenced_var_iterator ri;
-      tree var;
+      bitmap_iterator bi;
+      unsigned i;
 
       fprintf (file, "{ ");
 
-      FOR_EACH_REFERENCED_VAR_IN_BITMAP (set, var, ri)
+      EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
 	{
-	  print_generic_expr (file, var, 0);
+	  print_generic_expr (file, referenced_var (i), 0);
 	  fprintf (file, " ");
 	}
 
@@ -3201,11 +3201,12 @@ update_ssa (unsigned update_flags)
      memory symbols into the set MEM_SYMS_TO_RENAME.  */
   if (!bitmap_empty_p (syms_to_rename))
     {
-      referenced_var_iterator ri;
-      tree sym;
+      unsigned i;
+      bitmap_iterator bi;
 
-      FOR_EACH_REFERENCED_VAR_IN_BITMAP (syms_to_rename, sym, ri)
+      EXECUTE_IF_SET_IN_BITMAP (syms_to_rename, 0, i, bi)
 	{
+	  tree sym = referenced_var (i);
 	  if (is_gimple_reg (sym))
 	    bitmap_set_bit (regs_to_rename, i);
 	  else

gcc/tree-sra.c

@@ -1162,17 +1162,18 @@ scan_function (void)
   static const struct sra_walk_fns fns = {
     scan_use, scan_copy, scan_init, scan_ldst, true
   };
+  bitmap_iterator bi;
 
   sra_walk_function (&fns);
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
-      referenced_var_iterator ri;
-      tree var;
+      unsigned i;
 
       fputs ("\nScan results:\n", dump_file);
-      FOR_EACH_REFERENCED_VAR_IN_BITMAP (sra_candidates, var, ri)
+      EXECUTE_IF_SET_IN_BITMAP (sra_candidates, 0, i, bi)
 	{
+	  tree var = referenced_var (i);
 	  struct sra_elt *elt = lookup_element (NULL, var, NULL, NO_INSERT);
 	  if (elt)
 	    scan_dump (elt);
@@ -1949,18 +1950,19 @@ decide_block_copy (struct sra_elt *elt)
 static void
 decide_instantiations (void)
 {
+  unsigned int i;
   bool cleared_any;
   bitmap_head done_head;
-  referenced_var_iterator ri;
-  tree var;
+  bitmap_iterator bi;
 
   /* We cannot clear bits from a bitmap we're iterating over,
      so save up all the bits to clear until the end.  */
   bitmap_initialize (&done_head, &bitmap_default_obstack);
   cleared_any = false;
 
-  FOR_EACH_REFERENCED_VAR_IN_BITMAP (sra_candidates, var, ri)
+  EXECUTE_IF_SET_IN_BITMAP (sra_candidates, 0, i, bi)
     {
+      tree var = referenced_var (i);
       struct sra_elt *elt = lookup_element (NULL, var, NULL, NO_INSERT);
       if (elt)
 	{
@@ -1970,7 +1972,7 @@ decide_instantiations (void)
 	}
       if (!elt)
 	{
-	  bitmap_set_bit (&done_head, DECL_UID (var));
+	  bitmap_set_bit (&done_head, i);
 	  cleared_any = true;
 	}
     }
@@ -3530,11 +3532,12 @@ static void
 scalarize_parms (void)
 {
   tree list = NULL;
-  referenced_var_iterator ri;
-  tree var;
+  unsigned i;
+  bitmap_iterator bi;
 
-  FOR_EACH_REFERENCED_VAR_IN_BITMAP (needs_copy_in, var, ri)
+  EXECUTE_IF_SET_IN_BITMAP (needs_copy_in, 0, i, bi)
     {
+      tree var = referenced_var (i);
       struct sra_elt *elt = lookup_element (NULL, var, NULL, NO_INSERT);
       generate_copy_inout (elt, true, var, &list);
     }

gcc/tree-ssa-alias-warnings.c

@@ -452,11 +452,14 @@ build_reference_table (void)
 	  /* Add all aliased names to the interesting reference list.  */
 	  if (pi->pt_vars)
 	    {
-	      referenced_var_iterator ri;
-	      tree alias;
-
-	      FOR_EACH_REFERENCED_VAR_IN_BITMAP (pi->pt_vars, alias, ri)
-		add_key (ref_table->objs, alias, references_pool);
+	      unsigned ix;
+	      bitmap_iterator bi;
+
+	      EXECUTE_IF_SET_IN_BITMAP (pi->pt_vars, 0, ix, bi)
+		{
+		  tree alias = referenced_var (ix);
+		  add_key (ref_table->objs, alias, references_pool);
+		}
 	    }
 	}
     }
@@ -911,13 +914,17 @@ dsa_named_for (tree ptr)
       /* For all the variables it could be aliased to.  */
       if (pi->pt_vars)
 	{
-	  referenced_var_iterator ri;
-	  tree alias;
+	  unsigned ix;
+	  bitmap_iterator bi;
+
+	  EXECUTE_IF_SET_IN_BITMAP (pi->pt_vars, 0, ix, bi)
+	    {
+	      tree alias = referenced_var (ix);
 
-	  FOR_EACH_REFERENCED_VAR_IN_BITMAP (pi->pt_vars, alias, ri)
-	    if (nonstandard_alias_p (ptr, alias, false))
-	      strict_aliasing_warn (SSA_NAME_DEF_STMT (ptr),
-				    ptr, true, alias, false, true);
+	      if (nonstandard_alias_p (ptr, alias, false))
+		strict_aliasing_warn (SSA_NAME_DEF_STMT (ptr),
+				      ptr, true, alias, false, true);
+	    }
 	}
     }
 }

gcc/tree-ssa-alias.c

@@ -390,7 +390,8 @@ mark_aliases_call_clobbered (tree tag, VEC (tree, heap) **worklist,
 			     bitmap on_worklist, bitmap queued)
 {
   bitmap aliases;
-  referenced_var_iterator ri;
+  bitmap_iterator bi;
+  unsigned int i;
   tree entry;
   var_ann_t ta = var_ann (tag);
 
@@ -400,8 +401,9 @@ mark_aliases_call_clobbered (tree tag, VEC (tree, heap) **worklist,
   if (!aliases)
     return;
 
-  FOR_EACH_REFERENCED_VAR_IN_BITMAP (aliases, entry, ri)
+  EXECUTE_IF_SET_IN_BITMAP (aliases, 0, i, bi)
     {
+      entry = referenced_var (i);
       /* If you clobber one part of a structure, you
 	 clobber the entire thing.  While this does not make
 	 the world a particularly nice place, it is necessary
@@ -418,9 +420,9 @@ mark_aliases_call_clobbered (tree tag, VEC (tree, heap) **worklist,
     }
   if (!bitmap_empty_p (queued))
     {
-      FOR_EACH_REFERENCED_VAR_IN_BITMAP (queued, entry, ri)
+      EXECUTE_IF_SET_IN_BITMAP (queued, 0, i, bi)
 	{
-	  subvar_t svars = get_subvars_for_var (entry);
+	  subvar_t svars = get_subvars_for_var (referenced_var (i));
 	  unsigned int i;
 	  tree subvar;
 
@@ -482,7 +484,8 @@ compute_tag_properties (void)
       for (k = 0; VEC_iterate (tree, taglist, k, tag); k++)
 	{
 	  bitmap ma;
-	  referenced_var_iterator ri;
+	  bitmap_iterator bi;
+	  unsigned int i;
 	  tree entry;
 	  bool tagcc = is_call_clobbered (tag);
 	  bool tagglobal = MTAG_GLOBAL (tag);
@@ -494,8 +497,9 @@ compute_tag_properties (void)
 	  if (!ma)
 	    continue;
 
-	  FOR_EACH_REFERENCED_VAR_IN_BITMAP (ma, entry, ri)
+	  EXECUTE_IF_SET_IN_BITMAP (ma, 0, i, bi)
 	    {
+	      entry = referenced_var (i);
 	      /* Call clobbered entries cause the tag to be marked
 		 call clobbered.  */
 	      if (!tagcc && is_call_clobbered (entry))
@@ -577,10 +581,12 @@ set_initial_properties (struct alias_info *ai)
 
 	  if (pi->pt_vars)
 	    {
-	      referenced_var_iterator ri;
-	      tree alias;
-	      FOR_EACH_REFERENCED_VAR_IN_BITMAP (pi->pt_vars, alias, ri)
+	      bitmap_iterator bi;
+	      unsigned int j;	      
+	      EXECUTE_IF_SET_IN_BITMAP (pi->pt_vars, 0, j, bi)
 		{
+		  tree alias = referenced_var (j);
+
 		  /* If you clobber one part of a structure, you
 		     clobber the entire thing.  While this does not make
 		     the world a particularly nice place, it is necessary
@@ -594,9 +600,9 @@ set_initial_properties (struct alias_info *ai)
 	      /* Process variables we need to clobber all parts of.  */
 	      if (!bitmap_empty_p (queued))
 		{
-		  FOR_EACH_REFERENCED_VAR_IN_BITMAP (queued, alias, ri)
+		  EXECUTE_IF_SET_IN_BITMAP (queued, 0, j, bi)
 		    {
-		      subvar_t svars = get_subvars_for_var (alias);
+		      subvar_t svars = get_subvars_for_var (referenced_var (j));
 		      unsigned int i;
 		      tree subvar;
 
@@ -1182,11 +1188,13 @@ find_partition_for (mem_sym_stats_t mp_p)
 static void
 rewrite_alias_set_for (tree tag, bitmap new_aliases)
 {
-  referenced_var_iterator ri;
+  bitmap_iterator bi;
+  unsigned i;
   tree mpt, sym;
 
-  FOR_EACH_REFERENCED_VAR_IN_BITMAP (MTAG_ALIASES (tag), sym, ri)
+  EXECUTE_IF_SET_IN_BITMAP (MTAG_ALIASES (tag), 0, i, bi)
     {
+      sym = referenced_var (i);
       mpt = memory_partition (sym);
       if (mpt)
 	bitmap_set_bit (new_aliases, DECL_UID (mpt));
@@ -1297,10 +1305,9 @@ estimate_vop_reduction (struct mem_ref_stats_d *mem_ref_stats,
 static void
 update_reference_counts (struct mem_ref_stats_d *mem_ref_stats)
 {
-  referenced_var_iterator ri;
+  unsigned i;
+  bitmap_iterator bi;
   mem_sym_stats_t sym_stats;
-  unsigned int i;
-  tree sym;
 
   for (i = 1; i < num_ssa_names; i++)
     {
@@ -1313,7 +1320,9 @@ update_reference_counts (struct mem_ref_stats_d *mem_ref_stats)
 	  && (pi = SSA_NAME_PTR_INFO (ptr)) != NULL
 	  && pi->is_dereferenced)
 	{
-	  tree tag, alias;
+	  unsigned j;
+	  bitmap_iterator bj;
+	  tree tag;
 	  mem_sym_stats_t ptr_stats, tag_stats;
 
 	  /* If PTR has flow-sensitive points-to information, use
@@ -1339,8 +1348,9 @@ update_reference_counts (struct mem_ref_stats_d *mem_ref_stats)
 	     TAG's alias set, add as many indirect references to ALIAS
 	     as direct references there are for TAG.  */
 	  if (MTAG_ALIASES (tag))
-	    FOR_EACH_REFERENCED_VAR_IN_BITMAP (MTAG_ALIASES (tag), alias, ri)
+	    EXECUTE_IF_SET_IN_BITMAP (MTAG_ALIASES (tag), 0, j, bj)
 	      {
+		tree alias = referenced_var (j);
 		sym_stats = get_mem_sym_stats_for (alias);
 
 		/* All the direct references to TAG are indirect references
@@ -1360,8 +1370,9 @@ update_reference_counts (struct mem_ref_stats_d *mem_ref_stats)
 
   /* Call-clobbered symbols are indirectly written at every
      call/asm site.  */
-  FOR_EACH_REFERENCED_VAR_IN_BITMAP (gimple_call_clobbered_vars (cfun), sym, ri)
+  EXECUTE_IF_SET_IN_BITMAP (gimple_call_clobbered_vars (cfun), 0, i, bi)
     {
+      tree sym = referenced_var (i);
       sym_stats = get_mem_sym_stats_for (sym);
       sym_stats->num_indirect_writes += mem_ref_stats->num_call_sites
 	                                + mem_ref_stats->num_asm_sites;
@@ -1370,8 +1381,9 @@ update_reference_counts (struct mem_ref_stats_d *mem_ref_stats)
   /* Addressable symbols are indirectly written at some ASM sites.
      Since only ASM sites that clobber memory actually affect
      addressable symbols, this is an over-estimation.  */
-  FOR_EACH_REFERENCED_VAR_IN_BITMAP (gimple_addressable_vars (cfun), sym, ri)
+  EXECUTE_IF_SET_IN_BITMAP (gimple_addressable_vars (cfun), 0, i, bi)
     {
+      tree sym = referenced_var (i);
       sym_stats = get_mem_sym_stats_for (sym);
       sym_stats->num_indirect_writes += mem_ref_stats->num_asm_sites;
     }
@@ -3470,12 +3482,14 @@ dump_may_aliases_for (FILE *file, tree var)
   aliases = MTAG_ALIASES (var);
   if (aliases)
     {
-      referenced_var_iterator ri;
+      bitmap_iterator bi;
+      unsigned int i;
       tree al;
 
       fprintf (file, "{ ");
-      FOR_EACH_REFERENCED_VAR_IN_BITMAP (aliases, al, ri)
+      EXECUTE_IF_SET_IN_BITMAP (aliases, 0, i, bi)
 	{
+	  al = referenced_var (i);
 	  print_generic_expr (file, al, dump_flags);
 	  fprintf (file, " ");
 	}

gcc/tree-ssa-operands.c

@@ -1469,9 +1469,7 @@ add_virtual_operand (tree var, stmt_ann_t s_ann, int flags,
   if (MTAG_P (var))
     aliases = MTAG_ALIASES (var);
 
-  if (aliases == NULL
-      /* ???  We should not have created an empty aliases bitmap.  */
-      || bitmap_empty_p (aliases))
+  if (aliases == NULL)
     {
       if (!gimple_aliases_computed_p (cfun)
 	  && (flags & opf_def))
@@ -1485,16 +1483,18 @@ add_virtual_operand (tree var, stmt_ann_t s_ann, int flags,
     }
   else
     {
-      referenced_var_iterator ri;
+      bitmap_iterator bi;
+      unsigned int i;
       bool none_added = true;
-      tree al;
       
       /* The variable is aliased.  Add its aliases to the virtual
 	 operands.  */
       gcc_assert (!bitmap_empty_p (aliases));
 
-      FOR_EACH_REFERENCED_VAR_IN_BITMAP (aliases, al, ri)
+      EXECUTE_IF_SET_IN_BITMAP (aliases, 0, i, bi)
 	{
+	  tree al = referenced_var (i);
+
 	  /* For SFTs we have to consider all subvariables of the parent var
 	     if it is a potential points-to location.  */
 	  if (TREE_CODE (al) == STRUCT_FIELD_TAG
@@ -1779,10 +1779,10 @@ get_tmr_operands (tree stmt, tree expr, int flags)
 static void
 add_call_clobber_ops (tree stmt, tree callee)
 {
-  referenced_var_iterator ri;
+  unsigned u;
+  bitmap_iterator bi;
   stmt_ann_t s_ann = stmt_ann (stmt);
   bitmap not_read_b, not_written_b;
-  tree var;
   
   /* If we created .GLOBAL_VAR earlier, just use it.  */
   if (gimple_global_var (cfun))
@@ -1796,18 +1796,17 @@ add_call_clobber_ops (tree stmt, tree callee)
      set for each static if the call being processed does not read
      or write that variable.  */
   not_read_b = callee ? ipa_reference_get_not_read_global (callee) : NULL; 
-  not_written_b = callee ? ipa_reference_get_not_written_global (callee) : NULL;
+  not_written_b = callee ? ipa_reference_get_not_written_global (callee) : NULL; 
 
   /* Add a VDEF operand for every call clobbered variable.  */
-  FOR_EACH_REFERENCED_VAR_IN_BITMAP (gimple_call_clobbered_vars (cfun), var, ri)
+  EXECUTE_IF_SET_IN_BITMAP (gimple_call_clobbered_vars (cfun), 0, u, bi)
     {
-      unsigned int escape_mask;
+      tree var = referenced_var_lookup (u);
+      unsigned int escape_mask = var_ann (var)->escape_mask;
       tree real_var = var;
       bool not_read;
       bool not_written;
-
-      escape_mask = var_ann (var)->escape_mask;
-
+      
       /* Not read and not written are computed on regular vars, not
 	 subvars, so look at the parent var if this is an SFT. */
       if (TREE_CODE (var) == STRUCT_FIELD_TAG)
@@ -1864,10 +1863,10 @@ add_call_clobber_ops (tree stmt, tree callee)
 static void
 add_call_read_ops (tree stmt, tree callee)
 {
-  referenced_var_iterator ri;
+  unsigned u;
+  bitmap_iterator bi;
   stmt_ann_t s_ann = stmt_ann (stmt);
   bitmap not_read_b;
-  tree var;
 
   /* if the function is not pure, it may reference memory.  Add
      a VUSE for .GLOBAL_VAR if it has been created.  See add_referenced_var
@@ -1882,11 +1881,12 @@ add_call_read_ops (tree stmt, tree callee)
   not_read_b = callee ? ipa_reference_get_not_read_global (callee) : NULL; 
 
   /* Add a VUSE for each call-clobbered variable.  */
-  FOR_EACH_REFERENCED_VAR_IN_BITMAP (gimple_call_clobbered_vars (cfun), var, ri)
+  EXECUTE_IF_SET_IN_BITMAP (gimple_call_clobbered_vars (cfun), 0, u, bi)
     {
+      tree var = referenced_var (u);
       tree real_var = var;
       bool not_read;
-
+      
       clobber_stats.readonly_clobbers++;
 
       /* Not read and not written are computed on regular vars, not
@@ -2008,18 +2008,21 @@ get_asm_expr_operands (tree stmt)
   for (link = ASM_CLOBBERS (stmt); link; link = TREE_CHAIN (link))
     if (strcmp (TREE_STRING_POINTER (TREE_VALUE (link)), "memory") == 0)
       {
-	referenced_var_iterator ri;
-	tree var;
+	unsigned i;
+	bitmap_iterator bi;
 
 	s_ann->references_memory = true;
 
-	FOR_EACH_REFERENCED_VAR_IN_BITMAP (gimple_call_clobbered_vars (cfun),
-					   var, ri)
-	  add_stmt_operand (&var, s_ann, opf_def | opf_implicit);
+	EXECUTE_IF_SET_IN_BITMAP (gimple_call_clobbered_vars (cfun), 0, i, bi)
+	  {
+	    tree var = referenced_var (i);
+	    add_stmt_operand (&var, s_ann, opf_def | opf_implicit);
+	  }
 
-	FOR_EACH_REFERENCED_VAR_IN_BITMAP (gimple_addressable_vars (cfun),
-					   var, ri)
+	EXECUTE_IF_SET_IN_BITMAP (gimple_addressable_vars (cfun), 0, i, bi)
 	  {
+	    tree var = referenced_var (i);
+
 	    /* Subvars are explicitly represented in this list, so we
 	       don't need the original to be added to the clobber ops,
 	       but the original *will* be in this list because we keep

gcc/tree-ssa-structalias.c

@@ -3313,11 +3313,12 @@ update_alias_info (tree stmt, struct alias_info *ai)
 	 call-clobbered.  */
       if (stmt_escape_type != NO_ESCAPE)
 	{
-	  referenced_var_iterator ri;
-	  tree rvar;
+	  bitmap_iterator bi;
+	  unsigned i;
 
-	  FOR_EACH_REFERENCED_VAR_IN_BITMAP (addr_taken, rvar, ri)
+	  EXECUTE_IF_SET_IN_BITMAP (addr_taken, 0, i, bi)
 	    {
+	      tree rvar = referenced_var (i);
 	      if (!unmodifiable_var_p (rvar))
 		mark_call_clobbered (rvar, stmt_escape_type);
 	    }
@@ -3475,8 +3476,8 @@ update_alias_info (tree stmt, struct alias_info *ai)
      memory reference stats for all memory symbols referenced by STMT.  */
   if (stmt_references_memory_p (stmt))
     {
-      referenced_var_iterator ri;
-      tree sym;
+      unsigned i;
+      bitmap_iterator bi;
 
       mem_ref_stats->num_mem_stmts++;
 
@@ -3503,8 +3504,9 @@ update_alias_info (tree stmt, struct alias_info *ai)
 	 memory symbols in its argument list, but these cases do not
 	 occur so frequently as to constitute a serious problem.  */
       if (STORED_SYMS (stmt))
-	FOR_EACH_REFERENCED_VAR_IN_BITMAP (STORED_SYMS (stmt), sym, ri)
+	EXECUTE_IF_SET_IN_BITMAP (STORED_SYMS (stmt), 0, i, bi)
 	  {
+	    tree sym = referenced_var (i);
 	    pointer_set_insert (ai->written_vars, sym);
 	    if (!stmt_dereferences_ptr_p
 		&& stmt_escape_type != ESCAPE_TO_CALL
@@ -3518,8 +3520,8 @@ update_alias_info (tree stmt, struct alias_info *ai)
 	  && stmt_escape_type != ESCAPE_TO_CALL
 	  && stmt_escape_type != ESCAPE_TO_PURE_CONST
 	  && stmt_escape_type != ESCAPE_TO_ASM)
-	FOR_EACH_REFERENCED_VAR_IN_BITMAP (LOADED_SYMS (stmt), sym, ri)
-	  update_mem_sym_stats_from_stmt (sym, stmt, 1, 0);
+	EXECUTE_IF_SET_IN_BITMAP (LOADED_SYMS (stmt), 0, i, bi)
+	  update_mem_sym_stats_from_stmt (referenced_var (i), stmt, 1, 0);
     }
 }
 
@@ -4879,6 +4881,8 @@ set_used_smts (void)
 static void
 merge_smts_into (tree p, bitmap solution)
 {
+  unsigned int i;
+  bitmap_iterator bi;
   tree smt;
   bitmap aliases;
   tree var = p;
@@ -4890,19 +4894,18 @@ merge_smts_into (tree p, bitmap solution)
   if (smt)
     {
       alias_set_type smtset = get_alias_set (TREE_TYPE (smt));
-      referenced_var_iterator ri;
-      tree newsmt;
 
       /* Need to set the SMT subsets first before this
 	 will work properly.  */
       bitmap_set_bit (solution, DECL_UID (smt));
-      FOR_EACH_REFERENCED_VAR_IN_BITMAP (used_smts, newsmt, ri)
+      EXECUTE_IF_SET_IN_BITMAP (used_smts, 0, i, bi)
 	{
+	  tree newsmt = referenced_var (i);
 	  tree newsmttype = TREE_TYPE (newsmt);
 
 	  if (alias_set_subset_of (get_alias_set (newsmttype),
 				   smtset))
-	    bitmap_set_bit (solution, DECL_UID (newsmt));
+	    bitmap_set_bit (solution, i);
 	}
 
       aliases = MTAG_ALIASES (smt);

gcc/tree-ssa.c

@@ -378,23 +378,28 @@ verify_flow_insensitive_alias_info (void)
 
   FOR_EACH_REFERENCED_VAR (var, rvi)
     {
+      unsigned int j;
       bitmap aliases;
       tree alias;
-      referenced_var_iterator ri;
+      bitmap_iterator bi;
 
       if (!MTAG_P (var) || !MTAG_ALIASES (var))
 	continue;
       
       aliases = MTAG_ALIASES (var);
 
-      FOR_EACH_REFERENCED_VAR_IN_BITMAP (aliases, alias, ri)
-	if (TREE_CODE (alias) != MEMORY_PARTITION_TAG
-	    && !may_be_aliased (alias))
-	  {
-	    error ("non-addressable variable inside an alias set");
-	    debug_variable (alias);
-	    goto err;
-	  }
+      EXECUTE_IF_SET_IN_BITMAP (aliases, 0, j, bi)
+	{
+	  alias = referenced_var (j);
+
+	  if (TREE_CODE (alias) != MEMORY_PARTITION_TAG
+	      && !may_be_aliased (alias))
+	    {
+	      error ("non-addressable variable inside an alias set");
+	      debug_variable (alias);
+	      goto err;
+	    }
+	}
     }
 
   return;
@@ -481,17 +486,20 @@ err:
 static void
 verify_call_clobbering (void)
 {
-  referenced_var_iterator rvi;
+  unsigned int i;
+  bitmap_iterator bi;
   tree var;
+  referenced_var_iterator rvi;
 
   /* At all times, the result of the call_clobbered flag should
      match the result of the call_clobbered_vars bitmap.  Verify both
      that everything in call_clobbered_vars is marked
      call_clobbered, and that everything marked
      call_clobbered is in call_clobbered_vars.  */
-  FOR_EACH_REFERENCED_VAR_IN_BITMAP (gimple_call_clobbered_vars (cfun),
-				     var, rvi)
+  EXECUTE_IF_SET_IN_BITMAP (gimple_call_clobbered_vars (cfun), 0, i, bi)
     {
+      var = referenced_var (i);
+
       if (memory_partition (var))
 	var = memory_partition (var);
 
@@ -542,8 +550,8 @@ verify_memory_partitions (void)
 
   for (i = 0; VEC_iterate (tree, mpt_table, i, mpt); i++)
     {
-      referenced_var_iterator ri;
-      tree var;
+      unsigned j;
+      bitmap_iterator bj;
 
       if (MPT_SYMBOLS (mpt) == NULL)
 	{
@@ -552,14 +560,17 @@ verify_memory_partitions (void)
 	  goto err;
 	}
 
-      FOR_EACH_REFERENCED_VAR_IN_BITMAP (MPT_SYMBOLS (mpt), var, ri)
-	if (pointer_set_insert (partitioned_syms, var))
-	  {
-	    error ("Partitioned symbols should belong to exactly one "
-		   "partition");
-	    debug_variable (var);
-	    goto err;
-	  }
+      EXECUTE_IF_SET_IN_BITMAP (MPT_SYMBOLS (mpt), 0, j, bj)
+	{
+	  tree var = referenced_var (j);
+	  if (pointer_set_insert (partitioned_syms, var))
+	    {
+	      error ("Partitioned symbols should belong to exactly one "
+		     "partition");
+	      debug_variable (var);
+	      goto err;
+	    }
+	}
     }
 
   pointer_set_destroy (partitioned_syms);
@@ -763,6 +774,24 @@ int_tree_map_hash (const void *item)
   return ((const struct int_tree_map *)item)->uid;
 }
 
+/* Return true if the DECL_UID in both trees are equal.  */
+
+int
+uid_decl_map_eq (const void *va, const void *vb)
+{
+  const_tree a = (const_tree) va;
+  const_tree b = (const_tree) vb;
+  return (a->decl_minimal.uid == b->decl_minimal.uid);
+}
+
+/* Hash a tree in a uid_decl_map.  */
+
+unsigned int
+uid_decl_map_hash (const void *item)
+{
+  return ((const_tree)item)->decl_minimal.uid;
+}
+
 /* Return true if the uid in both int tree maps are equal.  */
 
 static int
@@ -806,7 +835,8 @@ void
 init_tree_ssa (void)
 {
   cfun->gimple_df = GGC_CNEW (struct gimple_df);
-  cfun->gimple_df->referenced_vars = BITMAP_GGC_ALLOC ();
+  cfun->gimple_df->referenced_vars = htab_create_ggc (20, uid_decl_map_hash, 
+				     		      uid_decl_map_eq, NULL);
   cfun->gimple_df->default_defs = htab_create_ggc (20, uid_ssaname_map_hash, 
 				                   uid_ssaname_map_eq, NULL);
   cfun->gimple_df->var_anns = htab_create_ggc (20, var_ann_hash, 
@@ -863,6 +893,7 @@ delete_tree_ssa (void)
         ggc_free (var->base.ann);
       var->base.ann = NULL;
     }
+  htab_delete (gimple_referenced_vars (cfun));
   cfun->gimple_df->referenced_vars = NULL;
 
   fini_ssanames ();

gcc/tree.c

@@ -110,12 +110,6 @@ static GTY(()) int next_decl_uid;
 /* Unique id for next type created.  */
 static GTY(()) int next_type_uid = 1;
 
-/* Mapping from unique DECL_UID to the decl tree node.  */
-static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
-     htab_t decl_for_uid_map;
-
-static void insert_decl_to_uid_decl_map (tree);
-
 /* Since we cannot rehash a type after it is in the table, we have to
    keep the hash code.  */
 
@@ -237,9 +231,6 @@ init_ttree (void)
   
   int_cst_node = make_node (INTEGER_CST);
 
-  decl_for_uid_map = htab_create_ggc (4093, uid_decl_map_hash,
-				      uid_decl_map_eq, NULL);
-
   tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON] = 1;
   tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_NON_COMMON] = 1;
   tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON] = 1;
@@ -610,7 +601,6 @@ make_node_stat (enum tree_code code MEM_STAT_DECL)
 	}
       DECL_SOURCE_LOCATION (t) = input_location;
       DECL_UID (t) = next_decl_uid++;
-      insert_decl_to_uid_decl_map (t);
 
       break;
 
@@ -714,7 +704,6 @@ copy_node_stat (tree node MEM_STAT_DECL)
 	  SET_DECL_RESTRICT_BASE (t, DECL_GET_RESTRICT_BASE (node));
 	  DECL_BASED_ON_RESTRICT_P (t) = 1;
 	}
-      insert_decl_to_uid_decl_map (t);
     }
   else if (TREE_CODE_CLASS (code) == tcc_type)
     {
@@ -3336,70 +3325,6 @@ build_nt_call_list (tree fn, tree arglist)
   return t;
 }
 
-/* Return true if the DECL_UID in both trees are equal.  */
-
-int
-uid_decl_map_eq (const void *va, const void *vb)
-{
-  const_tree a = (const_tree) va;
-  const_tree b = (const_tree) vb;
-  return (a->decl_minimal.uid == b->decl_minimal.uid);
-}
-
-/* Hash a tree in a uid_decl_map.  */
-
-unsigned int
-uid_decl_map_hash (const void *item)
-{
-  return ((const_tree)item)->decl_minimal.uid;
-}
-
-/* Insert the declaration NODE into the map mapping its unique uid
-   back to the tree.  */
-
-static void
-insert_decl_to_uid_decl_map (tree node)
-{
-  void **slot;
-  struct tree_decl_minimal key;
-
-  key.uid = DECL_UID (node);
-  slot = htab_find_slot_with_hash (decl_for_uid_map,
-				   &key, DECL_UID (node), INSERT);
-
-  /* We should never try to re-insert a decl with the same uid.
-     ???  The C++ frontend breaks this invariant.  Hopefully in a
-     non-fatal way, so just overwrite the slot in this case.  */
-#if 0
-  gcc_assert (!*slot);
-#endif
-
-  *(tree *)slot = node;
-}
-
-/* Lookup the declaration tree from its unique DECL_UID UID.  Returns
-   the tree node with DECL_UID UID or NULL, if this node was collected.  */
-
-tree
-lookup_decl_from_uid (int uid)
-{
-  struct tree_decl_minimal key;
-
-  key.uid = uid;
-  return (tree) htab_find_with_hash (decl_for_uid_map, &key, uid);
-}
-
-/* Print out the statistics for the decl_for_uid_map hash table.  */
-
-static void
-print_decl_for_uid_map_statistics (void)
-{
-  fprintf (stderr, "DECL_FOR_UID_MAP hash: size %ld, %ld elements, %f collisions\n",
-	   (long) htab_size (decl_for_uid_map),
-	   (long) htab_elements (decl_for_uid_map),
-	   htab_collisions (decl_for_uid_map));
-}
-
 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
    We do NOT enter this node in any sort of symbol table.
 
@@ -6729,7 +6654,6 @@ dump_tree_statistics (void)
   print_debug_expr_statistics ();
   print_value_expr_statistics ();
   print_restrict_base_statistics ();
-  print_decl_for_uid_map_statistics ();
   lang_hooks.print_statistics ();
 }
 

gcc/tree.h

@@ -5233,12 +5233,6 @@ struct tree_int_map GTY(())
 #define tree_int_map_hash tree_map_base_hash
 #define tree_int_map_marked_p tree_map_base_marked_p
 
-/* Map from a DECL_UID to the decl tree.  */
-
-extern unsigned int uid_decl_map_hash (const void *);
-extern int uid_decl_map_eq (const void *, const void *);
-extern tree lookup_decl_from_uid (int);
-
 /* Map from a tree to initialization/finalization priorities.  */
 
 struct tree_priority_map GTY(())