Merge from pch-branch up to tag pch-commit-20020603.

From-SVN: r54232

1 files changed, 85 insertions, 40 deletions

diff --git a/gcc/bitmap.c b/gcc/bitmap.c
index 189c06e..e22a524 100644
--- a/gcc/bitmap.c
+++ b/gcc/bitmap.c
@@ -23,6 +23,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "rtl.h"
 #include "flags.h"
 #include "obstack.h"
+#include "ggc.h"
 #include "bitmap.h"
 
 /* Obstack to allocate bitmap elements from.  */
@@ -40,13 +41,33 @@ static int bitmap_obstack_init = FALSE;
 /* Global data */
 bitmap_element bitmap_zero_bits;	/* An element of all zero bits.  */
 static bitmap_element *bitmap_free;	/* Freelist of bitmap elements.  */
+static GTY((deletable (""))) bitmap_element *bitmap_ggc_free;
 
+static void bitmap_elem_to_freelist	PARAMS ((bitmap, bitmap_element *));
 static void bitmap_element_free		PARAMS ((bitmap, bitmap_element *));
-static bitmap_element *bitmap_element_allocate PARAMS ((void));
+static bitmap_element *bitmap_element_allocate PARAMS ((bitmap));
 static int bitmap_element_zerop		PARAMS ((bitmap_element *));
 static void bitmap_element_link		PARAMS ((bitmap, bitmap_element *));
 static bitmap_element *bitmap_find_bit	PARAMS ((bitmap, unsigned int));
 
+/* Add ELEM to the appropriate freelist.  */
+static INLINE void
+bitmap_elem_to_freelist (head, elt)
+     bitmap head;
+     bitmap_element *elt;
+{
+  if (head->using_obstack)
+    {
+      elt->next = bitmap_free;
+      bitmap_free = elt;
+    }
+  else
+    {
+      elt->next = bitmap_ggc_free;
+      bitmap_ggc_free = elt;
+    }
+}
+
 /* Free a bitmap element.  Since these are allocated off the
    bitmap_obstack, "free" actually means "put onto the freelist".  */
 
@@ -75,56 +96,68 @@ bitmap_element_free (head, elt)
       if (head->current)
 	head->indx = head->current->indx;
     }
-
-  elt->next = bitmap_free;
-  bitmap_free = elt;
+  bitmap_elem_to_freelist (head, elt);
 }
 
 /* Allocate a bitmap element.  The bits are cleared, but nothing else is.  */
 
 static INLINE bitmap_element *
-bitmap_element_allocate ()
+bitmap_element_allocate (head)
+     bitmap head;
 {
   bitmap_element *element;
 
-  if (bitmap_free != 0)
-    {
-      element = bitmap_free;
-      bitmap_free = element->next;
-    }
-  else
+  if (head->using_obstack)
     {
-      /* We can't use gcc_obstack_init to initialize the obstack since
-	 print-rtl.c now calls bitmap functions, and bitmap is linked
-	 into the gen* functions.  */
-      if (!bitmap_obstack_init)
+      if (bitmap_free != 0)
 	{
-	  bitmap_obstack_init = TRUE;
-
-	  /* Let particular systems override the size of a chunk.  */
+	  element = bitmap_free;
+	  bitmap_free = element->next;
+	}
+      else
+	{
+	  /* We can't use gcc_obstack_init to initialize the obstack since
+	     print-rtl.c now calls bitmap functions, and bitmap is linked
+	     into the gen* functions.  */
+	  if (!bitmap_obstack_init)
+	    {
+	      bitmap_obstack_init = TRUE;
+	      
+	      /* Let particular systems override the size of a chunk.  */
 #ifndef OBSTACK_CHUNK_SIZE
 #define OBSTACK_CHUNK_SIZE 0
 #endif
-	  /* Let them override the alloc and free routines too.  */
+	      /* Let them override the alloc and free routines too.  */
 #ifndef OBSTACK_CHUNK_ALLOC
 #define OBSTACK_CHUNK_ALLOC xmalloc
 #endif
 #ifndef OBSTACK_CHUNK_FREE
 #define OBSTACK_CHUNK_FREE free
 #endif
-
+	      
 #if !defined(__GNUC__) || (__GNUC__ < 2)
 #define __alignof__(type) 0
 #endif
-
-	  obstack_specify_allocation (&bitmap_obstack, OBSTACK_CHUNK_SIZE,
-				      __alignof__ (bitmap_element),
-				      (void *(*) PARAMS ((long))) OBSTACK_CHUNK_ALLOC,
-				      (void (*) PARAMS ((void *))) OBSTACK_CHUNK_FREE);
+	      
+	      obstack_specify_allocation (&bitmap_obstack, OBSTACK_CHUNK_SIZE,
+					  __alignof__ (bitmap_element),
+					  (void *(*) PARAMS ((long))) OBSTACK_CHUNK_ALLOC,
+					  (void (*) PARAMS ((void *))) OBSTACK_CHUNK_FREE);
+	    }
+	  
+	  element = (bitmap_element *) obstack_alloc (&bitmap_obstack,
+						      sizeof (bitmap_element));
 	}
-
-      element = (bitmap_element *) obstack_alloc (&bitmap_obstack,
-						  sizeof (bitmap_element));
+    }
+  else
+    {
+      if (bitmap_ggc_free != NULL)
+	{
+          element = bitmap_ggc_free;
+          bitmap_ggc_free = element->next;
+	}
+      else
+	element = ggc_alloc (sizeof (bitmap_element));
     }
 
   memset (element->bits, 0, sizeof (element->bits));
@@ -232,8 +265,7 @@ bitmap_clear (head)
   for (element = head->first; element != 0; element = next)
     {
       next = element->next;
-      element->next = bitmap_free;
-      bitmap_free = element;
+      bitmap_elem_to_freelist (head, element);
     }
 
   head->first = head->current = 0;
@@ -256,7 +288,7 @@ bitmap_copy (to, from)
   /* Copy elements in forward direction one at a time */
   for (from_ptr = from->first; from_ptr; from_ptr = from_ptr->next)
     {
-      bitmap_element *to_elt = bitmap_element_allocate ();
+      bitmap_element *to_elt = bitmap_element_allocate (to);
 
       to_elt->indx = from_ptr->indx;
 
@@ -363,7 +395,7 @@ bitmap_set_bit (head, bit)
 
   if (ptr == 0)
     {
-      ptr = bitmap_element_allocate ();
+      ptr = bitmap_element_allocate (head);
       ptr->indx = bit / BITMAP_ELEMENT_ALL_BITS;
       ptr->bits[word_num] = bit_val;
       bitmap_element_link (head, ptr);
@@ -594,8 +626,7 @@ bitmap_operation (to, from1, from2, operation)
 	  changed = 1;
 	  to_tmp = to_ptr;
 	  to_ptr = to_ptr->next;
-	  to_tmp->next = bitmap_free;
-	  bitmap_free = to_tmp;
+	  bitmap_elem_to_freelist (to, to_tmp);
 	}
       if (to_ptr && to_ptr->indx == indx)
 	{
@@ -603,7 +634,7 @@ bitmap_operation (to, from1, from2, operation)
 	  to_ptr = to_ptr->next;
 	}
       else
-	to_tmp = bitmap_element_allocate ();
+	to_tmp = bitmap_element_allocate (to);
 
       /* Do the operation, and if any bits are set, link it into the
 	 linked list.  */
@@ -638,8 +669,7 @@ bitmap_operation (to, from1, from2, operation)
 	}
       else
 	{
-	  to_tmp->next = bitmap_free;
-	  bitmap_free = to_tmp;
+	  bitmap_elem_to_freelist (to, to_tmp);
 	}
     }
 
@@ -649,8 +679,16 @@ bitmap_operation (to, from1, from2, operation)
       changed = 1;
       for (to_tmp = to_ptr; to_tmp->next ; to_tmp = to_tmp->next)
 	continue;
-      to_tmp->next = bitmap_free;
-      bitmap_free = to_ptr;
+      if (to->using_obstack)
+	{
+	  to_tmp->next = bitmap_free;
+	  bitmap_free = to_ptr;
+	}
+      else
+	{
+	  to_tmp->next = bitmap_ggc_free;
+	  bitmap_ggc_free = to_ptr;
+	}
     }
 
 #undef DOIT
@@ -715,10 +753,15 @@ bitmap_union_of_diff (dst, a, b, c)
 /* Initialize a bitmap header.  */
 
 bitmap
-bitmap_initialize (head)
+bitmap_initialize (head, using_obstack)
      bitmap head;
+     int using_obstack;
 {
+  if (head == NULL && ! using_obstack)
+    head = ggc_alloc (sizeof (*head));
+  
   head->first = head->current = 0;
+  head->using_obstack = using_obstack;
 
   return head;
 }
@@ -800,3 +843,5 @@ bitmap_print (file, head, prefix, suffix)
 			    });
   fputs (suffix, file);
 }
+
+#include "gt-bitmap.h"