===================================================================
RCS file: /home/cvs/OpenXM_contrib2/asir2000/gc/mallocx.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -p -r1.4 -r1.5
--- OpenXM_contrib2/asir2000/gc/mallocx.c	2002/07/24 07:46:19	1.4
+++ OpenXM_contrib2/asir2000/gc/mallocx.c	2002/07/24 08:00:10	1.5
@@ -177,6 +177,7 @@ register int k;
     lw = ROUNDED_UP_WORDS(lb);
     n_blocks = OBJ_SZ_TO_BLOCKS(lw);
     init = GC_obj_kinds[k].ok_init;
+    if (GC_debugging_started) GC_print_all_smashed();
     GC_INVOKE_FINALIZERS();
     DISABLE_SIGNALS();
     LOCK();
@@ -286,6 +287,7 @@ register struct obj_kind * kind = GC_obj_kinds + k;
 register ptr_t op;
 DCL_LOCK_STATE;
 
+    if (GC_debugging_started) GC_print_all_smashed();
     GC_INVOKE_FINALIZERS();
     DISABLE_SIGNALS();
     LOCK();
@@ -323,10 +325,15 @@ extern ptr_t GC_reclaim_generic();
 /* GC_malloc_many or friends to replenish it.  (We do not round up	*/
 /* object sizes, since a call indicates the intention to consume many	*/
 /* objects of exactly this size.)					*/
+/* We return the free-list by assigning it to *result, since it is	*/
+/* not safe to return, e.g. a linked list of pointer-free objects,	*/
+/* since the collector would not retain the entire list if it were 	*/
+/* invoked just as we were returning.					*/
 /* Note that the client should usually clear the link field.		*/
-ptr_t GC_generic_malloc_many(lb, k)
+void GC_generic_malloc_many(lb, k, result)
 register word lb;
 register int k;
+ptr_t *result;
 {
 ptr_t op;
 ptr_t p;
@@ -345,13 +352,21 @@ DCL_LOCK_STATE;
     if (!SMALL_OBJ(lb)) {
         op = GC_generic_malloc(lb, k);
         if(0 != op) obj_link(op) = 0;
-        return(op);
+	*result = op;
+        return;
     }
     lw = ALIGNED_WORDS(lb);
+    if (GC_debugging_started) GC_print_all_smashed();
     GC_INVOKE_FINALIZERS();
     DISABLE_SIGNALS();
     LOCK();
     if (!GC_is_initialized) GC_init_inner();
+    /* Do our share of marking work */
+      if (GC_incremental && !GC_dont_gc) {
+        ENTER_GC();
+	GC_collect_a_little_inner(1);
+        EXIT_GC();
+      }
     /* First see if we can reclaim a page of objects waiting to be */
     /* reclaimed.						   */
     {
@@ -363,6 +378,7 @@ DCL_LOCK_STATE;
     	while ((hbp = *rlh) != 0) {
             hhdr = HDR(hbp);
             *rlh = hhdr -> hb_next;
+	    hhdr -> hb_last_reclaimed = (unsigned short) GC_gc_no;
 #	    ifdef PARALLEL_MARK
 		{
 		  signed_word my_words_allocd_tmp = GC_words_allocd_tmp;
@@ -403,6 +419,7 @@ DCL_LOCK_STATE;
 		GC_mem_found += my_words_allocd;
 #	      endif
 #	      ifdef PARALLEL_MARK
+		*result = op;
 		(void)GC_atomic_add(
 				(volatile GC_word *)(&GC_words_allocd_tmp),
 				(GC_word)(my_words_allocd));
@@ -410,7 +427,8 @@ DCL_LOCK_STATE;
 		-- GC_fl_builder_count;
 		if (GC_fl_builder_count == 0) GC_notify_all_builder();
 		GC_release_mark_lock();
-		return GC_clear_stack(op);
+		(void) GC_clear_stack(0);
+		return;
 #	      else
 	        GC_words_allocd += my_words_allocd;
 	        goto out;
@@ -464,11 +482,13 @@ DCL_LOCK_STATE;
 
 	  op = GC_build_fl(h, lw, ok -> ok_init, 0);
 #	  ifdef PARALLEL_MARK
+	    *result = op;
 	    GC_acquire_mark_lock();
 	    -- GC_fl_builder_count;
 	    if (GC_fl_builder_count == 0) GC_notify_all_builder();
 	    GC_release_mark_lock();
-	    return GC_clear_stack(op);
+	    (void) GC_clear_stack(0);
+	    return;
 #	  else
 	    goto out;
 #	  endif
@@ -481,14 +501,17 @@ DCL_LOCK_STATE;
       if (0 != op) obj_link(op) = 0;
     
   out:
+    *result = op;
     UNLOCK();
     ENABLE_SIGNALS();
-    return(GC_clear_stack(op));
+    (void) GC_clear_stack(0);
 }
 
 GC_PTR GC_malloc_many(size_t lb)
 {
-    return(GC_generic_malloc_many(lb, NORMAL));
+    ptr_t result;
+    GC_generic_malloc_many(lb, NORMAL, &result);
+    return result;
 }
 
 /* Note that the "atomic" version of this would be unsafe, since the	*/