[Git][cmucl/cmucl][master] 2 commits: Fix #69: Always compile in GC assertion code

22 Sep 2018


      Raymond Toy pushed to branch master at cmucl / cmucl
Commits:
7b4e019d by Raymond Toy at 2018-09-22T19:50:40Z
Fix #69: Always compile in GC assertion code
- - - - -
9cb80666 by Raymond Toy at 2018-09-22T19:50:40Z
Merge branch &#39;issue-69-compile-in-gc-assert&#39; into &#39;master&#39;
Fix #69: Always compile in GC assertion code
Closes #69
See merge request cmucl/cmucl!41
- - - - -
3 changed files:
- src/code/exports.lisp
- src/code/gc.lisp
- src/lisp/gencgc.c
Changes:
=====================================
src/code/exports.lisp
=====================================
@@ -1566,6 +1566,10 @@
         "*TRUST-DYNAMIC-EXTENT-DECLARATIONS*"
"INVALID-FASL")
+  ;; gencgc features
+  #+gencgc
+  (:export "GET-GC-ASSERTIONS"
+	   "SET-GC-ASSERTIONS")
;; run-program
   (:export "RUN-PROGRAM" "PROCESS-ALIVE-P" "PROCESS-CLOSE"
=====================================
src/code/gc.lisp
=====================================
@@ -22,7 +22,9 @@
      *bytes-consed-between-gcs* *gc-verbose* *gc-inhibit-hook*
      *gc-notify-before* *gc-notify-after* get-bytes-consed
      *gc-run-time* bytes-consed-between-gcs
-	  get-bytes-consed-dfixnum))
+	  get-bytes-consed-dfixnum
+	  get-gc-assertions
+	  set-gc-assertions))
(in-package "LISP")
 (export '(room))
@@ -72,10 +74,63 @@
 (progn
   (alien:def-alien-routine get_bytes_allocated_lower c-call:int)
   (alien:def-alien-routine get_bytes_allocated_upper c-call:int)
-
   (defun dynamic-usage ()
     (dfixnum:dfixnum-pair-integer
-     (get_bytes_allocated_upper) (get_bytes_allocated_lower))))
+     (get_bytes_allocated_upper) (get_bytes_allocated_lower)))
+
+  ;; Controls GC assertions that are enabled in the runtime.  A value
+  ;; of 0 disables all assertions (the normal default).
+  (alien:def-alien-variable ("gc_assert_level" gc-assert-level) c-call:int)
+  (alien:def-alien-variable ("verify_after_free_heap" gc-verify-after-free-heap) c-call:int)
+  (alien:def-alien-variable ("pre_verify_gen_0" gc-verify-new-objects) c-call:int)
+  (alien:def-alien-variable ("verify_gens" gc-verify-generations) c-call:int)
+  (defun get-gc-assertions ()
+    "Returns a list of the current GC assertion settings. The list is
+    in the same format as the keyword arguments to SET-GC-ASSERTIONS,
+    i.e.,
+
+      (apply #'set-gc-assertions (get-gc-assertions))
+
+   See SET-GC-ASSERTIONS for more information."
+    (list :assert-level gc-assert-level
+	  :verify-after-free-heap (not (zerop gc-verify-after-free-heap))
+	  :verify-generations gc-verify-generations
+	  :verify-new-objects (not (zerop gc-verify-new-objects))))
+  (defun set-gc-assertions (&key (assert-level 0 assert-level-p)
+			      (verify-after-free-heap nil verify-after-free-heap-p)
+			      (verify-generations 6 verify-generations-p)
+			      (verify-new-objects nil verify-new-objects-p))
+    "Set GC assertion to the specified value:
+       :ASSERT-LEVEL
+           Defaults to 0, higher values indicate more assertions are enabled.
+
+       :VERIFY-AFTER-FREE-HEAP
+           If non-NIL, the heap is verified for consistency whenever
+           part of the heap is collected.
+
+       :VERIFY-GENERATIONS
+           Set to generation number.  When GC occurs, generations
+           equal to or higher than this value are checked for
+           consistency.
+
+       :VERIFY-NEW-OBJECTS
+           When GC occurs for the newest generation, the heap for this
+           generation is checked for validity.
+"
+    (declare (type (and fixnum unsigned-byte) assert-level)
+	     (type boolean verify-after-free-heap)
+	     (type (integer 0 6) verify-generations)
+	     (type boolean verify-new-objects))
+    (when assert-level-p
+      (setf gc-assert-level assert-level))
+    (when verify-after-free-heap-p
+      (setf gc-verify-after-free-heap (if verify-after-free-heap 1 0)))
+    (when verify-generations-p
+      (setf gc-verify-generations verify-generations))
+    (when verify-new-objects-p
+      (setf gc-verify-new-objects (if verify-new-objects 1 0)))
+    (values))
+  )
#+cgc
 (c-var-frob dynamic-usage "bytes_allocated")
=====================================
src/lisp/gencgc.c
=====================================
@@ -148,14 +148,8 @@
/* Define for activating assertions.  */
-#if defined(x86) && defined(SOLARIS)
-#define GC_ASSERTIONS 1
-#endif
-
 /* Check for references to stack-allocated objects.  */
-#ifdef GC_ASSERTIONS
-
 static void *invalid_stack_start, *invalid_stack_end;
static inline void
@@ -214,17 +208,19 @@ check_escaped_stack_object(lispobj * where, lispobj obj)
 #endif
 }
-#endif /* GC_ASSERTIONS */
+#if defined(x86) && defined(SOLARIS)
+#define DEFAULT_GC_ASSERT_LEVEL 1
+#else
+#define DEFAULT_GC_ASSERT_LEVEL 0
+#endif
+
+int gc_assert_level = DEFAULT_GC_ASSERT_LEVEL;
-#ifdef GC_ASSERTIONS
 #define gc_assert(ex)		\
   do {				\
     if (!(ex)) gc_abort ();     \
   } while (0)
-#else
-#define gc_assert(ex)  (void) (ex)
-#endif
/*
@@ -264,15 +260,15 @@ int verify_gens = NUM_GENERATIONS;
  * makes GC very, very slow, so don't enable this unless you really
  * need it!)
  */
-boolean pre_verify_gen_0 = FALSE;
+int pre_verify_gen_0 = FALSE;
/*
  * Enable checking for bad pointers after gc_free_heap called from purify.
  */
 #if 0 && defined(DARWIN)
-boolean verify_after_free_heap = TRUE;
+int verify_after_free_heap = TRUE;
 #else
-boolean verify_after_free_heap = FALSE;
+int verify_after_free_heap = FALSE;
 #endif
/*
@@ -690,7 +686,6 @@ count_dont_move_pages(void)
  * Work through the pages and add up the number of bytes used for the
  * given generation.
  */
-#ifdef GC_ASSERTIONS
 static int
 generation_bytes_allocated(int generation)
 {
@@ -707,7 +702,6 @@ generation_bytes_allocated(int generation)
     }
     return bytes_allocated;
 }
-#endif
/*
  * Return the average age of the memory in a generation.
@@ -810,10 +804,11 @@ print_generation_stats(int verbose)
        }
    }
-#ifdef GC_ASSERTIONS
-	gc_assert(generations[i].bytes_allocated ==
-		  generation_bytes_allocated(i));
-#endif
+        if (gc_assert_level > 0) {
+            gc_assert(generations[i].bytes_allocated ==
+                      generation_bytes_allocated(i));
+        }
+
    fprintf(stderr, " %5d: %5d %5d %5d %5d %10d %6d %10d %4d %3d %7.4f\n",
    	i, boxed_cnt, unboxed_cnt, large_boxed_cnt, large_unboxed_cnt,
    	generations[i].bytes_allocated,
@@ -1070,9 +1065,11 @@ gc_alloc_new_region(int nbytes, int unboxed, struct alloc_region *alloc_region)
 #endif
/* Check that the region is in a reset state. */
-    gc_assert(alloc_region->first_page == 0
-	      && alloc_region->last_page == -1
-	      && alloc_region->free_pointer == alloc_region->end_addr);
+    if (gc_assert_level > 0) {
+        gc_assert(alloc_region->first_page == 0
+                  && alloc_region->last_page == -1
+                  && alloc_region->free_pointer == alloc_region->end_addr);
+    }
if (unboxed)
    restart_page =
@@ -1120,7 +1117,9 @@ gc_alloc_new_region(int nbytes, int unboxed, struct alloc_region *alloc_region)
 #endif
    }
-	gc_assert(!PAGE_WRITE_PROTECTED(first_page));
+        if (gc_assert_level > 0) {
+            gc_assert(!PAGE_WRITE_PROTECTED(first_page));
+        }
#if 0
    fprintf(stderr, "  first_page=%d bytes_used=%d\n",
@@ -1142,14 +1141,17 @@ gc_alloc_new_region(int nbytes, int unboxed, struct alloc_region *alloc_region)
        last_page++;
        num_pages++;
        bytes_found += GC_PAGE_SIZE;
-	    gc_assert(!PAGE_WRITE_PROTECTED(last_page));
+            if (gc_assert_level > 0) {
+                gc_assert(!PAGE_WRITE_PROTECTED(last_page));
+            }
    }
region_size = (GC_PAGE_SIZE - page_table[first_page].bytes_used)
        + GC_PAGE_SIZE * (last_page - first_page);
-	gc_assert(bytes_found == region_size);
-
+        if (gc_assert_level > 0) {
+            gc_assert(bytes_found == region_size);
+        }
 #if 0
    fprintf(stderr, "  last_page=%d bytes_found=%d num_pages=%d\n",
    	last_page, bytes_found, num_pages);
@@ -1209,11 +1211,13 @@ gc_alloc_new_region(int nbytes, int unboxed, struct alloc_region *alloc_region)
    page_table[first_page].first_object_offset = 0;
     }
-    gc_assert(PAGE_ALLOCATED(first_page));
-    gc_assert(PAGE_UNBOXED_VAL(first_page) == unboxed);
-    gc_assert(PAGE_GENERATION(first_page) == gc_alloc_generation);
-    gc_assert(!PAGE_LARGE_OBJECT(first_page));
-
+    if (gc_assert_level > 0) {
+        gc_assert(PAGE_ALLOCATED(first_page));
+        gc_assert(PAGE_UNBOXED_VAL(first_page) == unboxed);
+        gc_assert(PAGE_GENERATION(first_page) == gc_alloc_generation);
+        gc_assert(!PAGE_LARGE_OBJECT(first_page));
+    }
+    
     for (i = first_page + 1; i <= last_page; i++) {
    PAGE_FLAGS_UPDATE(i, PAGE_ALLOCATED_MASK | PAGE_LARGE_OBJECT_MASK
    		  | PAGE_UNBOXED_MASK | PAGE_GENERATION_MASK,
@@ -1371,8 +1375,10 @@ gc_alloc_update_page_tables(int unboxed, struct alloc_region *alloc_region)
     if (alloc_region->free_pointer != alloc_region->start_addr) {
    orig_first_page_bytes_used = page_table[first_page].bytes_used;
-	gc_assert(alloc_region->start_addr == page_address(first_page) +
-		  page_table[first_page].bytes_used);
+        if (gc_assert_level > 0) {
+            gc_assert(alloc_region->start_addr == page_address(first_page) +
+                      page_table[first_page].bytes_used);
+        }
/* All the pages used need to be updated */
@@ -1383,13 +1389,18 @@ gc_alloc_update_page_tables(int unboxed, struct alloc_region *alloc_region)
 #endif
/* If the page was free then setup the gen, and first_object_offset. */
-	if (page_table[first_page].bytes_used == 0)
-	    gc_assert(page_table[first_page].first_object_offset == 0);
+	if (page_table[first_page].bytes_used == 0) {
+            if (gc_assert_level > 0) {
+                gc_assert(page_table[first_page].first_object_offset == 0);
+            }
+        }
-	gc_assert(PAGE_ALLOCATED(first_page));
-	gc_assert(PAGE_UNBOXED_VAL(first_page) == unboxed);
-	gc_assert(PAGE_GENERATION(first_page) == gc_alloc_generation);
-	gc_assert(!PAGE_LARGE_OBJECT(first_page));
+        if (gc_assert_level > 0) {
+            gc_assert(PAGE_ALLOCATED(first_page));
+            gc_assert(PAGE_UNBOXED_VAL(first_page) == unboxed);
+            gc_assert(PAGE_GENERATION(first_page) == gc_alloc_generation);
+            gc_assert(!PAGE_LARGE_OBJECT(first_page));
+        }
byte_cnt = 0;
@@ -1415,14 +1426,15 @@ gc_alloc_update_page_tables(int unboxed, struct alloc_region *alloc_region)
 #if 0
        fprintf(stderr, "+");
 #endif
-	    gc_assert(PAGE_ALLOCATED(next_page));
-	    gc_assert(PAGE_UNBOXED_VAL(next_page) == unboxed);
-	    gc_assert(page_table[next_page].bytes_used == 0);
-	    gc_assert(PAGE_GENERATION(next_page) == gc_alloc_generation);
-	    gc_assert(!PAGE_LARGE_OBJECT(next_page));
-
-	    gc_assert(page_table[next_page].first_object_offset ==
-		      alloc_region->start_addr - page_address(next_page));
+            if (gc_assert_level > 0) {
+                gc_assert(PAGE_ALLOCATED(next_page));
+                gc_assert(PAGE_UNBOXED_VAL(next_page) == unboxed);
+                gc_assert(page_table[next_page].bytes_used == 0);
+                gc_assert(PAGE_GENERATION(next_page) == gc_alloc_generation);
+                gc_assert(!PAGE_LARGE_OBJECT(next_page));
+                gc_assert(page_table[next_page].first_object_offset ==
+                          alloc_region->start_addr - page_address(next_page));
+            }
/* Calc. the number of bytes used in this page. */
        more = 0;
@@ -1441,7 +1453,9 @@ gc_alloc_update_page_tables(int unboxed, struct alloc_region *alloc_region)
    bytes_allocated += region_size;
    generations[gc_alloc_generation].bytes_allocated += region_size;
-	gc_assert(byte_cnt - orig_first_page_bytes_used == region_size);
+        if (gc_assert_level > 0) {
+            gc_assert(byte_cnt - orig_first_page_bytes_used == region_size);
+        }
/*
     * Set the generations alloc restart page to the last page of
@@ -1471,7 +1485,9 @@ gc_alloc_update_page_tables(int unboxed, struct alloc_region *alloc_region)
/* Unallocate any unused pages. */
     while (next_page <= alloc_region->last_page) {
-	gc_assert(page_table[next_page].bytes_used == 0);
+        if (gc_assert_level > 0) {
+            gc_assert(page_table[next_page].bytes_used == 0);
+        }
    page_table[next_page].flags &= ~PAGE_ALLOCATED_MASK;
    next_page++;
     }
@@ -1591,7 +1607,9 @@ gc_alloc_large(int nbytes, int unboxed, struct alloc_region *alloc_region)
        break;
 #endif
    }
-	gc_assert(!PAGE_WRITE_PROTECTED(first_page));
+        if (gc_assert_level > 0) {
+            gc_assert(!PAGE_WRITE_PROTECTED(first_page));
+        }
#if 0
    fprintf(stderr, "  first_page=%d bytes_used=%d\n",
@@ -1607,13 +1625,17 @@ gc_alloc_large(int nbytes, int unboxed, struct alloc_region *alloc_region)
        last_page++;
        num_pages++;
        bytes_found += GC_PAGE_SIZE;
-	    gc_assert(!PAGE_WRITE_PROTECTED(last_page));
+            if (gc_assert_level > 0) {
+                gc_assert(!PAGE_WRITE_PROTECTED(last_page));
+            }
    }
region_size = (GC_PAGE_SIZE - page_table[first_page].bytes_used)
        + GC_PAGE_SIZE * (last_page - first_page);
-	gc_assert(bytes_found == region_size);
+        if (gc_assert_level > 0) {
+            gc_assert(bytes_found == region_size);
+        }
#if 0
    fprintf(stderr, "  last_page=%d bytes_found=%d num_pages=%d\n",
@@ -1641,7 +1663,9 @@ gc_alloc_large(int nbytes, int unboxed, struct alloc_region *alloc_region)
    	page_address(first_page));
 #endif
-    gc_assert(first_page > alloc_region->last_page);
+        if (gc_assert_level > 0) {
+            gc_assert(first_page > alloc_region->last_page);
+        }
     if (unboxed)
    generations[gc_alloc_generation].alloc_large_unboxed_start_page =
        last_page;
@@ -1669,10 +1693,12 @@ gc_alloc_large(int nbytes, int unboxed, struct alloc_region *alloc_region)
    page_table[first_page].first_object_offset = 0;
     }
-    gc_assert(PAGE_ALLOCATED(first_page));
-    gc_assert(PAGE_UNBOXED_VAL(first_page) == unboxed);
-    gc_assert(PAGE_GENERATION(first_page) == gc_alloc_generation);
-    gc_assert(PAGE_LARGE_OBJECT_VAL(first_page) == large);
+    if (gc_assert_level > 0) {
+        gc_assert(PAGE_ALLOCATED(first_page));
+        gc_assert(PAGE_UNBOXED_VAL(first_page) == unboxed);
+        gc_assert(PAGE_GENERATION(first_page) == gc_alloc_generation);
+        gc_assert(PAGE_LARGE_OBJECT_VAL(first_page) == large);
+    }
byte_cnt = 0;
@@ -1701,8 +1727,10 @@ gc_alloc_large(int nbytes, int unboxed, struct alloc_region *alloc_region)
    fprintf(stderr, "+");
 #endif
-	gc_assert(!PAGE_ALLOCATED(next_page));
-	gc_assert(page_table[next_page].bytes_used == 0);
+        if (gc_assert_level > 0) {
+            gc_assert(!PAGE_ALLOCATED(next_page));
+            gc_assert(page_table[next_page].bytes_used == 0);
+        }
if ((gencgc_unmap_zero == MODE_MADVISE)
             || (gencgc_unmap_zero == MODE_LAZY)) {
@@ -1727,7 +1755,9 @@ gc_alloc_large(int nbytes, int unboxed, struct alloc_region *alloc_region)
    next_page++;
     }
-    gc_assert(byte_cnt - orig_first_page_bytes_used == nbytes);
+    if (gc_assert_level > 0) {
+        gc_assert(byte_cnt - orig_first_page_bytes_used == nbytes);
+    }
bytes_allocated += nbytes;
     generations[gc_alloc_generation].bytes_allocated += nbytes;
@@ -1934,7 +1964,9 @@ gc_alloc_region(int nbytes, struct alloc_region *region, int unboxed, struct all
     }
/* Shouldn't happen? */
-    gc_assert(0);
+    if (gc_assert_level > 0) {
+        gc_assert(0);
+    }
     return 0;
 }
@@ -2244,9 +2276,11 @@ copy_object(lispobj object, int nwords)
     lispobj *new;
     lispobj *source, *dest;
-    gc_assert(Pointerp(object));
-    gc_assert(from_space_p(object));
-    gc_assert((nwords & 0x01) == 0);
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+        gc_assert(from_space_p(object));
+        gc_assert((nwords & 0x01) == 0);
+    }
/* get tag of object */
     tag = LowtagOf(object);
@@ -2286,9 +2320,11 @@ copy_large_object(lispobj object, int nwords)
     lispobj *source, *dest;
     int first_page;
-    gc_assert(Pointerp(object));
-    gc_assert(from_space_p(object));
-    gc_assert((nwords & 0x01) == 0);
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+        gc_assert(from_space_p(object));
+        gc_assert((nwords & 0x01) == 0);
+    }
if (gencgc_verbose && nwords > 1024 * 1024)
    fprintf(stderr, "** copy_large_object: %lu\n",
@@ -2296,7 +2332,9 @@ copy_large_object(lispobj object, int nwords)
/* Check if it's a large object. */
     first_page = find_page_index((void *) object);
-    gc_assert(first_page >= 0);
+    if (gc_assert_level > 0) {
+        gc_assert(first_page >= 0);
+    }
if (PAGE_LARGE_OBJECT(first_page)) {
    /* Promote the object. */
@@ -2314,18 +2352,22 @@ copy_large_object(lispobj object, int nwords)
     * anyway?).
     */
-	gc_assert(page_table[first_page].first_object_offset == 0);
+        if (gc_assert_level > 0) {
+            gc_assert(page_table[first_page].first_object_offset == 0);
+        }
next_page = first_page;
    remaining_bytes = nwords * sizeof(lispobj);
    while (remaining_bytes > GC_PAGE_SIZE) {
-	    gc_assert(PAGE_GENERATION(next_page) == from_space);
-	    gc_assert(PAGE_ALLOCATED(next_page));
-	    gc_assert(!PAGE_UNBOXED(next_page));
-	    gc_assert(PAGE_LARGE_OBJECT(next_page));
-	    gc_assert(page_table[next_page].first_object_offset ==
-		      GC_PAGE_SIZE * (first_page - next_page));
-	    gc_assert(page_table[next_page].bytes_used == GC_PAGE_SIZE);
+            if (gc_assert_level > 0) {
+                gc_assert(PAGE_GENERATION(next_page) == from_space);
+                gc_assert(PAGE_ALLOCATED(next_page));
+                gc_assert(!PAGE_UNBOXED(next_page));
+                gc_assert(PAGE_LARGE_OBJECT(next_page));
+                gc_assert(page_table[next_page].first_object_offset ==
+                          GC_PAGE_SIZE * (first_page - next_page));
+                gc_assert(page_table[next_page].bytes_used == GC_PAGE_SIZE);
+            }
PAGE_FLAGS_UPDATE(next_page, PAGE_GENERATION_MASK, new_space);
@@ -2348,11 +2390,15 @@ copy_large_object(lispobj object, int nwords)
     */
/* Object may have shrunk but shouldn't have grown - check. */
-	gc_assert(page_table[next_page].bytes_used >= remaining_bytes);
+        if (gc_assert_level > 0) {
+            gc_assert(page_table[next_page].bytes_used >= remaining_bytes);
+        }
PAGE_FLAGS_UPDATE(next_page, PAGE_GENERATION_MASK, new_space);
-	gc_assert(PAGE_ALLOCATED(next_page));
-	gc_assert(!PAGE_UNBOXED(next_page));
+        if (gc_assert_level > 0) {
+            gc_assert(PAGE_ALLOCATED(next_page));
+            gc_assert(!PAGE_UNBOXED(next_page));
+        }
/* Adjust the bytes_used. */
    old_bytes_used = page_table[next_page].bytes_used;
@@ -2376,7 +2422,9 @@ copy_large_object(lispobj object, int nwords)
         * object. These pages shouldn't be write protected as they
         * should be zero filled.
         */
-	    gc_assert(!PAGE_WRITE_PROTECTED(next_page));
+            if (gc_assert_level > 0) {
+                gc_assert(!PAGE_WRITE_PROTECTED(next_page));
+            }
old_bytes_used = page_table[next_page].bytes_used;
        page_table[next_page].flags &= ~PAGE_ALLOCATED_MASK;
@@ -2429,9 +2477,11 @@ copy_unboxed_object(lispobj object, int nwords)
     lispobj *new;
     lispobj *source, *dest;
-    gc_assert(Pointerp(object));
-    gc_assert(from_space_p(object));
-    gc_assert((nwords & 0x01) == 0);
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+        gc_assert(from_space_p(object));
+        gc_assert((nwords & 0x01) == 0);
+    }
/* get tag of object */
     tag = LowtagOf(object);
@@ -2472,9 +2522,11 @@ copy_large_unboxed_object(lispobj object, int nwords)
     lispobj *source, *dest;
     int first_page;
-    gc_assert(Pointerp(object));
-    gc_assert(from_space_p(object));
-    gc_assert((nwords & 0x01) == 0);
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+        gc_assert(from_space_p(object));
+        gc_assert((nwords & 0x01) == 0);
+    }
if (gencgc_verbose && nwords > 1024 * 1024)
    fprintf(stderr, "** copy_large_unboxed_object: %lu\n",
@@ -2482,7 +2534,9 @@ copy_large_unboxed_object(lispobj object, int nwords)
/* Check if it's a large object. */
     first_page = find_page_index((void *) object);
-    gc_assert(first_page >= 0);
+    if (gc_assert_level > 0) {
+        gc_assert(first_page >= 0);
+    }
if (PAGE_LARGE_OBJECT(first_page)) {
    /*
@@ -2496,17 +2550,21 @@ copy_large_unboxed_object(lispobj object, int nwords)
    int old_bytes_used;
    int mmask, mflags;
-	gc_assert(page_table[first_page].first_object_offset == 0);
+        if (gc_assert_level > 0) {
+            gc_assert(page_table[first_page].first_object_offset == 0);
+        }
next_page = first_page;
    remaining_bytes = nwords * sizeof(lispobj);
    while (remaining_bytes > GC_PAGE_SIZE) {
-	    gc_assert(PAGE_GENERATION(next_page) == from_space);
-	    gc_assert(PAGE_ALLOCATED(next_page));
-	    gc_assert(PAGE_LARGE_OBJECT(next_page));
-	    gc_assert(page_table[next_page].first_object_offset ==
-		      GC_PAGE_SIZE * (first_page - next_page));
-	    gc_assert(page_table[next_page].bytes_used == GC_PAGE_SIZE);
+            if (gc_assert_level > 0) {
+                gc_assert(PAGE_GENERATION(next_page) == from_space);
+                gc_assert(PAGE_ALLOCATED(next_page));
+                gc_assert(PAGE_LARGE_OBJECT(next_page));
+                gc_assert(page_table[next_page].first_object_offset ==
+                          GC_PAGE_SIZE * (first_page - next_page));
+                gc_assert(page_table[next_page].bytes_used == GC_PAGE_SIZE);
+            }
PAGE_FLAGS_UPDATE(next_page,
    		      PAGE_UNBOXED_MASK | PAGE_GENERATION_MASK,
@@ -2521,7 +2579,9 @@ copy_large_unboxed_object(lispobj object, int nwords)
     */
/* Object may have shrunk but shouldn't have grown - check. */
-	gc_assert(page_table[next_page].bytes_used >= remaining_bytes);
+        if (gc_assert_level > 0) {
+            gc_assert(page_table[next_page].bytes_used >= remaining_bytes);
+        }
PAGE_FLAGS_UPDATE(next_page, PAGE_ALLOCATED_MASK | PAGE_UNBOXED_MASK
    		  | PAGE_GENERATION_MASK,
@@ -2549,7 +2609,9 @@ copy_large_unboxed_object(lispobj object, int nwords)
         * object. These pages shouldn't be write protected, even if
         * boxed they should be zero filled.
         */
-	    gc_assert(!PAGE_WRITE_PROTECTED(next_page));
+            if (gc_assert_level > 0) {
+                gc_assert(!PAGE_WRITE_PROTECTED(next_page));
+            }
old_bytes_used = page_table[next_page].bytes_used;
        page_table[next_page].flags &= ~PAGE_ALLOCATED_MASK;
@@ -2667,15 +2729,17 @@ scavenge(void *start_obj, long nwords)
object = *start;
    /* Not a forwarding pointer. */
-	gc_assert(object != 0x01);
+        if (gc_assert_level > 0) {
+            gc_assert(object != 0x01);
+        }
#if DIRECT_SCAV
    words_scavenged = scavtab[TypeOf(object)] (start, object);
 #else /* not DIRECT_SCAV */
    if (Pointerp(object)) {
-#ifdef GC_ASSERTIONS
-	    check_escaped_stack_object(start, object);
-#endif
+            if (gc_assert_level > 0) {
+                check_escaped_stack_object(start, object);
+            }
if (from_space_p(object)) {
    	lispobj *ptr = (lispobj *) PTR(object);
@@ -2739,7 +2803,9 @@ scavenge(void *start_obj, long nwords)
    nwords -= words_scavenged;
     }
-    gc_assert(nwords == 0);
+    if (gc_assert_level > 0) {
+        gc_assert(nwords == 0);
+    }
 }
@@ -2943,7 +3009,9 @@ static lispobj trans_boxed(lispobj object);
 static int
 scav_function_pointer(lispobj * where, lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
if (from_space_p(object)) {
    lispobj first, *first_pointer;
@@ -2989,8 +3057,10 @@ scav_function_pointer(lispobj * where, lispobj object)
        first = copy;
    }
-	gc_assert(Pointerp(first));
-	gc_assert(!from_space_p(first));
+        if (gc_assert_level > 0) {
+            gc_assert(Pointerp(first));
+            gc_assert(!from_space_p(first));
+        }
*where = first;
     }
@@ -3003,7 +3073,9 @@ scav_function_pointer(lispobj * where, lispobj object)
     lispobj *first_pointer;
     lispobj copy;
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
/* Object is a pointer into from space - no a FP. */
     first_pointer = (lispobj *) PTR(object);
@@ -3029,8 +3101,10 @@ scav_function_pointer(lispobj * where, lispobj object)
    first_pointer[1] = copy;
     }
-    gc_assert(Pointerp(copy));
-    gc_assert(!from_space_p(copy));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(copy));
+        gc_assert(!from_space_p(copy));
+    }
*where = copy;
@@ -3407,7 +3481,9 @@ trans_code(struct code *code)
     }
-    gc_assert(TypeOf(code->header) == type_CodeHeader);
+    if (gc_assert_level > 0) {
+        gc_assert(TypeOf(code->header) == type_CodeHeader);
+    }
/* prepare to transport the code vector */
     l_code = (lispobj) code | type_OtherPointer;
@@ -3449,7 +3525,9 @@ trans_code(struct code *code)
    lispobj nfheaderl;
fheaderp = (struct function *) PTR(fheaderl);
-	gc_assert(TypeOf(fheaderp->header) == type_FunctionHeader);
+        if (gc_assert_level > 0) {
+            gc_assert(TypeOf(fheaderp->header) == type_FunctionHeader);
+        }
/*
     * Calcuate the new function pointer and the new function header.
@@ -3510,7 +3588,9 @@ scav_code_header(lispobj * where, lispobj object)
     fheaderl = code->entry_points;
     while (fheaderl != NIL) {
    fheaderp = (struct function *) PTR(fheaderl);
-	gc_assert(TypeOf(fheaderp->header) == type_FunctionHeader);
+        if (gc_assert_level > 0) {
+            gc_assert(TypeOf(fheaderp->header) == type_FunctionHeader);
+        }
scavenge(&fheaderp->name, 1);
    scavenge(&fheaderp->arglist, 1);
@@ -3693,7 +3773,9 @@ scav_instance_pointer(lispobj * where, lispobj object)
        first = first_pointer[1];
    else {
        first = trans_boxed(object);
-	    gc_assert(first != object);
+            if (gc_assert_level > 0) {
+                gc_assert(first != object);
+            }
        /* Set forwarding pointer */
        first_pointer[0] = 0x01;
        first_pointer[1] = first;
@@ -3711,7 +3793,9 @@ scav_instance_pointer(lispobj * where, lispobj object)
     /* Object is a pointer into from space - not a FP */
     copy = trans_boxed(object);
-    gc_assert(copy != object);
+    if (gc_assert_level > 0) {
+        gc_assert(copy != object);
+    }
first_pointer = (lispobj *) PTR(object);
@@ -3733,7 +3817,9 @@ static lispobj trans_list(lispobj object);
 static int
 scav_list_pointer(lispobj * where, lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
if (from_space_p(object)) {
    lispobj first, *first_pointer;
@@ -3756,8 +3842,11 @@ scav_list_pointer(lispobj * where, lispobj object)
        first_pointer[1] = first;
    }
-	gc_assert(Pointerp(first));
-	gc_assert(!from_space_p(first));
+        if (gc_assert_level > 0) {
+            gc_assert(Pointerp(first));
+            gc_assert(!from_space_p(first));
+        }
+
    *where = first;
     }
     return 1;
@@ -3768,12 +3857,16 @@ scav_list_pointer(lispobj * where, lispobj object)
 {
     lispobj first, *first_pointer;
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
/* Object is a pointer into from space - not FP */
first = trans_list(object);
-    gc_assert(first != object);
+    if (gc_assert_level > 0) {
+        gc_assert(first != object);
+    }
first_pointer = (lispobj *) PTR(object);
@@ -3781,8 +3874,11 @@ scav_list_pointer(lispobj * where, lispobj object)
     first_pointer[0] = 0x01;
     first_pointer[1] = first;
-    gc_assert(Pointerp(first));
-    gc_assert(!from_space_p(first));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(first));
+        gc_assert(!from_space_p(first));
+    }
+
     *where = first;
     return 1;
 }
@@ -3795,7 +3891,9 @@ trans_list(lispobj object)
     struct cons *cons, *new_cons;
     lispobj cdr;
-    gc_assert(from_space_p(object));
+    if (gc_assert_level > 0) {
+        gc_assert(from_space_p(object));
+    }
cons = (struct cons *) PTR(object);
@@ -3857,7 +3955,9 @@ trans_list(lispobj object)
 static int
 scav_other_pointer(lispobj * where, lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
if (from_space_p(object)) {
    lispobj first, *first_pointer;
@@ -3884,8 +3984,10 @@ scav_other_pointer(lispobj * where, lispobj object)
        }
    }
-	gc_assert(Pointerp(first));
-	gc_assert(!from_space_p(first));
+        if (gc_assert_level > 0) {
+            gc_assert(Pointerp(first));
+            gc_assert(!from_space_p(first));
+        }
     }
     return 1;
 }
@@ -3895,7 +3997,9 @@ scav_other_pointer(lispobj * where, lispobj object)
 {
     lispobj first, *first_pointer;
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
/* Object is a pointer into from space - not FP */
     first_pointer = (lispobj *) PTR(object);
@@ -3909,8 +4013,10 @@ scav_other_pointer(lispobj * where, lispobj object)
    *where = first;
     }
-    gc_assert(Pointerp(first));
-    gc_assert(!from_space_p(first));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(first));
+        gc_assert(!from_space_p(first));
+    }
return 1;
 }
@@ -3958,7 +4064,9 @@ trans_boxed(lispobj object)
     lispobj header;
     unsigned long length;
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
header = *((lispobj *) PTR(object));
     length = HeaderValue(header) + 1;
@@ -3973,7 +4081,9 @@ trans_boxed_large(lispobj object)
     lispobj header;
     unsigned long length;
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
header = *((lispobj *) PTR(object));
     length = HeaderValue(header) + 1;
@@ -4035,7 +4145,9 @@ trans_unboxed(lispobj object)
     unsigned long length;
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
header = *((lispobj *) PTR(object));
     length = HeaderValue(header) + 1;
@@ -4051,7 +4163,9 @@ trans_unboxed_large(lispobj object)
     unsigned long length;
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
header = *((lispobj *) PTR(object));
     length = HeaderValue(header) + 1;
@@ -4116,7 +4230,9 @@ scav_string(lispobj * where, lispobj object)
 static lispobj
 trans_string(lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
     return copy_large_unboxed_object(object,
    			     size_string((lispobj *) PTR(object)));
 }
@@ -4212,7 +4328,9 @@ free_hash_entry(struct hash_table *hash_table, int hash_index, int kv_index)
     unsigned *next_vector = u32_vector(hash_table->next_vector, 0);
     int free_p = 1;
-    gc_assert(length != UINT_MAX);
+    if (gc_assert_level > 0) {
+        gc_assert(length != UINT_MAX);
+    }
if (index_vector[hash_index] == kv_index)
    /* The entry is the first in the collinion chain.
@@ -4239,7 +4357,10 @@ free_hash_entry(struct hash_table *hash_table, int hash_index, int kv_index)
         unsigned hash_index;
         lispobj empty_symbol;
-	gc_assert(count > 0);
+        if (gc_assert_level > 0) {
+            gc_assert(count > 0);
+        }
+
    hash_table->number_entries = make_fixnum(count - 1);
    next_vector[kv_index] = fixnum_value(hash_table->next_free_kv);
    hash_table->next_free_kv = make_fixnum(kv_index);
@@ -4420,11 +4541,13 @@ scav_hash_entries(struct hash_table *hash_table, lispobj weak, int removep)
     next_vector = u32_vector(hash_table->next_vector, &next_vector_length);
     hash_vector = u32_vector(hash_table->hash_vector, 0);
-    gc_assert(length != UINT_MAX);
-    gc_assert(next_vector_length != UINT_MAX);
+    if (gc_assert_level > 0) {
+        gc_assert(length != UINT_MAX);
+        gc_assert(next_vector_length != UINT_MAX);
-    gc_assert(index_vector && next_vector);
-    gc_assert(next_vector_length * 2 == kv_length);
+        gc_assert(index_vector && next_vector);
+        gc_assert(next_vector_length * 2 == kv_length);
+    }
for (i = 1; i < next_vector_length; i++) {
    lispobj old_key = kv_vector[2 * i];
@@ -4499,8 +4622,10 @@ scav_weak_entries(struct hash_table *hash_table)
     u32_vector(hash_table->next_vector, &next_vector_length);
     hash_vector = u32_vector(hash_table->hash_vector, 0);
-    gc_assert(length != UINT_MAX);
-    gc_assert(next_vector_length != UINT_MAX);
+    if (gc_assert_level > 0) {
+        gc_assert(length != UINT_MAX);
+        gc_assert(next_vector_length != UINT_MAX);
+    }
for (i = 1; i < next_vector_length; i++) {
    lispobj old_key = kv_vector[2 * i];
@@ -4637,8 +4762,10 @@ scav_hash_vector(lispobj * where, lispobj object)
scavenge(kv_vector, 2);
-    gc_assert(Pointerp(kv_vector[0]));
-    gc_assert(Pointerp(kv_vector[1]));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(kv_vector[0]));
+        gc_assert(Pointerp(kv_vector[1]));
+    }
hash_table_obj = kv_vector[0];
     hash_table = (struct hash_table *) PTR(hash_table_obj);
@@ -4666,10 +4793,14 @@ scav_hash_vector(lispobj * where, lispobj object)
 #endif
#if !(defined(sparc) || (defined(DARWIN) && defined(__ppc__)))
-    gc_assert(where == (lispobj *) PTR(hash_table->table));
+    if (gc_assert_level > 0) {
+        gc_assert(where == (lispobj *) PTR(hash_table->table));
+    }
 #endif
-    gc_assert(TypeOf(hash_table->instance_header) == type_InstanceHeader);
-    gc_assert(TypeOf(*(lispobj *) PTR(empty_symbol)) == type_SymbolHeader);
+    if (gc_assert_level > 0) {
+        gc_assert(TypeOf(hash_table->instance_header) == type_InstanceHeader);
+        gc_assert(TypeOf(*(lispobj *) PTR(empty_symbol)) == type_SymbolHeader);
+    }
/* Scavenging the hash table which fix the positions of the other
        needed objects.  */
@@ -4679,18 +4810,16 @@ scav_hash_vector(lispobj * where, lispobj object)
     }
 #endif
-#ifdef GC_ASSERTIONS
-    {
+    if (gc_assert_level > 0) {
         /*
          * Check to see that hash-table-rehash-threshold is a single
          * float in the range (0, 1]
          */
         lispobj threshold_obj = (lispobj) hash_table->rehash_threshold;
-        float* raw_slots = PTR(threshold_obj);
-        float threshold = raw_slots[2];
+        struct single_float* float_slot = (struct single_float*) PTR(threshold_obj);
+        float threshold = float_slot->value;
         gc_assert(threshold > 0 && threshold <= 1);
     }
-#endif
scavenge((lispobj *) hash_table, HASH_TABLE_SIZE);
@@ -4725,7 +4854,9 @@ size_vector(lispobj * where)
 static lispobj
 trans_vector(lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
     return copy_large_object(object, size_vector((lispobj *) PTR(object)));
 }
@@ -4755,7 +4886,9 @@ scav_vector_bit(lispobj * where, lispobj object)
 static lispobj
 trans_vector_bit(lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
     return copy_large_unboxed_object(object,
    			     size_vector_bit((lispobj *) PTR(object)));
 }
@@ -4786,7 +4919,9 @@ scav_vector_unsigned_byte_2(lispobj * where, lispobj object)
 static lispobj
 trans_vector_unsigned_byte_2(lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
     return copy_large_unboxed_object(object,
    			     size_vector_unsigned_byte_2((lispobj *)
    							 PTR(object)));
@@ -4818,7 +4953,9 @@ scav_vector_unsigned_byte_4(lispobj * where, lispobj object)
 static lispobj
 trans_vector_unsigned_byte_4(lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
     return copy_large_unboxed_object(object,
    			     size_vector_unsigned_byte_4((lispobj *)
    							 PTR(object)));
@@ -4850,7 +4987,9 @@ scav_vector_unsigned_byte_8(lispobj * where, lispobj object)
 static lispobj
 trans_vector_unsigned_byte_8(lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
     return copy_large_unboxed_object(object,
    			     size_vector_unsigned_byte_8((lispobj *)
    							 PTR(object)));
@@ -4882,7 +5021,9 @@ scav_vector_unsigned_byte_16(lispobj * where, lispobj object)
 static lispobj
 trans_vector_unsigned_byte_16(lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
     return copy_large_unboxed_object(object,
    			     size_vector_unsigned_byte_16((lispobj *)
    							  PTR(object)));
@@ -4914,7 +5055,9 @@ scav_vector_unsigned_byte_32(lispobj * where, lispobj object)
 static lispobj
 trans_vector_unsigned_byte_32(lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
     return copy_large_unboxed_object(object,
    			     size_vector_unsigned_byte_32((lispobj *)
    							  PTR(object)));
@@ -4946,7 +5089,9 @@ scav_vector_single_float(lispobj * where, lispobj object)
 static lispobj
 trans_vector_single_float(lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
     return copy_large_unboxed_object(object,
    			     size_vector_single_float((lispobj *)
    						      PTR(object)));
@@ -4978,7 +5123,9 @@ scav_vector_double_float(lispobj * where, lispobj object)
 static lispobj
 trans_vector_double_float(lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
     return copy_large_unboxed_object(object,
    			     size_vector_double_float((lispobj *)
    						      PTR(object)));
@@ -5011,7 +5158,9 @@ scav_vector_long_float(lispobj * where, lispobj object)
 static lispobj
 trans_vector_long_float(lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
     return copy_large_unboxed_object(object,
    			     size_vector_long_float((lispobj *)
    						    PTR(object)));
@@ -5041,7 +5190,9 @@ scav_vector_double_double_float(lispobj * where, lispobj object)
 static lispobj
 trans_vector_double_double_float(lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
     return copy_large_unboxed_object(object,
    			     size_vector_double_double_float((lispobj *)
    						    PTR(object)));
@@ -5074,7 +5225,9 @@ scav_vector_complex_single_float(lispobj * where, lispobj object)
 static lispobj
 trans_vector_complex_single_float(lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
     return copy_large_unboxed_object(object,
    			     size_vector_complex_single_float(
    							      (lispobj
@@ -5110,7 +5263,9 @@ scav_vector_complex_double_float(lispobj * where, lispobj object)
 static lispobj
 trans_vector_complex_double_float(lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
     return copy_large_unboxed_object(object,
    			     size_vector_complex_double_float(
    							      (lispobj
@@ -5147,7 +5302,9 @@ scav_vector_complex_long_float(lispobj * where, lispobj object)
 static lispobj
 trans_vector_complex_long_float(lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
     return copy_large_unboxed_object(object,
    			     size_vector_complex_long_float((lispobj *)
    							    PTR
@@ -5178,7 +5335,9 @@ scav_vector_complex_double_double_float(lispobj * where, lispobj object)
 static lispobj
 trans_vector_complex_double_double_float(lispobj object)
 {
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
     return copy_large_unboxed_object(object,
    			     size_vector_complex_double_double_float((lispobj *)
    								     PTR
@@ -5219,7 +5378,9 @@ trans_weak_pointer(lispobj object)
 {
     lispobj copy;
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
     copy = copy_object(object, WEAK_POINTER_NWORDS);
 #if 0
     fprintf(stderr, "Transport weak pointer %p to %p\n", object, copy);
@@ -5303,7 +5464,9 @@ trans_scavenger_hook(lispobj object)
 {
     lispobj copy;
-    gc_assert(Pointerp(object));
+    if (gc_assert_level > 0) {
+        gc_assert(Pointerp(object));
+    }
 #if 0
     printf("Transporting scav pointer from 0x%08x\n", object);
 #endif
@@ -6034,7 +6197,9 @@ maybe_adjust_large_object(lispobj * where)
     nwords = (sizetab[TypeOf(where[0])]) (where);
first_page = find_page_index((void *) where);
-    gc_assert(first_page >= 0);
+    if (gc_assert_level > 0) {
+        gc_assert(first_page >= 0);
+    }
/*
      * Note: Any page write protection must be removed, else a later
@@ -6043,17 +6208,21 @@ maybe_adjust_large_object(lispobj * where)
      * lets do it for them all (they'll probably be written anyway?).
      */
-    gc_assert(page_table[first_page].first_object_offset == 0);
+    if (gc_assert_level > 0) {
+        gc_assert(page_table[first_page].first_object_offset == 0);
+    }
next_page = first_page;
     remaining_bytes = nwords * sizeof(lispobj);
     while (remaining_bytes > GC_PAGE_SIZE) {
-	gc_assert(PAGE_GENERATION(next_page) == from_space);
-	gc_assert(PAGE_ALLOCATED(next_page));
-	gc_assert(PAGE_LARGE_OBJECT(next_page));
-	gc_assert(page_table[next_page].first_object_offset ==
-		  GC_PAGE_SIZE * (first_page - next_page));
-	gc_assert(page_table[next_page].bytes_used == GC_PAGE_SIZE);
+	if (gc_assert_level > 0) {
+	    gc_assert(PAGE_GENERATION(next_page) == from_space);
+	    gc_assert(PAGE_ALLOCATED(next_page));
+	    gc_assert(PAGE_LARGE_OBJECT(next_page));
+	    gc_assert(page_table[next_page].first_object_offset ==
+		      GC_PAGE_SIZE * (first_page - next_page));
+	    gc_assert(page_table[next_page].bytes_used == GC_PAGE_SIZE);
+	}
PAGE_FLAGS_UPDATE(next_page, PAGE_UNBOXED_MASK,
    		  unboxed << PAGE_UNBOXED_SHIFT);
@@ -6062,7 +6231,9 @@ maybe_adjust_large_object(lispobj * where)
     * Shouldn't be write protected at this stage. Essential that the
     * pages aren't.
     */
-	gc_assert(!PAGE_WRITE_PROTECTED(next_page));
+	if (gc_assert_level > 0) {
+	    gc_assert(!PAGE_WRITE_PROTECTED(next_page));
+	}
    remaining_bytes -= GC_PAGE_SIZE;
    next_page++;
     }
@@ -6073,12 +6244,16 @@ maybe_adjust_large_object(lispobj * where)
      */
/* Object may have shrunk but shouldn't have grown - check. */
-    gc_assert(page_table[next_page].bytes_used >= remaining_bytes);
+    if (gc_assert_level > 0) {
+	gc_assert(page_table[next_page].bytes_used >= remaining_bytes);
+    }
page_table[next_page].flags |= PAGE_ALLOCATED_MASK;
     PAGE_FLAGS_UPDATE(next_page, PAGE_UNBOXED_MASK,
    	      unboxed << PAGE_UNBOXED_SHIFT);
-    gc_assert(PAGE_UNBOXED(next_page) == PAGE_UNBOXED(first_page));
+    if (gc_assert_level > 0) {
+	gc_assert(PAGE_UNBOXED(next_page) == PAGE_UNBOXED(first_page));
+    }
/* Adjust the bytes_used. */
     old_bytes_used = page_table[next_page].bytes_used;
@@ -6103,7 +6278,9 @@ maybe_adjust_large_object(lispobj * where)
     * object. These pages shouldn't be write protected as they should
     * be zero filled.
     */
-	gc_assert(!PAGE_WRITE_PROTECTED(next_page));
+	if (gc_assert_level > 0) {
+	    gc_assert(!PAGE_WRITE_PROTECTED(next_page));
+	}
old_bytes_used = page_table[next_page].bytes_used;
    page_table[next_page].flags &= ~PAGE_ALLOCATED_MASK;
@@ -6177,10 +6354,12 @@ preserve_pointer(void *addr)
     while (page_table[first_page].first_object_offset != 0) {
    first_page--;
    /* Do some checks */
-	gc_assert(page_table[first_page].bytes_used == GC_PAGE_SIZE);
-	gc_assert(PAGE_GENERATION(first_page) == from_space);
-	gc_assert(PAGE_ALLOCATED(first_page));
-	gc_assert(PAGE_UNBOXED(first_page) == region_unboxed);
+	if (gc_assert_level > 0) {
+	    gc_assert(page_table[first_page].bytes_used == GC_PAGE_SIZE);
+	    gc_assert(PAGE_GENERATION(first_page) == from_space);
+	    gc_assert(PAGE_ALLOCATED(first_page));
+	    gc_assert(PAGE_UNBOXED(first_page) == region_unboxed);
+	}
     }
/*
@@ -6212,8 +6391,10 @@ preserve_pointer(void *addr)
      * marking all pages as dont_move.
      */
     for (i = first_page;; i++) {
-	gc_assert(PAGE_ALLOCATED(i));
-	gc_assert(PAGE_UNBOXED(i) == region_unboxed);
+	if (gc_assert_level > 0) {
+	    gc_assert(PAGE_ALLOCATED(i));
+	    gc_assert(PAGE_UNBOXED(i) == region_unboxed);
+	}
/* Mark the page static */
    page_table[i].flags |= PAGE_DONT_MOVE_MASK;
@@ -6236,7 +6417,9 @@ preserve_pointer(void *addr)
     * have pointers into the old-space which need
     * scavenging. Shouldn't be write protected at this stage.
     */
-	gc_assert(!PAGE_WRITE_PROTECTED(i));
+	if (gc_assert_level > 0) {
+	    gc_assert(!PAGE_WRITE_PROTECTED(i));
+	}
/* Check if this is the last page in this contiguous block */
    if (page_table[i].bytes_used < GC_PAGE_SIZE
@@ -6249,7 +6432,9 @@ preserve_pointer(void *addr)
     }
/* Check that the page is now static */
-    gc_assert(PAGE_DONT_MOVE(addr_page_index));
+    if (gc_assert_level > 0) {
+	gc_assert(PAGE_DONT_MOVE(addr_page_index));
+    }
return;
 }
@@ -6341,8 +6526,10 @@ update_page_write_prot(unsigned page)
     int num_words = page_table[page].bytes_used / sizeof(lispobj);
/* Shouldn't be a free page. */
-    gc_assert(PAGE_ALLOCATED(page));
-    gc_assert(page_table[page].bytes_used != 0);
+    if (gc_assert_level > 0) {
+	gc_assert(PAGE_ALLOCATED(page));
+	gc_assert(page_table[page].bytes_used != 0);
+    }
/* Skip if it's already write protected or an unboxed page. */
     if (PAGE_WRITE_PROTECTED(page) || PAGE_UNBOXED(page))
@@ -6445,7 +6632,9 @@ scavenge_generation(int generation)
        int last_page;
/* This should be the start of a contiguous block */
-	    gc_assert(page_table[i].first_object_offset == 0);
+	    if (gc_assert_level > 0) {
+		gc_assert(page_table[i].first_object_offset == 0);
+	    }
/*
         * Need to find the full extent of this contiguous block in case
@@ -6827,7 +7016,9 @@ scavenge_newspace_generation(int generation)
    	int offset = (*previous_new_areas)[i].offset;
    	int size = (*previous_new_areas)[i].size / sizeof(lispobj);
-		gc_assert((*previous_new_areas)[i].size % 4 == 0);
+		if (gc_assert_level > 0) {
+		    gc_assert((*previous_new_areas)[i].size % 4 == 0);
+		}
#if 0
    	fprintf(stderr, "*S page %d offset %d size %d\n", page, offset,
@@ -7234,8 +7425,10 @@ verify_space(lispobj * start, size_t words)
    	      fheaderl = code->entry_points;
    	      while (fheaderl != NIL) {
    		  fheaderp = (struct function *) PTR(fheaderl);
-			  gc_assert(TypeOf(fheaderp->header) ==
-				    type_FunctionHeader);
+			  if (gc_assert_level > 0) {
+			      gc_assert(TypeOf(fheaderp->header) ==
+					type_FunctionHeader);
+			  }
    		  verify_space(&fheaderp->name, 1);
    		  verify_space(&fheaderp->arglist, 1);
    		  verify_space(&fheaderp->type, 1);
@@ -7350,7 +7543,9 @@ verify_generation(int generation)
        int region_unboxed = PAGE_UNBOXED(i);
/* This should be the start of a contiguous block */
-	    gc_assert(page_table[i].first_object_offset == 0);
+	    if (gc_assert_level > 0) {
+		gc_assert(page_table[i].first_object_offset == 0);
+	    }
/*
         * Need to find the full extent of this contiguous block in case
@@ -7454,7 +7649,9 @@ write_protect_generation_pages(int generation)
 {
     int i;
-    gc_assert(generation < NUM_GENERATIONS);
+    if (gc_assert_level > 0) {
+	gc_assert(generation < NUM_GENERATIONS);
+    }
for (i = 0; i < last_free_page; i++)
    if (PAGE_ALLOCATED(i) && !PAGE_UNBOXED(i)
@@ -7528,7 +7725,6 @@ garbage_collect_generation(int generation, int raise)
     unsigned long i;
     unsigned long read_only_space_size, static_space_size;
-#ifdef GC_ASSERTIONS
 #if defined(i386) || defined(__x86_64)
     invalid_stack_start = (void *) control_stack;
     invalid_stack_end = (void *) &raise;
@@ -7536,12 +7732,13 @@ garbage_collect_generation(int generation, int raise)
     invalid_stack_start = (void *) &raise;
     invalid_stack_end = (void *) control_stack_end;
 #endif /* not i386 */
-#endif /* GC_ASSERTIONS */
-    gc_assert(generation <= NUM_GENERATIONS - 1);
+    if (gc_assert_level > 0) {
+	gc_assert(generation <= NUM_GENERATIONS - 1);
+	/* The oldest generation can't be raised. */
+	gc_assert(generation != NUM_GENERATIONS - 1 || raise == 0);
+    }
-    /* The oldest generation can't be raised. */
-    gc_assert(generation != NUM_GENERATIONS - 1 || raise == 0);
/* Initialise the weak pointer list. */
     weak_pointers = NULL;
@@ -7553,8 +7750,11 @@ garbage_collect_generation(int generation, int raise)
      * done. Setup this new generation. There should be no pages
      * allocated to it yet.
      */
-    if (!raise)
-	gc_assert(generations[NUM_GENERATIONS].bytes_allocated == 0);
+    if (!raise) {
+	if (gc_assert_level > 0) {
+	    gc_assert(generations[NUM_GENERATIONS].bytes_allocated == 0);
+	}
+    }
/* Set the global src and dest. generations */
     from_space = generation;
@@ -7615,7 +7815,9 @@ garbage_collect_generation(int generation, int raise)
     * There shouldn't be any non-movable pages because we don't have
     * any conservative pointers!
     */
-	gc_assert(num_dont_move_pages == 0);
+	if (gc_assert_level > 0) {
+	    gc_assert(num_dont_move_pages == 0);
+	}
 #endif
     }
@@ -7742,7 +7944,9 @@ garbage_collect_generation(int generation, int raise)
        if (page_table[i].bytes_used != 0
    	&& PAGE_GENERATION(i) == NUM_GENERATIONS)
    	    PAGE_FLAGS_UPDATE(i, PAGE_GENERATION_MASK, generation);
-	gc_assert(generations[generation].bytes_allocated == 0);
+	if (gc_assert_level > 0) {
+	    gc_assert(generations[generation].bytes_allocated == 0);
+	}
    generations[generation].bytes_allocated =
        generations[NUM_GENERATIONS].bytes_allocated;
    generations[NUM_GENERATIONS].bytes_allocated = 0;
@@ -7827,7 +8031,9 @@ collect_garbage(unsigned last_gen)
/* Verify the new objects created by lisp code. */
     if (pre_verify_gen_0) {
-	fprintf(stderr, "Pre-Checking generation 0\n");
+	if (gencgc_verbose > 0) {
+	    fprintf(stderr, "Pre-Checking generation 0\n");
+	}
    verify_generation(0);
     }
@@ -7918,7 +8124,9 @@ collect_garbage(unsigned last_gen)
      * Set gc_alloc back to generation 0. The current regions should be
      * flushed after the above GCs.
      */
-    gc_assert(boxed_region.free_pointer - boxed_region.start_addr == 0);
+    if (gc_assert_level > 0) {
+	gc_assert(boxed_region.free_pointer - boxed_region.start_addr == 0);
+    }
     gc_alloc_generation = 0;
update_dynamic_space_free_pointer();
@@ -8012,8 +8220,10 @@ gc_free_heap(void)
        /*
              * Double check that the page is zero filled.
              */
-	    gc_assert(!PAGE_ALLOCATED(page));
-	    gc_assert(page_table[page].bytes_used == 0);
+	    if (gc_assert_level > 0) {
+		gc_assert(!PAGE_ALLOCATED(page));
+		gc_assert(page_table[page].bytes_used == 0);
+	    }
page_start = (int *) page_address(page);
@@ -8212,10 +8422,14 @@ alloc(int nbytes)
      * current_dynamic_space_free_pointer) and therefore contains the
      * pseudo-atomic bits.
      */
-    gc_assert(((unsigned) get_current_region_free() & lowtag_Mask) == 0);
+    if (gc_assert_level > 0) {
+	gc_assert(((unsigned) get_current_region_free() & lowtag_Mask) == 0);
+    }
 #endif
-    gc_assert((nbytes & lowtag_Mask) == 0);
-    gc_assert(get_pseudo_atomic_atomic());
+    if (gc_assert_level > 0) {
+	gc_assert((nbytes & lowtag_Mask) == 0);
+	gc_assert(get_pseudo_atomic_atomic());
+    }
bytes_allocated_sum += nbytes;
View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/compare/d7f49e5153e53ddb7fa1ccc10...
-- 
View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/compare/d7f49e5153e53ddb7fa1ccc10...
You're receiving this email because of your account on gitlab.common-lisp.net.



    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

[Git][cmucl/cmucl][master] 2 commits: Fix #69: Always compile in GC assertion code