X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fsbitmap.c;h=a25bff4ba94ea6add74627938ae565d75c2b1eeb;hb=224f24454c2501497c7fc75d731fc948f215748e;hp=3cec45de6278f82013a8fffd037bf50853c1e908;hpb=f0af5a8826645f54448b3b82f1ab364bd8952562;p=pf3gnuchains%2Fgcc-fork.git

diff --git a/gcc/sbitmap.c b/gcc/sbitmap.c
index 3cec45de627..a25bff4ba94 100644
--- a/gcc/sbitmap.c
+++ b/gcc/sbitmap.c
@@ -1,5 +1,5 @@
 /* Simple bitmaps.
-   Copyright (C) 1999, 2000, 2002, 2003 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2000, 2002, 2003, 2004 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -15,8 +15,8 @@ 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, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.  */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.  */
 
 #include "config.h"
 #include "system.h"
@@ -25,8 +25,46 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "rtl.h"
 #include "flags.h"
 #include "hard-reg-set.h"
+#include "obstack.h"
 #include "basic-block.h"
 
+#if GCC_VERSION >= 3400
+#if HOST_BITS_PER_WIDEST_FAST_INT == HOST_BITS_PER_LONG
+#define do_popcount(x) __builtin_popcountl(x)
+#elif HOST_BITS_PER_WIDEST_FAST_INT == HOST_BITS_PER_LONGLONG
+#define do_popcount(x) __builtin_popcountll(x)
+#else
+#error "internal error: sbitmap.h and hwint.h are inconsistent"
+#endif
+#else
+static unsigned long sbitmap_elt_popcount (SBITMAP_ELT_TYPE);
+#define do_popcount(x) sbitmap_elt_popcount((x))
+#endif
+
+/* This macro controls debugging that is as expensive as the
+   operations it verifies.  */
+
+/* #define BITMAP_DEBUGGING  */
+#ifdef BITMAP_DEBUGGING
+
+/* Verify the population count of sbitmap A matches the cached value,
+   if there is a cached value. */
+
+void
+sbitmap_verify_popcount (sbitmap a)
+{
+  unsigned ix;
+  unsigned int lastword;
+  
+  if (!a->popcount)
+    return;
+
+  lastword = a->size;
+  for (ix = 0; ix < lastword; ix++)
+    gcc_assert (a->popcount[ix] == do_popcount (a->elms[ix]));
+}
+#endif
+
 /* Bitmap manipulation routines.  */
 
 /* Allocate a simple bitmap of N_ELMS bits.  */
@@ -44,7 +82,19 @@ sbitmap_alloc (unsigned int n_elms)
   bmap = xmalloc (amt);
   bmap->n_bits = n_elms;
   bmap->size = size;
-  bmap->bytes = bytes;
+  bmap->popcount = NULL;
+  return bmap;
+}
+
+/* Allocate a simple bitmap of N_ELMS bits, and a popcount array.  */
+
+sbitmap
+sbitmap_alloc_with_popcount (unsigned int n_elms)
+{
+  sbitmap bmap;
+  
+  bmap = sbitmap_alloc (n_elms);  
+  bmap->popcount = xmalloc (bmap->size * sizeof (unsigned char));
   return bmap;
 }
 
@@ -60,18 +110,22 @@ sbitmap_resize (sbitmap bmap, unsigned int n_elms, int def)
 
   size = SBITMAP_SET_SIZE (n_elms);
   bytes = size * sizeof (SBITMAP_ELT_TYPE);
-  if (bytes > bmap->bytes)
+  if (bytes > SBITMAP_SIZE_BYTES (bmap))
     {
       amt = (sizeof (struct simple_bitmap_def)
 	    + bytes - sizeof (SBITMAP_ELT_TYPE));
       bmap = xrealloc (bmap, amt);
+      if (bmap->popcount)
+	bmap->popcount = xrealloc (bmap->popcount,
+				   size * sizeof (unsigned char));
     }
 
   if (n_elms > bmap->n_bits)
     {
       if (def)
 	{
-	  memset (bmap->elms + bmap->size, -1, bytes - bmap->bytes);
+	  memset (bmap->elms + bmap->size, -1, 
+		  bytes - SBITMAP_SIZE_BYTES (bmap));
 
 	  /* Set the new bits if the original last element.  */
 	  last_bit = bmap->n_bits % SBITMAP_ELT_BITS;
@@ -86,20 +140,56 @@ sbitmap_resize (sbitmap bmap, unsigned int n_elms, int def)
 	      &= (SBITMAP_ELT_TYPE)-1 >> (SBITMAP_ELT_BITS - last_bit);
 	}
       else
-	memset (bmap->elms + bmap->size, 0, bytes - bmap->bytes);
+	{
+	  memset (bmap->elms + bmap->size, 0, 
+		  bytes - SBITMAP_SIZE_BYTES (bmap));
+	  if (bmap->popcount)
+	    memset (bmap->popcount + bmap->size, 0,
+		    (size * sizeof (unsigned char)) 
+		    - (bmap->size * sizeof (unsigned char)));
+		    
+	}
     }
   else if (n_elms < bmap->n_bits)
     {
       /* Clear the surplus bits in the last word.  */
       last_bit = n_elms % SBITMAP_ELT_BITS;
       if (last_bit)
-	bmap->elms[size - 1]
-	  &= (SBITMAP_ELT_TYPE)-1 >> (SBITMAP_ELT_BITS - last_bit);
+	{
+	  bmap->elms[size - 1]
+	    &= (SBITMAP_ELT_TYPE)-1 >> (SBITMAP_ELT_BITS - last_bit);
+	  if (bmap->popcount)
+	    bmap->popcount[size - 1] = do_popcount (bmap->elms[size - 1]);
+	}
     }
 
   bmap->n_bits = n_elms;
   bmap->size = size;
-  bmap->bytes = bytes;
+  return bmap;
+}
+
+/* Re-allocate a simple bitmap of N_ELMS bits. New storage is uninitialized.  */
+
+sbitmap
+sbitmap_realloc (sbitmap src, unsigned int n_elms)
+{
+  unsigned int bytes, size, amt;
+  sbitmap bmap;
+
+  size = SBITMAP_SET_SIZE (n_elms);
+  bytes = size * sizeof (SBITMAP_ELT_TYPE);
+  amt = (sizeof (struct simple_bitmap_def)
+	 + bytes - sizeof (SBITMAP_ELT_TYPE));
+
+  if (SBITMAP_SIZE_BYTES (src)  >= bytes)
+    {
+      src->n_bits = n_elms;
+      return src;
+    }
+
+  bmap = (sbitmap) xrealloc (src, amt);
+  bmap->n_bits = n_elms;
+  bmap->size = size;
   return bmap;
 }
 
@@ -139,7 +229,7 @@ sbitmap_vector_alloc (unsigned int n_vecs, unsigned int n_elms)
       bitmap_vector[i] = b;
       b->n_bits = n_elms;
       b->size = size;
-      b->bytes = bytes;
+      b->popcount = NULL;
     }
 
   return bitmap_vector;
@@ -151,6 +241,18 @@ void
 sbitmap_copy (sbitmap dst, sbitmap src)
 {
   memcpy (dst->elms, src->elms, sizeof (SBITMAP_ELT_TYPE) * dst->size);
+  if (dst->popcount)
+    memcpy (dst->popcount, src->popcount, sizeof (unsigned char) * dst->size);
+}
+
+/* Copy the first N elements of sbitmap SRC to DST.  */
+
+void
+sbitmap_copy_n (sbitmap dst, sbitmap src, unsigned int n)
+{
+  memcpy (dst->elms, src->elms, sizeof (SBITMAP_ELT_TYPE) * n);  
+  if (dst->popcount)
+    memcpy (dst->popcount, src->popcount, sizeof (unsigned char) * n);
 }
 
 /* Determine if a == b.  */
@@ -165,7 +267,9 @@ sbitmap_equal (sbitmap a, sbitmap b)
 void
 sbitmap_zero (sbitmap bmap)
 {
-  memset (bmap->elms, 0, bmap->bytes);
+  memset (bmap->elms, 0, SBITMAP_SIZE_BYTES (bmap));
+  if (bmap->popcount)
+    memset (bmap->popcount, 0, bmap->size * sizeof (unsigned char));
 }
 
 /* Set all elements in a bitmap to ones.  */
@@ -175,12 +279,19 @@ sbitmap_ones (sbitmap bmap)
 {
   unsigned int last_bit;
 
-  memset (bmap->elms, -1, bmap->bytes);
+  memset (bmap->elms, -1, SBITMAP_SIZE_BYTES (bmap));
+  if (bmap->popcount)
+    memset (bmap->popcount, -1, bmap->size * sizeof (unsigned char));
 
   last_bit = bmap->n_bits % SBITMAP_ELT_BITS;
   if (last_bit)
-    bmap->elms[bmap->size - 1]
-      = (SBITMAP_ELT_TYPE)-1 >> (SBITMAP_ELT_BITS - last_bit);
+    {
+      bmap->elms[bmap->size - 1]
+	= (SBITMAP_ELT_TYPE)-1 >> (SBITMAP_ELT_BITS - last_bit);
+      if (bmap->popcount)
+	bmap->popcount[bmap->size - 1] 
+	  = do_popcount (bmap->elms[bmap->size - 1]);
+    }
 }
 
 /* Zero a vector of N_VECS bitmaps.  */
@@ -219,6 +330,8 @@ sbitmap_union_of_diff_cg (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
   sbitmap_ptr cp = c->elms;
   SBITMAP_ELT_TYPE changed = 0;
 
+  gcc_assert (!dst->popcount);
+  
   for (i = 0; i < n; i++)
     {
       SBITMAP_ELT_TYPE tmp = *ap++ | (*bp++ & ~*cp++);
@@ -238,6 +351,9 @@ sbitmap_union_of_diff (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
   sbitmap_ptr bp = b->elms;
   sbitmap_ptr cp = c->elms;
 
+  gcc_assert (!dst->popcount && !a->popcount
+	      && !b->popcount && !c->popcount);
+
   for (i = 0; i < n; i++)
     *dstp++ = *ap++ | (*bp++ & ~*cp++);
 }
@@ -250,9 +366,18 @@ sbitmap_not (sbitmap dst, sbitmap src)
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
   sbitmap_ptr srcp = src->elms;
+  unsigned int last_bit;
+
+  gcc_assert (!dst->popcount);  
 
   for (i = 0; i < n; i++)
     *dstp++ = ~*srcp++;
+
+  /* Zero all bits past n_bits, by ANDing dst with sbitmap_ones.  */
+  last_bit = src->n_bits % SBITMAP_ELT_BITS;
+  if (last_bit)
+    dst->elms[n-1] = dst->elms[n-1]
+      & ((SBITMAP_ELT_TYPE)-1 >> (SBITMAP_ELT_BITS - last_bit));
 }
 
 /* Set the bits in DST to be the difference between the bits
@@ -267,9 +392,10 @@ sbitmap_difference (sbitmap dst, sbitmap a, sbitmap b)
   sbitmap_ptr ap = a->elms;
   sbitmap_ptr bp = b->elms;
 
+  gcc_assert (!dst->popcount);
+
   /* A should be at least as large as DEST, to have a defined source.  */
-  if (a->size < dst_size)
-    abort ();
+  gcc_assert (a->size >= dst_size);
   /* If minuend is smaller, we simply pretend it to be zero bits, i.e.
      only copy the subtrahend into dest.  */
   if (b->size < min_size)
@@ -283,6 +409,24 @@ sbitmap_difference (sbitmap dst, sbitmap a, sbitmap b)
       *dstp++ = *ap++;
 }
 
+/* Return true if there are any bits set in A are also set in B.
+   Return false otherwise.  */
+
+bool
+sbitmap_any_common_bits (sbitmap a, sbitmap b)
+{
+  sbitmap_ptr ap = a->elms;
+  sbitmap_ptr bp = b->elms;
+  unsigned int i, n;
+
+  n = MIN (a->size, b->size);
+  for (i = 0; i < n; i++)
+    if ((*ap++ & *bp++) != 0)
+      return true;
+
+  return false;
+}
+
 /* Set DST to be (A and B).
    Return nonzero if any change is made.  */
 
@@ -295,10 +439,12 @@ sbitmap_a_and_b_cg (sbitmap dst, sbitmap a, sbitmap b)
   sbitmap_ptr bp = b->elms;
   SBITMAP_ELT_TYPE changed = 0;
 
+  gcc_assert (!dst->popcount);
+
   for (i = 0; i < n; i++)
     {
       SBITMAP_ELT_TYPE tmp = *ap++ & *bp++;
-      changed = *dstp ^ tmp;
+      changed |= *dstp ^ tmp;
       *dstp++ = tmp;
     }
 
@@ -312,9 +458,25 @@ sbitmap_a_and_b (sbitmap dst, sbitmap a, sbitmap b)
   sbitmap_ptr dstp = dst->elms;
   sbitmap_ptr ap = a->elms;
   sbitmap_ptr bp = b->elms;
+  bool has_popcount = dst->popcount != NULL;
+  unsigned char *popcountp = dst->popcount;
 
   for (i = 0; i < n; i++)
-    *dstp++ = *ap++ & *bp++;
+    {
+      SBITMAP_ELT_TYPE tmp = *ap++ & *bp++;
+      if (has_popcount)
+	{
+	  bool wordchanged = (*dstp ^ tmp) != 0;
+	  if (wordchanged)
+	    *popcountp = do_popcount (tmp);
+	  popcountp++;
+	}      
+      *dstp++ = tmp;
+    }
+#ifdef BITMAP_DEBUGGING
+  if (has_popcount)
+    sbitmap_verify_popcount (dst);
+#endif
 }
 
 /* Set DST to be (A xor B)).
@@ -328,11 +490,13 @@ sbitmap_a_xor_b_cg (sbitmap dst, sbitmap a, sbitmap b)
   sbitmap_ptr ap = a->elms;
   sbitmap_ptr bp = b->elms;
   SBITMAP_ELT_TYPE changed = 0;
+  
+  gcc_assert (!dst->popcount);
 
   for (i = 0; i < n; i++)
     {
       SBITMAP_ELT_TYPE tmp = *ap++ ^ *bp++;
-      changed = *dstp ^ tmp;
+      changed |= *dstp ^ tmp;
       *dstp++ = tmp;
     }
 
@@ -346,9 +510,25 @@ sbitmap_a_xor_b (sbitmap dst, sbitmap a, sbitmap b)
   sbitmap_ptr dstp = dst->elms;
   sbitmap_ptr ap = a->elms;
   sbitmap_ptr bp = b->elms;
+  bool has_popcount = dst->popcount != NULL;
+  unsigned char *popcountp = dst->popcount;
 
   for (i = 0; i < n; i++)
-    *dstp++ = *ap++ ^ *bp++;
+    {
+      SBITMAP_ELT_TYPE tmp = *ap++ ^ *bp++;
+      if (has_popcount)
+	{
+	  bool wordchanged = (*dstp ^ tmp) != 0;
+	  if (wordchanged)
+	    *popcountp = do_popcount (tmp);
+	  popcountp++;
+	} 
+      *dstp++ = tmp;
+    }
+#ifdef BITMAP_DEBUGGING
+  if (has_popcount)
+    sbitmap_verify_popcount (dst);
+#endif
 }
 
 /* Set DST to be (A or B)).
@@ -363,10 +543,12 @@ sbitmap_a_or_b_cg (sbitmap dst, sbitmap a, sbitmap b)
   sbitmap_ptr bp = b->elms;
   SBITMAP_ELT_TYPE changed = 0;
 
+  gcc_assert (!dst->popcount);
+
   for (i = 0; i < n; i++)
     {
       SBITMAP_ELT_TYPE tmp = *ap++ | *bp++;
-      changed = *dstp ^ tmp;
+      changed |= *dstp ^ tmp;
       *dstp++ = tmp;
     }
 
@@ -380,9 +562,25 @@ sbitmap_a_or_b (sbitmap dst, sbitmap a, sbitmap b)
   sbitmap_ptr dstp = dst->elms;
   sbitmap_ptr ap = a->elms;
   sbitmap_ptr bp = b->elms;
+  bool has_popcount = dst->popcount != NULL;
+  unsigned char *popcountp = dst->popcount;
 
   for (i = 0; i < n; i++)
-    *dstp++ = *ap++ | *bp++;
+    {
+      SBITMAP_ELT_TYPE tmp = *ap++ | *bp++;
+      if (has_popcount)
+	{
+	  bool wordchanged = (*dstp ^ tmp) != 0;
+	  if (wordchanged)
+	    *popcountp = do_popcount (tmp);
+	  popcountp++;
+	} 
+      *dstp++ = tmp;
+    }
+#ifdef BITMAP_DEBUGGING
+  if (has_popcount)
+    sbitmap_verify_popcount (dst);
+#endif
 }
 
 /* Return nonzero if A is a subset of B.  */
@@ -413,6 +611,8 @@ sbitmap_a_or_b_and_c_cg (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
   sbitmap_ptr cp = c->elms;
   SBITMAP_ELT_TYPE changed = 0;
 
+  gcc_assert (!dst->popcount);
+
   for (i = 0; i < n; i++)
     {
       SBITMAP_ELT_TYPE tmp = *ap++ | (*bp++ & *cp++);
@@ -432,6 +632,8 @@ sbitmap_a_or_b_and_c (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
   sbitmap_ptr bp = b->elms;
   sbitmap_ptr cp = c->elms;
 
+  gcc_assert (!dst->popcount);
+
   for (i = 0; i < n; i++)
     *dstp++ = *ap++ | (*bp++ & *cp++);
 }
@@ -449,6 +651,8 @@ sbitmap_a_and_b_or_c_cg (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
   sbitmap_ptr cp = c->elms;
   SBITMAP_ELT_TYPE changed = 0;
 
+  gcc_assert (!dst->popcount);
+
   for (i = 0; i < n; i++)
     {
       SBITMAP_ELT_TYPE tmp = *ap++ & (*bp++ | *cp++);
@@ -482,12 +686,16 @@ 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 = b->succ; e != 0; e = e->succ_next)
+  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;
     }
@@ -495,11 +703,12 @@ sbitmap_intersection_of_succs (sbitmap dst, sbitmap *src, int bb)
   if (e == 0)
     sbitmap_ones (dst);
   else
-    for (e = e->succ_next; e != 0; e = e->succ_next)
+    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;
 
@@ -519,9 +728,13 @@ 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 = b->pred; e != 0; e = e->pred_next)
+  for (e = NULL, ix = 0; ix < EDGE_COUNT (b->preds); ix++)
     {
+      e = EDGE_PRED (b, ix);
       if (e->src == ENTRY_BLOCK_PTR)
 	continue;
 
@@ -532,11 +745,12 @@ sbitmap_intersection_of_preds (sbitmap dst, sbitmap *src, int bb)
   if (e == 0)
     sbitmap_ones (dst);
   else
-    for (e = e->pred_next; e != 0; e = e->pred_next)
+    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;
 
@@ -556,9 +770,13 @@ 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;
 
-  for (e = b->succ; e != 0; e = e->succ_next)
+  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;
 
@@ -566,14 +784,15 @@ sbitmap_union_of_succs (sbitmap dst, sbitmap *src, int bb)
       break;
     }
 
-  if (e == 0)
+  if (ix == EDGE_COUNT (b->succs))
     sbitmap_zero (dst);
   else
-    for (e = e->succ_next; e != 0; e = e->succ_next)
+    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;
 
@@ -593,9 +812,13 @@ 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;
 
-  for (e = b->pred; e != 0; e = e->pred_next)
+  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;
 
@@ -603,14 +826,15 @@ sbitmap_union_of_preds (sbitmap dst, sbitmap *src, int bb)
       break;
     }
 
-  if (e == 0)
+  if (ix == EDGE_COUNT (b->preds))
     sbitmap_zero (dst);
   else
-    for (e = e->pred_next; e != 0; e = e->pred_next)
+    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;
 
@@ -627,9 +851,11 @@ sbitmap_union_of_preds (sbitmap dst, sbitmap *src, int bb)
 int
 sbitmap_first_set_bit (sbitmap bmap)
 {
-  unsigned int n;
+  unsigned int n = 0;
+  sbitmap_iterator sbi;
 
-  EXECUTE_IF_SET_IN_SBITMAP (bmap, 0, n, { return n; });
+  EXECUTE_IF_SET_IN_SBITMAP (bmap, 0, n, sbi)
+    return n;
   return -1;
 }
 
@@ -730,3 +956,82 @@ dump_sbitmap_vector (FILE *file, const char *title, const char *subtitle,
 
   fprintf (file, "\n");
 }
+
+#if GCC_VERSION < 3400
+/* Table of number of set bits in a character, indexed by value of char.  */
+static unsigned char popcount_table[] =
+{
+    0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+    1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+    1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+    2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+    1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+    2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+    2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+    3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8,
+};
+
+/* Count the bits in an SBITMAP element A.  */
+
+static unsigned long
+sbitmap_elt_popcount (SBITMAP_ELT_TYPE a)
+{
+  unsigned long ret = 0;
+  unsigned i;
+
+  if (a == 0)
+    return 0;
+
+  /* Just do this the table way for now  */
+  for (i = 0; i < SBITMAP_ELT_BITS; i += 8)
+    ret += popcount_table[(a >> i) & 0xff];
+  return ret;
+}
+#endif
+
+/* Count the number of bits in SBITMAP a, up to bit MAXBIT.  */
+
+unsigned long
+sbitmap_popcount (sbitmap a, unsigned long maxbit)
+{
+  unsigned long count = 0;
+  unsigned ix;
+  unsigned int lastword;
+
+  if (maxbit == 0)
+    return 0;
+  
+  if (maxbit >= a->n_bits)
+    maxbit = a->n_bits;
+
+  /* Count the bits in the full word.  */
+  lastword = MIN (a->size, SBITMAP_SET_SIZE (maxbit + 1) - 1);
+  for (ix = 0; ix < lastword; ix++)
+    {
+      if (a->popcount)
+	{
+	  count += a->popcount[ix];
+#ifdef BITMAP_DEBUGGING
+	  gcc_assert (a->popcount[ix] == do_popcount (a->elms[ix]));
+#endif
+	}
+      else
+	count += do_popcount (a->elms[ix]);
+    }
+
+  /* Count the remaining bits.  */
+  if (lastword < a->size)
+    {
+      unsigned int bitindex;
+      SBITMAP_ELT_TYPE theword = a->elms[lastword];
+
+      bitindex = maxbit % SBITMAP_ELT_BITS;
+      if (bitindex != 0)
+	{
+	  theword &= (SBITMAP_ELT_TYPE)-1 >> (SBITMAP_ELT_BITS - bitindex);
+	  count += do_popcount (theword);
+	}
+    }
+  return count;
+}
+