1 files changed, 269 insertions, 119 deletions

diff --git a/contrib/gcc/sbitmap.c b/contrib/gcc/sbitmap.c
index cd9deba..74c24c9 100644
--- a/contrib/gcc/sbitmap.c
+++ b/contrib/gcc/sbitmap.c
@@ -1,5 +1,5 @@
 /* Simple bitmaps.
-   Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2000, 2002, 2003 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -47,6 +47,64 @@ sbitmap_alloc (n_elms)
   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 (bmap, n_elms, def)
+     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 = (sbitmap) xrealloc ((PTR) bmap, amt);
+    }
+
+  if (n_elms > bmap->n_bits)
+    {
+      if (def)
+	{
+	  memset ((PTR) (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 ((PTR) (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;
+}
+
 /* Allocate a vector of N_VECS bitmaps of N_ELMS bits.  */
 
 sbitmap *
@@ -106,6 +164,7 @@ sbitmap_equal (a, b)
 {
   return !memcmp (a->elms, b->elms, sizeof (SBITMAP_ELT_TYPE) * a->size);
 }
+
 /* Zero all elements in a bitmap.  */
 
 void
@@ -159,29 +218,41 @@ sbitmap_vector_ones (bmap, n_vecs)
 
 /* Set DST to be A union (B - C).
    DST = A | (B & ~C).
-   Return non-zero if any change is made.  */
+   Returns true if any change is made.  */
 
-int
-sbitmap_union_of_diff (dst, a, b, c)
+bool
+sbitmap_union_of_diff_cg (dst, a, b, c)
      sbitmap dst, a, b, c;
 {
-  unsigned int i;
-  sbitmap_ptr dstp, ap, bp, cp;
-  int changed = 0;
-
-  for (dstp = dst->elms, ap = a->elms, bp = b->elms, cp = c->elms, i = 0;
-       i < dst->size; i++, dstp++)
+  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;
+  SBITMAP_ELT_TYPE changed = 0;
+
+  for (i = 0; i < n; i++)
     {
       SBITMAP_ELT_TYPE tmp = *ap++ | (*bp++ & ~*cp++);
-
-      if (*dstp != tmp)
-	{
-	  changed = 1;
-	  *dstp = tmp;
-	}
+      changed |= *dstp ^ tmp;
+      *dstp++ = tmp;
     }
 
-  return changed;
+  return changed != 0;
+}
+
+void
+sbitmap_union_of_diff (dst, a, b, c)
+     sbitmap dst, a, b, 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;
+
+  for (i = 0; i < n; i++)
+    *dstp++ = *ap++ | (*bp++ & ~*cp++);
 }
 
 /* Set bitmap DST to the bitwise negation of the bitmap SRC.  */
@@ -190,11 +261,12 @@ void
 sbitmap_not (dst, src)
      sbitmap dst, src;
 {
-  unsigned int i;
-  sbitmap_ptr dstp, srcp;
+  unsigned int i, n = dst->size;
+  sbitmap_ptr dstp = dst->elms;
+  sbitmap_ptr srcp = src->elms;
 
-  for (dstp = dst->elms, srcp = src->elms, i = 0; i < dst->size; i++)
-    *dstp++ = ~(*srcp++);
+  for (i = 0; i < n; i++)
+    *dstp++ = ~*srcp++;
 }
 
 /* Set the bits in DST to be the difference between the bits
@@ -204,156 +276,226 @@ void
 sbitmap_difference (dst, a, b)
      sbitmap dst, a, b;
 {
-  unsigned int i;
-  sbitmap_ptr dstp, ap, bp;
+  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;
   
-  for (dstp = dst->elms, ap = a->elms, bp = b->elms, i = 0; i < dst->size; i++)
+  /* A should be at least as large as DEST, to have a defined source.  */
+  if (a->size < dst_size)
+    abort ();
+  /* 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)
+    min_size = b->size;
+  for (i = 0; i < min_size; i++)
     *dstp++ = *ap++ & (~*bp++);
+  /* Now fill the rest of dest from A, if B was too short.
+     This makes sense only when destination and A differ.  */
+  if (dst != a && i != dst_size)
+    for (; i < dst_size; i++)
+      *dstp++ = *ap++;
 }
 
 /* Set DST to be (A and B).
-   Return non-zero if any change is made.  */
+   Return nonzero if any change is made.  */
 
-int
-sbitmap_a_and_b (dst, a, b)
+bool
+sbitmap_a_and_b_cg (dst, a, b)
      sbitmap dst, a, b;
 {
-  unsigned int i;
-  sbitmap_ptr dstp, ap, bp;
-  int changed = 0;
+  unsigned int i, n = dst->size;
+  sbitmap_ptr dstp = dst->elms;
+  sbitmap_ptr ap = a->elms;
+  sbitmap_ptr bp = b->elms;
+  SBITMAP_ELT_TYPE changed = 0;
 
-  for (dstp = dst->elms, ap = a->elms, bp = b->elms, i = 0; i < dst->size;
-       i++, dstp++)
+  for (i = 0; i < n; i++)
     {
       SBITMAP_ELT_TYPE tmp = *ap++ & *bp++;
-
-      if (*dstp != tmp)
-	{
-	  changed = 1;
-	  *dstp = tmp;
-	}
+      changed = *dstp ^ tmp;
+      *dstp++ = tmp;
     }
 
-  return changed;
+  return changed != 0;
+}
+
+void
+sbitmap_a_and_b (dst, a, b)
+     sbitmap dst, a, b;
+{
+  unsigned int i, n = dst->size;
+  sbitmap_ptr dstp = dst->elms;
+  sbitmap_ptr ap = a->elms;
+  sbitmap_ptr bp = b->elms;
+
+  for (i = 0; i < n; i++)
+    *dstp++ = *ap++ & *bp++;
 }
 
 /* Set DST to be (A xor B)).
-   Return non-zero if any change is made.  */
+   Return nonzero if any change is made.  */
 
-int
-sbitmap_a_xor_b (dst, a, b)
+bool
+sbitmap_a_xor_b_cg (dst, a, b)
      sbitmap dst, a, b;
 {
-  unsigned int i;
-  sbitmap_ptr dstp, ap, bp;
-  int changed = 0;
-  
-  for (dstp = dst->elms, ap = a->elms, bp = b->elms, i = 0; i < dst->size;
-       i++, dstp++)
+  unsigned int i, n = dst->size;
+  sbitmap_ptr dstp = dst->elms;
+  sbitmap_ptr ap = a->elms;
+  sbitmap_ptr bp = b->elms;
+  SBITMAP_ELT_TYPE changed = 0;
+
+  for (i = 0; i < n; i++)
     {
       SBITMAP_ELT_TYPE tmp = *ap++ ^ *bp++;
-      
-      if (*dstp != tmp)
-	{
-	  changed = 1;
-	  *dstp = tmp;
-	}
+      changed = *dstp ^ tmp;
+      *dstp++ = tmp;
     }
-  return changed;
+
+  return changed != 0;
+}
+
+void
+sbitmap_a_xor_b (dst, a, b)
+     sbitmap dst, a, b;
+{
+  unsigned int i, n = dst->size;
+  sbitmap_ptr dstp = dst->elms;
+  sbitmap_ptr ap = a->elms;
+  sbitmap_ptr bp = b->elms;
+
+  for (i = 0; i < n; i++)
+    *dstp++ = *ap++ ^ *bp++;
 }
 
 /* Set DST to be (A or B)).
-   Return non-zero if any change is made.  */
+   Return nonzero if any change is made.  */
 
-int
-sbitmap_a_or_b (dst, a, b)
+bool
+sbitmap_a_or_b_cg (dst, a, b)
      sbitmap dst, a, b;
 {
-  unsigned int i;
-  sbitmap_ptr dstp, ap, bp;
-  int changed = 0;
+  unsigned int i, n = dst->size;
+  sbitmap_ptr dstp = dst->elms;
+  sbitmap_ptr ap = a->elms;
+  sbitmap_ptr bp = b->elms;
+  SBITMAP_ELT_TYPE changed = 0;
 
-  for (dstp = dst->elms, ap = a->elms, bp = b->elms, i = 0; i < dst->size;
-       i++, dstp++)
+  for (i = 0; i < n; i++)
     {
       SBITMAP_ELT_TYPE tmp = *ap++ | *bp++;
-
-      if (*dstp != tmp)
-	{
-	  changed = 1;
-	  *dstp = tmp;
-	}
+      changed = *dstp ^ tmp;
+      *dstp++ = tmp;
     }
 
-  return changed;
+  return changed != 0;
 }
 
-/* Return non-zero if A is a subset of B.  */
+void
+sbitmap_a_or_b (dst, a, b)
+     sbitmap dst, a, b;
+{
+  unsigned int i, n = dst->size;
+  sbitmap_ptr dstp = dst->elms;
+  sbitmap_ptr ap = a->elms;
+  sbitmap_ptr bp = b->elms;
+
+  for (i = 0; i < n; i++)
+    *dstp++ = *ap++ | *bp++;
+}
 
-int
+/* Return nonzero if A is a subset of B.  */
+
+bool
 sbitmap_a_subset_b_p (a, b)
      sbitmap a, b;
 {
-  unsigned int i;
+  unsigned int i, n = a->size;
   sbitmap_ptr ap, bp;
 
-  for (ap = a->elms, bp = b->elms, i = 0; i < a->size; i++, ap++, bp++)
+  for (ap = a->elms, bp = b->elms, i = 0; i < n; i++, ap++, bp++)
     if ((*ap | *bp) != *bp)
-      return 0;
+      return false;
 
-  return 1;
+  return true;
 }
 
 /* Set DST to be (A or (B and C)).
-   Return non-zero if any change is made.  */
+   Return nonzero if any change is made.  */
 
-int
-sbitmap_a_or_b_and_c (dst, a, b, c)
+bool
+sbitmap_a_or_b_and_c_cg (dst, a, b, c)
      sbitmap dst, a, b, c;
 {
-  unsigned int i;
-  sbitmap_ptr dstp, ap, bp, cp;
-  int changed = 0;
-
-  for (dstp = dst->elms, ap = a->elms, bp = b->elms, cp = c->elms, i = 0;
-       i < dst->size; i++, dstp++)
+  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;
+  SBITMAP_ELT_TYPE changed = 0;
+
+  for (i = 0; i < n; i++)
     {
       SBITMAP_ELT_TYPE tmp = *ap++ | (*bp++ & *cp++);
-
-      if (*dstp != tmp)
-	{
-	  changed = 1;
-	  *dstp = tmp;
-	}
+      changed |= *dstp ^ tmp;
+      *dstp++ = tmp;
     }
 
-  return changed;
+  return changed != 0;
+}
+
+void
+sbitmap_a_or_b_and_c (dst, a, b, c)
+     sbitmap dst, a, b, 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;
+
+  for (i = 0; i < n; i++)
+    *dstp++ = *ap++ | (*bp++ & *cp++);
 }
 
 /* Set DST to be (A and (B or C)).
-   Return non-zero if any change is made.  */
+   Return nonzero if any change is made.  */
 
-int
-sbitmap_a_and_b_or_c (dst, a, b, c)
+bool
+sbitmap_a_and_b_or_c_cg (dst, a, b, c)
      sbitmap dst, a, b, c;
 {
-  unsigned int i;
-  sbitmap_ptr dstp, ap, bp, cp;
-  int changed = 0;
-
-  for (dstp = dst->elms, ap = a->elms, bp = b->elms, cp = c->elms, i = 0;
-       i < dst->size; i++, dstp++)
+  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;
+  SBITMAP_ELT_TYPE changed = 0;
+
+  for (i = 0; i < n; i++)
     {
       SBITMAP_ELT_TYPE tmp = *ap++ & (*bp++ | *cp++);
-
-      if (*dstp != tmp)
-	{
-	  changed = 1;
-	  *dstp = tmp;
-	}
+      changed |= *dstp ^ tmp;
+      *dstp++ = tmp;
     }
 
-  return changed;
+  return changed != 0;
+}
+
+void
+sbitmap_a_and_b_or_c (dst, a, b, c)
+     sbitmap dst, a, b, 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;
+
+  for (i = 0; i < n; i++)
+    *dstp++ = *ap++ & (*bp++ | *cp++);
 }
 
 #ifdef IN_GCC
@@ -373,7 +515,7 @@ sbitmap_intersection_of_succs (dst, src, bb)
   for (e = b->succ; e != 0; e = e->succ_next)
     {
       if (e->dest == EXIT_BLOCK_PTR)
-        continue;
+	continue;
 
       sbitmap_copy (dst, src[e->dest->index]);
       break;
@@ -413,7 +555,7 @@ sbitmap_intersection_of_preds (dst, src, bb)
   for (e = b->pred; e != 0; e = e->pred_next)
     {
       if (e->src == ENTRY_BLOCK_PTR)
-        continue;
+	continue;
 
       sbitmap_copy (dst, src[e->src->index]);
       break;
@@ -453,7 +595,7 @@ sbitmap_union_of_succs (dst, src, bb)
   for (e = b->succ; e != 0; e = e->succ_next)
     {
       if (e->dest == EXIT_BLOCK_PTR)
-        continue;
+	continue;
 
       sbitmap_copy (dst, src[e->dest->index]);
       break;
@@ -493,7 +635,7 @@ sbitmap_union_of_preds (dst, src, bb)
   for (e = b->pred; e != 0; e = e->pred_next)
     {
       if (e->src== ENTRY_BLOCK_PTR)
-        continue;
+	continue;
 
       sbitmap_copy (dst, src[e->src->index]);
       break;
@@ -509,7 +651,7 @@ sbitmap_union_of_preds (dst, src, bb)
 
 	if (e->src == ENTRY_BLOCK_PTR)
 	  continue;
-	
+
 	p = src[e->src->index]->elms;
 	r = dst->elms;
 	for (i = 0; i < set_size; i++)
@@ -587,27 +729,35 @@ dump_sbitmap (file, bmap)
 }
 
 void
-debug_sbitmap (bmap)
+dump_sbitmap_file (file, bmap)
+     FILE *file;
      sbitmap bmap;
 {
   unsigned int i, pos;
 
-  fprintf (stderr, "n_bits = %d, set = {", bmap->n_bits);
+  fprintf (file, "n_bits = %d, set = {", bmap->n_bits);
 
   for (pos = 30, i = 0; i < bmap->n_bits; i++)
     if (TEST_BIT (bmap, i))
       {
 	if (pos > 70)
 	  {
-	    fprintf (stderr, "\n");
+	    fprintf (file, "\n  ");
 	    pos = 0;
 	  }
 
-	fprintf (stderr, "%d ", i);
-	pos += 1 + (i >= 10) + (i >= 100);
+	fprintf (file, "%d ", i);
+	pos += 2 + (i >= 10) + (i >= 100) + (i >= 1000);
       }
 
-  fprintf (stderr, "}\n");
+  fprintf (file, "}\n");
+}
+
+void
+debug_sbitmap (bmap)
+     sbitmap bmap;
+{
+  dump_sbitmap_file (stderr, bmap);
 }
 
 void