v3: fix config.status instantiation of subdir makefiles.

[pf3gnuchains/gcc-fork.git] / boehm-gc / allchblk.c

diff --git a/boehm-gc/allchblk.c b/boehm-gc/allchblk.c
index 2b03939..1a1efc6 100644 (file)
--- a/boehm-gc/allchblk.c
+++ b/boehm-gc/allchblk.c
@@ -111,7 +111,7 @@ void GC_print_hblkfreelist()
     for (i = 0; i <= N_HBLK_FLS; ++i) {
       h = GC_hblkfreelist[i];
 #     ifdef USE_MUNMAP
-        if (0 != h) GC_printf1("Free list %ld (Total size %ld):\n",
+        if (0 != h) GC_printf1("Free list %ld:\n",
                               (unsigned long)i);
 #     else
         if (0 != h) GC_printf2("Free list %ld (Total size %ld):\n",
@@ -133,10 +133,12 @@ void GC_print_hblkfreelist()
         h = hhdr -> hb_next;
       }
     }
-    if (total_free != GC_large_free_bytes) {
+#   ifndef USE_MUNMAP
+      if (total_free != GC_large_free_bytes) {
        GC_printf1("GC_large_free_bytes = %lu (INCONSISTENT!!)\n",
                   (unsigned long) GC_large_free_bytes);
-    }
+      }
+#   endif
     GC_printf1("Total of %lu bytes on free list\n", (unsigned long)total_free);
 }
 
@@ -181,7 +183,7 @@ void GC_dump_regions()
            hhdr = HDR(p);
            GC_printf1("\t0x%lx ", (unsigned long)p);
            if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
-               GC_printf1("Missing header!!\n", hhdr);
+               GC_printf1("Missing header!!(%ld)\n", hhdr);
                p += HBLKSIZE;
                continue;
            }
@@ -283,8 +285,8 @@ int n;
        GET_HDR(hhdr -> hb_prev, phdr);
        phdr -> hb_next = hhdr -> hb_next;
     }
+    FREE_ASSERT(GC_free_bytes[index] >= hhdr -> hb_sz);
     INCR_FREE_BYTES(index, - (signed_word)(hhdr -> hb_sz));
-    FREE_ASSERT(GC_free_bytes[index] >= 0);
     if (0 != hhdr -> hb_next) {
        hdr * nhdr;
        GC_ASSERT(!IS_FORWARDING_ADDR_OR_NIL(NHDR(hhdr)));
@@ -375,9 +377,8 @@ void GC_unmap_old(void)
        if (!IS_MAPPED(hhdr)) continue;
        threshold = (unsigned short)(GC_gc_no - UNMAP_THRESHOLD);
        last_rec = hhdr -> hb_last_reclaimed;
-       if (last_rec > GC_gc_no
-           || last_rec < threshold && threshold < GC_gc_no
-                                      /* not recently wrapped */) {
+       if ((last_rec > GC_gc_no || last_rec < threshold)
+           && threshold < GC_gc_no /* not recently wrapped */) {
           sz = hhdr -> hb_sz;
          GC_unmap((ptr_t)h, sz);
          hhdr -> hb_flags |= WAS_UNMAPPED;
@@ -422,6 +423,7 @@ void GC_merge_unmapped(void)
              } else {
                GC_remap((ptr_t)h, size);
                hhdr -> hb_flags &= ~WAS_UNMAPPED;
+               hhdr -> hb_last_reclaimed = nexthdr -> hb_last_reclaimed;
              }
            } else {
              /* Unmap any gap in the middle */
@@ -468,7 +470,11 @@ int index;
     if (total_size == bytes) return h;
     rest = (struct hblk *)((word)h + bytes);
     rest_hdr = GC_install_header(rest);
-    if (0 == rest_hdr) return(0);
+    if (0 == rest_hdr) {
+       /* This may be very bad news ... */
+       WARN("Header allocation failed: Dropping block.\n", 0);
+       return(0);
+    }
     rest_hdr -> hb_sz = total_size - bytes;
     rest_hdr -> hb_flags = 0;
 #   ifdef GC_ASSERTIONS
@@ -584,8 +590,9 @@ int n;
            GET_HDR(hbp, hhdr);
            size_avail = hhdr->hb_sz;
            if (size_avail < size_needed) continue;
-           if (!GC_use_entire_heap
-               && size_avail != size_needed
+           if (size_avail != size_needed
+               && !GC_use_entire_heap
+               && !GC_dont_gc
                && USED_HEAP_SIZE >= GC_requested_heapsize
                && !TRUE_INCREMENTAL && GC_should_collect()) {
 #              ifdef USE_MUNMAP
@@ -602,7 +609,8 @@ int n;
                    /* If we are deallocating lots of memory from       */
                    /* finalizers, fail and collect sooner rather       */
                    /* than later.                                      */
-                   if (GC_finalizer_mem_freed > (GC_heapsize >> 4))  {
+                   if (WORDS_TO_BYTES(GC_finalizer_mem_freed)
+                       > (GC_heapsize >> 4))  {
                      continue;
                    }
 #              endif /* !USE_MUNMAP */
@@ -692,7 +700,7 @@ int n;
                      struct hblk * h;
                      struct hblk * prev = hhdr -> hb_prev;
                      
-                     GC_words_wasted += total_size;
+                     GC_words_wasted += BYTES_TO_WORDS(total_size);
                      GC_large_free_bytes -= total_size;
                      GC_remove_from_fl(hhdr, n);
                      for (h = hbp; h < limit; h++) {
@@ -784,6 +792,9 @@ signed_word size;
     size = HBLKSIZE * OBJ_SZ_TO_BLOCKS(size);
     GC_remove_counts(hbp, (word)size);
     hhdr->hb_sz = size;
+#   ifdef USE_MUNMAP
+      hhdr -> hb_last_reclaimed = GC_gc_no;
+#   endif
     
     /* Check for duplicate deallocation in the easy case */
       if (HBLK_IS_FREE(hhdr)) {
@@ -809,11 +820,17 @@ signed_word size;
        if (IS_MAPPED(prevhdr)) {
          GC_remove_from_fl(prevhdr, FL_UNKNOWN);
          prevhdr -> hb_sz += hhdr -> hb_sz;
+#        ifdef USE_MUNMAP
+           prevhdr -> hb_last_reclaimed = GC_gc_no;
+#        endif
          GC_remove_header(hbp);
          hbp = prev;
          hhdr = prevhdr;
        }
       }
+    /* FIXME: It is not clear we really always want to do these merges */
+    /* with -DUSE_MUNMAP, since it updates ages and hence prevents     */
+    /* unmapping.                                                      */
 
     GC_large_free_bytes += size;
     GC_add_to_fl(hbp, hhdr);