ggc-common.c: Update pre-function commentary.

	* ggc-common.c: Update pre-function commentary.
	* ggc-page.c: Likewise.
	(poison): Remove.
	(poison_pages): Use memset directly.
	(ggc_alloc_obj): Likewise.  Use a different pattern than poison_pages.
	(ggc_collect): Poison before sweeping.
	* ggc-simple.c: Update pre-function commentary.
	(ggc_alloc_obj): Poison non-zeroed memory.

From-SVN: r30275

4 files changed, 90 insertions, 28 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 59039ec..718a270 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,14 @@
+Sat Oct 30 14:31:48 1999  Richard Henderson  <rth@cygnus.com>
+
+	* ggc-common.c: Update pre-function commentary.
+	* ggc-page.c: Likewise.
+	(poison): Remove.
+	(poison_pages): Use memset directly.
+	(ggc_alloc_obj): Likewise.  Use a different pattern than poison_pages.
+	(ggc_collect): Poison before sweeping.
+	* ggc-simple.c: Update pre-function commentary.
+	(ggc_alloc_obj): Poison non-zeroed memory.
+
 Sat Oct 30 14:28:52 1999  Mark Mitchell  <mark@codesourcery.com>
 
 	* ggc-common.c (ggc_print_statistics): Make arguments to fprintf
diff --git a/gcc/ggc-common.c b/gcc/ggc-common.c
index ab8c3a1..8c15dc0 100644
--- a/gcc/ggc-common.c
+++ b/gcc/ggc-common.c
@@ -97,6 +97,9 @@ ggc_mark_tree_hash_table_ptr (elt)
   ggc_mark_tree_hash_table (*(struct hash_table **) elt);
 }
 
+/* Type-correct function to pass to ggc_add_root.  It just forwards
+   ELT (which is really a char **) to ggc_mark_string.  */
+
 static void
 ggc_mark_string_ptr (elt)
      void *elt;
@@ -104,6 +107,12 @@ ggc_mark_string_ptr (elt)
   ggc_mark_string (*(char **)elt);
 }
 
+/* Add BASE as a new garbage collection root.  It is an array of
+   length NELT with each element SIZE bytes long.  CB is a 
+   function that will be called with a pointer to each element
+   of the array; it is the intention that CB call the appropriate
+   routine to mark gc-able memory for that element.  */
+
 void
 ggc_add_root (base, nelt, size, cb)
      void *base;
@@ -121,6 +130,8 @@ ggc_add_root (base, nelt, size, cb)
   roots = x;
 }
 
+/* Register an array of rtx as a GC root.  */
+
 void
 ggc_add_rtx_root (base, nelt)
      rtx *base;
@@ -129,6 +140,8 @@ ggc_add_rtx_root (base, nelt)
   ggc_add_root (base, nelt, sizeof(rtx), ggc_mark_rtx_ptr);
 }
 
+/* Register an array of trees as a GC root.  */
+
 void
 ggc_add_tree_root (base, nelt)
      tree *base;
@@ -137,7 +150,7 @@ ggc_add_tree_root (base, nelt)
   ggc_add_root (base, nelt, sizeof(tree), ggc_mark_tree_ptr);
 }
 
-/* Add V (a varray full of trees) to the list of GC roots.  */
+/* Register a varray of trees as a GC root.  */
 
 void
 ggc_add_tree_varray_root (base, nelt)
@@ -148,8 +161,7 @@ ggc_add_tree_varray_root (base, nelt)
 		ggc_mark_tree_varray_ptr);
 }
 
-/* Add HT (a hash-table where ever key is a tree) to the list of GC
-   roots.  */
+/* Register a hash table of trees as a GC root.  */
 
 void
 ggc_add_tree_hash_table_root (base, nelt)
@@ -160,6 +172,8 @@ ggc_add_tree_hash_table_root (base, nelt)
 		ggc_mark_tree_hash_table_ptr);
 }
 
+/* Register an array of strings as a GC root.  */
+
 void
 ggc_add_string_root (base, nelt)
      char **base;
@@ -168,6 +182,7 @@ ggc_add_string_root (base, nelt)
   ggc_add_root (base, nelt, sizeof (char *), ggc_mark_string_ptr);
 }
 
+/* Remove the previously registered GC root at BASE.  */
 
 void
 ggc_del_root (base)
@@ -191,6 +206,8 @@ ggc_del_root (base)
   abort();
 }
 
+/* Iterate through all registered roots and mark each element.  */
+
 void
 ggc_mark_roots ()
 {
@@ -208,6 +225,9 @@ ggc_mark_roots ()
     }
 }
 
+/* R had not been previously marked, but has now been marked via
+   ggc_set_mark.  Now recurse and process the children.  */
+
 void
 ggc_mark_rtx_children (r)
      rtx r;
@@ -285,6 +305,9 @@ ggc_mark_rtx_children (r)
     }
 }
 
+/* V had not been previously marked, but has now been marked via
+   ggc_set_mark.  Now recurse and process the children.  */
+
 void
 ggc_mark_rtvec_children (v)
      rtvec v;
@@ -296,6 +319,9 @@ ggc_mark_rtvec_children (v)
     ggc_mark_rtx (RTVEC_ELT (v, i));
 }
 
+/* T had not been previously marked, but has now been marked via
+   ggc_set_mark.  Now recurse and process the children.  */
+
 void
 ggc_mark_tree_children (t)
      tree t;
@@ -466,7 +492,10 @@ ggc_mark_tree_hash_table (ht)
   hash_traverse (ht, ggc_mark_tree_hash_table_entry, /*info=*/0);
 }
 
-/* Allocation wrappers.  */
+/* Allocate a gc-able string.  If CONTENTS is null, then the memory will
+   be uninitialized.  If LENGTH is -1, then CONTENTS is assumed to be a
+   null-terminated string and the memory sized accordingly.  Otherwise,
+   the memory is filled with LENGTH bytes from CONTENTS.  */
 
 char *
 ggc_alloc_string (contents, length)
diff --git a/gcc/ggc-page.c b/gcc/ggc-page.c
index 154ec2c..9177943 100644
--- a/gcc/ggc-page.c
+++ b/gcc/ggc-page.c
@@ -281,7 +281,6 @@ static void clear_marks PROTO ((void));
 static void sweep_pages PROTO ((void));
 
 #ifdef GGC_POISON
-static void poison PROTO ((void *, size_t));
 static void poison_pages PROTO ((void));
 #endif
 
@@ -346,8 +345,8 @@ lookup_page_table_entry(p)
   return base[L1][L2];
 }
 
-
 /* Set the page table entry for a page.  */
+
 static void
 set_page_table_entry(p, entry)
      void *p;
@@ -384,8 +383,8 @@ found:
   base[L1][L2] = entry;
 }
 
-
 /* Prints the page-entry for object size ORDER, for debugging.  */
+
 void
 debug_print_page_list (order)
      int order;
@@ -402,20 +401,9 @@ debug_print_page_list (order)
   fflush (stdout);
 }
 
-#ifdef GGC_POISON
-/* `Poisons' the region of memory starting at START and extending for
-   LEN bytes.  */
-static inline void
-poison (start, len)
-     void *start;
-     size_t len;
-{
-  memset (start, 0xa5, len);
-}
-#endif
-
 /* Allocate SIZE bytes of anonymous memory, preferably near PREF,
    (if non-null).  */
+
 static inline char *
 alloc_anon (pref, size)
      char *pref ATTRIBUTE_UNUSED;
@@ -456,6 +444,7 @@ alloc_anon (pref, size)
 /* Allocate a new page for allocating objects of size 2^ORDER,
    and return an entry for it.  The entry is not added to the
    appropriate page_table list.  */
+
 static inline struct page_entry *
 alloc_page (order)
      unsigned order;
@@ -496,7 +485,7 @@ alloc_page (order)
     }
   else
     {
-      /* Actually allocate the memory, using mmap.  */
+      /* Actually allocate the memory.  */
       page = alloc_anon (NULL, entry_size);
     }
 
@@ -525,8 +514,8 @@ alloc_page (order)
   return entry;
 }
 
+/* For a page that is no longer needed, put it on the free page list.  */
 
-/* Free a page when it's no longer needed.  */
 static inline void
 free_page (entry)
      page_entry *entry;
@@ -542,8 +531,8 @@ free_page (entry)
   G.free_pages = entry;
 }
 
+/* Release the free page cache to the system.  */
 
-/* Release the page cache to the system.  */
 static inline void
 release_pages ()
 {
@@ -598,9 +587,9 @@ release_pages ()
   G.free_pages = NULL;
 }
 
-
 /* This table provides a fast way to determine ceil(log_2(size)) for
    allocation requests.  The minimum allocation size is four bytes.  */
+
 static unsigned char const size_lookup[257] = 
 { 
   2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 
@@ -624,6 +613,7 @@ static unsigned char const size_lookup[257] =
 
 /* Allocate a chunk of memory of SIZE bytes.  If ZERO is non-zero, the
    memory is zeroed; otherwise, its contents are undefined.  */
+
 void *
 ggc_alloc_obj (size, zero)
      size_t size;
@@ -721,8 +711,9 @@ ggc_alloc_obj (size, zero)
 #ifdef GGC_POISON
   /* `Poison' the entire allocated object before zeroing the requested area,
      so that bytes beyond the end, if any, will not necessarily be zero.  */
-  poison (result, 1 << order);
+  memset (result, 0xaf, 1 << order);
 #endif
+
   if (zero)
     memset (result, 0, size);
 
@@ -738,10 +729,10 @@ ggc_alloc_obj (size, zero)
   return result;
 }
 
-
-/* If P is not marked, marks it and returns 0.  Otherwise returns 1.
+/* If P is not marked, marks it and return false.  Otherwise return true.
    P must have been allocated by the GC allocator; it mustn't point to
    static objects, stack variables, or memory allocated with malloc.  */
+
 int
 ggc_set_mark (p)
      void *p;
@@ -780,6 +771,8 @@ ggc_set_mark (p)
   return 0;
 }
 
+/* Mark P, but check first that it was allocated by the collector.  */
+
 void
 ggc_mark_if_gcable (p)
      void *p;
@@ -788,6 +781,8 @@ ggc_mark_if_gcable (p)
     ggc_set_mark (p);
 }
 
+/* Return the size of the gc-able object P.  */
+
 size_t
 ggc_get_size (p)
      void *p;
@@ -797,6 +792,7 @@ ggc_get_size (p)
 }
 
 /* Initialize the ggc-mmap allocator.  */
+
 void
 init_ggc ()
 {
@@ -841,6 +837,8 @@ init_ggc ()
   ggc_add_string_root (&empty_string, 1);
 }
 
+/* Increment the `GC context'.  Objects allocated in an outer context
+   are never freed, eliminating the need to register their roots.  */
 
 void
 ggc_push_context ()
@@ -852,6 +850,8 @@ ggc_push_context ()
     abort ();
 }
 
+/* Decrement the `GC context'.  All objects allocated since the 
+   previous ggc_push_context are migrated to the outer context.  */
 
 void
 ggc_pop_context ()
@@ -890,6 +890,8 @@ ggc_pop_context ()
     }
 }
 
+/* Unmark all objects.  */
+
 static inline void
 clear_marks ()
 {
@@ -932,6 +934,9 @@ clear_marks ()
     }
 }
 
+/* Free all empty pages.  Partially empty pages need no attention
+   because the `mark' bit doubles as an `unused' bit.  */
+
 static inline void
 sweep_pages ()
 {
@@ -1024,6 +1029,8 @@ sweep_pages ()
 }
 
 #ifdef GGC_POISON
+/* Clobber all free objects.  */
+
 static inline void
 poison_pages ()
 {
@@ -1052,13 +1059,15 @@ poison_pages ()
 	      word = i / HOST_BITS_PER_LONG;
 	      bit = i % HOST_BITS_PER_LONG;
 	      if (((p->in_use_p[word] >> bit) & 1) == 0)
-		poison (p->page + i * size, size);
+		memset (p->page + i * size, 0xa5, size);
 	    }
 	}
     }
 }
 #endif
 
+/* Top level mark-and-sweep routine.  */
+
 void
 ggc_collect ()
 {
@@ -1086,12 +1095,13 @@ ggc_collect ()
 
   clear_marks ();
   ggc_mark_roots ();
-  sweep_pages ();
   
 #ifdef GGC_POISON
   poison_pages ();
 #endif
 
+  sweep_pages ();
+
   G.allocated_last_gc = G.allocated;
   if (G.allocated_last_gc < GGC_MIN_LAST_ALLOCATED)
     G.allocated_last_gc = GGC_MIN_LAST_ALLOCATED;
diff --git a/gcc/ggc-simple.c b/gcc/ggc-simple.c
index 194863e..53d6579 100644
--- a/gcc/ggc-simple.c
+++ b/gcc/ggc-simple.c
@@ -200,6 +200,10 @@ ggc_alloc_obj (size, zero)
 
   if (zero)
     memset (&x->u, 0, size);
+#ifdef GGC_POISON
+  else
+    memset (&x->u, 0xaf, size);
+#endif
 
   tree_insert (x);
   G.allocated += size;
@@ -232,6 +236,8 @@ ggc_set_mark (p)
   return 0;
 }
 
+/* Mark a node, but check first to see that it's really gc-able memory.  */
+
 void
 ggc_mark_if_gcable (p)
      void *p;
@@ -253,6 +259,8 @@ ggc_mark_if_gcable (p)
   G.objects += 1;
 }
 
+/* Return the size of the gc-able object P.  */
+
 size_t
 ggc_get_size (p)
      void *p;
@@ -262,6 +270,8 @@ ggc_get_size (p)
   return x->size;
 }
 
+/* Unmark all objects.  */
+
 static void
 clear_marks (x)
      struct ggc_mem *x;
@@ -273,6 +283,8 @@ clear_marks (x)
     clear_marks (x->sub[1]);
 }
 
+/* Free all objects in the current context that are not marked.  */
+
 static void
 sweep_objs (root)
      struct ggc_mem **root;