sbitmap.h (struct int_list): Remove.

	* sbitmap.h (struct int_list): Remove.
	(sbitmap_intersect_of_predsucc, sbitmap_union_of_predsucc):
	Remove prototypes of non-existing function.
	(sbitmap_intersect_of_predecessors, sbitmap_intersect_of_successors,
	sbitmap_union_of_predecessors, sbitmap_union_of_successors): Remove
	unused defines.
	(sbitmap_intersection_of_succs, sbitmap_intersection_of_preds,
	sbitmap_union_of_succs, sbitmap_union_of_preds): Move prototypes to...
	* basic-block.h: ... here.
	* sbitmap.c: Do not include basic-block.h.
	(sbitmap_intersection_of_succs, sbitmap_intersection_of_preds,
	sbitmap_union_of_succs, sbitmap_union_of_preds): Move functions to...
	* cfganal.c: ... here.
	* bt-load.c (compute_out, link_btr_uses): Update for above changes.
	* gcse.c (compute_code_hoist_vbeinout): Likewise.
	* lcm.c (compute_antinout_edge, compute_available): Likewise.
	* Makefile.in: Fix sbitmap.o dependencies.

From-SVN: r189785

9 files changed, 210 insertions, 218 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 4ffeb4ef726..6ab125ca83a 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,23 @@
+2012-07-22  Steven Bosscher  <steven@gcc.gnu.org>
+
+	* sbitmap.h (struct int_list): Remove.
+	(sbitmap_intersect_of_predsucc, sbitmap_union_of_predsucc):
+	Remove prototypes of non-existing function.
+	(sbitmap_intersect_of_predecessors, sbitmap_intersect_of_successors,
+	sbitmap_union_of_predecessors, sbitmap_union_of_successors): Remove
+	unused defines.
+	(sbitmap_intersection_of_succs, sbitmap_intersection_of_preds,
+	sbitmap_union_of_succs, sbitmap_union_of_preds): Move prototypes to...
+	* basic-block.h: ... here.
+	* sbitmap.c: Do not include basic-block.h.
+	(sbitmap_intersection_of_succs, sbitmap_intersection_of_preds,
+	sbitmap_union_of_succs, sbitmap_union_of_preds): Move functions to...
+	* cfganal.c: ... here.
+	* bt-load.c (compute_out, link_btr_uses): Update for above changes.
+	* gcse.c (compute_code_hoist_vbeinout): Likewise.
+	* lcm.c (compute_antinout_edge, compute_available): Likewise.
+	* Makefile.in: Fix sbitmap.o dependencies.
+
 2012-07-23  Jan-Benedict Glaw  <jbglaw@lug-owl.de>
 	    Nick Clifton  <nickc@redhat.com>
 
diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index d48c696e831..c688fa58805 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -1842,7 +1842,7 @@ graph.o: graph.c $(SYSTEM_H) coretypes.h $(TM_H) toplev.h $(DIAGNOSTIC_CORE_H) $
     $(RTL_H) $(FUNCTION_H) hard-reg-set.h $(BASIC_BLOCK_H) graph.h $(OBSTACK_H) \
     $(CONFIG_H) $(EMIT_RTL_H)
 
-sbitmap.o: sbitmap.c sbitmap.h $(CONFIG_H) $(SYSTEM_H) coretypes.h $(BASIC_BLOCK_H)
+sbitmap.o: sbitmap.c sbitmap.h $(CONFIG_H) $(SYSTEM_H) coretypes.h
 ebitmap.o: ebitmap.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(EBITMAP_H)
 sparseset.o: sparseset.c $(SYSTEM_H) sparseset.h $(CONFIG_H)
 
diff --git a/gcc/basic-block.h b/gcc/basic-block.h
index 24f178f3e75..15d34e0e1ac 100644
--- a/gcc/basic-block.h
+++ b/gcc/basic-block.h
@@ -674,6 +674,12 @@ ei_cond (edge_iterator ei, edge *p)
 #define CLEANUP_CFGLAYOUT	32	/* Do cleanup in cfglayout mode.  */
 #define CLEANUP_CFG_CHANGED	64      /* The caller changed the CFG.  */
 
+/* In cfganal.c */
+extern void sbitmap_intersection_of_succs (sbitmap, sbitmap *, basic_block);
+extern void sbitmap_intersection_of_preds (sbitmap, sbitmap *, basic_block);
+extern void sbitmap_union_of_succs (sbitmap, sbitmap *, basic_block);
+extern void sbitmap_union_of_preds (sbitmap, sbitmap *, basic_block);
+
 /* In lcm.c */
 extern struct edge_list *pre_edge_lcm (int, sbitmap *, sbitmap *,
 				       sbitmap *, sbitmap *, sbitmap **,
diff --git a/gcc/bt-load.c b/gcc/bt-load.c
index 7ec4454746d..2cab03cc86e 100644
--- a/gcc/bt-load.c
+++ b/gcc/bt-load.c
@@ -650,7 +650,7 @@ compute_out (sbitmap *bb_out, sbitmap *bb_gen, sbitmap *bb_kill, int max_uid)
       changed = 0;
       for (i = NUM_FIXED_BLOCKS; i < last_basic_block; i++)
 	{
-	  sbitmap_union_of_preds (bb_in, bb_out, i);
+	  sbitmap_union_of_preds (bb_in, bb_out, BASIC_BLOCK (i));
 	  changed |= sbitmap_union_of_diff_cg (bb_out[i], bb_gen[i],
 					       bb_in, bb_kill[i]);
 	}
@@ -673,7 +673,7 @@ link_btr_uses (btr_def *def_array, btr_user *use_array, sbitmap *bb_out,
       rtx insn;
       rtx last;
 
-      sbitmap_union_of_preds (reaching_defs, bb_out, i);
+      sbitmap_union_of_preds (reaching_defs, bb_out, BASIC_BLOCK (i));
       for (insn = BB_HEAD (bb), last = NEXT_INSN (BB_END (bb));
 	   insn != last;
 	   insn = NEXT_INSN (insn))
diff --git a/gcc/cfganal.c b/gcc/cfganal.c
index c906e17e358..692be3808b8 100644
--- a/gcc/cfganal.c
+++ b/gcc/cfganal.c
@@ -1182,4 +1182,177 @@ compute_idf (bitmap def_blocks, bitmap_head *dfs)
   return phi_insertion_points;
 }
 
+/* Intersection and union of preds/succs for sbitmap based data flow
+   solvers.  All four functions defined below take the same arguments:
+   B is the basic block to perform the operation for.  DST is the
+   target sbitmap, i.e. the result.  SRC is an sbitmap vector of size
+   last_basic_block so that it can be indexed with basic block indices.
+   DST may be (but does not have to be) SRC[B->index].  */
 
+/* Set the bitmap DST to the intersection of SRC of successors of
+   basic block B.  */
+
+void
+sbitmap_intersection_of_succs (sbitmap dst, sbitmap *src,
+			       basic_block b)
+{
+  unsigned int set_size = dst->size;
+  edge e;
+  unsigned ix;
+
+  gcc_assert (!dst->popcount);
+
+  for (e = NULL, ix = 0; ix < EDGE_COUNT (b->succs); ix++)
+    {
+      e = EDGE_SUCC (b, ix);
+      if (e->dest == EXIT_BLOCK_PTR)
+	continue;
+
+      sbitmap_copy (dst, src[e->dest->index]);
+      break;
+    }
+
+  if (e == 0)
+    sbitmap_ones (dst);
+  else
+    for (++ix; ix < EDGE_COUNT (b->succs); ix++)
+      {
+	unsigned int i;
+	SBITMAP_ELT_TYPE *p, *r;
+
+	e = EDGE_SUCC (b, ix);
+	if (e->dest == EXIT_BLOCK_PTR)
+	  continue;
+
+	p = src[e->dest->index]->elms;
+	r = dst->elms;
+	for (i = 0; i < set_size; i++)
+	  *r++ &= *p++;
+      }
+}
+
+/* Set the bitmap DST to the intersection of SRC of predecessors of
+   basic block B.  */
+
+void
+sbitmap_intersection_of_preds (sbitmap dst, sbitmap *src,
+			       basic_block b)
+{
+  unsigned int set_size = dst->size;
+  edge e;
+  unsigned ix;
+
+  gcc_assert (!dst->popcount);
+
+  for (e = NULL, ix = 0; ix < EDGE_COUNT (b->preds); ix++)
+    {
+      e = EDGE_PRED (b, ix);
+      if (e->src == ENTRY_BLOCK_PTR)
+	continue;
+
+      sbitmap_copy (dst, src[e->src->index]);
+      break;
+    }
+
+  if (e == 0)
+    sbitmap_ones (dst);
+  else
+    for (++ix; ix < EDGE_COUNT (b->preds); ix++)
+      {
+	unsigned int i;
+	SBITMAP_ELT_TYPE *p, *r;
+
+	e = EDGE_PRED (b, ix);
+	if (e->src == ENTRY_BLOCK_PTR)
+	  continue;
+
+	p = src[e->src->index]->elms;
+	r = dst->elms;
+	for (i = 0; i < set_size; i++)
+	  *r++ &= *p++;
+      }
+}
+
+/* Set the bitmap DST to the union of SRC of successors of
+   basic block B.  */
+
+void
+sbitmap_union_of_succs (sbitmap dst, sbitmap *src,
+			basic_block b)
+{
+  unsigned int set_size = dst->size;
+  edge e;
+  unsigned ix;
+
+  gcc_assert (!dst->popcount);
+
+  for (ix = 0; ix < EDGE_COUNT (b->succs); ix++)
+    {
+      e = EDGE_SUCC (b, ix);
+      if (e->dest == EXIT_BLOCK_PTR)
+	continue;
+
+      sbitmap_copy (dst, src[e->dest->index]);
+      break;
+    }
+
+  if (ix == EDGE_COUNT (b->succs))
+    sbitmap_zero (dst);
+  else
+    for (ix++; ix < EDGE_COUNT (b->succs); ix++)
+      {
+	unsigned int i;
+	SBITMAP_ELT_TYPE *p, *r;
+
+	e = EDGE_SUCC (b, ix);
+	if (e->dest == EXIT_BLOCK_PTR)
+	  continue;
+
+	p = src[e->dest->index]->elms;
+	r = dst->elms;
+	for (i = 0; i < set_size; i++)
+	  *r++ |= *p++;
+      }
+}
+
+/* Set the bitmap DST to the union of SRC of predecessors of
+   basic block B.  */
+
+void
+sbitmap_union_of_preds (sbitmap dst, sbitmap *src,
+			basic_block b)
+{
+  unsigned int set_size = dst->size;
+  edge e;
+  unsigned ix;
+
+  gcc_assert (!dst->popcount);
+
+  for (ix = 0; ix < EDGE_COUNT (b->preds); ix++)
+    {
+      e = EDGE_PRED (b, ix);
+      if (e->src== ENTRY_BLOCK_PTR)
+	continue;
+
+      sbitmap_copy (dst, src[e->src->index]);
+      break;
+    }
+
+  if (ix == EDGE_COUNT (b->preds))
+    sbitmap_zero (dst);
+  else
+    for (ix++; ix < EDGE_COUNT (b->preds); ix++)
+      {
+	unsigned int i;
+	SBITMAP_ELT_TYPE *p, *r;
+
+	e = EDGE_PRED (b, ix);
+	if (e->src == ENTRY_BLOCK_PTR)
+	  continue;
+
+	p = src[e->src->index]->elms;
+	r = dst->elms;
+	for (i = 0; i < set_size; i++)
+	  *r++ |= *p++;
+      }
+}
diff --git a/gcc/gcse.c b/gcc/gcse.c
index fd5a89763a6..f7c42d20092 100644
--- a/gcc/gcse.c
+++ b/gcc/gcse.c
@@ -2790,7 +2790,7 @@ compute_code_hoist_vbeinout (void)
 	  if (bb->next_bb != EXIT_BLOCK_PTR)
 	    {
 	      sbitmap_intersection_of_succs (hoist_vbeout[bb->index],
-					     hoist_vbein, bb->index);
+					     hoist_vbein, bb);
 
 	      /* Include expressions in VBEout that are calculated
 		 in BB and available at its end.  */
diff --git a/gcc/lcm.c b/gcc/lcm.c
index 236dbf351c3..fec2ba45d30 100644
--- a/gcc/lcm.c
+++ b/gcc/lcm.c
@@ -145,7 +145,7 @@ compute_antinout_edge (sbitmap *antloc, sbitmap *transp, sbitmap *antin,
 	  /* Clear the aux field of this block so that it can be added to
 	     the worklist again if necessary.  */
 	  bb->aux = NULL;
-	  sbitmap_intersection_of_succs (antout[bb->index], antin, bb->index);
+	  sbitmap_intersection_of_succs (antout[bb->index], antin, bb);
 	}
 
       if (sbitmap_a_or_b_and_c_cg (antin[bb->index], antloc[bb->index],
@@ -526,7 +526,7 @@ compute_available (sbitmap *avloc, sbitmap *kill, sbitmap *avout,
 	  /* Clear the aux field of this block so that it can be added to
 	     the worklist again if necessary.  */
 	  bb->aux = NULL;
-	  sbitmap_intersection_of_preds (avin[bb->index], avout, bb->index);
+	  sbitmap_intersection_of_preds (avin[bb->index], avout, bb);
 	}
 
       if (sbitmap_union_of_diff_cg (avout[bb->index], avloc[bb->index],
diff --git a/gcc/sbitmap.c b/gcc/sbitmap.c
index 23d459ec309..d606736c4c7 100644
--- a/gcc/sbitmap.c
+++ b/gcc/sbitmap.c
@@ -23,15 +23,6 @@ along with GCC; see the file COPYING3.  If not see
 #include "coretypes.h"
 #include "sbitmap.h"
 
-#ifdef IN_GCC
-/* FIXME: sbitmap is just a data structure, but we define dataflow functions
-   here also.  This is conditional on IN_GCC (see second #ifdef IN_GCC
-   further down).
-   For now, also only conditionally include basic-block.h, but we should
-   find a better place for the dataflow functions.  Perhaps cfganal.c?  */
-#include "basic-block.h"
-#endif
-
 #if GCC_VERSION >= 3400
 #  if HOST_BITS_PER_WIDEST_FAST_INT == HOST_BITS_PER_LONG
 #    define do_popcount(x) __builtin_popcountl(x)
@@ -744,184 +735,6 @@ sbitmap_a_and_b_or_c (sbitmap dst, const_sbitmap a, const_sbitmap b, const_sbitm
     *dstp++ = *ap++ & (*bp++ | *cp++);
 }
 
-#ifdef IN_GCC
-/* FIXME: depends on basic-block.h, see comment at start of this file.
-
-   Ironically, the comments before the functions below suggest they do
-   dataflow using the "new flow graph structures", but that's the *old*
-   new data structures.  The functions receive basic block numbers and
-   use BASIC_BLOCK(idx) to get the basic block.  They should receive
-   the basic block directly,  *sigh*.  */
-
-/* Set the bitmap DST to the intersection of SRC of successors of
-   block number BB, using the new flow graph structures.  */
-
-void
-sbitmap_intersection_of_succs (sbitmap dst, sbitmap *src, int bb)
-{
-  basic_block b = BASIC_BLOCK (bb);
-  unsigned int set_size = dst->size;
-  edge e;
-  unsigned ix;
-
-  gcc_assert (!dst->popcount);
-
-  for (e = NULL, ix = 0; ix < EDGE_COUNT (b->succs); ix++)
-    {
-      e = EDGE_SUCC (b, ix);
-      if (e->dest == EXIT_BLOCK_PTR)
-	continue;
-
-      sbitmap_copy (dst, src[e->dest->index]);
-      break;
-    }
-
-  if (e == 0)
-    sbitmap_ones (dst);
-  else
-    for (++ix; ix < EDGE_COUNT (b->succs); ix++)
-      {
-	unsigned int i;
-	sbitmap_ptr p, r;
-
-	e = EDGE_SUCC (b, ix);
-	if (e->dest == EXIT_BLOCK_PTR)
-	  continue;
-
-	p = src[e->dest->index]->elms;
-	r = dst->elms;
-	for (i = 0; i < set_size; i++)
-	  *r++ &= *p++;
-      }
-}
-
-/* Set the bitmap DST to the intersection of SRC of predecessors of
-   block number BB, using the new flow graph structures.  */
-
-void
-sbitmap_intersection_of_preds (sbitmap dst, sbitmap *src, int bb)
-{
-  basic_block b = BASIC_BLOCK (bb);
-  unsigned int set_size = dst->size;
-  edge e;
-  unsigned ix;
-
-  gcc_assert (!dst->popcount);
-
-  for (e = NULL, ix = 0; ix < EDGE_COUNT (b->preds); ix++)
-    {
-      e = EDGE_PRED (b, ix);
-      if (e->src == ENTRY_BLOCK_PTR)
-	continue;
-
-      sbitmap_copy (dst, src[e->src->index]);
-      break;
-    }
-
-  if (e == 0)
-    sbitmap_ones (dst);
-  else
-    for (++ix; ix < EDGE_COUNT (b->preds); ix++)
-      {
-	unsigned int i;
-	sbitmap_ptr p, r;
-
-	e = EDGE_PRED (b, ix);
-	if (e->src == ENTRY_BLOCK_PTR)
-	  continue;
-
-	p = src[e->src->index]->elms;
-	r = dst->elms;
-	for (i = 0; i < set_size; i++)
-	  *r++ &= *p++;
-      }
-}
-
-/* Set the bitmap DST to the union of SRC of successors of
-   block number BB, using the new flow graph structures.  */
-
-void
-sbitmap_union_of_succs (sbitmap dst, sbitmap *src, int bb)
-{
-  basic_block b = BASIC_BLOCK (bb);
-  unsigned int set_size = dst->size;
-  edge e;
-  unsigned ix;
-
-  gcc_assert (!dst->popcount);
-
-  for (ix = 0; ix < EDGE_COUNT (b->succs); ix++)
-    {
-      e = EDGE_SUCC (b, ix);
-      if (e->dest == EXIT_BLOCK_PTR)
-	continue;
-
-      sbitmap_copy (dst, src[e->dest->index]);
-      break;
-    }
-
-  if (ix == EDGE_COUNT (b->succs))
-    sbitmap_zero (dst);
-  else
-    for (ix++; ix < EDGE_COUNT (b->succs); ix++)
-      {
-	unsigned int i;
-	sbitmap_ptr p, r;
-
-	e = EDGE_SUCC (b, ix);
-	if (e->dest == EXIT_BLOCK_PTR)
-	  continue;
-
-	p = src[e->dest->index]->elms;
-	r = dst->elms;
-	for (i = 0; i < set_size; i++)
-	  *r++ |= *p++;
-      }
-}
-
-/* Set the bitmap DST to the union of SRC of predecessors of
-   block number BB, using the new flow graph structures.  */
-
-void
-sbitmap_union_of_preds (sbitmap dst, sbitmap *src, int bb)
-{
-  basic_block b = BASIC_BLOCK (bb);
-  unsigned int set_size = dst->size;
-  edge e;
-  unsigned ix;
-
-  gcc_assert (!dst->popcount);
-
-  for (ix = 0; ix < EDGE_COUNT (b->preds); ix++)
-    {
-      e = EDGE_PRED (b, ix);
-      if (e->src== ENTRY_BLOCK_PTR)
-	continue;
-
-      sbitmap_copy (dst, src[e->src->index]);
-      break;
-    }
-
-  if (ix == EDGE_COUNT (b->preds))
-    sbitmap_zero (dst);
-  else
-    for (ix++; ix < EDGE_COUNT (b->preds); ix++)
-      {
-	unsigned int i;
-	sbitmap_ptr p, r;
-
-	e = EDGE_PRED (b, ix);
-	if (e->src == ENTRY_BLOCK_PTR)
-	  continue;
-
-	p = src[e->src->index]->elms;
-	r = dst->elms;
-	for (i = 0; i < set_size; i++)
-	  *r++ |= *p++;
-      }
-}
-#endif
-
 /* Return number of first bit set in the bitmap, -1 if none.  */
 
 int
@@ -1021,13 +834,13 @@ void
 dump_sbitmap_vector (FILE *file, const char *title, const char *subtitle,
 		     sbitmap *bmaps, int n_maps)
 {
-  int bb;
+  int i;
 
   fprintf (file, "%s\n", title);
-  for (bb = 0; bb < n_maps; bb++)
+  for (i = 0; i < n_maps; i++)
     {
-      fprintf (file, "%s %d\n", subtitle, bb);
-      dump_sbitmap (file, bmaps[bb]);
+      fprintf (file, "%s %d\n", subtitle, i);
+      dump_sbitmap (file, bmaps[i]);
     }
 
   fprintf (file, "\n");
diff --git a/gcc/sbitmap.h b/gcc/sbitmap.h
index f78e0bf2866..9bd4ccdcde0 100644
--- a/gcc/sbitmap.h
+++ b/gcc/sbitmap.h
@@ -201,8 +201,6 @@ do {									\
 #define sbitmap_free(MAP)		(free((MAP)->popcount), free((MAP)))
 #define sbitmap_vector_free(VEC)	free(VEC)
 
-struct int_list;
-
 extern void dump_sbitmap (FILE *, const_sbitmap);
 extern void dump_sbitmap_file (FILE *, const_sbitmap);
 extern void dump_sbitmap_vector (FILE *, const char *, const char *, sbitmap *,
@@ -241,26 +239,8 @@ extern bool sbitmap_a_subset_b_p (const_sbitmap, const_sbitmap);
 extern int sbitmap_first_set_bit (const_sbitmap);
 extern int sbitmap_last_set_bit (const_sbitmap);
 
-extern void sbitmap_intersect_of_predsucc (sbitmap, sbitmap *, int,
-					   struct int_list **);
-#define sbitmap_intersect_of_predecessors  sbitmap_intersect_of_predsucc
-#define sbitmap_intersect_of_successors    sbitmap_intersect_of_predsucc
-
-extern void sbitmap_union_of_predsucc (sbitmap, sbitmap *, int,
-				       struct int_list **);
-#define sbitmap_union_of_predecessors  sbitmap_union_of_predsucc
-#define sbitmap_union_of_successors    sbitmap_union_of_predsucc
-
-/* Intersection and Union of preds/succs using the new flow graph
-   structure instead of the pred/succ arrays.  */
-
-extern void sbitmap_intersection_of_succs (sbitmap, sbitmap *, int);
-extern void sbitmap_intersection_of_preds (sbitmap, sbitmap *, int);
-extern void sbitmap_union_of_succs (sbitmap, sbitmap *, int);
-extern void sbitmap_union_of_preds (sbitmap, sbitmap *, int);
-
 extern void debug_sbitmap (const_sbitmap);
 extern sbitmap sbitmap_realloc (sbitmap, unsigned int);
-extern unsigned long sbitmap_popcount(const_sbitmap, unsigned long);
+extern unsigned long sbitmap_popcount (const_sbitmap, unsigned long);
 extern void sbitmap_verify_popcount (const_sbitmap);
 #endif /* ! GCC_SBITMAP_H */