This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH INSTALLED]: const typedefs part 8/N


(Sorry for the empty message before.)

This patch uses the const_sbitmap typedef.

Tested on sparc-sun-solaris2.10, no regressions.  Installed.

		--Kaveh


2007-07-24  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.

diff -rup orig/egcc-SVN20070721/gcc/sbitmap.c egcc-SVN20070721/gcc/sbitmap.c
--- orig/egcc-SVN20070721/gcc/sbitmap.c	2007-06-11 23:02:47.000000000 -0400
+++ egcc-SVN20070721/gcc/sbitmap.c	2007-07-24 23:26:36.632944448 -0400
@@ -52,7 +52,7 @@ static unsigned long sbitmap_elt_popcoun
    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_vec
 /* 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

 /* 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, unsi
    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, s
 }

 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, sbit
 /* 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
    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, sbit
    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
 }

 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,
    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
 }

 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,
    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
 }

 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,
 /* 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
    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, sb
 }

 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, sbitm
    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, sb
 }

 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, sbi
 /* 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 b
 }

 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 c

 #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 -rup orig/egcc-SVN20070721/gcc/sbitmap.h egcc-SVN20070721/gcc/sbitmap.h
--- orig/egcc-SVN20070721/gcc/sbitmap.h	2007-06-11 23:02:48.000000000 -0400
+++ egcc-SVN20070721/gcc/sbitmap.h	2007-07-24 23:17:10.430255303 -0400
@@ -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 bi
 /* 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 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 (sbitmap);
-extern int sbitmap_last_set_bit (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_pred
 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 */


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]