X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fsbitmap.c;h=dfd764528cb05fe608cac46eb6958d03809f372c;hb=e8ce43d44c18b97c4bccf7c8a25ca34ca164025e;hp=74aa7cd1b4e40caa419d691fc59611095a3f85e6;hpb=f712a0dcd3010d64361b11d5f7b7d71700f69aab;p=pf3gnuchains%2Fgcc-fork.git

diff --git a/gcc/sbitmap.c b/gcc/sbitmap.c
index 74aa7cd1b4e..dfd764528cb 100644
--- a/gcc/sbitmap.c
+++ b/gcc/sbitmap.c
@@ -1,5 +1,5 @@
 /* Simple bitmaps.
-   Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2000, 2002, 2003 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -20,6 +20,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 
 #include "config.h"
 #include "system.h"
+#include "coretypes.h"
+#include "tm.h"
 #include "rtl.h"
 #include "flags.h"
 #include "hard-reg-set.h"
@@ -30,8 +32,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 /* Allocate a simple bitmap of N_ELMS bits.  */
 
 sbitmap
-sbitmap_alloc (n_elms)
-     unsigned int n_elms;
+sbitmap_alloc (unsigned int n_elms)
 {
   unsigned int bytes, size, amt;
   sbitmap bmap;
@@ -40,7 +41,88 @@ sbitmap_alloc (n_elms)
   bytes = size * sizeof (SBITMAP_ELT_TYPE);
   amt = (sizeof (struct simple_bitmap_def)
 	 + bytes - sizeof (SBITMAP_ELT_TYPE));
-  bmap = (sbitmap) xmalloc (amt);
+  bmap = xmalloc (amt);
+  bmap->n_bits = n_elms;
+  bmap->size = size;
+  bmap->bytes = bytes;
+  return bmap;
+}
+
+/* Resize a simple bitmap BMAP to N_ELMS bits.  If increasing the
+   size of BMAP, clear the new bits to zero if the DEF argument
+   is zero, and set them to one otherwise.  */
+
+sbitmap
+sbitmap_resize (sbitmap bmap, unsigned int n_elms, int def)
+{
+  unsigned int bytes, size, amt;
+  unsigned int last_bit;
+
+  size = SBITMAP_SET_SIZE (n_elms);
+  bytes = size * sizeof (SBITMAP_ELT_TYPE);
+  if (bytes > bmap->bytes)
+    {
+      amt = (sizeof (struct simple_bitmap_def)
+	    + bytes - sizeof (SBITMAP_ELT_TYPE));
+      bmap = xrealloc (bmap, amt);
+    }
+
+  if (n_elms > bmap->n_bits)
+    {
+      if (def)
+	{
+	  memset (bmap->elms + bmap->size, -1, bytes - bmap->bytes);
+
+	  /* Set the new bits if the original last element.  */
+	  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));
+
+	  /* Clear the unused bit in the new last element.  */
+	  last_bit = n_elms % SBITMAP_ELT_BITS;
+	  if (last_bit)
+	    bmap->elms[size - 1]
+	      &= (SBITMAP_ELT_TYPE)-1 >> (SBITMAP_ELT_BITS - last_bit);
+	}
+      else
+	memset (bmap->elms + bmap->size, 0, bytes - bmap->bytes);
+    }
+  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->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 (src->bytes  >= bytes)
+    {
+      src->n_bits = n_elms;
+      return src;
+    }
+
+  bmap = (sbitmap) xrealloc (src, amt);
   bmap->n_bits = n_elms;
   bmap->size = size;
   bmap->bytes = bytes;
@@ -50,8 +132,7 @@ sbitmap_alloc (n_elms)
 /* Allocate a vector of N_VECS bitmaps of N_ELMS bits.  */
 
 sbitmap *
-sbitmap_vector_alloc (n_vecs, n_elms)
-     unsigned int n_vecs, n_elms;
+sbitmap_vector_alloc (unsigned int n_vecs, unsigned int n_elms)
 {
   unsigned int i, bytes, offset, elm_bytes, size, amt, vector_bytes;
   sbitmap *bitmap_vector;
@@ -75,7 +156,7 @@ sbitmap_vector_alloc (n_vecs, n_elms)
   }
 
   amt = vector_bytes + (n_vecs * elm_bytes);
-  bitmap_vector = (sbitmap *) xmalloc (amt);
+  bitmap_vector = xmalloc (amt);
 
   for (i = 0, offset = vector_bytes; i < n_vecs; i++, offset += elm_bytes)
     {
@@ -93,16 +174,14 @@ sbitmap_vector_alloc (n_vecs, n_elms)
 /* Copy sbitmap SRC to DST.  */
 
 void
-sbitmap_copy (dst, src)
-     sbitmap dst, src;
+sbitmap_copy (sbitmap dst, sbitmap src)
 {
   memcpy (dst->elms, src->elms, sizeof (SBITMAP_ELT_TYPE) * dst->size);
 }
 
 /* Determine if a == b.  */
 int
-sbitmap_equal (a, b)
-     sbitmap a, b;
+sbitmap_equal (sbitmap a, sbitmap b)
 {
   return !memcmp (a->elms, b->elms, sizeof (SBITMAP_ELT_TYPE) * a->size);
 }
@@ -110,21 +189,19 @@ sbitmap_equal (a, b)
 /* Zero all elements in a bitmap.  */
 
 void
-sbitmap_zero (bmap)
-     sbitmap bmap;
+sbitmap_zero (sbitmap bmap)
 {
-  memset ((PTR) bmap->elms, 0, bmap->bytes);
+  memset (bmap->elms, 0, bmap->bytes);
 }
 
 /* Set all elements in a bitmap to ones.  */
 
 void
-sbitmap_ones (bmap)
-     sbitmap bmap;
+sbitmap_ones (sbitmap bmap)
 {
   unsigned int last_bit;
 
-  memset ((PTR) bmap->elms, -1, bmap->bytes);
+  memset (bmap->elms, -1, bmap->bytes);
 
   last_bit = bmap->n_bits % SBITMAP_ELT_BITS;
   if (last_bit)
@@ -135,9 +212,7 @@ sbitmap_ones (bmap)
 /* Zero a vector of N_VECS bitmaps.  */
 
 void
-sbitmap_vector_zero (bmap, n_vecs)
-     sbitmap *bmap;
-     unsigned int n_vecs;
+sbitmap_vector_zero (sbitmap *bmap, unsigned int n_vecs)
 {
   unsigned int i;
 
@@ -148,9 +223,7 @@ sbitmap_vector_zero (bmap, n_vecs)
 /* Set a vector of N_VECS bitmaps to ones.  */
 
 void
-sbitmap_vector_ones (bmap, n_vecs)
-     sbitmap *bmap;
-     unsigned int n_vecs;
+sbitmap_vector_ones (sbitmap *bmap, unsigned int n_vecs)
 {
   unsigned int i;
 
@@ -163,8 +236,7 @@ sbitmap_vector_ones (bmap, n_vecs)
    Returns true if any change is made.  */
 
 bool
-sbitmap_union_of_diff_cg (dst, a, b, c)
-     sbitmap dst, a, b, c;
+sbitmap_union_of_diff_cg (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
@@ -184,8 +256,7 @@ sbitmap_union_of_diff_cg (dst, a, b, c)
 }
 
 void
-sbitmap_union_of_diff (dst, a, b, c)
-     sbitmap dst, a, b, c;
+sbitmap_union_of_diff (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
@@ -200,30 +271,35 @@ sbitmap_union_of_diff (dst, a, b, c)
 /* Set bitmap DST to the bitwise negation of the bitmap SRC.  */
 
 void
-sbitmap_not (dst, src)
-     sbitmap dst, src;
+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;
 
   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
    in A and the bits in B. i.e. dst = a & (~b).  */
 
 void
-sbitmap_difference (dst, a, b)
-     sbitmap dst, a, b;
+sbitmap_difference (sbitmap dst, sbitmap a, 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;
-  
+
   /* A should be at least as large as DEST, to have a defined source.  */
   if (a->size < dst_size)
     abort ();
@@ -244,8 +320,7 @@ sbitmap_difference (dst, a, b)
    Return nonzero if any change is made.  */
 
 bool
-sbitmap_a_and_b_cg (dst, a, b)
-     sbitmap dst, a, b;
+sbitmap_a_and_b_cg (sbitmap dst, sbitmap a, sbitmap b)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
@@ -256,7 +331,7 @@ sbitmap_a_and_b_cg (dst, a, b)
   for (i = 0; i < n; i++)
     {
       SBITMAP_ELT_TYPE tmp = *ap++ & *bp++;
-      changed = *dstp ^ tmp;
+      changed |= *dstp ^ tmp;
       *dstp++ = tmp;
     }
 
@@ -264,8 +339,7 @@ sbitmap_a_and_b_cg (dst, a, b)
 }
 
 void
-sbitmap_a_and_b (dst, a, b)
-     sbitmap dst, a, b;
+sbitmap_a_and_b (sbitmap dst, sbitmap a, sbitmap b)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
@@ -280,8 +354,7 @@ sbitmap_a_and_b (dst, a, b)
    Return nonzero if any change is made.  */
 
 bool
-sbitmap_a_xor_b_cg (dst, a, b)
-     sbitmap dst, a, b;
+sbitmap_a_xor_b_cg (sbitmap dst, sbitmap a, sbitmap b)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
@@ -292,7 +365,7 @@ sbitmap_a_xor_b_cg (dst, a, b)
   for (i = 0; i < n; i++)
     {
       SBITMAP_ELT_TYPE tmp = *ap++ ^ *bp++;
-      changed = *dstp ^ tmp;
+      changed |= *dstp ^ tmp;
       *dstp++ = tmp;
     }
 
@@ -300,8 +373,7 @@ sbitmap_a_xor_b_cg (dst, a, b)
 }
 
 void
-sbitmap_a_xor_b (dst, a, b)
-     sbitmap dst, a, b;
+sbitmap_a_xor_b (sbitmap dst, sbitmap a, sbitmap b)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
@@ -316,8 +388,7 @@ sbitmap_a_xor_b (dst, a, b)
    Return nonzero if any change is made.  */
 
 bool
-sbitmap_a_or_b_cg (dst, a, b)
-     sbitmap dst, a, b;
+sbitmap_a_or_b_cg (sbitmap dst, sbitmap a, sbitmap b)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
@@ -328,7 +399,7 @@ sbitmap_a_or_b_cg (dst, a, b)
   for (i = 0; i < n; i++)
     {
       SBITMAP_ELT_TYPE tmp = *ap++ | *bp++;
-      changed = *dstp ^ tmp;
+      changed |= *dstp ^ tmp;
       *dstp++ = tmp;
     }
 
@@ -336,8 +407,7 @@ sbitmap_a_or_b_cg (dst, a, b)
 }
 
 void
-sbitmap_a_or_b (dst, a, b)
-     sbitmap dst, a, b;
+sbitmap_a_or_b (sbitmap dst, sbitmap a, sbitmap b)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
@@ -351,8 +421,7 @@ sbitmap_a_or_b (dst, a, b)
 /* Return nonzero if A is a subset of B.  */
 
 bool
-sbitmap_a_subset_b_p (a, b)
-     sbitmap a, b;
+sbitmap_a_subset_b_p (sbitmap a, sbitmap b)
 {
   unsigned int i, n = a->size;
   sbitmap_ptr ap, bp;
@@ -368,8 +437,7 @@ sbitmap_a_subset_b_p (a, b)
    Return nonzero if any change is made.  */
 
 bool
-sbitmap_a_or_b_and_c_cg (dst, a, b, c)
-     sbitmap dst, a, b, c;
+sbitmap_a_or_b_and_c_cg (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
@@ -389,8 +457,7 @@ sbitmap_a_or_b_and_c_cg (dst, a, b, c)
 }
 
 void
-sbitmap_a_or_b_and_c (dst, a, b, c)
-     sbitmap dst, a, b, c;
+sbitmap_a_or_b_and_c (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
@@ -406,8 +473,7 @@ sbitmap_a_or_b_and_c (dst, a, b, c)
    Return nonzero if any change is made.  */
 
 bool
-sbitmap_a_and_b_or_c_cg (dst, a, b, c)
-     sbitmap dst, a, b, c;
+sbitmap_a_and_b_or_c_cg (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
@@ -427,8 +493,7 @@ sbitmap_a_and_b_or_c_cg (dst, a, b, c)
 }
 
 void
-sbitmap_a_and_b_or_c (dst, a, b, c)
-     sbitmap dst, a, b, c;
+sbitmap_a_and_b_or_c (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
 {
   unsigned int i, n = dst->size;
   sbitmap_ptr dstp = dst->elms;
@@ -445,10 +510,7 @@ sbitmap_a_and_b_or_c (dst, a, b, c)
    block number BB, using the new flow graph structures.  */
 
 void
-sbitmap_intersection_of_succs (dst, src, bb)
-     sbitmap dst;
-     sbitmap *src;
-     int bb;
+sbitmap_intersection_of_succs (sbitmap dst, sbitmap *src, int bb)
 {
   basic_block b = BASIC_BLOCK (bb);
   unsigned int set_size = dst->size;
@@ -485,10 +547,7 @@ sbitmap_intersection_of_succs (dst, src, bb)
    block number BB, using the new flow graph structures.  */
 
 void
-sbitmap_intersection_of_preds (dst, src, bb)
-     sbitmap dst;
-     sbitmap *src;
-     int bb;
+sbitmap_intersection_of_preds (sbitmap dst, sbitmap *src, int bb)
 {
   basic_block b = BASIC_BLOCK (bb);
   unsigned int set_size = dst->size;
@@ -525,10 +584,7 @@ sbitmap_intersection_of_preds (dst, src, bb)
    block number BB, using the new flow graph structures.  */
 
 void
-sbitmap_union_of_succs (dst, src, bb)
-     sbitmap dst;
-     sbitmap *src;
-     int bb;
+sbitmap_union_of_succs (sbitmap dst, sbitmap *src, int bb)
 {
   basic_block b = BASIC_BLOCK (bb);
   unsigned int set_size = dst->size;
@@ -565,10 +621,7 @@ sbitmap_union_of_succs (dst, src, bb)
    block number BB, using the new flow graph structures.  */
 
 void
-sbitmap_union_of_preds (dst, src, bb)
-     sbitmap dst;
-     sbitmap *src;
-     int bb;
+sbitmap_union_of_preds (sbitmap dst, sbitmap *src, int bb)
 {
   basic_block b = BASIC_BLOCK (bb);
   unsigned int set_size = dst->size;
@@ -605,8 +658,7 @@ sbitmap_union_of_preds (dst, src, bb)
 /* Return number of first bit set in the bitmap, -1 if none.  */
 
 int
-sbitmap_first_set_bit (bmap)
-     sbitmap bmap;
+sbitmap_first_set_bit (sbitmap bmap)
 {
   unsigned int n;
 
@@ -617,8 +669,7 @@ sbitmap_first_set_bit (bmap)
 /* Return number of last bit set in the bitmap, -1 if none.  */
 
 int
-sbitmap_last_set_bit (bmap)
-     sbitmap bmap;
+sbitmap_last_set_bit (sbitmap bmap)
 {
   int i;
   SBITMAP_ELT_TYPE *ptr = bmap->elms;
@@ -648,9 +699,7 @@ sbitmap_last_set_bit (bmap)
 }
 
 void
-dump_sbitmap (file, bmap)
-     FILE *file;
-     sbitmap bmap;
+dump_sbitmap (FILE *file, sbitmap bmap)
 {
   unsigned int i, n, j;
   unsigned int set_size = bmap->size;
@@ -671,9 +720,7 @@ dump_sbitmap (file, bmap)
 }
 
 void
-dump_sbitmap_file (file, bmap)
-     FILE *file;
-     sbitmap bmap;
+dump_sbitmap_file (FILE *file, sbitmap bmap)
 {
   unsigned int i, pos;
 
@@ -696,18 +743,14 @@ dump_sbitmap_file (file, bmap)
 }
 
 void
-debug_sbitmap (bmap)
-     sbitmap bmap;
+debug_sbitmap (sbitmap bmap)
 {
   dump_sbitmap_file (stderr, bmap);
 }
 
 void
-dump_sbitmap_vector (file, title, subtitle, bmaps, n_maps)
-     FILE *file;
-     const char *title, *subtitle;
-     sbitmap *bmaps;
-     int n_maps;
+dump_sbitmap_vector (FILE *file, const char *title, const char *subtitle,
+		     sbitmap *bmaps, int n_maps)
 {
   int bb;