X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fgc.c;h=b7fee149f980ec1d6fd0c9638840554dd836acad;hb=872175cd9cb5b4966a36d4bd92421cc407a0355b;hp=99bd897991f8578864f763a556f9e3697dfe080d;hpb=dfa55a883f94470267b626dae77ce7e7dfac3df6;p=sbcl.git

diff --git a/src/runtime/gc.c b/src/runtime/gc.c
index 99bd897..b7fee14 100644
--- a/src/runtime/gc.c
+++ b/src/runtime/gc.c
@@ -1,11 +1,17 @@
 /*
- * Stop and Copy GC based on Cheney's algorithm.
- *
- * $Header$
- * 
- * Written by Christopher Hoover.
+ * stop and copy GC based on Cheney's algorithm
  */
 
+/*
+ * This software is part of the SBCL system. See the README file for
+ * more information.
+ *
+ * This software is derived from the CMU CL system, which was
+ * written at Carnegie Mellon University and released into the
+ * public domain. The software is in the public domain and is
+ * provided with absolutely no warranty. See the COPYING and CREDITS
+ * files for more information.
+ */
 
 #include <stdio.h>
 #include <sys/time.h>
@@ -20,6 +26,8 @@
 #include "validate.h"
 #include "lispregs.h"
 #include "interr.h"
+
+/* So you need to debug? */
 #if 0
 #define PRINTNOISE
 #define DEBUG_SPACE_PREDICATES
@@ -60,31 +68,33 @@ static int scav_lose(lispobj *where, lispobj object);
 #define CEILING(x,y) (((x) + ((y) - 1)) & (~((y) - 1)))
 
 
-/* Predicates */
+/* predicates */
 
 #if defined(DEBUG_SPACE_PREDICATES)
 
-boolean from_space_p(lispobj object)
+boolean
+from_space_p(lispobj object)
 {
 	lispobj *ptr;
 
 	/* this can be called for untagged pointers as well as for 
 	   descriptors, so this assertion's not applicable
-	   gc_assert(Pointerp(object));
+	   gc_assert(is_lisp_pointer(object));
 	*/
-	ptr = (lispobj *) PTR(object);
+	ptr = (lispobj *) native_pointer(object);
 
 	return ((from_space <= ptr) &&
 		(ptr < from_space_free_pointer));
 }	    
 
-boolean new_space_p(lispobj object)
+boolean
+new_space_p(lispobj object)
 {
 	lispobj *ptr;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
-	ptr = (lispobj *) PTR(object);
+	ptr = (lispobj *) native_pointer(object);
 		
 	return ((new_space <= ptr) &&
 		(ptr < new_space_free_pointer));
@@ -103,7 +113,7 @@ boolean new_space_p(lispobj object)
 #endif
 
 
-/* Copying Objects */
+/* copying objects */
 
 static lispobj
 copy_object(lispobj object, int nwords)
@@ -112,7 +122,7 @@ copy_object(lispobj object, int nwords)
 	lispobj *new;
 	lispobj *source, *dest;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 	gc_assert(from_space_p(object));
 	gc_assert((nwords & 0x01) == 0);
 
@@ -124,7 +134,7 @@ copy_object(lispobj object, int nwords)
 	new_space_free_pointer += nwords;
 
 	dest = new;
-	source = (lispobj *) PTR(object);
+	source = (lispobj *) native_pointer(object);
 
 #ifdef DEBUG_COPY_VERBOSE
 	fprintf(stderr,"Copying %d words from %p to %p\n", nwords,source,new);
@@ -143,10 +153,11 @@ copy_object(lispobj object, int nwords)
 }
 
 
-/* Collect Garbage */
+/* collecting garbage */
 
 #ifdef PRINTNOISE
-static double tv_diff(struct timeval *x, struct timeval *y)
+static double
+tv_diff(struct timeval *x, struct timeval *y)
 {
     return (((double) x->tv_sec + (double) x->tv_usec * 1.0e-6) -
 	    ((double) y->tv_sec + (double) y->tv_usec * 1.0e-6));
@@ -160,7 +171,8 @@ static double tv_diff(struct timeval *x, struct timeval *y)
 #else
 #define U32 unsigned long
 #endif
-static void zero_stack(void)
+static void
+zero_stack(void)
 {
     U32 *ptr = (U32 *)current_control_stack_pointer;
  search:
@@ -180,10 +192,11 @@ static void zero_stack(void)
 #undef U32
 
 
-/* this is not generational.  It's called with a last_gen arg, which we shun.
- */
-
-void collect_garbage(unsigned ignore)
+/* Note: The generic GC interface we're implementing passes us a
+ * last_generation argument. That's meaningless for us, since we're
+ * not a generational GC. So we ignore it. */
+void
+collect_garbage(unsigned ignore)
 {
 #ifdef PRINTNOISE
 struct timeval start_tv, stop_tv;
@@ -217,14 +230,12 @@ struct timeval start_tv, stop_tv;
 	/* Set up from space and new space pointers. */
 
 	from_space = current_dynamic_space;
-#ifndef ibmrt
 	from_space_free_pointer = dynamic_space_free_pointer;
-#else
-	from_space_free_pointer = (lispobj *)SymbolValue(ALLOCATION_POINTER);
-#endif
 
+#ifdef PRINTNOISE
 	fprintf(stderr,"from_space = %lx\n",
 		(unsigned long) current_dynamic_space);
+#endif
 	if (current_dynamic_space == (lispobj *) DYNAMIC_0_SPACE_START)
 	    new_space = (lispobj *)DYNAMIC_1_SPACE_START;
 	else if (current_dynamic_space == (lispobj *) DYNAMIC_1_SPACE_START)
@@ -264,14 +275,9 @@ struct timeval start_tv, stop_tv;
 	scavenge(((lispobj *)CONTROL_STACK_START), control_stack_size);
 		 
 
-#ifdef ibmrt
-	binding_stack_size =
-	    (lispobj *)SymbolValue(BINDING_STACK_POINTER) - binding_stack;
-#else
 	binding_stack_size = 
 	  current_binding_stack_pointer - 
 	    (lispobj *)BINDING_STACK_START;
-#endif
 #ifdef PRINTNOISE
 	printf("Scavenging the binding stack %x - %x (%d words) ...\n",
 	       BINDING_STACK_START,current_binding_stack_pointer,
@@ -316,11 +322,7 @@ struct timeval start_tv, stop_tv;
 		(os_vm_size_t) DYNAMIC_SPACE_SIZE);
 
 	current_dynamic_space = new_space;
-#ifndef ibmrt
 	dynamic_space_free_pointer = new_space_free_pointer;
-#else
-	SetSymbolValue(ALLOCATION_POINTER, (lispobj)new_space_free_pointer);
-#endif
 
 #ifdef PRINTNOISE
 	size_discarded = (from_space_free_pointer - from_space) * sizeof(lispobj);
@@ -369,9 +371,7 @@ struct timeval start_tv, stop_tv;
 }
 
 
-/* Scavenging */
-
-#define DIRECT_SCAV 0
+/* scavenging */
 
 static void
 scavenge(lispobj *start, u32 nwords)
@@ -388,18 +388,16 @@ scavenge(lispobj *start, u32 nwords)
 		       (unsigned long) start, (unsigned long) object, type);
 #endif
 
-#if DIRECT_SCAV
-		words_scavenged = (scavtab[type])(start, object);
-#else
-                if (Pointerp(object)) {
+                if (is_lisp_pointer(object)) {
 		    /* It be a pointer. */
 		    if (from_space_p(object)) {
                         /* It currently points to old space.  Check for a */
                         /* forwarding pointer. */
                         lispobj first_word;
 
-                        first_word = *((lispobj *)PTR(object));
-                        if (Pointerp(first_word) && new_space_p(first_word)) {
+                        first_word = *((lispobj *)native_pointer(object));
+                        if (is_lisp_pointer(first_word) &&
+			    new_space_p(first_word)) {
                             /* Yep, there be a forwarding pointer. */
                             *start = first_word;
                             words_scavenged = 1;
@@ -441,14 +439,15 @@ scavenge(lispobj *start, u32 nwords)
                     words_scavenged = (scavtab[type])(start, object);
 
                 }
-#endif
+
 		start += words_scavenged;
 		nwords -= words_scavenged;
 	}
 	gc_assert(nwords == 0);
 }
 
-static void scavenge_newspace(void)
+static void
+scavenge_newspace(void)
 {
     lispobj *here, *next;
 
@@ -462,13 +461,13 @@ static void scavenge_newspace(void)
     }
     /* printf("done with newspace\n"); */
 }
-
 
-/* Scavenging Interrupt Contexts */
+/* scavenging interrupt contexts */
 
 static int boxed_registers[] = BOXED_REGISTERS;
 
-static void scavenge_interrupt_context(os_context_t *context)
+static void
+scavenge_interrupt_context(os_context_t *context)
 {
 	int i;
 #ifdef reg_LIP
@@ -549,22 +548,22 @@ static void scavenge_interrupt_context(os_context_t *context)
 
 void scavenge_interrupt_contexts(void)
 {
-	int i, index;
-	os_context_t *context;
+    int i, index;
+    os_context_t *context;
 
-	index = fixnum_value(SymbolValue(FREE_INTERRUPT_CONTEXT_INDEX));
-	printf("Number of active contexts: %d\n", index);
+    index = fixnum_value(SymbolValue(FREE_INTERRUPT_CONTEXT_INDEX));
 
-	for (i = 0; i < index; i++) {
-		context = lisp_interrupt_contexts[i];
-		scavenge_interrupt_context(context); 
-	}
+    for (i = 0; i < index; i++) {
+	context = lisp_interrupt_contexts[i];
+	scavenge_interrupt_context(context); 
+    }
 }
 
 
-/* Debugging Code */
+/* debugging code */
 
-void print_garbage(lispobj *from_space, lispobj *from_space_free_pointer)
+void
+print_garbage(lispobj *from_space, lispobj *from_space_free_pointer)
 {
 	lispobj *start;
 	int total_words_not_copied;
@@ -579,7 +578,7 @@ void print_garbage(lispobj *from_space, lispobj *from_space_free_pointer)
 		lispobj header;
 
 		object = *start;
-		forwardp = Pointerp(object) && new_space_p(object);
+		forwardp = is_lisp_pointer(object) && new_space_p(object);
 
 		if (forwardp) {
 			int tag;
@@ -599,7 +598,7 @@ void print_garbage(lispobj *from_space, lispobj *from_space_free_pointer)
 				nwords = 1;
 				break;
 			case type_OtherPointer:
-				pointer = (lispobj *) PTR(object);
+				pointer = (lispobj *) native_pointer(object);
 				header = *pointer;
 				type = TypeOf(header);
 				nwords = (sizetab[type])(pointer);
@@ -619,57 +618,13 @@ void print_garbage(lispobj *from_space, lispobj *from_space_free_pointer)
 }
 
 
-/* Code and Code-Related Objects */
+/* code and code-related objects */
 
 #define RAW_ADDR_OFFSET (6*sizeof(lispobj) - type_FunctionPointer)
 
 static lispobj trans_function_header(lispobj object);
 static lispobj trans_boxed(lispobj object);
 
-#if DIRECT_SCAV
-static int
-scav_function_pointer(lispobj *where, lispobj object)
-{
-	gc_assert(Pointerp(object));
-
-	if (from_space_p(object)) {
-		lispobj first, *first_pointer;
-
-		/* object is a pointer into from space.  check to see */
-		/* if it has been forwarded */
-		first_pointer = (lispobj *) PTR(object);
-		first = *first_pointer;
-		
-		if (!(Pointerp(first) && new_space_p(first))) {
-			int type;
-			lispobj copy;
-
-			/* must transport object -- object may point */
-			/* to either a function header, a closure */
-			/* function header, or to a closure header. */
-			
-			type = TypeOf(first);
-			switch (type) {
-			  case type_FunctionHeader:
-			  case type_ClosureFunctionHeader:
-			    copy = trans_function_header(object);
-			    break;
-			  default:
-			    copy = trans_boxed(object);
-			    break;
-			}
-
-			first = *first_pointer = copy;
-		}
-
-		gc_assert(Pointerp(first));
-		gc_assert(!from_space_p(first));
-
-		*where = first;
-	}
-	return 1;
-}
-#else
 static int
 scav_function_pointer(lispobj *where, lispobj object)
 {
@@ -678,10 +633,10 @@ scav_function_pointer(lispobj *where, lispobj object)
   lispobj first;
   int type;
 
-  gc_assert(Pointerp(object));
+  gc_assert(is_lisp_pointer(object));
       
   /* object is a pointer into from space. Not a FP */
-  first_pointer = (lispobj *) PTR(object);
+  first_pointer = (lispobj *) native_pointer(object);
   first = *first_pointer;
 		
   /* must transport object -- object may point */
@@ -701,13 +656,12 @@ scav_function_pointer(lispobj *where, lispobj object)
   
   first = *first_pointer = copy;
 
-  gc_assert(Pointerp(first));
+  gc_assert(is_lisp_pointer(first));
   gc_assert(!from_space_p(first));
 
   *where = first;
   return 1;
 }
-#endif
 
 static struct code *
 trans_code(struct code *code)
@@ -725,11 +679,11 @@ trans_code(struct code *code)
 
 	/* if object has already been transported, just return pointer */
 	first = code->header;
-	if (Pointerp(first) && new_space_p(first)) {
+	if (is_lisp_pointer(first) && new_space_p(first)) {
 #ifdef DEBUG_CODE_GC
 	    printf("Was already transported\n");
 #endif
-	    return (struct code *) PTR(first);
+	    return (struct code *) native_pointer(first);
 	}
 	
 	gc_assert(TypeOf(first) == type_CodeHeader);
@@ -743,7 +697,7 @@ trans_code(struct code *code)
 	nwords = CEILING(nwords, 2);
 
 	l_new_code = copy_object(l_code, nwords);
-	new_code = (struct code *) PTR(l_new_code);
+	new_code = (struct code *) native_pointer(l_new_code);
 
 	displacement = l_new_code - l_code;
 
@@ -766,13 +720,13 @@ trans_code(struct code *code)
 		struct function *fheaderp, *nfheaderp;
 		lispobj nfheaderl;
 		
-		fheaderp = (struct function *) PTR(fheaderl);
+		fheaderp = (struct function *) native_pointer(fheaderl);
 		gc_assert(TypeOf(fheaderp->header) == type_FunctionHeader);
 
 		/* calcuate the new function pointer and the new */
 		/* function header */
 		nfheaderl = fheaderl + displacement;
-		nfheaderp = (struct function *) PTR(nfheaderl);
+		nfheaderp = (struct function *) native_pointer(nfheaderl);
 
 		/* set forwarding pointer */
 #ifdef DEBUG_CODE_GC
@@ -826,12 +780,12 @@ scav_code_header(lispobj *where, lispobj object)
 	/* code data block */
 	fheaderl = code->entry_points;
 	while (fheaderl != NIL) {
-		fheaderp = (struct function *) PTR(fheaderl);
+		fheaderp = (struct function *) native_pointer(fheaderl);
 		gc_assert(TypeOf(fheaderp->header) == type_FunctionHeader);
 		
 #if defined(DEBUG_CODE_GC)
 		printf("Scavenging boxed section of entry point located at 0x%08x.\n",
-		       (unsigned long) PTR(fheaderl));
+		       (unsigned long) native_pointer(fheaderl));
 #endif
 		scavenge(&fheaderp->name, 1);
 		scavenge(&fheaderp->arglist, 1);
@@ -848,7 +802,7 @@ trans_code_header(lispobj object)
 {
 	struct code *ncode;
 
-	ncode = trans_code((struct code *) PTR(object));
+	ncode = trans_code((struct code *) native_pointer(object));
 	return (lispobj) LOW_WORD(ncode) | type_OtherPointer;
 }
 
@@ -886,7 +840,7 @@ trans_return_pc_header(lispobj object)
 	unsigned long offset;
 	struct code *code, *ncode;
 	lispobj ret;
-	return_pc = (struct function *) PTR(object);
+	return_pc = (struct function *) native_pointer(object);
 	offset = HeaderValue(return_pc->header)  * 4 ;
 
 	/* Transport the whole code object */
@@ -896,7 +850,7 @@ trans_return_pc_header(lispobj object)
 #endif
 	ncode = trans_code(code);
 	if(object==0x304748d7) {
-	    /* ldb_monitor(); */
+	    /* monitor_or_something(); */
 	}
 	ret= ((lispobj) LOW_WORD(ncode) + offset) | type_OtherPointer;
 #ifdef DEBUG_CODE_GC
@@ -905,12 +859,12 @@ trans_return_pc_header(lispobj object)
 	return ret;
 }
 
-/* On the 386, closures hold a pointer to the raw address instead of the
-   function object, so we can use CALL [$FDEFN+const] to invoke the function
-   without loading it into a register.  Given that code objects don't move,
-   we don't need to update anything, but we do have to figure out that the
-   function is still live. */
-#ifdef i386
+/* On the 386, closures hold a pointer to the raw address instead of
+ * the function object, so we can use CALL [$FDEFN+const] to invoke
+ * the function without loading it into a register. Given that code
+ * objects don't move, we don't need to update anything, but we do
+ * have to figure out that the function is still live. */
+#ifdef __i386__
 static
 scav_closure_header(where, object)
 lispobj *where, object;
@@ -944,7 +898,7 @@ trans_function_header(lispobj object)
 	unsigned long offset;
 	struct code *code, *ncode;
 	
-	fheader = (struct function *) PTR(object);
+	fheader = (struct function *) native_pointer(object);
 	offset = HeaderValue(fheader->header) * 4;
 
 	/* Transport the whole code object */
@@ -956,89 +910,43 @@ trans_function_header(lispobj object)
 
 
 
-/* Instances */
-
-#if DIRECT_SCAV
-static int
-scav_instance_pointer(lispobj *where, lispobj object)
-{
-    if (from_space_p(object)) {
-	lispobj first, *first_pointer;
+/* instances */
 
-	/* object is a pointer into from space.  check to see */
-	/* if it has been forwarded */
-	first_pointer = (lispobj *) PTR(object);
-	first = *first_pointer;
-		
-	if (!(Pointerp(first) && new_space_p(first)))
-	    first = *first_pointer = trans_boxed(object);
-	*where = first;
-    }
-    return 1;
-}
-#else
 static int
 scav_instance_pointer(lispobj *where, lispobj object)
 {
   lispobj  *first_pointer;
   
   /* object is a pointer into from space.  Not a FP */
-  first_pointer = (lispobj *) PTR(object);
+  first_pointer = (lispobj *) native_pointer(object);
   
   *where = *first_pointer = trans_boxed(object);
   return 1;
 }
-#endif
 
 
-/* Lists and Conses */
+/* lists and conses */
 
 static lispobj trans_list(lispobj object);
 
-#if DIRECT_SCAV
-static int
-scav_list_pointer(lispobj *where, lispobj object)
-{
-	gc_assert(Pointerp(object));
-
-	if (from_space_p(object)) {
-		lispobj first, *first_pointer;
-
-		/* object is a pointer into from space.  check to see */
-		/* if it has been forwarded */
-		first_pointer = (lispobj *) PTR(object);
-		first = *first_pointer;
-		
-		if (!(Pointerp(first) && new_space_p(first)))
-			first = *first_pointer = trans_list(object);
-
-		gc_assert(Pointerp(first));
-		gc_assert(!from_space_p(first));
-	
-		*where = first;
-	}
-	return 1;
-}
-#else
 static int
 scav_list_pointer(lispobj *where, lispobj object)
 {
   lispobj first, *first_pointer;
 
-  gc_assert(Pointerp(object));
+  gc_assert(is_lisp_pointer(object));
 
   /* object is a pointer into from space.  Not a FP. */
-  first_pointer = (lispobj *) PTR(object);
+  first_pointer = (lispobj *) native_pointer(object);
   
   first = *first_pointer = trans_list(object);
   
-  gc_assert(Pointerp(first));
+  gc_assert(is_lisp_pointer(first));
   gc_assert(!from_space_p(first));
   
   *where = first;
   return 1;
 }
-#endif
 
 static lispobj
 trans_list(lispobj object)
@@ -1046,11 +954,11 @@ trans_list(lispobj object)
 	lispobj new_list_pointer;
 	struct cons *cons, *new_cons;
 	
-	cons = (struct cons *) PTR(object);
+	cons = (struct cons *) native_pointer(object);
 
 	/* ### Don't use copy_object here. */
 	new_list_pointer = copy_object(object, 2);
-	new_cons = (struct cons *) PTR(new_list_pointer);
+	new_cons = (struct cons *) native_pointer(new_list_pointer);
 
 	/* Set forwarding pointer. */
 	cons->car = new_list_pointer;
@@ -1066,15 +974,15 @@ trans_list(lispobj object)
 
                 if (LowtagOf(cdr) != type_ListPointer ||
                     !from_space_p(cdr) ||
-                    (Pointerp(first = *(lispobj *)PTR(cdr)) &&
-                     new_space_p(first)))
+                    (is_lisp_pointer(first = *(lispobj *)native_pointer(cdr))
+		     && new_space_p(first)))
                 	break;
 
-		cdr_cons = (struct cons *) PTR(cdr);
+		cdr_cons = (struct cons *) native_pointer(cdr);
 
 		/* ### Don't use copy_object here */
 		new_cdr = copy_object(cdr, 2);
-		new_cdr_cons = (struct cons *) PTR(new_cdr);
+		new_cdr_cons = (struct cons *) native_pointer(new_cdr);
 
 		/* Set forwarding pointer */
 		cdr_cons->car = new_cdr;
@@ -1092,55 +1000,28 @@ trans_list(lispobj object)
 }
 
 
-/* Scavenging and Transporting Other Pointers */
-
-#if DIRECT_SCAV
-static int
-scav_other_pointer(lispobj *where, lispobj object)
-{
-	gc_assert(Pointerp(object));
-
-	if (from_space_p(object)) {
-		lispobj first, *first_pointer;
-
-		/* object is a pointer into from space.  check to see */
-		/* if it has been forwarded */
-		first_pointer = (lispobj *) PTR(object);
-		first = *first_pointer;
-		
-		if (!(Pointerp(first) && new_space_p(first)))
-			first = *first_pointer = 
-				(transother[TypeOf(first)])(object);
+/* scavenging and transporting other pointers */
 
-		gc_assert(Pointerp(first));
-		gc_assert(!from_space_p(first));
-
-		*where = first;
-	}
-	return 1;
-}
-#else
 static int
 scav_other_pointer(lispobj *where, lispobj object)
 {
   lispobj first, *first_pointer;
 
-  gc_assert(Pointerp(object));
+  gc_assert(is_lisp_pointer(object));
 
   /* Object is a pointer into from space - not a FP */
-  first_pointer = (lispobj *) PTR(object);
+  first_pointer = (lispobj *) native_pointer(object);
   first = *first_pointer = (transother[TypeOf(*first_pointer)])(object);
 
-  gc_assert(Pointerp(first));
+  gc_assert(is_lisp_pointer(first));
   gc_assert(!from_space_p(first));
 
   *where = first;
   return 1;
 }
-#endif
 
 
-/* Immediate, Boxed, and Unboxed Objects */
+/* immediate, boxed, and unboxed objects */
 
 static int
 size_pointer(lispobj *where)
@@ -1181,9 +1062,9 @@ trans_boxed(lispobj object)
 	lispobj header;
 	unsigned long length;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
-	header = *((lispobj *) PTR(object));
+	header = *((lispobj *) native_pointer(object));
 	length = HeaderValue(header) + 1;
 	length = CEILING(length, 2);
 
@@ -1204,7 +1085,7 @@ size_boxed(lispobj *where)
 }
 
 /* Note: on the sparc we don't have to do anything special for fdefns, */
-/* cause the raw-addr has a function lowtag. */
+/* 'cause the raw-addr has a function lowtag. */
 #ifndef sparc
 static int
 scav_fdefn(lispobj *where, lispobj object)
@@ -1242,9 +1123,9 @@ trans_unboxed(lispobj object)
 	unsigned long length;
 
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
-	header = *((lispobj *) PTR(object));
+	header = *((lispobj *) native_pointer(object));
 	length = HeaderValue(header) + 1;
 	length = CEILING(length, 2);
 
@@ -1265,7 +1146,7 @@ size_unboxed(lispobj *where)
 }
 
 
-/* Vector-Like Objects */
+/* vector-like objects */
 
 #define NWORDS(x,y) (CEILING((x),(y)) / (y))
 
@@ -1291,12 +1172,12 @@ trans_string(lispobj object)
 	struct vector *vector;
 	int length, nwords;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
 	/* NOTE: Strings contain one more byte of data than the length */
 	/* slot indicates. */
 
-	vector = (struct vector *) PTR(object);
+	vector = (struct vector *) native_pointer(object);
 	length = fixnum_value(vector->length) + 1;
 	nwords = CEILING(NWORDS(length, 4) + 2, 2);
 
@@ -1335,9 +1216,9 @@ trans_vector(lispobj object)
 	struct vector *vector;
 	int length, nwords;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
-	vector = (struct vector *) PTR(object);
+	vector = (struct vector *) native_pointer(object);
 
 	length = fixnum_value(vector->length);
 	nwords = CEILING(length + 2, 2);
@@ -1378,9 +1259,9 @@ trans_vector_bit(lispobj object)
 	struct vector *vector;
 	int length, nwords;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
-	vector = (struct vector *) PTR(object);
+	vector = (struct vector *) native_pointer(object);
 	length = fixnum_value(vector->length);
 	nwords = CEILING(NWORDS(length, 32) + 2, 2);
 
@@ -1420,9 +1301,9 @@ trans_vector_unsigned_byte_2(lispobj object)
 	struct vector *vector;
 	int length, nwords;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
-	vector = (struct vector *) PTR(object);
+	vector = (struct vector *) native_pointer(object);
 	length = fixnum_value(vector->length);
 	nwords = CEILING(NWORDS(length, 16) + 2, 2);
 
@@ -1462,9 +1343,9 @@ trans_vector_unsigned_byte_4(lispobj object)
 	struct vector *vector;
 	int length, nwords;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
-	vector = (struct vector *) PTR(object);
+	vector = (struct vector *) native_pointer(object);
 	length = fixnum_value(vector->length);
 	nwords = CEILING(NWORDS(length, 8) + 2, 2);
 
@@ -1504,9 +1385,9 @@ trans_vector_unsigned_byte_8(lispobj object)
 	struct vector *vector;
 	int length, nwords;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
-	vector = (struct vector *) PTR(object);
+	vector = (struct vector *) native_pointer(object);
 	length = fixnum_value(vector->length);
 	nwords = CEILING(NWORDS(length, 4) + 2, 2);
 
@@ -1546,9 +1427,9 @@ trans_vector_unsigned_byte_16(lispobj object)
 	struct vector *vector;
 	int length, nwords;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
-	vector = (struct vector *) PTR(object);
+	vector = (struct vector *) native_pointer(object);
 	length = fixnum_value(vector->length);
 	nwords = CEILING(NWORDS(length, 2) + 2, 2);
 
@@ -1588,9 +1469,9 @@ trans_vector_unsigned_byte_32(lispobj object)
 	struct vector *vector;
 	int length, nwords;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
-	vector = (struct vector *) PTR(object);
+	vector = (struct vector *) native_pointer(object);
 	length = fixnum_value(vector->length);
 	nwords = CEILING(length + 2, 2);
 
@@ -1630,9 +1511,9 @@ trans_vector_single_float(lispobj object)
 	struct vector *vector;
 	int length, nwords;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
-	vector = (struct vector *) PTR(object);
+	vector = (struct vector *) native_pointer(object);
 	length = fixnum_value(vector->length);
 	nwords = CEILING(length + 2, 2);
 
@@ -1672,9 +1553,9 @@ trans_vector_double_float(lispobj object)
 	struct vector *vector;
 	int length, nwords;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
-	vector = (struct vector *) PTR(object);
+	vector = (struct vector *) native_pointer(object);
 	length = fixnum_value(vector->length);
 	nwords = CEILING(length * 2 + 2, 2);
 
@@ -1717,9 +1598,9 @@ trans_vector_long_float(lispobj object)
 	struct vector *vector;
 	int length, nwords;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
-	vector = (struct vector *) PTR(object);
+	vector = (struct vector *) native_pointer(object);
 	length = fixnum_value(vector->length);
 #ifdef sparc
 	nwords = CEILING(length * 4 + 2, 2);
@@ -1765,9 +1646,9 @@ trans_vector_complex_single_float(lispobj object)
 	struct vector *vector;
 	int length, nwords;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
-	vector = (struct vector *) PTR(object);
+	vector = (struct vector *) native_pointer(object);
 	length = fixnum_value(vector->length);
 	nwords = CEILING(length * 2 + 2, 2);
 
@@ -1808,9 +1689,9 @@ trans_vector_complex_double_float(lispobj object)
 	struct vector *vector;
 	int length, nwords;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
-	vector = (struct vector *) PTR(object);
+	vector = (struct vector *) native_pointer(object);
 	length = fixnum_value(vector->length);
 	nwords = CEILING(length * 4 + 2, 2);
 
@@ -1853,9 +1734,9 @@ trans_vector_complex_long_float(lispobj object)
 	struct vector *vector;
 	int length, nwords;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
-	vector = (struct vector *) PTR(object);
+	vector = (struct vector *) native_pointer(object);
 	length = fixnum_value(vector->length);
 #ifdef sparc
 	nwords = CEILING(length * 8 + 2, 2);
@@ -1881,7 +1762,7 @@ size_vector_complex_long_float(lispobj *where)
 #endif
 
 
-/* Weak Pointers */
+/* weak pointers */
 
 #define WEAK_POINTER_NWORDS \
 	CEILING((sizeof(struct weak_pointer) / sizeof(lispobj)), 2)
@@ -1902,7 +1783,7 @@ trans_weak_pointer(lispobj object)
 	lispobj copy;
 	struct weak_pointer *wp;
 
-	gc_assert(Pointerp(object));
+	gc_assert(is_lisp_pointer(object));
 
 #if defined(DEBUG_WEAK)
 	printf("Transporting weak pointer from 0x%08x\n", object);
@@ -1912,7 +1793,7 @@ trans_weak_pointer(lispobj object)
 	/* been transported so they can be fixed up in a post-GC pass. */
 
 	copy = copy_object(object, WEAK_POINTER_NWORDS);
-	wp = (struct weak_pointer *) PTR(copy);
+	wp = (struct weak_pointer *) native_pointer(copy);
 	
 
 	/* Push the weak pointer onto the list of weak pointers. */
@@ -1944,7 +1825,7 @@ void scan_weak_pointers(void)
 		printf("Value: 0x%08x\n", (unsigned int) value);
 #endif		
 
-		if (!(Pointerp(value) && from_space_p(value)))
+		if (!(is_lisp_pointer(value) && from_space_p(value)))
 			continue;
 
 		/* Now, we need to check if the object has been */
@@ -1952,14 +1833,14 @@ void scan_weak_pointers(void)
 		/* still good and needs to be updated.  Otherwise, the */
 		/* weak pointer needs to be nil'ed out. */
 
-		first_pointer = (lispobj *) PTR(value);
+		first_pointer = (lispobj *) native_pointer(value);
 		first = *first_pointer;
 		
 #if defined(DEBUG_WEAK)
 		printf("First: 0x%08x\n", (unsigned long) first);
 #endif		
 
-		if (Pointerp(first) && new_space_p(first))
+		if (is_lisp_pointer(first) && new_space_p(first))
 			wp->value = first;
 		else {
 			wp->value = NIL;
@@ -1970,7 +1851,7 @@ void scan_weak_pointers(void)
 
 
 
-/* Initialization */
+/* initialization */
 
 static int
 scav_lose(lispobj *where, lispobj object)
@@ -2000,11 +1881,17 @@ size_lose(lispobj *where)
 	return 1;
 }
 
-void gc_init(void)
+/* KLUDGE: SBCL already has two GC implementations, and if someday the
+ * precise generational GC is revived, it might have three. It would
+ * be nice to share the scavtab[] data set up here, and perhaps other
+ * things too, between all of them, rather than trying to maintain
+ * multiple copies. -- WHN 2001-05-09 */
+void
+gc_init(void)
 {
 	int i;
 
-	/* Scavenge Table */
+	/* scavenge table */
 	for (i = 0; i < 256; i++)
 	    scavtab[i] = scav_lose; 
 	/* scavtab[i] = scav_immediate; */
@@ -2080,7 +1967,7 @@ void gc_init(void)
 	scavtab[type_FunctionHeader] = scav_function_header;
 	scavtab[type_ClosureFunctionHeader] = scav_function_header;
 	scavtab[type_ReturnPcHeader] = scav_return_pc_header;
-#ifdef i386
+#ifdef __i386__
 	scavtab[type_ClosureHeader] = scav_closure_header;
 	scavtab[type_FuncallableInstanceHeader] = scav_closure_header;
 	scavtab[type_ByteCodeFunction] = scav_closure_header;
@@ -2273,12 +2160,8 @@ void gc_init(void)
         sizetab[type_InstanceHeader] = size_boxed;
 	sizetab[type_Fdefn] = size_boxed;
 }
-
-
 
-/* Noise to manipulate the gc trigger stuff. */
-
-#ifndef ibmrt
+/* noise to manipulate the gc trigger stuff */
 
 void set_auto_gc_trigger(os_vm_size_t dynamic_usage)
 {
@@ -2332,5 +2215,3 @@ void clear_auto_gc_trigger(void)
 	current_auto_gc_trigger = NULL;
     }
 }
-
-#endif