sbitmap.c (sbitmap_verify_popcount, [...]): Constify.

	* sbitmap.c (sbitmap_verify_popcount, sbitmap_alloc_with_popcount,
	sbitmap_copy, sbitmap_copy_n, sbitmap_equal, sbitmap_empty_p,
	sbitmap_union_of_diff_cg, sbitmap_union_of_diff, sbitmap_not,
	sbitmap_difference, sbitmap_any_common_bits, sbitmap_a_and_b_cg,
	sbitmap_a_and_b, sbitmap_a_xor_b_cg, sbitmap_a_xor_b,
	sbitmap_a_or_b_cg, sbitmap_a_or_b, sbitmap_a_subset_b_p,
	sbitmap_a_or_b_and_c_cg, sbitmap_a_or_b_and_c,
	sbitmap_a_and_b_or_c_cg, sbitmap_a_and_b_or_c,
	sbitmap_first_set_bit, sbitmap_last_set_bit, dump_sbitmap,
	dump_sbitmap_file, debug_sbitmap, popcount_table,
	sbitmap_popcount): Constify.
	* sbitmap.h (const_sbitmap, const_sbitmap_ptr): New.
	(sbitmap_iterator, sbitmap_iter_init, dump_sbitmap,
	dump_sbitmap_file, sbitmap_copy, sbitmap_copy_n, sbitmap_equal,
	sbitmap_empty_p, sbitmap_union_of_diff, sbitmap_union_of_diff_cg,
	sbitmap_difference, sbitmap_not, sbitmap_a_or_b_and_c,
	sbitmap_a_or_b_and_c_cg, sbitmap_a_and_b_or_c,
	sbitmap_a_and_b_or_c_cg, sbitmap_any_common_bits, sbitmap_a_and_b,
	sbitmap_a_and_b_cg, sbitmap_a_or_b, sbitmap_a_or_b_cg,
	sbitmap_a_xor_b, sbitmap_a_xor_b_cg, sbitmap_a_subset_b_p,
	sbitmap_first_set_bit, sbitmap_last_set_bit, debug_sbitmap,
	sbitmap_popcount, sbitmap_verify_popcount): Constify.

From-SVN: r126929

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 4aea3ae55c99024fc51322c4837b0d85cf2abeb6..1ae4b363c7ac8948d56ee6c22daa9c51dadaf9e9 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,28 @@
+2007-07-25  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+
+       * sbitmap.c (sbitmap_verify_popcount, sbitmap_alloc_with_popcount,
+       sbitmap_copy, sbitmap_copy_n, sbitmap_equal, sbitmap_empty_p,
+       sbitmap_union_of_diff_cg, sbitmap_union_of_diff, sbitmap_not,
+       sbitmap_difference, sbitmap_any_common_bits, sbitmap_a_and_b_cg,
+       sbitmap_a_and_b, sbitmap_a_xor_b_cg, sbitmap_a_xor_b,
+       sbitmap_a_or_b_cg, sbitmap_a_or_b, sbitmap_a_subset_b_p,
+       sbitmap_a_or_b_and_c_cg, sbitmap_a_or_b_and_c,
+       sbitmap_a_and_b_or_c_cg, sbitmap_a_and_b_or_c,
+       sbitmap_first_set_bit, sbitmap_last_set_bit, dump_sbitmap,
+       dump_sbitmap_file, debug_sbitmap, popcount_table,
+       sbitmap_popcount): Constify.
+       * sbitmap.h (const_sbitmap, const_sbitmap_ptr): New.
+       (sbitmap_iterator, sbitmap_iter_init, dump_sbitmap,
+       dump_sbitmap_file, sbitmap_copy, sbitmap_copy_n, sbitmap_equal,
+       sbitmap_empty_p, sbitmap_union_of_diff, sbitmap_union_of_diff_cg,
+       sbitmap_difference, sbitmap_not, sbitmap_a_or_b_and_c,
+       sbitmap_a_or_b_and_c_cg, sbitmap_a_and_b_or_c,
+       sbitmap_a_and_b_or_c_cg, sbitmap_any_common_bits, sbitmap_a_and_b,
+       sbitmap_a_and_b_cg, sbitmap_a_or_b, sbitmap_a_or_b_cg,
+       sbitmap_a_xor_b, sbitmap_a_xor_b_cg, sbitmap_a_subset_b_p,
+       sbitmap_first_set_bit, sbitmap_last_set_bit, debug_sbitmap,
+       sbitmap_popcount, sbitmap_verify_popcount): Constify.
+
 2007-07-25  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
 
        * bitmap.c (hash_descriptor, eq_descriptor, bitmap_element_zerop,

diff --git a/gcc/sbitmap.c b/gcc/sbitmap.c
index 65a4686eff9eb37362af0edbdb0c6e68a07d2d9a..acc40a1f87f35010d0e457c7e84bd95d224e8b13 100644 (file)
--- a/gcc/sbitmap.c
+++ b/gcc/sbitmap.c
@@ -52,7 +52,7 @@ static unsigned long sbitmap_elt_popcount (SBITMAP_ELT_TYPE);
    if there is a cached value. */
 
 void
-sbitmap_verify_popcount (sbitmap a)
+sbitmap_verify_popcount (const_sbitmap a)
 {
   unsigned ix;
   unsigned int lastword;
@@ -92,9 +92,7 @@ sbitmap_alloc (unsigned int n_elms)
 sbitmap
 sbitmap_alloc_with_popcount (unsigned int n_elms)
 {
-  sbitmap bmap;
-  
-  bmap = sbitmap_alloc (n_elms);  
+  sbitmap const bmap = sbitmap_alloc (n_elms);  
   bmap->popcount = xmalloc (bmap->size * sizeof (unsigned char));
   return bmap;
 }
@@ -239,7 +237,7 @@ sbitmap_vector_alloc (unsigned int n_vecs, unsigned int n_elms)
 /* Copy sbitmap SRC to DST.  */
 
 void
-sbitmap_copy (sbitmap dst, sbitmap src)
+sbitmap_copy (sbitmap dst, const_sbitmap src)
 {
   memcpy (dst->elms, src->elms, sizeof (SBITMAP_ELT_TYPE) * dst->size);
   if (dst->popcount)
@@ -249,7 +247,7 @@ sbitmap_copy (sbitmap dst, sbitmap src)
 /* Copy the first N elements of sbitmap SRC to DST.  */
 
 void
-sbitmap_copy_n (sbitmap dst, sbitmap src, unsigned int n)
+sbitmap_copy_n (sbitmap dst, const_sbitmap src, unsigned int n)
 {
   memcpy (dst->elms, src->elms, sizeof (SBITMAP_ELT_TYPE) * n);  
   if (dst->popcount)
@@ -258,7 +256,7 @@ sbitmap_copy_n (sbitmap dst, sbitmap src, unsigned int n)
 
 /* Determine if a == b.  */
 int
-sbitmap_equal (sbitmap a, sbitmap b)
+sbitmap_equal (const_sbitmap a, const_sbitmap b)
 {
   return !memcmp (a->elms, b->elms, sizeof (SBITMAP_ELT_TYPE) * a->size);
 }
@@ -266,7 +264,7 @@ sbitmap_equal (sbitmap a, sbitmap b)
 /* Return true if the bitmap is empty.  */
 
 bool
-sbitmap_empty_p (sbitmap bmap)
+sbitmap_empty_p (const_sbitmap bmap)
 {
   unsigned int i;
   for (i=0; i<bmap->size; i++)
@@ -335,20 +333,20 @@ sbitmap_vector_ones (sbitmap *bmap, unsigned int n_vecs)
    Returns true if any change is made.  */
 
 bool
-sbitmap_union_of_diff_cg (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
+sbitmap_union_of_diff_cg (sbitmap dst, const_sbitmap a, const_sbitmap b, const_sbitmap c)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
-  sbitmap_ptr ap = a->elms;
-  sbitmap_ptr bp = b->elms;
-  sbitmap_ptr cp = c->elms;
+  const_sbitmap_ptr ap = a->elms;
+  const_sbitmap_ptr bp = b->elms;
+  const_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++);
+      const SBITMAP_ELT_TYPE tmp = *ap++ | (*bp++ & ~*cp++);
       changed |= *dstp ^ tmp;
       *dstp++ = tmp;
     }
@@ -357,13 +355,13 @@ sbitmap_union_of_diff_cg (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
 }
 
 void
-sbitmap_union_of_diff (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
+sbitmap_union_of_diff (sbitmap dst, const_sbitmap a, const_sbitmap b, const_sbitmap c)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
-  sbitmap_ptr ap = a->elms;
-  sbitmap_ptr bp = b->elms;
-  sbitmap_ptr cp = c->elms;
+  const_sbitmap_ptr ap = a->elms;
+  const_sbitmap_ptr bp = b->elms;
+  const_sbitmap_ptr cp = c->elms;
 
   gcc_assert (!dst->popcount && !a->popcount
              && !b->popcount && !c->popcount);
@@ -375,11 +373,11 @@ sbitmap_union_of_diff (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
 /* Set bitmap DST to the bitwise negation of the bitmap SRC.  */
 
 void
-sbitmap_not (sbitmap dst, sbitmap src)
+sbitmap_not (sbitmap dst, const_sbitmap src)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
-  sbitmap_ptr srcp = src->elms;
+  const_sbitmap_ptr srcp = src->elms;
   unsigned int last_bit;
 
   gcc_assert (!dst->popcount);  
@@ -398,13 +396,13 @@ sbitmap_not (sbitmap dst, sbitmap src)
    in A and the bits in B. i.e. dst = a & (~b).  */
 
 void
-sbitmap_difference (sbitmap dst, sbitmap a, sbitmap b)
+sbitmap_difference (sbitmap dst, const_sbitmap a, const_sbitmap b)
 {
   unsigned int i, dst_size = dst->size;
   unsigned int min_size = dst->size;
   sbitmap_ptr dstp = dst->elms;
-  sbitmap_ptr ap = a->elms;
-  sbitmap_ptr bp = b->elms;
+  const_sbitmap_ptr ap = a->elms;
+  const_sbitmap_ptr bp = b->elms;
 
   gcc_assert (!dst->popcount);
 
@@ -427,10 +425,10 @@ sbitmap_difference (sbitmap dst, sbitmap a, sbitmap b)
    Return false otherwise.  */
 
 bool
-sbitmap_any_common_bits (sbitmap a, sbitmap b)
+sbitmap_any_common_bits (const_sbitmap a, const_sbitmap b)
 {
-  sbitmap_ptr ap = a->elms;
-  sbitmap_ptr bp = b->elms;
+  const_sbitmap_ptr ap = a->elms;
+  const_sbitmap_ptr bp = b->elms;
   unsigned int i, n;
 
   n = MIN (a->size, b->size);
@@ -445,19 +443,19 @@ sbitmap_any_common_bits (sbitmap a, sbitmap b)
    Return nonzero if any change is made.  */
 
 bool
-sbitmap_a_and_b_cg (sbitmap dst, sbitmap a, sbitmap b)
+sbitmap_a_and_b_cg (sbitmap dst, const_sbitmap a, const_sbitmap b)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
-  sbitmap_ptr ap = a->elms;
-  sbitmap_ptr bp = b->elms;
+  const_sbitmap_ptr ap = a->elms;
+  const_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++;
+      const SBITMAP_ELT_TYPE tmp = *ap++ & *bp++;
       changed |= *dstp ^ tmp;
       *dstp++ = tmp;
     }
@@ -466,18 +464,18 @@ sbitmap_a_and_b_cg (sbitmap dst, sbitmap a, sbitmap b)
 }
 
 void
-sbitmap_a_and_b (sbitmap dst, sbitmap a, sbitmap b)
+sbitmap_a_and_b (sbitmap dst, const_sbitmap a, const_sbitmap b)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
-  sbitmap_ptr ap = a->elms;
-  sbitmap_ptr bp = b->elms;
+  const_sbitmap_ptr ap = a->elms;
+  const_sbitmap_ptr bp = b->elms;
   bool has_popcount = dst->popcount != NULL;
   unsigned char *popcountp = dst->popcount;
 
   for (i = 0; i < n; i++)
     {
-      SBITMAP_ELT_TYPE tmp = *ap++ & *bp++;
+      const SBITMAP_ELT_TYPE tmp = *ap++ & *bp++;
       if (has_popcount)
        {
          bool wordchanged = (*dstp ^ tmp) != 0;
@@ -497,19 +495,19 @@ sbitmap_a_and_b (sbitmap dst, sbitmap a, sbitmap b)
    Return nonzero if any change is made.  */
 
 bool
-sbitmap_a_xor_b_cg (sbitmap dst, sbitmap a, sbitmap b)
+sbitmap_a_xor_b_cg (sbitmap dst, const_sbitmap a, const_sbitmap b)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
-  sbitmap_ptr ap = a->elms;
-  sbitmap_ptr bp = b->elms;
+  const_sbitmap_ptr ap = a->elms;
+  const_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++;
+      const SBITMAP_ELT_TYPE tmp = *ap++ ^ *bp++;
       changed |= *dstp ^ tmp;
       *dstp++ = tmp;
     }
@@ -518,18 +516,18 @@ sbitmap_a_xor_b_cg (sbitmap dst, sbitmap a, sbitmap b)
 }
 
 void
-sbitmap_a_xor_b (sbitmap dst, sbitmap a, sbitmap b)
+sbitmap_a_xor_b (sbitmap dst, const_sbitmap a, const_sbitmap b)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
-  sbitmap_ptr ap = a->elms;
-  sbitmap_ptr bp = b->elms;
+  const_sbitmap_ptr ap = a->elms;
+  const_sbitmap_ptr bp = b->elms;
   bool has_popcount = dst->popcount != NULL;
   unsigned char *popcountp = dst->popcount;
 
   for (i = 0; i < n; i++)
     {
-      SBITMAP_ELT_TYPE tmp = *ap++ ^ *bp++;
+      const SBITMAP_ELT_TYPE tmp = *ap++ ^ *bp++;
       if (has_popcount)
        {
          bool wordchanged = (*dstp ^ tmp) != 0;
@@ -549,19 +547,19 @@ sbitmap_a_xor_b (sbitmap dst, sbitmap a, sbitmap b)
    Return nonzero if any change is made.  */
 
 bool
-sbitmap_a_or_b_cg (sbitmap dst, sbitmap a, sbitmap b)
+sbitmap_a_or_b_cg (sbitmap dst, const_sbitmap a, const_sbitmap b)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
-  sbitmap_ptr ap = a->elms;
-  sbitmap_ptr bp = b->elms;
+  const_sbitmap_ptr ap = a->elms;
+  const_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++;
+      const SBITMAP_ELT_TYPE tmp = *ap++ | *bp++;
       changed |= *dstp ^ tmp;
       *dstp++ = tmp;
     }
@@ -570,18 +568,18 @@ sbitmap_a_or_b_cg (sbitmap dst, sbitmap a, sbitmap b)
 }
 
 void
-sbitmap_a_or_b (sbitmap dst, sbitmap a, sbitmap b)
+sbitmap_a_or_b (sbitmap dst, const_sbitmap a, const_sbitmap b)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
-  sbitmap_ptr ap = a->elms;
-  sbitmap_ptr bp = b->elms;
+  const_sbitmap_ptr ap = a->elms;
+  const_sbitmap_ptr bp = b->elms;
   bool has_popcount = dst->popcount != NULL;
   unsigned char *popcountp = dst->popcount;
 
   for (i = 0; i < n; i++)
     {
-      SBITMAP_ELT_TYPE tmp = *ap++ | *bp++;
+      const SBITMAP_ELT_TYPE tmp = *ap++ | *bp++;
       if (has_popcount)
        {
          bool wordchanged = (*dstp ^ tmp) != 0;
@@ -600,10 +598,10 @@ sbitmap_a_or_b (sbitmap dst, sbitmap a, sbitmap b)
 /* Return nonzero if A is a subset of B.  */
 
 bool
-sbitmap_a_subset_b_p (sbitmap a, sbitmap b)
+sbitmap_a_subset_b_p (const_sbitmap a, const_sbitmap b)
 {
   unsigned int i, n = a->size;
-  sbitmap_ptr ap, bp;
+  const_sbitmap_ptr ap, bp;
 
   for (ap = a->elms, bp = b->elms, i = 0; i < n; i++, ap++, bp++)
     if ((*ap | *bp) != *bp)
@@ -616,20 +614,20 @@ sbitmap_a_subset_b_p (sbitmap a, sbitmap b)
    Return nonzero if any change is made.  */
 
 bool
-sbitmap_a_or_b_and_c_cg (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
+sbitmap_a_or_b_and_c_cg (sbitmap dst, const_sbitmap a, const_sbitmap b, const_sbitmap c)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
-  sbitmap_ptr ap = a->elms;
-  sbitmap_ptr bp = b->elms;
-  sbitmap_ptr cp = c->elms;
+  const_sbitmap_ptr ap = a->elms;
+  const_sbitmap_ptr bp = b->elms;
+  const_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++);
+      const SBITMAP_ELT_TYPE tmp = *ap++ | (*bp++ & *cp++);
       changed |= *dstp ^ tmp;
       *dstp++ = tmp;
     }
@@ -638,13 +636,13 @@ sbitmap_a_or_b_and_c_cg (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
 }
 
 void
-sbitmap_a_or_b_and_c (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
+sbitmap_a_or_b_and_c (sbitmap dst, const_sbitmap a, const_sbitmap b, const_sbitmap c)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
-  sbitmap_ptr ap = a->elms;
-  sbitmap_ptr bp = b->elms;
-  sbitmap_ptr cp = c->elms;
+  const_sbitmap_ptr ap = a->elms;
+  const_sbitmap_ptr bp = b->elms;
+  const_sbitmap_ptr cp = c->elms;
 
   gcc_assert (!dst->popcount);
 
@@ -656,20 +654,20 @@ sbitmap_a_or_b_and_c (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
    Return nonzero if any change is made.  */
 
 bool
-sbitmap_a_and_b_or_c_cg (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
+sbitmap_a_and_b_or_c_cg (sbitmap dst, const_sbitmap a, const_sbitmap b, const_sbitmap c)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
-  sbitmap_ptr ap = a->elms;
-  sbitmap_ptr bp = b->elms;
-  sbitmap_ptr cp = c->elms;
+  const_sbitmap_ptr ap = a->elms;
+  const_sbitmap_ptr bp = b->elms;
+  const_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++);
+      const SBITMAP_ELT_TYPE tmp = *ap++ & (*bp++ | *cp++);
       changed |= *dstp ^ tmp;
       *dstp++ = tmp;
     }
@@ -678,13 +676,13 @@ sbitmap_a_and_b_or_c_cg (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
 }
 
 void
-sbitmap_a_and_b_or_c (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
+sbitmap_a_and_b_or_c (sbitmap dst, const_sbitmap a, const_sbitmap b, const_sbitmap c)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
-  sbitmap_ptr ap = a->elms;
-  sbitmap_ptr bp = b->elms;
-  sbitmap_ptr cp = c->elms;
+  const_sbitmap_ptr ap = a->elms;
+  const_sbitmap_ptr bp = b->elms;
+  const_sbitmap_ptr cp = c->elms;
 
   for (i = 0; i < n; i++)
     *dstp++ = *ap++ & (*bp++ | *cp++);
@@ -863,7 +861,7 @@ sbitmap_union_of_preds (sbitmap dst, sbitmap *src, int bb)
 /* Return number of first bit set in the bitmap, -1 if none.  */
 
 int
-sbitmap_first_set_bit (sbitmap bmap)
+sbitmap_first_set_bit (const_sbitmap bmap)
 {
   unsigned int n = 0;
   sbitmap_iterator sbi;
@@ -876,14 +874,14 @@ sbitmap_first_set_bit (sbitmap bmap)
 /* Return number of last bit set in the bitmap, -1 if none.  */
 
 int
-sbitmap_last_set_bit (sbitmap bmap)
+sbitmap_last_set_bit (const_sbitmap bmap)
 {
   int i;
-  SBITMAP_ELT_TYPE *ptr = bmap->elms;
+  const SBITMAP_ELT_TYPE *const ptr = bmap->elms;
 
   for (i = bmap->size - 1; i >= 0; i--)
     {
-      SBITMAP_ELT_TYPE word = ptr[i];
+      const SBITMAP_ELT_TYPE word = ptr[i];
 
       if (word != 0)
        {
@@ -906,7 +904,7 @@ sbitmap_last_set_bit (sbitmap bmap)
 }
 
 void
-dump_sbitmap (FILE *file, sbitmap bmap)
+dump_sbitmap (FILE *file, const_sbitmap bmap)
 {
   unsigned int i, n, j;
   unsigned int set_size = bmap->size;
@@ -927,7 +925,7 @@ dump_sbitmap (FILE *file, sbitmap bmap)
 }
 
 void
-dump_sbitmap_file (FILE *file, sbitmap bmap)
+dump_sbitmap_file (FILE *file, const_sbitmap bmap)
 {
   unsigned int i, pos;
 
@@ -950,7 +948,7 @@ dump_sbitmap_file (FILE *file, sbitmap bmap)
 }
 
 void
-debug_sbitmap (sbitmap bmap)
+debug_sbitmap (const_sbitmap bmap)
 {
   dump_sbitmap_file (stderr, bmap);
 }
@@ -973,7 +971,7 @@ dump_sbitmap_vector (FILE *file, const char *title, const char *subtitle,
 
 #if GCC_VERSION < 3400
 /* Table of number of set bits in a character, indexed by value of char.  */
-static unsigned char popcount_table[] =
+static const 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,
@@ -1006,7 +1004,7 @@ sbitmap_elt_popcount (SBITMAP_ELT_TYPE a)
 /* Count the number of bits in SBITMAP a, up to bit MAXBIT.  */
 
 unsigned long
-sbitmap_popcount (sbitmap a, unsigned long maxbit)
+sbitmap_popcount (const_sbitmap a, unsigned long maxbit)
 {
   unsigned long count = 0;
   unsigned ix;

diff --git a/gcc/sbitmap.h b/gcc/sbitmap.h
index 86febb4609b7aa59bd4592dff9314ecf98b39a2e..7c00e03902b4f535676d5bc099d8bc2c755adfaf 100644 (file)
--- a/gcc/sbitmap.h
+++ b/gcc/sbitmap.h
@@ -44,8 +44,10 @@ typedef struct simple_bitmap_def
   unsigned int size;           /* Size in elements.  */
   SBITMAP_ELT_TYPE elms[1];    /* The elements.  */
 } *sbitmap;
+typedef const struct simple_bitmap_def *const_sbitmap;
 
 typedef SBITMAP_ELT_TYPE *sbitmap_ptr;
+typedef const SBITMAP_ELT_TYPE *const_sbitmap_ptr;
 
 /* Return the set size needed for N elements.  */
 #define SBITMAP_SET_SIZE(N) (((N) + SBITMAP_ELT_BITS - 1) / SBITMAP_ELT_BITS)
@@ -94,7 +96,7 @@ RESET_BIT (sbitmap map,  unsigned int bitno)
 /* The iterator for sbitmap.  */
 typedef struct {
   /* The pointer to the first word of the bitmap.  */
-  SBITMAP_ELT_TYPE *ptr;
+  const SBITMAP_ELT_TYPE *ptr;
 
   /* The size of the bitmap.  */
   unsigned int size;
@@ -113,7 +115,7 @@ typedef struct {
    MIN.  */
 
 static inline void
-sbitmap_iter_init (sbitmap_iterator *i, sbitmap bmp, unsigned int min)
+sbitmap_iter_init (sbitmap_iterator *i, const_sbitmap bmp, unsigned int min)
 {
   i->word_num = min / (unsigned int) SBITMAP_ELT_BITS;
   i->bit_num = min;
@@ -206,42 +208,42 @@ do {                                                                      \
 
 struct int_list;
 
-extern void dump_sbitmap (FILE *, sbitmap);
-extern void dump_sbitmap_file (FILE *, sbitmap);
+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 *,
                                 int);
 extern sbitmap sbitmap_alloc (unsigned int);
 extern sbitmap sbitmap_alloc_with_popcount (unsigned int);
 extern sbitmap *sbitmap_vector_alloc (unsigned int, unsigned int);
 extern sbitmap sbitmap_resize (sbitmap, unsigned int, int);
-extern void sbitmap_copy (sbitmap, sbitmap);
-extern void sbitmap_copy_n (sbitmap, sbitmap, unsigned int);
-extern int sbitmap_equal (sbitmap, sbitmap);
-extern bool sbitmap_empty_p (sbitmap);
+extern void sbitmap_copy (sbitmap, const_sbitmap);
+extern void sbitmap_copy_n (sbitmap, const_sbitmap, unsigned int);
+extern int sbitmap_equal (const_sbitmap, const_sbitmap);
+extern bool sbitmap_empty_p (const_sbitmap);
 extern void sbitmap_zero (sbitmap);
 extern void sbitmap_ones (sbitmap);
 extern void sbitmap_vector_zero (sbitmap *, unsigned int);
 extern void sbitmap_vector_ones (sbitmap *, unsigned int);
 
-extern void sbitmap_union_of_diff (sbitmap, sbitmap, sbitmap, sbitmap);
-extern bool sbitmap_union_of_diff_cg (sbitmap, sbitmap, sbitmap, sbitmap);
-extern void sbitmap_difference (sbitmap, sbitmap, sbitmap);
-extern void sbitmap_not (sbitmap, sbitmap);
-extern void sbitmap_a_or_b_and_c (sbitmap, sbitmap, sbitmap, sbitmap);
-extern bool sbitmap_a_or_b_and_c_cg (sbitmap, sbitmap, sbitmap, sbitmap);
-extern void sbitmap_a_and_b_or_c (sbitmap, sbitmap, sbitmap, sbitmap);
-extern bool sbitmap_a_and_b_or_c_cg (sbitmap, sbitmap, sbitmap, sbitmap);
-extern bool sbitmap_any_common_bits (sbitmap, sbitmap);
-extern void sbitmap_a_and_b (sbitmap, sbitmap, sbitmap);
-extern bool sbitmap_a_and_b_cg (sbitmap, sbitmap, sbitmap);
-extern void sbitmap_a_or_b (sbitmap, sbitmap, sbitmap);
-extern bool sbitmap_a_or_b_cg (sbitmap, sbitmap, sbitmap);
-extern void sbitmap_a_xor_b (sbitmap, sbitmap, sbitmap);
-extern bool sbitmap_a_xor_b_cg (sbitmap, sbitmap, sbitmap);
-extern bool sbitmap_a_subset_b_p (sbitmap, sbitmap);
-
-extern int sbitmap_first_set_bit (sbitmap);
-extern int sbitmap_last_set_bit (sbitmap);
+extern void sbitmap_union_of_diff (sbitmap, const_sbitmap, const_sbitmap, const_sbitmap);
+extern bool sbitmap_union_of_diff_cg (sbitmap, const_sbitmap, const_sbitmap, const_sbitmap);
+extern void sbitmap_difference (sbitmap, const_sbitmap, const_sbitmap);
+extern void sbitmap_not (sbitmap, const_sbitmap);
+extern void sbitmap_a_or_b_and_c (sbitmap, const_sbitmap, const_sbitmap, const_sbitmap);
+extern bool sbitmap_a_or_b_and_c_cg (sbitmap, const_sbitmap, const_sbitmap, const_sbitmap);
+extern void sbitmap_a_and_b_or_c (sbitmap, const_sbitmap, const_sbitmap, const_sbitmap);
+extern bool sbitmap_a_and_b_or_c_cg (sbitmap, const_sbitmap, const_sbitmap, const_sbitmap);
+extern bool sbitmap_any_common_bits (const_sbitmap, const_sbitmap);
+extern void sbitmap_a_and_b (sbitmap, const_sbitmap, const_sbitmap);
+extern bool sbitmap_a_and_b_cg (sbitmap, const_sbitmap, const_sbitmap);
+extern void sbitmap_a_or_b (sbitmap, const_sbitmap, const_sbitmap);
+extern bool sbitmap_a_or_b_cg (sbitmap, const_sbitmap, const_sbitmap);
+extern void sbitmap_a_xor_b (sbitmap, const_sbitmap, const_sbitmap);
+extern bool sbitmap_a_xor_b_cg (sbitmap, const_sbitmap, const_sbitmap);
+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 **);
@@ -261,8 +263,8 @@ 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 (sbitmap);
+extern void debug_sbitmap (const_sbitmap);
 extern sbitmap sbitmap_realloc (sbitmap, unsigned int);
-extern unsigned long sbitmap_popcount(sbitmap, unsigned long);
-extern void sbitmap_verify_popcount (sbitmap);
+extern unsigned long sbitmap_popcount(const_sbitmap, unsigned long);
+extern void sbitmap_verify_popcount (const_sbitmap);
 #endif /* ! GCC_SBITMAP_H */