0.7.6.1:
[sbcl.git] / src / runtime / gc.c
index b335682..1be1249 100644 (file)
@@ -75,29 +75,29 @@ static int scav_lose(lispobj *where, lispobj object);
 boolean
 from_space_p(lispobj object)
 {
-       lispobj *ptr;
+    lispobj *ptr;
 
-       /* this can be called for untagged pointers as well as for 
-          descriptors, so this assertion's not applicable
-          gc_assert(is_lisp_pointer(object));
-       */
-       ptr = (lispobj *) native_pointer(object);
+    /* this can be called for untagged pointers as well as for 
+       descriptors, so this assertion's not applicable
+       gc_assert(is_lisp_pointer(object));
+    */
+    ptr = (lispobj *) native_pointer(object);
 
-       return ((from_space <= ptr) &&
-               (ptr < from_space_free_pointer));
+    return ((from_space <= ptr) &&
+           (ptr < from_space_free_pointer));
 }          
 
 boolean
 new_space_p(lispobj object)
 {
-       lispobj *ptr;
+    lispobj *ptr;
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-       ptr = (lispobj *) native_pointer(object);
+    ptr = (lispobj *) native_pointer(object);
                
-       return ((new_space <= ptr) &&
-               (ptr < new_space_free_pointer));
+    return ((new_space <= ptr) &&
+           (ptr < new_space_free_pointer));
 }          
 
 #else
@@ -118,38 +118,38 @@ new_space_p(lispobj object)
 static lispobj
 copy_object(lispobj object, int nwords)
 {
-       int tag;
-       lispobj *new;
-       lispobj *source, *dest;
+    int tag;
+    lispobj *new;
+    lispobj *source, *dest;
 
-       gc_assert(is_lisp_pointer(object));
-       gc_assert(from_space_p(object));
-       gc_assert((nwords & 0x01) == 0);
+    gc_assert(is_lisp_pointer(object));
+    gc_assert(from_space_p(object));
+    gc_assert((nwords & 0x01) == 0);
 
-       /* get tag of object */
-       tag = LowtagOf(object);
+    /* get tag of object */
+    tag = lowtag_of(object);
 
-       /* allocate space */
-       new = new_space_free_pointer;
-       new_space_free_pointer += nwords;
+    /* allocate space */
+    new = new_space_free_pointer;
+    new_space_free_pointer += nwords;
 
-       dest = new;
-       source = (lispobj *) native_pointer(object);
+    dest = new;
+    source = (lispobj *) native_pointer(object);
 
 #ifdef DEBUG_COPY_VERBOSE
-       fprintf(stderr,"Copying %d words from %p to %p\n", nwords,source,new);
+    fprintf(stderr,"Copying %d words from %p to %p\n", nwords,source,new);
 #endif
 
-       /* copy the object */
-       while (nwords > 0) {
-            dest[0] = source[0];
-            dest[1] = source[1];
-            dest += 2;
-            source += 2;
-            nwords -= 2;
-       }
-       /* return lisp pointer of new object */
-       return (lispobj)(LOW_WORD(new) | tag);
+    /* copy the object */
+    while (nwords > 0) {
+       dest[0] = source[0];
+       dest[1] = source[1];
+       dest += 2;
+       source += 2;
+       nwords -= 2;
+    }
+    /* return lisp pointer of new object */
+    return (lispobj)(LOW_WORD(new) | tag);
 }
 
 \f
@@ -199,174 +199,202 @@ void
 collect_garbage(unsigned ignore)
 {
 #ifdef PRINTNOISE
-struct timeval start_tv, stop_tv;
-       struct rusage start_rusage, stop_rusage;
-       double real_time, system_time, user_time;
-       double percent_retained, gc_rate;
-       unsigned long size_discarded;
-       unsigned long size_retained;
-#endif
-       lispobj *current_static_space_free_pointer;
-       unsigned long static_space_size; 
-       unsigned long control_stack_size, binding_stack_size; 
-       sigset_t tmp, old;
+    struct timeval start_tv, stop_tv;
+    struct rusage start_rusage, stop_rusage;
+    double real_time, system_time, user_time;
+    double percent_retained, gc_rate;
+    unsigned long size_discarded;
+    unsigned long size_retained;
+#endif
+    lispobj *current_static_space_free_pointer;
+    unsigned long static_space_size; 
+    unsigned long control_stack_size, binding_stack_size; 
+    sigset_t tmp, old;
 
 #ifdef PRINTNOISE
-       printf("[Collecting garbage ... \n");
+    printf("[Collecting garbage ... \n");
        
-       getrusage(RUSAGE_SELF, &start_rusage);
-       gettimeofday(&start_tv, (struct timezone *) 0);
+    getrusage(RUSAGE_SELF, &start_rusage);
+    gettimeofday(&start_tv, (struct timezone *) 0);
 #endif
        
-       sigemptyset(&tmp);
-       sigaddset_blockable(&tmp);
-       sigprocmask(SIG_BLOCK, &tmp, &old);
+    sigemptyset(&tmp);
+    sigaddset_blockable(&tmp);
+    sigprocmask(SIG_BLOCK, &tmp, &old);
 
-       current_static_space_free_pointer =
-           (lispobj *) ((unsigned long)
-                        SymbolValue(STATIC_SPACE_FREE_POINTER));
+    current_static_space_free_pointer =
+       (lispobj *) ((unsigned long)
+                    SymbolValue(STATIC_SPACE_FREE_POINTER));
 
 
-       /* Set up from space and new space pointers. */
+    /* Set up from space and new space pointers. */
 
-       from_space = current_dynamic_space;
-       from_space_free_pointer = dynamic_space_free_pointer;
+    from_space = current_dynamic_space;
+    from_space_free_pointer = dynamic_space_free_pointer;
 
 #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)
-           new_space = (lispobj *) DYNAMIC_0_SPACE_START;
-       else {
-           lose("GC lossage.  Current dynamic space is bogus!\n");
-       }
-       new_space_free_pointer = new_space;
+    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)
+       new_space = (lispobj *) DYNAMIC_0_SPACE_START;
+    else {
+       lose("GC lossage.  Current dynamic space is bogus!\n");
+    }
+    new_space_free_pointer = new_space;
+#if 0
+    /* at one time we had the bright idea of using mprotect() to
+     * hide the semispace that we're not using at the moment, so
+     * we'd see immediately if anyone had a pointer to it.
+     * Unfortunately, if we gc during a call to an assembler
+     * routine with a "raw" return style, at least on PPC we are
+     * expected to return into oldspace because we can't easily
+     * update the link register - it's not tagged, and we can't do
+     * it as an offset of reg_CODE because the calling routine
+     * might be nowhere near our code vector.  We hope that we
+     * don't run very far in oldspace before it catapults us into
+     * newspace by either calling something else or returning
+     */
 
+    /* write-enable */
+    os_protect(new_space,DYNAMIC_SPACE_SIZE,OS_VM_PROT_ALL);
+#endif
 
-       /* Initialize the weak pointer list. */
-       weak_pointers = (struct weak_pointer *) NULL;
+    /* Initialize the weak pointer list. */
+    weak_pointers = (struct weak_pointer *) NULL;
 
 
-       /* Scavenge all of the roots. */
+    /* Scavenge all of the roots. */
 #ifdef PRINTNOISE
-       printf("Scavenging interrupt contexts ...\n");
+    printf("Scavenging interrupt contexts ...\n");
 #endif
-       scavenge_interrupt_contexts();
+    scavenge_interrupt_contexts();
 
 #ifdef PRINTNOISE
-       printf("Scavenging interrupt handlers (%d bytes) ...\n",
-              (int)sizeof(interrupt_handlers));
+    printf("Scavenging interrupt handlers (%d bytes) ...\n",
+          (int)sizeof(interrupt_handlers));
 #endif
-       scavenge((lispobj *) interrupt_handlers,
-                sizeof(interrupt_handlers) / sizeof(lispobj));
+    scavenge((lispobj *) interrupt_handlers,
+            sizeof(interrupt_handlers) / sizeof(lispobj));
        
-       /* _size quantities are in units of sizeof(lispobj) - i.e. 4 */
-       control_stack_size = 
-           current_control_stack_pointer-
-           (lispobj *)CONTROL_STACK_START;
+    /* _size quantities are in units of sizeof(lispobj) - i.e. 4 */
+    control_stack_size = 
+       current_control_stack_pointer-
+       (lispobj *)CONTROL_STACK_START;
 #ifdef PRINTNOISE
-       printf("Scavenging the control stack at %p (%ld words) ...\n",
-              ((lispobj *)CONTROL_STACK_START), 
-              control_stack_size);
+    printf("Scavenging the control stack at %p (%ld words) ...\n",
+          ((lispobj *)CONTROL_STACK_START), 
+          control_stack_size);
 #endif
-       scavenge(((lispobj *)CONTROL_STACK_START), control_stack_size);
+    scavenge(((lispobj *)CONTROL_STACK_START), control_stack_size);
                 
 
-       binding_stack_size = 
-         current_binding_stack_pointer - 
-           (lispobj *)BINDING_STACK_START;
+    binding_stack_size = 
+       current_binding_stack_pointer - 
+       (lispobj *)BINDING_STACK_START;
 #ifdef PRINTNOISE
-       printf("Scavenging the binding stack %x - %x (%d words) ...\n",
-              BINDING_STACK_START,current_binding_stack_pointer,
-              (int)(binding_stack_size));
+    printf("Scavenging the binding stack %x - %x (%d words) ...\n",
+          BINDING_STACK_START,current_binding_stack_pointer,
+          (int)(binding_stack_size));
 #endif
-       scavenge(((lispobj *)BINDING_STACK_START), binding_stack_size);
+    scavenge(((lispobj *)BINDING_STACK_START), binding_stack_size);
                 
-       static_space_size = 
-           current_static_space_free_pointer - (lispobj *) STATIC_SPACE_START;
+    static_space_size = 
+       current_static_space_free_pointer - (lispobj *) STATIC_SPACE_START;
 #ifdef PRINTNOISE
-       printf("Scavenging static space %x - %x (%d words) ...\n",
-              STATIC_SPACE_START,current_static_space_free_pointer,
-              (int)(static_space_size));
+    printf("Scavenging static space %x - %x (%d words) ...\n",
+          STATIC_SPACE_START,current_static_space_free_pointer,
+          (int)(static_space_size));
 #endif
-       scavenge(((lispobj *)STATIC_SPACE_START), static_space_size);
+    scavenge(((lispobj *)STATIC_SPACE_START), static_space_size);
 
-       /* Scavenge newspace. */
+    /* Scavenge newspace. */
 #ifdef PRINTNOISE
-       printf("Scavenging new space (%d bytes) ...\n",
-              (int)((new_space_free_pointer - new_space) * sizeof(lispobj)));
+    printf("Scavenging new space (%d bytes) ...\n",
+          (int)((new_space_free_pointer - new_space) * sizeof(lispobj)));
 #endif
-       scavenge_newspace();
+    scavenge_newspace();
 
 
 #if defined(DEBUG_PRINT_GARBAGE)
-       print_garbage(from_space, from_space_free_pointer);
+    print_garbage(from_space, from_space_free_pointer);
 #endif
 
-       /* Scan the weak pointers. */
+    /* Scan the weak pointers. */
 #ifdef PRINTNOISE
-       printf("Scanning weak pointers ...\n");
+    printf("Scanning weak pointers ...\n");
 #endif
-       scan_weak_pointers();
+    scan_weak_pointers();
 
 
-       /* Flip spaces. */
+    /* Flip spaces. */
 #ifdef PRINTNOISE
-       printf("Flipping spaces ...\n");
+    printf("Flipping spaces ...\n");
 #endif
 
-       os_zero((os_vm_address_t) current_dynamic_space,
-               (os_vm_size_t) DYNAMIC_SPACE_SIZE);
+    os_zero((os_vm_address_t) current_dynamic_space,
+           (os_vm_size_t) DYNAMIC_SPACE_SIZE);
 
-       current_dynamic_space = new_space;
-       dynamic_space_free_pointer = new_space_free_pointer;
+    current_dynamic_space = new_space;
+    dynamic_space_free_pointer = new_space_free_pointer;
 
 #ifdef PRINTNOISE
-       size_discarded = (from_space_free_pointer - from_space) * sizeof(lispobj);
-       size_retained = (new_space_free_pointer - new_space) * sizeof(lispobj);
+    size_discarded = (from_space_free_pointer - from_space) * sizeof(lispobj);
+    size_retained = (new_space_free_pointer - new_space) * sizeof(lispobj);
 #endif
 
-       /* Zero stack. */
+    /* Zero stack. */
 #ifdef PRINTNOISE
-       printf("Zeroing empty part of control stack ...\n");
+    printf("Zeroing empty part of control stack ...\n");
 #endif
-       zero_stack();
+    zero_stack();
 
-       sigprocmask(SIG_SETMASK, &old, 0);
+    sigprocmask(SIG_SETMASK, &old, 0);
 
 
 #ifdef PRINTNOISE
-       gettimeofday(&stop_tv, (struct timezone *) 0);
-       getrusage(RUSAGE_SELF, &stop_rusage);
+    gettimeofday(&stop_tv, (struct timezone *) 0);
+    getrusage(RUSAGE_SELF, &stop_rusage);
 
-       printf("done.]\n");
+    printf("done.]\n");
        
-       percent_retained = (((float) size_retained) /
-                            ((float) size_discarded)) * 100.0;
+    percent_retained = (((float) size_retained) /
+                       ((float) size_discarded)) * 100.0;
 
-       printf("Total of %ld bytes out of %ld bytes retained (%3.2f%%).\n",
-              size_retained, size_discarded, percent_retained);
+    printf("Total of %ld bytes out of %ld bytes retained (%3.2f%%).\n",
+          size_retained, size_discarded, percent_retained);
 
-       real_time = tv_diff(&stop_tv, &start_tv);
-       user_time = tv_diff(&stop_rusage.ru_utime, &start_rusage.ru_utime);
-       system_time = tv_diff(&stop_rusage.ru_stime, &start_rusage.ru_stime);
+    real_time = tv_diff(&stop_tv, &start_tv);
+    user_time = tv_diff(&stop_rusage.ru_utime, &start_rusage.ru_utime);
+    system_time = tv_diff(&stop_rusage.ru_stime, &start_rusage.ru_stime);
 
 #if 0
-       printf("Statistics:\n");
-       printf("%10.2f sec of real time\n", real_time);
-       printf("%10.2f sec of user time,\n", user_time);
-       printf("%10.2f sec of system time.\n", system_time);
+    printf("Statistics:\n");
+    printf("%10.2f sec of real time\n", real_time);
+    printf("%10.2f sec of user time,\n", user_time);
+    printf("%10.2f sec of system time.\n", system_time);
 #else
-        printf("Statistics: %10.2fs real, %10.2fs user, %10.2fs system.\n",
-               real_time, user_time, system_time);
+    printf("Statistics: %10.2fs real, %10.2fs user, %10.2fs system.\n",
+          real_time, user_time, system_time);
 #endif        
 
-       gc_rate = ((float) size_retained / (float) (1<<20)) / real_time;
+    gc_rate = ((float) size_retained / (float) (1<<20)) / real_time;
+       
+    printf("%10.2f M bytes/sec collected.\n", gc_rate);
+#endif
+    /* os_flush_icache((os_vm_address_t) 0, sizeof(unsigned long)); */
 
-       printf("%10.2f M bytes/sec collected.\n", gc_rate);
+#if 0
+    /* see comment above about mprotecting oldspace */
+
+    /* zero the from space now, to make it easier to find stale
+       pointers to it */
+
+    /* pray that both dynamic spaces are the same size ... */
+    memset(from_space,(DYNAMIC_0_SPACE_END-DYNAMIC_0_SPACE_START-1),0);
+    os_protect(from_space,DYNAMIC_SPACE_SIZE,0); /* write-protect */
 #endif
 }
 
@@ -376,74 +404,74 @@ struct timeval start_tv, stop_tv;
 static void
 scavenge(lispobj *start, u32 nwords)
 {
-       while (nwords > 0) {
-               lispobj object;
-               int type, words_scavenged;
+    while (nwords > 0) {
+       lispobj object;
+       int type, words_scavenged;
 
-               object = *start;
-               type = TypeOf(object);
+       object = *start;
+       type = widetag_of(object);
 
 #if defined(DEBUG_SCAVENGE_VERBOSE)
-               fprintf(stderr,"Scavenging object at 0x%08x, object = 0x%08x, type = %d\n",
-                      (unsigned long) start, (unsigned long) object, type);
-#endif
-
-                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 *)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;
-                        }
-                        else {
-                            /* Scavenge that pointer. */
-                            words_scavenged = (scavtab[type])(start, object);
-                        }
-                    }
-                    else {
-                        /* It points somewhere other than oldspace.  Leave */
-                        /* it alone. */
-                        words_scavenged = 1;
-                    }
-                }
-               else if(nwords==1) {
-                   /* there are some situations where an
-                      other-immediate may end up in a descriptor
-                      register.  I'm not sure whether this is
-                      supposed to happen, but if it does then we
-                      don't want to (a) barf or (b) scavenge over the
-                      data-block, because there isn't one.  So, if
-                      we're checking a single word and it's anything
-                      other than a pointer, just hush it up */
-
-                   words_scavenged=1;
-                   if((scavtab[type]==scav_lose) ||
-                      (((scavtab[type])(start,object))>1)) {
-                       fprintf(stderr,"warning: attempted to scavenge non-descriptor value %x at %p.  If you can\nreproduce this warning, send a test case to sbcl-devel@lists.sourceforge.net\n",
-                               object,start);
-                   }
+       fprintf(stderr,"Scavenging object at 0x%08x, object = 0x%08x, type = %d\n",
+               (unsigned long) start, (unsigned long) object, type);
+#endif
+
+       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 *)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;
+               }
+               else {
+                   /* Scavenge that pointer. */
+                   words_scavenged = (scavtab[type])(start, object);
                }
-                else if ((object & 3) == 0) {
-                    /* It's a fixnum.  Real easy. */
-                    words_scavenged = 1;
-                }
-                else {
-                    /* It's some random header object. */
-                    words_scavenged = (scavtab[type])(start, object);
-
-                }
-
-               start += words_scavenged;
-               nwords -= words_scavenged;
+           }
+           else {
+               /* It points somewhere other than oldspace.  Leave */
+               /* it alone. */
+               words_scavenged = 1;
+           }
        }
-       gc_assert(nwords == 0);
+       else if (nwords==1) {
+           /* there are some situations where an
+              other-immediate may end up in a descriptor
+              register.  I'm not sure whether this is
+              supposed to happen, but if it does then we
+              don't want to (a) barf or (b) scavenge over the
+              data-block, because there isn't one.  So, if
+              we're checking a single word and it's anything
+              other than a pointer, just hush it up */
+
+           words_scavenged=1;
+           if ((scavtab[type]==scav_lose) ||
+               (((scavtab[type])(start,object))>1)) {
+               fprintf(stderr,"warning: attempted to scavenge non-descriptor value %x at %p.  If you can\nreproduce this warning, send a test case to sbcl-devel@lists.sourceforge.net\n",
+                       object,start);
+           }
+       }
+       else if ((object & 3) == 0) {
+           /* It's a fixnum.  Real easy. */
+           words_scavenged = 1;
+       }
+       else {
+           /* It's some random header object. */
+           words_scavenged = (scavtab[type])(start, object);
+
+       }
+
+       start += words_scavenged;
+       nwords -= words_scavenged;
+    }
+    gc_assert(nwords == 0);
 }
 
 static void
@@ -469,81 +497,104 @@ static int boxed_registers[] = BOXED_REGISTERS;
 static void
 scavenge_interrupt_context(os_context_t *context)
 {
-       int i;
+    int i;
 #ifdef reg_LIP
-       unsigned long lip;
-       unsigned long lip_offset;
-       int lip_register_pair;
+    unsigned long lip;
+    unsigned long lip_offset;
+    int lip_register_pair;
 #endif
-       unsigned long pc_code_offset;
-#ifdef SC_NPC
-       unsigned long npc_code_offset;
+    unsigned long pc_code_offset;
+#ifdef ARCH_HAS_LINK_REGISTER
+    unsigned long lr_code_offset;
 #endif
-
-       /* Find the LIP's register pair and calculate its offset */
-       /* before we scavenge the context. */
+#ifdef ARCH_HAS_NPC_REGISTER
+    unsigned long npc_code_offset;
+#endif
+#ifdef DEBUG_SCAVENGE_VERBOSE
+    fprintf(stderr, "Scavenging interrupt context at 0x%x\n",context);
+#endif
+    /* Find the LIP's register pair and calculate its offset */
+    /* before we scavenge the context. */
 #ifdef reg_LIP
-       lip = *os_context_register_addr(context, reg_LIP);
-       /*  0x7FFFFFFF or 0x7FFFFFFFFFFFFFFF ? */
-       lip_offset = 0x7FFFFFFF;
-       lip_register_pair = -1;
-       for (i = 0; i < (sizeof(boxed_registers) / sizeof(int)); i++) {
-               unsigned long reg;
-               long offset;
-               int index;
-
-               index = boxed_registers[i];
-               reg = *os_context_register_addr(context, index);
-               /* would be using PTR if not for integer length issues */
-               if ((reg & ~((1L<<lowtag_Bits)-1)) <= lip) {
-                       offset = lip - reg;
-                       if (offset < lip_offset) {
-                               lip_offset = offset;
-                               lip_register_pair = index;
-                       }
-               }
+    lip = *os_context_register_addr(context, reg_LIP);
+    /*  0x7FFFFFFF or 0x7FFFFFFFFFFFFFFF ? */
+    lip_offset = 0x7FFFFFFF;
+    lip_register_pair = -1;
+    for (i = 0; i < (sizeof(boxed_registers) / sizeof(int)); i++) {
+       unsigned long reg;
+       long offset;
+       int index;
+
+       index = boxed_registers[i];
+       reg = *os_context_register_addr(context, index);
+       /* would be using PTR if not for integer length issues */
+       if ((reg & ~((1L<<N_LOWTAG_BITS)-1)) <= lip) {
+           offset = lip - reg;
+           if (offset < lip_offset) {
+               lip_offset = offset;
+               lip_register_pair = index;
+           }
        }
-#endif reg_LIP
-
-       /* Compute the PC's offset from the start of the CODE */
-       /* register. */
-       pc_code_offset = *os_context_pc_addr(context) - 
-           *os_context_register_addr(context, reg_CODE);
-#ifdef SC_NPC
-       npc_code_offset = SC_NPC(context) - SC_REG(context, reg_CODE);
-#endif SC_NPC
+    }
+#endif /* reg_LIP */
+
+    /* Compute the PC's offset from the start of the CODE */
+    /* register. */
+    pc_code_offset =
+       *os_context_pc_addr(context) - 
+       *os_context_register_addr(context, reg_CODE);
+#ifdef ARCH_HAS_NPC_REGISTER
+    npc_code_offset =
+       *os_context_npc_addr(context) - 
+       *os_context_register_addr(context, reg_CODE);
+#endif 
+#ifdef ARCH_HAS_LINK_REGISTER
+    lr_code_offset =
+       *os_context_lr_addr(context) - 
+       *os_context_register_addr(context, reg_CODE);
+#endif
               
-       /* Scanvenge all boxed registers in the context. */
-       for (i = 0; i < (sizeof(boxed_registers) / sizeof(int)); i++) {
-               int index;
-               lispobj foo;
+    /* Scavenge all boxed registers in the context. */
+    for (i = 0; i < (sizeof(boxed_registers) / sizeof(int)); i++) {
+       int index;
+       lispobj foo;
                
-               index = boxed_registers[i];
-                foo = *os_context_register_addr(context,index);
-                scavenge((lispobj *) &foo, 1);
-                *os_context_register_addr(context,index) = foo;
+       index = boxed_registers[i];
+       foo = *os_context_register_addr(context,index);
+       scavenge((lispobj *) &foo, 1);
+       *os_context_register_addr(context,index) = foo;
 
-               /* this is unlikely to work as intended on bigendian
-                * 64 bit platforms */
+       /* this is unlikely to work as intended on bigendian
+        * 64 bit platforms */
 
-               scavenge((lispobj *)
-                        os_context_register_addr(context, index), 1);
-       }
+       scavenge((lispobj *)
+                os_context_register_addr(context, index), 1);
+    }
 
 #ifdef reg_LIP
-       /* Fix the LIP */
-       *os_context_register_addr(context, reg_LIP) =
-           *os_context_register_addr(context, lip_register_pair) + lip_offset;
-#endif reg_LIP
+    /* Fix the LIP */
+    *os_context_register_addr(context, reg_LIP) =
+       *os_context_register_addr(context, lip_register_pair) + lip_offset;
+#endif /* reg_LIP */
        
-       /* Fix the PC if it was in from space */
-       if (from_space_p(*os_context_pc_addr(context)))
-           *os_context_pc_addr(context) = 
-               *os_context_register_addr(context, reg_CODE) + pc_code_offset;
-#ifdef SC_NPC
-       if (from_space_p(SC_NPC(context)))
-               SC_NPC(context) = SC_REG(context, reg_CODE) + npc_code_offset;
-#endif SC_NPC
+    /* Fix the PC if it was in from space */
+    if (from_space_p(*os_context_pc_addr(context)))
+       *os_context_pc_addr(context) = 
+           *os_context_register_addr(context, reg_CODE) + pc_code_offset;
+#ifdef ARCH_HAS_LINK_REGISTER
+    /* Fix the LR ditto; important if we're being called from 
+     * an assembly routine that expects to return using blr, otherwise
+     * harmless */
+    if (from_space_p(*os_context_lr_addr(context)))
+       *os_context_lr_addr(context) = 
+           *os_context_register_addr(context, reg_CODE) + lr_code_offset;
+#endif
+
+#ifdef ARCH_HAS_NPC_REGISTER
+    if (from_space_p(*os_context_npc_addr(context)))
+       *os_context_npc_addr(context) = 
+           *os_context_register_addr(context, reg_CODE) + npc_code_offset;
+#endif
 }
 
 void scavenge_interrupt_contexts(void)
@@ -553,6 +604,9 @@ void scavenge_interrupt_contexts(void)
 
     index = fixnum_value(SymbolValue(FREE_INTERRUPT_CONTEXT_INDEX));
 
+#ifdef DEBUG_SCAVENGE_VERBOSE
+    fprintf(stderr, "%d interrupt contexts to scan\n",index);
+#endif
     for (i = 0; i < index; i++) {
        context = lisp_interrupt_contexts[i];
        scavenge_interrupt_context(context); 
@@ -565,65 +619,63 @@ void scavenge_interrupt_contexts(void)
 void
 print_garbage(lispobj *from_space, lispobj *from_space_free_pointer)
 {
-       lispobj *start;
-       int total_words_not_copied;
-
-       printf("Scanning from space ...\n");
-
-       total_words_not_copied = 0;
-       start = from_space;
-       while (start < from_space_free_pointer) {
-               lispobj object;
-               int forwardp, type, nwords;
-               lispobj header;
-
-               object = *start;
-               forwardp = is_lisp_pointer(object) && new_space_p(object);
-
-               if (forwardp) {
-                       int tag;
-                       lispobj *pointer;
-
-                       tag = LowtagOf(object);
-
-                       switch (tag) {
-                       case type_ListPointer:
-                               nwords = 2;
-                               break;
-                       case type_InstancePointer:
-                               printf("Don't know about instances yet!\n");
-                               nwords = 1;
-                               break;
-                       case type_FunPointer:
-                               nwords = 1;
-                               break;
-                       case type_OtherPointer:
-                               pointer = (lispobj *) native_pointer(object);
-                               header = *pointer;
-                               type = TypeOf(header);
-                               nwords = (sizetab[type])(pointer);
-                       }
-               } else {
-                       type = TypeOf(object);
-                       nwords = (sizetab[type])(start);
-                       total_words_not_copied += nwords;
-                       printf("%4d words not copied at 0x%16lx; ",
-                              nwords, (unsigned long) start);
-                       printf("Header word is 0x%08x\n", 
-                              (unsigned int) object);
-               }
-               start += nwords;
+    lispobj *start;
+    int total_words_not_copied;
+
+    printf("Scanning from space ...\n");
+
+    total_words_not_copied = 0;
+    start = from_space;
+    while (start < from_space_free_pointer) {
+       lispobj object;
+       int forwardp, type, nwords;
+       lispobj header;
+
+       object = *start;
+       forwardp = is_lisp_pointer(object) && new_space_p(object);
+
+       if (forwardp) {
+           int tag;
+           lispobj *pointer;
+
+           tag = lowtag_of(object);
+
+           switch (tag) {
+           case LIST_POINTER_LOWTAG:
+               nwords = 2;
+               break;
+           case INSTANCE_POINTER_LOWTAG:
+               printf("Don't know about instances yet!\n");
+               nwords = 1;
+               break;
+           case FUN_POINTER_LOWTAG:
+               nwords = 1;
+               break;
+           case OTHER_POINTER_LOWTAG:
+               pointer = (lispobj *) native_pointer(object);
+               header = *pointer;
+               type = widetag_of(header);
+               nwords = (sizetab[type])(pointer);
+           }
+       } else {
+           type = widetag_of(object);
+           nwords = (sizetab[type])(start);
+           total_words_not_copied += nwords;
+           printf("%4d words not copied at 0x%16lx; ",
+                  nwords, (unsigned long) start);
+           printf("Header word is 0x%08x\n", 
+                  (unsigned int) object);
        }
-       printf("%d total words not copied.\n", total_words_not_copied);
+       start += nwords;
+    }
+    printf("%d total words not copied.\n", total_words_not_copied);
 }
 
 \f
 /* code and code-related objects */
 
-/* FIXME: (1) Shouldn't this be defined in sbcl.h? (2) Shouldn't it
- * be in the same units as FDEFN_RAW_ADDR_OFFSET? (This is measured
- * in words, that's measured in bytes. Gotta love CMU CL..) */
-#define FUN_RAW_ADDR_OFFSET (6*sizeof(lispobj) - type_FunPointer)
+/* FIXME: Shouldn't this be defined in sbcl.h? */
+#define FUN_RAW_ADDR_OFFSET (6*sizeof(lispobj) - FUN_POINTER_LOWTAG)
 
 static lispobj trans_fun_header(lispobj object);
 static lispobj trans_boxed(lispobj object);
@@ -631,198 +683,198 @@ static lispobj trans_boxed(lispobj object);
 static int
 scav_fun_pointer(lispobj *where, lispobj object)
 {
-  lispobj  *first_pointer;
-  lispobj copy;
-  lispobj first;
-  int type;
+    lispobj  *first_pointer;
+    lispobj copy;
+    lispobj first;
+    int type;
 
-  gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
       
-  /* object is a pointer into from space. Not a FP */
-  first_pointer = (lispobj *) native_pointer(object);
-  first = *first_pointer;
+    /* object is a pointer into from space. Not a FP */
+    first_pointer = (lispobj *) native_pointer(object);
+    first = *first_pointer;
                
-  /* must transport object -- object may point */
-  /* to either a function header, a closure */
-  /* function header, or to a closure header. */
+    /* 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_SimpleFunHeader:
-  case type_ClosureFunHeader:
-    copy = trans_fun_header(object);
-    break;
-  default:
-    copy = trans_boxed(object);
-    break;
-  }
+    type = widetag_of(first);
+    switch (type) {
+    case SIMPLE_FUN_HEADER_WIDETAG:
+    case CLOSURE_FUN_HEADER_WIDETAG:
+       copy = trans_fun_header(object);
+       break;
+    default:
+       copy = trans_boxed(object);
+       break;
+    }
   
-  first = *first_pointer = copy;
+    first = *first_pointer = copy;
 
-  gc_assert(is_lisp_pointer(first));
-  gc_assert(!from_space_p(first));
+    gc_assert(is_lisp_pointer(first));
+    gc_assert(!from_space_p(first));
 
-  *where = first;
-  return 1;
+    *where = first;
+    return 1;
 }
 
 static struct code *
 trans_code(struct code *code)
 {
-       struct code *new_code;
-       lispobj first, l_code, l_new_code;
-       int nheader_words, ncode_words, nwords;
-       unsigned long displacement;
-       lispobj fheaderl, *prev_pointer;
+    struct code *new_code;
+    lispobj first, l_code, l_new_code;
+    int nheader_words, ncode_words, nwords;
+    unsigned long displacement;
+    lispobj fheaderl, *prev_pointer;
 
 #if defined(DEBUG_CODE_GC)
-       printf("\nTransporting code object located at 0x%08x.\n",
-              (unsigned long) code);
+    printf("\nTransporting code object located at 0x%08x.\n",
+          (unsigned long) code);
 #endif
 
-       /* if object has already been transported, just return pointer */
-       first = code->header;
-       if (is_lisp_pointer(first) && new_space_p(first)) {
+    /* if object has already been transported, just return pointer */
+    first = code->header;
+    if (is_lisp_pointer(first) && new_space_p(first)) {
 #ifdef DEBUG_CODE_GC
-           printf("Was already transported\n");
+       printf("Was already transported\n");
 #endif
-           return (struct code *) native_pointer(first);
-       }
+       return (struct code *) native_pointer(first);
+    }
        
-       gc_assert(TypeOf(first) == type_CodeHeader);
+    gc_assert(widetag_of(first) == CODE_HEADER_WIDETAG);
 
-       /* prepare to transport the code vector */
-       l_code = (lispobj) LOW_WORD(code) | type_OtherPointer;
+    /* prepare to transport the code vector */
+    l_code = (lispobj) LOW_WORD(code) | OTHER_POINTER_LOWTAG;
 
-       ncode_words = fixnum_value(code->code_size);
-       nheader_words = HeaderValue(code->header);
-       nwords = ncode_words + nheader_words;
-       nwords = CEILING(nwords, 2);
+    ncode_words = fixnum_value(code->code_size);
+    nheader_words = HeaderValue(code->header);
+    nwords = ncode_words + nheader_words;
+    nwords = CEILING(nwords, 2);
 
-       l_new_code = copy_object(l_code, nwords);
-       new_code = (struct code *) native_pointer(l_new_code);
+    l_new_code = copy_object(l_code, nwords);
+    new_code = (struct code *) native_pointer(l_new_code);
 
-       displacement = l_new_code - l_code;
+    displacement = l_new_code - l_code;
 
 #if defined(DEBUG_CODE_GC)
-       printf("Old code object at 0x%08x, new code object at 0x%08x.\n",
-              (unsigned long) code, (unsigned long) new_code);
-       printf("Code object is %d words long.\n", nwords);
+    printf("Old code object at 0x%08x, new code object at 0x%08x.\n",
+          (unsigned long) code, (unsigned long) new_code);
+    printf("Code object is %d words long.\n", nwords);
 #endif
 
-       /* set forwarding pointer */
-       code->header = l_new_code;
+    /* set forwarding pointer */
+    code->header = l_new_code;
        
-       /* set forwarding pointers for all the function headers in the */
-       /* code object.  also fix all self pointers */
+    /* set forwarding pointers for all the function headers in the */
+    /* code object.  also fix all self pointers */
 
-       fheaderl = code->entry_points;
-       prev_pointer = &new_code->entry_points;
+    fheaderl = code->entry_points;
+    prev_pointer = &new_code->entry_points;
 
-       while (fheaderl != NIL) {
-               struct simple_fun *fheaderp, *nfheaderp;
-               lispobj nfheaderl;
+    while (fheaderl != NIL) {
+       struct simple_fun *fheaderp, *nfheaderp;
+       lispobj nfheaderl;
                
-               fheaderp = (struct simple_fun *) native_pointer(fheaderl);
-               gc_assert(TypeOf(fheaderp->header) == type_SimpleFunHeader);
+       fheaderp = (struct simple_fun *) native_pointer(fheaderl);
+       gc_assert(widetag_of(fheaderp->header) == SIMPLE_FUN_HEADER_WIDETAG);
 
-               /* calcuate the new function pointer and the new */
-               /* function header */
-               nfheaderl = fheaderl + displacement;
-               nfheaderp = (struct simple_fun *) native_pointer(nfheaderl);
+       /* Calculate the new function pointer and the new */
+       /* function header. */
+       nfheaderl = fheaderl + displacement;
+       nfheaderp = (struct simple_fun *) native_pointer(nfheaderl);
 
-               /* set forwarding pointer */
+       /* set forwarding pointer */
 #ifdef DEBUG_CODE_GC
-               printf("fheaderp->header (at %x) <- %x\n",
-                      &(fheaderp->header) , nfheaderl);
+       printf("fheaderp->header (at %x) <- %x\n",
+              &(fheaderp->header) , nfheaderl);
 #endif
-               fheaderp->header = nfheaderl;
+       fheaderp->header = nfheaderl;
                
-               /* fix self pointer */
-               nfheaderp->self = nfheaderl;
+       /* fix self pointer */
+       nfheaderp->self = nfheaderl;
 
-               *prev_pointer = nfheaderl;
+       *prev_pointer = nfheaderl;
 
-               fheaderl = fheaderp->next;
-               prev_pointer = &nfheaderp->next;
-       }
+       fheaderl = fheaderp->next;
+       prev_pointer = &nfheaderp->next;
+    }
 
 #ifndef MACH
-        os_flush_icache((os_vm_address_t) (((int *)new_code) + nheader_words),
-                       ncode_words * sizeof(int));
+    os_flush_icache((os_vm_address_t) (((int *)new_code) + nheader_words),
+                   ncode_words * sizeof(int));
 #endif
-       return new_code;
+    return new_code;
 }
 
 static int
 scav_code_header(lispobj *where, lispobj object)
 {
-       struct code *code;
-       int nheader_words, ncode_words, nwords;
-       lispobj fheaderl;
-       struct simple_fun *fheaderp;
+    struct code *code;
+    int nheader_words, ncode_words, nwords;
+    lispobj fheaderl;
+    struct simple_fun *fheaderp;
 
-       code = (struct code *) where;
-       ncode_words = fixnum_value(code->code_size);
-       nheader_words = HeaderValue(object);
-       nwords = ncode_words + nheader_words;
-       nwords = CEILING(nwords, 2);
+    code = (struct code *) where;
+    ncode_words = fixnum_value(code->code_size);
+    nheader_words = HeaderValue(object);
+    nwords = ncode_words + nheader_words;
+    nwords = CEILING(nwords, 2);
 
 #if defined(DEBUG_CODE_GC)
-       printf("\nScavening code object at 0x%08x.\n",
-              (unsigned long) where);
-       printf("Code object is %d words long.\n", nwords);
-       printf("Scavenging boxed section of code data block (%d words).\n",
-              nheader_words - 1);
-#endif
-
-       /* Scavenge the boxed section of the code data block */
-       scavenge(where + 1, nheader_words - 1);
-
-       /* Scavenge the boxed section of each function object in the */
-       /* code data block */
-       fheaderl = code->entry_points;
-       while (fheaderl != NIL) {
-               fheaderp = (struct simple_fun *) native_pointer(fheaderl);
-               gc_assert(TypeOf(fheaderp->header) == type_SimpleFunHeader);
+    printf("\nScavening code object at 0x%08x.\n",
+          (unsigned long) where);
+    printf("Code object is %d words long.\n", nwords);
+    printf("Scavenging boxed section of code data block (%d words).\n",
+          nheader_words - 1);
+#endif
+
+    /* Scavenge the boxed section of the code data block */
+    scavenge(where + 1, nheader_words - 1);
+
+    /* Scavenge the boxed section of each function object in the */
+    /* code data block */
+    fheaderl = code->entry_points;
+    while (fheaderl != NIL) {
+       fheaderp = (struct simple_fun *) native_pointer(fheaderl);
+       gc_assert(widetag_of(fheaderp->header) == SIMPLE_FUN_HEADER_WIDETAG);
                
 #if defined(DEBUG_CODE_GC)
-               printf("Scavenging boxed section of entry point located at 0x%08x.\n",
-                      (unsigned long) native_pointer(fheaderl));
+       printf("Scavenging boxed section of entry point located at 0x%08x.\n",
+              (unsigned long) native_pointer(fheaderl));
 #endif
-               scavenge(&fheaderp->name, 1);
-               scavenge(&fheaderp->arglist, 1);
-               scavenge(&fheaderp->type, 1);
+       scavenge(&fheaderp->name, 1);
+       scavenge(&fheaderp->arglist, 1);
+       scavenge(&fheaderp->type, 1);
                
-               fheaderl = fheaderp->next;
-       }
+       fheaderl = fheaderp->next;
+    }
        
-       return nwords;
+    return nwords;
 }
 
 static lispobj
 trans_code_header(lispobj object)
 {
-       struct code *ncode;
+    struct code *ncode;
 
-       ncode = trans_code((struct code *) native_pointer(object));
-       return (lispobj) LOW_WORD(ncode) | type_OtherPointer;
+    ncode = trans_code((struct code *) native_pointer(object));
+    return (lispobj) LOW_WORD(ncode) | OTHER_POINTER_LOWTAG;
 }
 
 static int
 size_code_header(lispobj *where)
 {
-       struct code *code;
-       int nheader_words, ncode_words, nwords;
+    struct code *code;
+    int nheader_words, ncode_words, nwords;
 
-       code = (struct code *) where;
+    code = (struct code *) where;
        
-       ncode_words = fixnum_value(code->code_size);
-       nheader_words = HeaderValue(code->header);
-       nwords = ncode_words + nheader_words;
-       nwords = CEILING(nwords, 2);
+    ncode_words = fixnum_value(code->code_size);
+    nheader_words = HeaderValue(code->header);
+    nwords = ncode_words + nheader_words;
+    nwords = CEILING(nwords, 2);
 
-       return nwords;
+    return nwords;
 }
 
 
@@ -839,27 +891,27 @@ scav_return_pc_header(lispobj *where, lispobj object)
 static lispobj
 trans_return_pc_header(lispobj object)
 {
-       struct simple_fun *return_pc;
-       unsigned long offset;
-       struct code *code, *ncode;
-       lispobj ret;
-       return_pc = (struct simple_fun *) native_pointer(object);
-       offset = HeaderValue(return_pc->header)  * 4 ;
+    struct simple_fun *return_pc;
+    unsigned long offset;
+    struct code *code, *ncode;
+    lispobj ret;
+    return_pc = (struct simple_fun *) native_pointer(object);
+    offset = HeaderValue(return_pc->header)  * 4 ;
 
-       /* Transport the whole code object */
-       code = (struct code *) ((unsigned long) return_pc - offset);
+    /* Transport the whole code object */
+    code = (struct code *) ((unsigned long) return_pc - offset);
 #ifdef DEBUG_CODE_GC
-       printf("trans_return_pc_header object=%x, code=%lx\n",object,code);
+    printf("trans_return_pc_header object=%x, code=%lx\n",object,code);
 #endif
-       ncode = trans_code(code);
-       if(object==0x304748d7) {
-           /* monitor_or_something(); */
-       }
-       ret= ((lispobj) LOW_WORD(ncode) + offset) | type_OtherPointer;
+    ncode = trans_code(code);
+    if (object==0x304748d7) {
+       /* monitor_or_something(); */
+    }
+    ret= ((lispobj) LOW_WORD(ncode) + offset) | OTHER_POINTER_LOWTAG;
 #ifdef DEBUG_CODE_GC
-       printf("trans_return_pc_header returning %x\n",ret);
+    printf("trans_return_pc_header returning %x\n",ret);
 #endif
-       return ret;
+    return ret;
 }
 
 /* On the 386, closures hold a pointer to the raw address instead of
@@ -872,14 +924,14 @@ static
 scav_closure_header(where, object)
 lispobj *where, object;
 {
-       struct closure *closure;
-       lispobj fun;
+    struct closure *closure;
+    lispobj fun;
 
-       closure = (struct closure *)where;
-       fun = closure->fun - FUN_RAW_ADDR_OFFSET;
-       scavenge(&fun, 1);
+    closure = (struct closure *)where;
+    fun = closure->fun - FUN_RAW_ADDR_OFFSET;
+    scavenge(&fun, 1);
 
-       return 2;
+    return 2;
 }
 #endif
 
@@ -897,18 +949,18 @@ scav_fun_header(lispobj *where, lispobj object)
 static lispobj
 trans_fun_header(lispobj object)
 {
-       struct simple_fun *fheader;
-       unsigned long offset;
-       struct code *code, *ncode;
+    struct simple_fun *fheader;
+    unsigned long offset;
+    struct code *code, *ncode;
        
-       fheader = (struct simple_fun *) native_pointer(object);
-       offset = HeaderValue(fheader->header) * 4;
+    fheader = (struct simple_fun *) native_pointer(object);
+    offset = HeaderValue(fheader->header) * 4;
 
-       /* Transport the whole code object */
-       code = (struct code *) ((unsigned long) fheader - offset);
-       ncode = trans_code(code);
+    /* Transport the whole code object */
+    code = (struct code *) ((unsigned long) fheader - offset);
+    ncode = trans_code(code);
 
-       return ((lispobj) LOW_WORD(ncode) + offset) | type_FunPointer;
+    return ((lispobj) LOW_WORD(ncode) + offset) | FUN_POINTER_LOWTAG;
 }
 
 
@@ -918,13 +970,13 @@ trans_fun_header(lispobj object)
 static int
 scav_instance_pointer(lispobj *where, lispobj object)
 {
-  lispobj  *first_pointer;
+    lispobj  *first_pointer;
   
-  /* object is a pointer into from space.  Not a FP */
-  first_pointer = (lispobj *) native_pointer(object);
+    /* object is a pointer into from space.  Not a FP */
+    first_pointer = (lispobj *) native_pointer(object);
   
-  *where = *first_pointer = trans_boxed(object);
-  return 1;
+    *where = *first_pointer = trans_boxed(object);
+    return 1;
 }
 
 \f
@@ -935,71 +987,71 @@ static lispobj trans_list(lispobj object);
 static int
 scav_list_pointer(lispobj *where, lispobj object)
 {
-  lispobj first, *first_pointer;
+    lispobj first, *first_pointer;
 
-  gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-  /* object is a pointer into from space.  Not a FP. */
-  first_pointer = (lispobj *) native_pointer(object);
+    /* object is a pointer into from space.  Not a FP. */
+    first_pointer = (lispobj *) native_pointer(object);
   
-  first = *first_pointer = trans_list(object);
+    first = *first_pointer = trans_list(object);
   
-  gc_assert(is_lisp_pointer(first));
-  gc_assert(!from_space_p(first));
+    gc_assert(is_lisp_pointer(first));
+    gc_assert(!from_space_p(first));
   
-  *where = first;
-  return 1;
+    *where = first;
+    return 1;
 }
 
 static lispobj
 trans_list(lispobj object)
 {
-       lispobj new_list_pointer;
-       struct cons *cons, *new_cons;
+    lispobj new_list_pointer;
+    struct cons *cons, *new_cons;
        
-       cons = (struct cons *) native_pointer(object);
+    cons = (struct cons *) native_pointer(object);
 
-       /* ### Don't use copy_object here. */
-       new_list_pointer = copy_object(object, 2);
-       new_cons = (struct cons *) native_pointer(new_list_pointer);
+    /* ### Don't use copy_object here. */
+    new_list_pointer = copy_object(object, 2);
+    new_cons = (struct cons *) native_pointer(new_list_pointer);
 
-       /* Set forwarding pointer. */
-       cons->car = new_list_pointer;
+    /* Set forwarding pointer. */
+    cons->car = new_list_pointer;
        
-       /* Try to linearize the list in the cdr direction to help reduce */
-       /* paging. */
+    /* Try to linearize the list in the cdr direction to help reduce */
+    /* paging. */
 
-       while (1) {
-               lispobj cdr, new_cdr, first;
-               struct cons *cdr_cons, *new_cdr_cons;
+    while (1) {
+       lispobj cdr, new_cdr, first;
+       struct cons *cdr_cons, *new_cdr_cons;
 
-               cdr = cons->cdr;
+       cdr = cons->cdr;
 
-                if (LowtagOf(cdr) != type_ListPointer ||
-                    !from_space_p(cdr) ||
-                    (is_lisp_pointer(first = *(lispobj *)native_pointer(cdr))
-                    && new_space_p(first)))
-                       break;
+       if (lowtag_of(cdr) != LIST_POINTER_LOWTAG ||
+           !from_space_p(cdr) ||
+           (is_lisp_pointer(first = *(lispobj *)native_pointer(cdr))
+            && new_space_p(first)))
+           break;
 
-               cdr_cons = (struct cons *) native_pointer(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 *) native_pointer(new_cdr);
+       /* ### Don't use copy_object here */
+       new_cdr = copy_object(cdr, 2);
+       new_cdr_cons = (struct cons *) native_pointer(new_cdr);
 
-               /* Set forwarding pointer */
-               cdr_cons->car = new_cdr;
+       /* Set forwarding pointer */
+       cdr_cons->car = new_cdr;
 
-               /* Update the cdr of the last cons copied into new */
-               /* space to keep the newspace scavenge from having to */
-               /* do it. */
-               new_cons->cdr = new_cdr;
+       /* Update the cdr of the last cons copied into new */
+       /* space to keep the newspace scavenge from having to */
+       /* do it. */
+       new_cons->cdr = new_cdr;
                
-               cons = cdr_cons;
-               new_cons = new_cdr_cons;
-       }
+       cons = cdr_cons;
+       new_cons = new_cdr_cons;
+    }
 
-       return new_list_pointer;
+    return new_list_pointer;
 }
 
 \f
@@ -1008,19 +1060,19 @@ trans_list(lispobj object)
 static int
 scav_other_pointer(lispobj *where, lispobj object)
 {
-  lispobj first, *first_pointer;
+    lispobj first, *first_pointer;
 
-  gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-  /* Object is a pointer into from space - not a FP */
-  first_pointer = (lispobj *) native_pointer(object);
-  first = *first_pointer = (transother[TypeOf(*first_pointer)])(object);
+    /* Object is a pointer into from space - not a FP */
+    first_pointer = (lispobj *) native_pointer(object);
+    first = *first_pointer = (transother[widetag_of(*first_pointer)])(object);
 
-  gc_assert(is_lisp_pointer(first));
-  gc_assert(!from_space_p(first));
+    gc_assert(is_lisp_pointer(first));
+    gc_assert(!from_space_p(first));
 
-  *where = first;
-  return 1;
+    *where = first;
+    return 1;
 }
 
 \f
@@ -1062,29 +1114,29 @@ scav_boxed(lispobj *where, lispobj object)
 static lispobj
 trans_boxed(lispobj object)
 {
-       lispobj header;
-       unsigned long length;
+    lispobj header;
+    unsigned long length;
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-       header = *((lispobj *) native_pointer(object));
-       length = HeaderValue(header) + 1;
-       length = CEILING(length, 2);
+    header = *((lispobj *) native_pointer(object));
+    length = HeaderValue(header) + 1;
+    length = CEILING(length, 2);
 
-       return copy_object(object, length);
+    return copy_object(object, length);
 }
 
 static int
 size_boxed(lispobj *where)
 {
-       lispobj header;
-       unsigned long length;
+    lispobj header;
+    unsigned long length;
 
-       header = *where;
-       length = HeaderValue(header) + 1;
-       length = CEILING(length, 2);
+    header = *where;
+    length = HeaderValue(header) + 1;
+    length = CEILING(length, 2);
 
-       return length;
+    return length;
 }
 
 /* Note: on the sparc we don't have to do anything special for fdefns, */
@@ -1112,41 +1164,41 @@ scav_fdefn(lispobj *where, lispobj object)
 static int
 scav_unboxed(lispobj *where, lispobj object)
 {
-       unsigned long length;
+    unsigned long length;
 
-       length = HeaderValue(object) + 1;
-       length = CEILING(length, 2);
+    length = HeaderValue(object) + 1;
+    length = CEILING(length, 2);
 
-       return length;
+    return length;
 }
 
 static lispobj
 trans_unboxed(lispobj object)
 {
-       lispobj header;
-       unsigned long length;
+    lispobj header;
+    unsigned long length;
 
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-       header = *((lispobj *) native_pointer(object));
-       length = HeaderValue(header) + 1;
-       length = CEILING(length, 2);
+    header = *((lispobj *) native_pointer(object));
+    length = HeaderValue(header) + 1;
+    length = CEILING(length, 2);
 
-       return copy_object(object, length);
+    return copy_object(object, length);
 }
 
 static int
 size_unboxed(lispobj *where)
 {
-       lispobj header;
-       unsigned long length;
+    lispobj header;
+    unsigned long length;
 
-       header = *where;
-       length = HeaderValue(header) + 1;
-       length = CEILING(length, 2);
+    header = *where;
+    length = HeaderValue(header) + 1;
+    length = CEILING(length, 2);
 
-       return length;
+    return length;
 }
 
 \f
@@ -1157,58 +1209,60 @@ size_unboxed(lispobj *where)
 static int
 scav_string(lispobj *where, lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       /* NOTE: Strings contain one more byte of data than the length */
-       /* slot indicates. */
+    /* NOTE: Strings contain one more byte of data than the length */
+    /* slot indicates. */
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length) + 1;
-       nwords = CEILING(NWORDS(length, 4) + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length) + 1;
+    nwords = CEILING(NWORDS(length, 4) + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 static lispobj
 trans_string(lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-       /* NOTE: Strings contain one more byte of data than the length */
-       /* slot indicates. */
+    /* NOTE: Strings contain one more byte of data than the length */
+    /* slot indicates. */
 
-       vector = (struct vector *) native_pointer(object);
-       length = fixnum_value(vector->length) + 1;
-       nwords = CEILING(NWORDS(length, 4) + 2, 2);
+    vector = (struct vector *) native_pointer(object);
+    length = fixnum_value(vector->length) + 1;
+    nwords = CEILING(NWORDS(length, 4) + 2, 2);
 
-       return copy_object(object, nwords);
+    return copy_object(object, nwords);
 }
 
 static int
 size_string(lispobj *where)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       /* NOTE: Strings contain one more byte of data than the length */
-       /* slot indicates. */
+    /* NOTE: Strings contain one more byte of data than the length */
+    /* slot indicates. */
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length) + 1;
-       nwords = CEILING(NWORDS(length, 4) + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length) + 1;
+    nwords = CEILING(NWORDS(length, 4) + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 static int
 scav_vector(lispobj *where, lispobj object)
 {
-    if (HeaderValue(object) == subtype_VectorValidHashing)
-        *where = (subtype_VectorMustRehash<<type_Bits) | type_SimpleVector;
+    if (HeaderValue(object) == subtype_VectorValidHashing) {
+        *where =
+           (subtype_VectorMustRehash<<N_WIDETAG_BITS) | SIMPLE_VECTOR_WIDETAG;
+    }
 
     return 1;
 }
@@ -1217,551 +1271,550 @@ scav_vector(lispobj *where, lispobj object)
 static lispobj
 trans_vector(lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-       vector = (struct vector *) native_pointer(object);
+    vector = (struct vector *) native_pointer(object);
 
-       length = fixnum_value(vector->length);
-       nwords = CEILING(length + 2, 2);
+    length = fixnum_value(vector->length);
+    nwords = CEILING(length + 2, 2);
 
-       return copy_object(object, nwords);
+    return copy_object(object, nwords);
 }
 
 static int
 size_vector(lispobj *where)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(length + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(length + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 
 static int
 scav_vector_bit(lispobj *where, lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(NWORDS(length, 32) + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(NWORDS(length, 32) + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 static lispobj
 trans_vector_bit(lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-       vector = (struct vector *) native_pointer(object);
-       length = fixnum_value(vector->length);
-       nwords = CEILING(NWORDS(length, 32) + 2, 2);
+    vector = (struct vector *) native_pointer(object);
+    length = fixnum_value(vector->length);
+    nwords = CEILING(NWORDS(length, 32) + 2, 2);
 
-       return copy_object(object, nwords);
+    return copy_object(object, nwords);
 }
 
 static int
 size_vector_bit(lispobj *where)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(NWORDS(length, 32) + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(NWORDS(length, 32) + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 
 static int
 scav_vector_unsigned_byte_2(lispobj *where, lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(NWORDS(length, 16) + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(NWORDS(length, 16) + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 static lispobj
 trans_vector_unsigned_byte_2(lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-       vector = (struct vector *) native_pointer(object);
-       length = fixnum_value(vector->length);
-       nwords = CEILING(NWORDS(length, 16) + 2, 2);
+    vector = (struct vector *) native_pointer(object);
+    length = fixnum_value(vector->length);
+    nwords = CEILING(NWORDS(length, 16) + 2, 2);
 
-       return copy_object(object, nwords);
+    return copy_object(object, nwords);
 }
 
 static int
 size_vector_unsigned_byte_2(lispobj *where)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(NWORDS(length, 16) + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(NWORDS(length, 16) + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 
 static int
 scav_vector_unsigned_byte_4(lispobj *where, lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(NWORDS(length, 8) + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(NWORDS(length, 8) + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 static lispobj
 trans_vector_unsigned_byte_4(lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-       vector = (struct vector *) native_pointer(object);
-       length = fixnum_value(vector->length);
-       nwords = CEILING(NWORDS(length, 8) + 2, 2);
+    vector = (struct vector *) native_pointer(object);
+    length = fixnum_value(vector->length);
+    nwords = CEILING(NWORDS(length, 8) + 2, 2);
 
-       return copy_object(object, nwords);
+    return copy_object(object, nwords);
 }
 
 static int
 size_vector_unsigned_byte_4(lispobj *where)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(NWORDS(length, 8) + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(NWORDS(length, 8) + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 
 static int
 scav_vector_unsigned_byte_8(lispobj *where, lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(NWORDS(length, 4) + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(NWORDS(length, 4) + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 static lispobj
 trans_vector_unsigned_byte_8(lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-       vector = (struct vector *) native_pointer(object);
-       length = fixnum_value(vector->length);
-       nwords = CEILING(NWORDS(length, 4) + 2, 2);
+    vector = (struct vector *) native_pointer(object);
+    length = fixnum_value(vector->length);
+    nwords = CEILING(NWORDS(length, 4) + 2, 2);
 
-       return copy_object(object, nwords);
+    return copy_object(object, nwords);
 }
 
 static int
 size_vector_unsigned_byte_8(lispobj *where)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(NWORDS(length, 4) + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(NWORDS(length, 4) + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 
 static int
 scav_vector_unsigned_byte_16(lispobj *where, lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(NWORDS(length, 2) + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(NWORDS(length, 2) + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 static lispobj
 trans_vector_unsigned_byte_16(lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-       vector = (struct vector *) native_pointer(object);
-       length = fixnum_value(vector->length);
-       nwords = CEILING(NWORDS(length, 2) + 2, 2);
+    vector = (struct vector *) native_pointer(object);
+    length = fixnum_value(vector->length);
+    nwords = CEILING(NWORDS(length, 2) + 2, 2);
 
-       return copy_object(object, nwords);
+    return copy_object(object, nwords);
 }
 
 static int
 size_vector_unsigned_byte_16(lispobj *where)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(NWORDS(length, 2) + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(NWORDS(length, 2) + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 
 static int
 scav_vector_unsigned_byte_32(lispobj *where, lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(length + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(length + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 static lispobj
 trans_vector_unsigned_byte_32(lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-       vector = (struct vector *) native_pointer(object);
-       length = fixnum_value(vector->length);
-       nwords = CEILING(length + 2, 2);
+    vector = (struct vector *) native_pointer(object);
+    length = fixnum_value(vector->length);
+    nwords = CEILING(length + 2, 2);
 
-       return copy_object(object, nwords);
+    return copy_object(object, nwords);
 }
 
 static int
 size_vector_unsigned_byte_32(lispobj *where)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(length + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(length + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
-
 static int
 scav_vector_single_float(lispobj *where, lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(length + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(length + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 static lispobj
 trans_vector_single_float(lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-       vector = (struct vector *) native_pointer(object);
-       length = fixnum_value(vector->length);
-       nwords = CEILING(length + 2, 2);
+    vector = (struct vector *) native_pointer(object);
+    length = fixnum_value(vector->length);
+    nwords = CEILING(length + 2, 2);
 
-       return copy_object(object, nwords);
+    return copy_object(object, nwords);
 }
 
 static int
 size_vector_single_float(lispobj *where)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(length + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(length + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 
 static int
 scav_vector_double_float(lispobj *where, lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(length * 2 + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(length * 2 + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 static lispobj
 trans_vector_double_float(lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-       vector = (struct vector *) native_pointer(object);
-       length = fixnum_value(vector->length);
-       nwords = CEILING(length * 2 + 2, 2);
+    vector = (struct vector *) native_pointer(object);
+    length = fixnum_value(vector->length);
+    nwords = CEILING(length * 2 + 2, 2);
 
-       return copy_object(object, nwords);
+    return copy_object(object, nwords);
 }
 
 static int
 size_vector_double_float(lispobj *where)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(length * 2 + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(length * 2 + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 
-#ifdef type_SimpleArrayLongFloat
+#ifdef SIMPLE_ARRAY_LONG_FLOAT_WIDETAG
 static int
 scav_vector_long_float(lispobj *where, lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
 #ifdef sparc
-       nwords = CEILING(length * 4 + 2, 2);
+    nwords = CEILING(length * 4 + 2, 2);
 #endif
 
-       return nwords;
+    return nwords;
 }
 
 static lispobj
 trans_vector_long_float(lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-       vector = (struct vector *) native_pointer(object);
-       length = fixnum_value(vector->length);
+    vector = (struct vector *) native_pointer(object);
+    length = fixnum_value(vector->length);
 #ifdef sparc
-       nwords = CEILING(length * 4 + 2, 2);
+    nwords = CEILING(length * 4 + 2, 2);
 #endif
 
-       return copy_object(object, nwords);
+    return copy_object(object, nwords);
 }
 
 static int
 size_vector_long_float(lispobj *where)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
 #ifdef sparc
-       nwords = CEILING(length * 4 + 2, 2);
+    nwords = CEILING(length * 4 + 2, 2);
 #endif
 
-       return nwords;
+    return nwords;
 }
 #endif
 
 
-#ifdef type_SimpleArrayComplexSingleFloat
+#ifdef SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG
 static int
 scav_vector_complex_single_float(lispobj *where, lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(length * 2 + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(length * 2 + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 static lispobj
 trans_vector_complex_single_float(lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-       vector = (struct vector *) native_pointer(object);
-       length = fixnum_value(vector->length);
-       nwords = CEILING(length * 2 + 2, 2);
+    vector = (struct vector *) native_pointer(object);
+    length = fixnum_value(vector->length);
+    nwords = CEILING(length * 2 + 2, 2);
 
-       return copy_object(object, nwords);
+    return copy_object(object, nwords);
 }
 
 static int
 size_vector_complex_single_float(lispobj *where)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(length * 2 + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(length * 2 + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 #endif
 
-#ifdef type_SimpleArrayComplexDoubleFloat
+#ifdef SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG
 static int
 scav_vector_complex_double_float(lispobj *where, lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(length * 4 + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(length * 4 + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 
 static lispobj
 trans_vector_complex_double_float(lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-       vector = (struct vector *) native_pointer(object);
-       length = fixnum_value(vector->length);
-       nwords = CEILING(length * 4 + 2, 2);
+    vector = (struct vector *) native_pointer(object);
+    length = fixnum_value(vector->length);
+    nwords = CEILING(length * 4 + 2, 2);
 
-       return copy_object(object, nwords);
+    return copy_object(object, nwords);
 }
 
 static int
 size_vector_complex_double_float(lispobj *where)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
-       nwords = CEILING(length * 4 + 2, 2);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
+    nwords = CEILING(length * 4 + 2, 2);
 
-       return nwords;
+    return nwords;
 }
 #endif
 
-#ifdef type_SimpleArrayComplexLongFloat
+#ifdef SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG
 static int
 scav_vector_complex_long_float(lispobj *where, lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
 #ifdef sparc
-       nwords = CEILING(length * 8 + 2, 2);
+    nwords = CEILING(length * 8 + 2, 2);
 #endif
 
-       return nwords;
+    return nwords;
 }
 
 static lispobj
 trans_vector_complex_long_float(lispobj object)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
-       vector = (struct vector *) native_pointer(object);
-       length = fixnum_value(vector->length);
+    vector = (struct vector *) native_pointer(object);
+    length = fixnum_value(vector->length);
 #ifdef sparc
-       nwords = CEILING(length * 8 + 2, 2);
+    nwords = CEILING(length * 8 + 2, 2);
 #endif
 
-       return copy_object(object, nwords);
+    return copy_object(object, nwords);
 }
 
 static int
 size_vector_complex_long_float(lispobj *where)
 {
-       struct vector *vector;
-       int length, nwords;
+    struct vector *vector;
+    int length, nwords;
 
-       vector = (struct vector *) where;
-       length = fixnum_value(vector->length);
+    vector = (struct vector *) where;
+    length = fixnum_value(vector->length);
 #ifdef sparc
-       nwords = CEILING(length * 8 + 2, 2);
+    nwords = CEILING(length * 8 + 2, 2);
 #endif
 
-       return nwords;
+    return nwords;
 }
 #endif
 
@@ -1774,83 +1827,83 @@ size_vector_complex_long_float(lispobj *where)
 static int
 scav_weak_pointer(lispobj *where, lispobj object)
 {
-       /* Do not let GC scavenge the value slot of the weak pointer */
-       /* (that is why it is a weak pointer).  Note:  we could use */
-       /* the scav_unboxed method here. */
+    /* Do not let GC scavenge the value slot of the weak pointer */
+    /* (that is why it is a weak pointer).  Note:  we could use */
+    /* the scav_unboxed method here. */
 
-       return WEAK_POINTER_NWORDS;
+    return WEAK_POINTER_NWORDS;
 }
 
 static lispobj
 trans_weak_pointer(lispobj object)
 {
-       lispobj copy;
-       struct weak_pointer *wp;
+    lispobj copy;
+    struct weak_pointer *wp;
 
-       gc_assert(is_lisp_pointer(object));
+    gc_assert(is_lisp_pointer(object));
 
 #if defined(DEBUG_WEAK)
-       printf("Transporting weak pointer from 0x%08x\n", object);
+    printf("Transporting weak pointer from 0x%08x\n", object);
 #endif
 
-       /* Need to remember where all the weak pointers are that have */
-       /* been transported so they can be fixed up in a post-GC pass. */
+    /* Need to remember where all the weak pointers are that have */
+    /* been transported so they can be fixed up in a post-GC pass. */
 
-       copy = copy_object(object, WEAK_POINTER_NWORDS);
-       wp = (struct weak_pointer *) native_pointer(copy);
+    copy = copy_object(object, WEAK_POINTER_NWORDS);
+    wp = (struct weak_pointer *) native_pointer(copy);
        
 
-       /* Push the weak pointer onto the list of weak pointers. */
-       wp->next = LOW_WORD(weak_pointers);
-       weak_pointers = wp;
+    /* Push the weak pointer onto the list of weak pointers. */
+    wp->next = LOW_WORD(weak_pointers);
+    weak_pointers = wp;
 
-       return copy;
+    return copy;
 }
 
 static int
 size_weak_pointer(lispobj *where)
 {
-       return WEAK_POINTER_NWORDS;
+    return WEAK_POINTER_NWORDS;
 }
 
 void scan_weak_pointers(void)
 {
-       struct weak_pointer *wp;
+    struct weak_pointer *wp;
 
-       for (wp = weak_pointers; wp != (struct weak_pointer *) NULL;
-            wp = (struct weak_pointer *)((unsigned long)wp->next)) {
-               lispobj value;
-               lispobj first, *first_pointer;
+    for (wp = weak_pointers; wp != (struct weak_pointer *) NULL;
+        wp = (struct weak_pointer *)((unsigned long)wp->next)) {
+       lispobj value;
+       lispobj first, *first_pointer;
 
-               value = wp->value;
+       value = wp->value;
 
 #if defined(DEBUG_WEAK)
-               printf("Weak pointer at 0x%p\n",  wp);
-               printf("Value: 0x%08x\n", (unsigned int) value);
+       printf("Weak pointer at 0x%p\n",  wp);
+       printf("Value: 0x%08x\n", (unsigned int) value);
 #endif         
 
-               if (!(is_lisp_pointer(value) && from_space_p(value)))
-                       continue;
+       if (!(is_lisp_pointer(value) && from_space_p(value)))
+           continue;
 
-               /* Now, we need to check if the object has been */
-               /* forwarded.  If it has been, the weak pointer is */
-               /* still good and needs to be updated.  Otherwise, the */
-               /* weak pointer needs to be nil'ed out. */
+       /* Now, we need to check if the object has been */
+       /* forwarded.  If it has been, the weak pointer is */
+       /* still good and needs to be updated.  Otherwise, the */
+       /* weak pointer needs to be nil'ed out. */
 
-               first_pointer = (lispobj *) native_pointer(value);
-               first = *first_pointer;
+       first_pointer = (lispobj *) native_pointer(value);
+       first = *first_pointer;
                
 #if defined(DEBUG_WEAK)
-               printf("First: 0x%08x\n", (unsigned long) first);
+       printf("First: 0x%08x\n", (unsigned long) first);
 #endif         
 
-               if (is_lisp_pointer(first) && new_space_p(first))
-                       wp->value = first;
-               else {
-                       wp->value = NIL;
-                       wp->broken = T;
-               }
+       if (is_lisp_pointer(first) && new_space_p(first))
+           wp->value = first;
+       else {
+           wp->value = NIL;
+           wp->broken = T;
        }
+    }
 }
 
 
@@ -1878,11 +1931,11 @@ trans_lose(lispobj object)
 static int
 size_lose(lispobj *where)
 {
-       fprintf(stderr, "Size lossage.  No size function for object at 0x%p\n",
-               where);
-       fprintf(stderr, "First word of object: 0x%08x\n",
-               (u32) *where);
-       return 1;
+    fprintf(stderr, "Size lossage.  No size function for object at 0x%p\n",
+           where);
+    fprintf(stderr, "First word of object: 0x%08x\n",
+           (u32) *where);
+    return 1;
 }
 
 /* KLUDGE: SBCL already has two GC implementations, and if someday the
@@ -1893,292 +1946,331 @@ size_lose(lispobj *where)
 void
 gc_init(void)
 {
-       int i;
-
-       /* scavenge table */
-       for (i = 0; i < 256; i++)
-           scavtab[i] = scav_lose; 
-       /* scavtab[i] = scav_immediate; */
-
-       for (i = 0; i < 32; i++) {
-               scavtab[type_EvenFixnum|(i<<3)] = scav_immediate;
-               scavtab[type_FunPointer|(i<<3)] = scav_fun_pointer;
-               /* OtherImmediate0 */
-               scavtab[type_ListPointer|(i<<3)] = scav_list_pointer;
-               scavtab[type_OddFixnum|(i<<3)] = scav_immediate;
-               scavtab[type_InstancePointer|(i<<3)] = scav_instance_pointer;
-               /* OtherImmediate1 */
-               scavtab[type_OtherPointer|(i<<3)] = scav_other_pointer;
-       }
+    int i;
+
+    /* scavenge table */
+    for (i = 0; i < 256; i++)
+       scavtab[i] = scav_lose; 
+    /* scavtab[i] = scav_immediate; */
+
+    for (i = 0; i < 32; i++) {
+       scavtab[EVEN_FIXNUM_LOWTAG|(i<<3)] = scav_immediate;
+       scavtab[FUN_POINTER_LOWTAG|(i<<3)] = scav_fun_pointer;
+       /* skipping OTHER_IMMEDIATE_0_LOWTAG */
+       scavtab[LIST_POINTER_LOWTAG|(i<<3)] = scav_list_pointer;
+       scavtab[ODD_FIXNUM_LOWTAG|(i<<3)] = scav_immediate;
+       scavtab[INSTANCE_POINTER_LOWTAG|(i<<3)] =scav_instance_pointer;
+       /* skipping OTHER_IMMEDIATE_1_LOWTAG */
+       scavtab[OTHER_POINTER_LOWTAG|(i<<3)] = scav_other_pointer;
+    }
 
-       scavtab[type_Bignum] = scav_unboxed;
-       scavtab[type_Ratio] = scav_boxed;
-       scavtab[type_SingleFloat] = scav_unboxed;
-       scavtab[type_DoubleFloat] = scav_unboxed;
-#ifdef type_LongFloat
-       scavtab[type_LongFloat] = scav_unboxed;
-#endif
-       scavtab[type_Complex] = scav_boxed;
-#ifdef type_ComplexSingleFloat
-       scavtab[type_ComplexSingleFloat] = scav_unboxed;
-#endif
-#ifdef type_ComplexDoubleFloat
-       scavtab[type_ComplexDoubleFloat] = scav_unboxed;
-#endif
-#ifdef type_ComplexLongFloat
-       scavtab[type_ComplexLongFloat] = scav_unboxed;
-#endif
-       scavtab[type_SimpleArray] = scav_boxed;
-       scavtab[type_SimpleString] = scav_string;
-       scavtab[type_SimpleBitVector] = scav_vector_bit;
-       scavtab[type_SimpleVector] = scav_vector;
-       scavtab[type_SimpleArrayUnsignedByte2] = scav_vector_unsigned_byte_2;
-       scavtab[type_SimpleArrayUnsignedByte4] = scav_vector_unsigned_byte_4;
-       scavtab[type_SimpleArrayUnsignedByte8] = scav_vector_unsigned_byte_8;
-       scavtab[type_SimpleArrayUnsignedByte16] = scav_vector_unsigned_byte_16;
-       scavtab[type_SimpleArrayUnsignedByte32] = scav_vector_unsigned_byte_32;
-#ifdef type_SimpleArraySignedByte8
-       scavtab[type_SimpleArraySignedByte8] = scav_vector_unsigned_byte_8;
-#endif
-#ifdef type_SimpleArraySignedByte16
-       scavtab[type_SimpleArraySignedByte16] = scav_vector_unsigned_byte_16;
-#endif
-#ifdef type_SimpleArraySignedByte30
-       scavtab[type_SimpleArraySignedByte30] = scav_vector_unsigned_byte_32;
-#endif
-#ifdef type_SimpleArraySignedByte32
-       scavtab[type_SimpleArraySignedByte32] = scav_vector_unsigned_byte_32;
-#endif
-       scavtab[type_SimpleArraySingleFloat] = scav_vector_single_float;
-       scavtab[type_SimpleArrayDoubleFloat] = scav_vector_double_float;
-#ifdef type_SimpleArrayLongFloat
-       scavtab[type_SimpleArrayLongFloat] = scav_vector_long_float;
-#endif
-#ifdef type_SimpleArrayComplexSingleFloat
-       scavtab[type_SimpleArrayComplexSingleFloat] = scav_vector_complex_single_float;
-#endif
-#ifdef type_SimpleArrayComplexDoubleFloat
-       scavtab[type_SimpleArrayComplexDoubleFloat] = scav_vector_complex_double_float;
-#endif
-#ifdef type_SimpleArrayComplexLongFloat
-       scavtab[type_SimpleArrayComplexLongFloat] = scav_vector_complex_long_float;
-#endif
-       scavtab[type_ComplexString] = scav_boxed;
-       scavtab[type_ComplexBitVector] = scav_boxed;
-       scavtab[type_ComplexVector] = scav_boxed;
-       scavtab[type_ComplexArray] = scav_boxed;
-       scavtab[type_CodeHeader] = scav_code_header;
-       scavtab[type_SimpleFunHeader] = scav_fun_header;
-       scavtab[type_ClosureFunHeader] = scav_fun_header;
-       scavtab[type_ReturnPcHeader] = scav_return_pc_header;
+    scavtab[BIGNUM_WIDETAG] = scav_unboxed;
+    scavtab[RATIO_WIDETAG] = scav_boxed;
+    scavtab[SINGLE_FLOAT_WIDETAG] = scav_unboxed;
+    scavtab[DOUBLE_FLOAT_WIDETAG] = scav_unboxed;
+#ifdef LONG_FLOAT_WIDETAG
+    scavtab[LONG_FLOAT_WIDETAG] = scav_unboxed;
+#endif
+    scavtab[COMPLEX_WIDETAG] = scav_boxed;
+#ifdef COMPLEX_SINGLE_FLOAT_WIDETAG
+    scavtab[COMPLEX_SINGLE_FLOAT_WIDETAG] = scav_unboxed;
+#endif
+#ifdef COMPLEX_DOUBLE_FLOAT_WIDETAG
+    scavtab[COMPLEX_DOUBLE_FLOAT_WIDETAG] = scav_unboxed;
+#endif
+#ifdef COMPLEX_LONG_FLOAT_WIDETAG
+    scavtab[COMPLEX_LONG_FLOAT_WIDETAG] = scav_unboxed;
+#endif
+    scavtab[SIMPLE_ARRAY_WIDETAG] = scav_boxed;
+    scavtab[SIMPLE_STRING_WIDETAG] = scav_string;
+    scavtab[SIMPLE_BIT_VECTOR_WIDETAG] = scav_vector_bit;
+    scavtab[SIMPLE_VECTOR_WIDETAG] = scav_vector;
+    scavtab[SIMPLE_ARRAY_UNSIGNED_BYTE_2_WIDETAG] =
+       scav_vector_unsigned_byte_2;
+    scavtab[SIMPLE_ARRAY_UNSIGNED_BYTE_4_WIDETAG] =
+       scav_vector_unsigned_byte_4;
+    scavtab[SIMPLE_ARRAY_UNSIGNED_BYTE_8_WIDETAG] =
+       scav_vector_unsigned_byte_8;
+    scavtab[SIMPLE_ARRAY_UNSIGNED_BYTE_16_WIDETAG] =
+       scav_vector_unsigned_byte_16;
+    scavtab[SIMPLE_ARRAY_UNSIGNED_BYTE_32_WIDETAG] =
+       scav_vector_unsigned_byte_32;
+#ifdef SIMPLE_ARRAY_SIGNED_BYTE_8_WIDETAG
+    scavtab[SIMPLE_ARRAY_SIGNED_BYTE_8_WIDETAG] =
+       scav_vector_unsigned_byte_8;
+#endif
+#ifdef SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG
+    scavtab[SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG] =
+       scav_vector_unsigned_byte_16;
+#endif
+#ifdef SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG
+    scavtab[SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG] =
+       scav_vector_unsigned_byte_32;
+#endif
+#ifdef SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG
+    scavtab[SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG] =
+       scav_vector_unsigned_byte_32;
+#endif
+    scavtab[SIMPLE_ARRAY_SINGLE_FLOAT_WIDETAG] = scav_vector_single_float;
+    scavtab[SIMPLE_ARRAY_DOUBLE_FLOAT_WIDETAG] = scav_vector_double_float;
+#ifdef SIMPLE_ARRAY_LONG_FLOAT_WIDETAG
+    scavtab[SIMPLE_ARRAY_LONG_FLOAT_WIDETAG] = scav_vector_long_float;
+#endif
+#ifdef SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG
+    scavtab[SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG] =
+       scav_vector_complex_single_float;
+#endif
+#ifdef SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG
+    scavtab[SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG] =
+       scav_vector_complex_double_float;
+#endif
+#ifdef SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG
+    scavtab[SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG] =
+       scav_vector_complex_long_float;
+#endif
+    scavtab[COMPLEX_STRING_WIDETAG] = scav_boxed;
+    scavtab[COMPLEX_BIT_VECTOR_WIDETAG] = scav_boxed;
+    scavtab[COMPLEX_VECTOR_WIDETAG] = scav_boxed;
+    scavtab[COMPLEX_ARRAY_WIDETAG] = scav_boxed;
+    scavtab[CODE_HEADER_WIDETAG] = scav_code_header;
+    scavtab[SIMPLE_FUN_HEADER_WIDETAG] = scav_fun_header;
+    scavtab[CLOSURE_FUN_HEADER_WIDETAG] = scav_fun_header;
+    scavtab[RETURN_PC_HEADER_WIDETAG] = scav_return_pc_header;
 #ifdef __i386__
-       scavtab[type_ClosureHeader] = scav_closure_header;
-       scavtab[type_FuncallableInstanceHeader] = scav_closure_header;
+    scavtab[CLOSURE_HEADER_WIDETAG] = scav_closure_header;
+    scavtab[FUNCALLABLE_INSTANCE_HEADER_WIDETAG] = scav_closure_header;
 #else
-       scavtab[type_ClosureHeader] = scav_boxed;
-       scavtab[type_FuncallableInstanceHeader] = scav_boxed;
-#endif
-       scavtab[type_ValueCellHeader] = scav_boxed;
-        scavtab[type_SymbolHeader] = scav_boxed;
-       scavtab[type_BaseChar] = scav_immediate;
-       scavtab[type_Sap] = scav_unboxed;
-       scavtab[type_UnboundMarker] = scav_immediate;
-       scavtab[type_WeakPointer] = scav_weak_pointer;
-        scavtab[type_InstanceHeader] = scav_boxed;
+    scavtab[CLOSURE_HEADER_WIDETAG] = scav_boxed;
+    scavtab[FUNCALLABLE_INSTANCE_HEADER_WIDETAG] = scav_boxed;
+#endif
+    scavtab[VALUE_CELL_HEADER_WIDETAG] = scav_boxed;
+    scavtab[SYMBOL_HEADER_WIDETAG] = scav_boxed;
+    scavtab[BASE_CHAR_WIDETAG] = scav_immediate;
+    scavtab[SAP_WIDETAG] = scav_unboxed;
+    scavtab[UNBOUND_MARKER_WIDETAG] = scav_immediate;
+    scavtab[WEAK_POINTER_WIDETAG] = scav_weak_pointer;
+    scavtab[INSTANCE_HEADER_WIDETAG] = scav_boxed;
 #ifndef sparc
-        scavtab[type_Fdefn] = scav_fdefn;
+    scavtab[FDEFN_WIDETAG] = scav_fdefn;
 #else
-        scavtab[type_Fdefn] = scav_boxed;
-#endif
-
-       /* Transport Other Table */
-       for (i = 0; i < 256; i++)
-               transother[i] = trans_lose;
-
-       transother[type_Bignum] = trans_unboxed;
-       transother[type_Ratio] = trans_boxed;
-       transother[type_SingleFloat] = trans_unboxed;
-       transother[type_DoubleFloat] = trans_unboxed;
-#ifdef type_LongFloat
-       transother[type_LongFloat] = trans_unboxed;
-#endif
-       transother[type_Complex] = trans_boxed;
-#ifdef type_ComplexSingleFloat
-       transother[type_ComplexSingleFloat] = trans_unboxed;
-#endif
-#ifdef type_ComplexDoubleFloat
-       transother[type_ComplexDoubleFloat] = trans_unboxed;
-#endif
-#ifdef type_ComplexLongFloat
-       transother[type_ComplexLongFloat] = trans_unboxed;
-#endif
-       transother[type_SimpleArray] = trans_boxed;
-       transother[type_SimpleString] = trans_string;
-       transother[type_SimpleBitVector] = trans_vector_bit;
-       transother[type_SimpleVector] = trans_vector;
-       transother[type_SimpleArrayUnsignedByte2] = trans_vector_unsigned_byte_2;
-       transother[type_SimpleArrayUnsignedByte4] = trans_vector_unsigned_byte_4;
-       transother[type_SimpleArrayUnsignedByte8] = trans_vector_unsigned_byte_8;
-       transother[type_SimpleArrayUnsignedByte16] = trans_vector_unsigned_byte_16;
-       transother[type_SimpleArrayUnsignedByte32] = trans_vector_unsigned_byte_32;
-#ifdef type_SimpleArraySignedByte8
-       transother[type_SimpleArraySignedByte8] = trans_vector_unsigned_byte_8;
-#endif
-#ifdef type_SimpleArraySignedByte16
-       transother[type_SimpleArraySignedByte16] = trans_vector_unsigned_byte_16;
-#endif
-#ifdef type_SimpleArraySignedByte30
-       transother[type_SimpleArraySignedByte30] = trans_vector_unsigned_byte_32;
-#endif
-#ifdef type_SimpleArraySignedByte32
-       transother[type_SimpleArraySignedByte32] = trans_vector_unsigned_byte_32;
-#endif
-       transother[type_SimpleArraySingleFloat] = trans_vector_single_float;
-       transother[type_SimpleArrayDoubleFloat] = trans_vector_double_float;
-#ifdef type_SimpleArrayLongFloat
-       transother[type_SimpleArrayLongFloat] = trans_vector_long_float;
-#endif
-#ifdef type_SimpleArrayComplexSingleFloat
-       transother[type_SimpleArrayComplexSingleFloat] = trans_vector_complex_single_float;
-#endif
-#ifdef type_SimpleArrayComplexDoubleFloat
-       transother[type_SimpleArrayComplexDoubleFloat] = trans_vector_complex_double_float;
-#endif
-#ifdef type_SimpleArrayComplexLongFloat
-       transother[type_SimpleArrayComplexLongFloat] = trans_vector_complex_long_float;
-#endif
-       transother[type_ComplexString] = trans_boxed;
-       transother[type_ComplexBitVector] = trans_boxed;
-       transother[type_ComplexVector] = trans_boxed;
-       transother[type_ComplexArray] = trans_boxed;
-       transother[type_CodeHeader] = trans_code_header;
-       transother[type_SimpleFunHeader] = trans_fun_header;
-       transother[type_ClosureFunHeader] = trans_fun_header;
-       transother[type_ReturnPcHeader] = trans_return_pc_header;
-       transother[type_ClosureHeader] = trans_boxed;
-       transother[type_FuncallableInstanceHeader] = trans_boxed;
-       transother[type_ValueCellHeader] = trans_boxed;
-       transother[type_SymbolHeader] = trans_boxed;
-       transother[type_BaseChar] = trans_immediate;
-       transother[type_Sap] = trans_unboxed;
-       transother[type_UnboundMarker] = trans_immediate;
-       transother[type_WeakPointer] = trans_weak_pointer;
-        transother[type_InstanceHeader] = trans_boxed;
-       transother[type_Fdefn] = trans_boxed;
-
-       /* Size table */
-
-       for (i = 0; i < 256; i++)
-               sizetab[i] = size_lose;
-
-       for (i = 0; i < 32; i++) {
-               sizetab[type_EvenFixnum|(i<<3)] = size_immediate;
-               sizetab[type_FunPointer|(i<<3)] = size_pointer;
-               /* OtherImmediate0 */
-               sizetab[type_ListPointer|(i<<3)] = size_pointer;
-               sizetab[type_OddFixnum|(i<<3)] = size_immediate;
-               sizetab[type_InstancePointer|(i<<3)] = size_pointer;
-               /* OtherImmediate1 */
-               sizetab[type_OtherPointer|(i<<3)] = size_pointer;
-       }
+    scavtab[FDEFN_WIDETAG] = scav_boxed;
+#endif
+
+    /* Transport Other Table */
+    for (i = 0; i < 256; i++)
+       transother[i] = trans_lose;
+
+    transother[BIGNUM_WIDETAG] = trans_unboxed;
+    transother[RATIO_WIDETAG] = trans_boxed;
+    transother[SINGLE_FLOAT_WIDETAG] = trans_unboxed;
+    transother[DOUBLE_FLOAT_WIDETAG] = trans_unboxed;
+#ifdef LONG_FLOAT_WIDETAG
+    transother[LONG_FLOAT_WIDETAG] = trans_unboxed;
+#endif
+    transother[COMPLEX_WIDETAG] = trans_boxed;
+#ifdef COMPLEX_SINGLE_FLOAT_WIDETAG
+    transother[COMPLEX_SINGLE_FLOAT_WIDETAG] = trans_unboxed;
+#endif
+#ifdef COMPLEX_DOUBLE_FLOAT_WIDETAG
+    transother[COMPLEX_DOUBLE_FLOAT_WIDETAG] = trans_unboxed;
+#endif
+#ifdef COMPLEX_LONG_FLOAT_WIDETAG
+    transother[COMPLEX_LONG_FLOAT_WIDETAG] = trans_unboxed;
+#endif
+    transother[SIMPLE_ARRAY_WIDETAG] = trans_boxed;
+    transother[SIMPLE_STRING_WIDETAG] = trans_string;
+    transother[SIMPLE_BIT_VECTOR_WIDETAG] = trans_vector_bit;
+    transother[SIMPLE_VECTOR_WIDETAG] = trans_vector;
+    transother[SIMPLE_ARRAY_UNSIGNED_BYTE_2_WIDETAG] =
+       trans_vector_unsigned_byte_2;
+    transother[SIMPLE_ARRAY_UNSIGNED_BYTE_4_WIDETAG] =
+       trans_vector_unsigned_byte_4;
+    transother[SIMPLE_ARRAY_UNSIGNED_BYTE_8_WIDETAG] =
+       trans_vector_unsigned_byte_8;
+    transother[SIMPLE_ARRAY_UNSIGNED_BYTE_16_WIDETAG] =
+       trans_vector_unsigned_byte_16;
+    transother[SIMPLE_ARRAY_UNSIGNED_BYTE_32_WIDETAG] =
+       trans_vector_unsigned_byte_32;
+#ifdef SIMPLE_ARRAY_SIGNED_BYTE_8_WIDETAG
+    transother[SIMPLE_ARRAY_SIGNED_BYTE_8_WIDETAG] =
+       trans_vector_unsigned_byte_8;
+#endif
+#ifdef SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG
+    transother[SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG] =
+       trans_vector_unsigned_byte_16;
+#endif
+#ifdef SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG
+    transother[SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG] =
+       trans_vector_unsigned_byte_32;
+#endif
+#ifdef SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG
+    transother[SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG] =
+       trans_vector_unsigned_byte_32;
+#endif
+    transother[SIMPLE_ARRAY_SINGLE_FLOAT_WIDETAG] =
+       trans_vector_single_float;
+    transother[SIMPLE_ARRAY_DOUBLE_FLOAT_WIDETAG] =
+       trans_vector_double_float;
+#ifdef SIMPLE_ARRAY_LONG_FLOAT_WIDETAG
+    transother[SIMPLE_ARRAY_LONG_FLOAT_WIDETAG] =
+       trans_vector_long_float;
+#endif
+#ifdef SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG
+    transother[SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG] =
+       trans_vector_complex_single_float;
+#endif
+#ifdef SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG
+    transother[SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG] =
+       trans_vector_complex_double_float;
+#endif
+#ifdef SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG
+    transother[SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG] =
+       trans_vector_complex_long_float;
+#endif
+    transother[COMPLEX_STRING_WIDETAG] = trans_boxed;
+    transother[COMPLEX_BIT_VECTOR_WIDETAG] = trans_boxed;
+    transother[COMPLEX_VECTOR_WIDETAG] = trans_boxed;
+    transother[COMPLEX_ARRAY_WIDETAG] = trans_boxed;
+    transother[CODE_HEADER_WIDETAG] = trans_code_header;
+    transother[SIMPLE_FUN_HEADER_WIDETAG] = trans_fun_header;
+    transother[CLOSURE_FUN_HEADER_WIDETAG] = trans_fun_header;
+    transother[RETURN_PC_HEADER_WIDETAG] = trans_return_pc_header;
+    transother[CLOSURE_HEADER_WIDETAG] = trans_boxed;
+    transother[FUNCALLABLE_INSTANCE_HEADER_WIDETAG] = trans_boxed;
+    transother[VALUE_CELL_HEADER_WIDETAG] = trans_boxed;
+    transother[SYMBOL_HEADER_WIDETAG] = trans_boxed;
+    transother[BASE_CHAR_WIDETAG] = trans_immediate;
+    transother[SAP_WIDETAG] = trans_unboxed;
+    transother[UNBOUND_MARKER_WIDETAG] = trans_immediate;
+    transother[WEAK_POINTER_WIDETAG] = trans_weak_pointer;
+    transother[INSTANCE_HEADER_WIDETAG] = trans_boxed;
+    transother[FDEFN_WIDETAG] = trans_boxed;
+
+    /* Size table */
+
+    for (i = 0; i < 256; i++)
+       sizetab[i] = size_lose;
+
+    for (i = 0; i < 32; i++) {
+       sizetab[EVEN_FIXNUM_LOWTAG|(i<<3)] = size_immediate;
+       sizetab[FUN_POINTER_LOWTAG|(i<<3)] = size_pointer;
+       /* skipping OTHER_IMMEDIATE_0_LOWTAG */
+       sizetab[LIST_POINTER_LOWTAG|(i<<3)] = size_pointer;
+       sizetab[ODD_FIXNUM_LOWTAG|(i<<3)] = size_immediate;
+       sizetab[INSTANCE_POINTER_LOWTAG|(i<<3)] = size_pointer;
+       /* skipping OTHER_IMMEDIATE_1_LOWTAG */
+       sizetab[OTHER_POINTER_LOWTAG|(i<<3)] = size_pointer;
+    }
 
-       sizetab[type_Bignum] = size_unboxed;
-       sizetab[type_Ratio] = size_boxed;
-       sizetab[type_SingleFloat] = size_unboxed;
-       sizetab[type_DoubleFloat] = size_unboxed;
-#ifdef type_LongFloat
-       sizetab[type_LongFloat] = size_unboxed;
-#endif
-       sizetab[type_Complex] = size_boxed;
-#ifdef type_ComplexSingleFloat
-       sizetab[type_ComplexSingleFloat] = size_unboxed;
-#endif
-#ifdef type_ComplexDoubleFloat
-       sizetab[type_ComplexDoubleFloat] = size_unboxed;
-#endif
-#ifdef type_ComplexLongFloat
-       sizetab[type_ComplexLongFloat] = size_unboxed;
-#endif
-       sizetab[type_SimpleArray] = size_boxed;
-       sizetab[type_SimpleString] = size_string;
-       sizetab[type_SimpleBitVector] = size_vector_bit;
-       sizetab[type_SimpleVector] = size_vector;
-       sizetab[type_SimpleArrayUnsignedByte2] = size_vector_unsigned_byte_2;
-       sizetab[type_SimpleArrayUnsignedByte4] = size_vector_unsigned_byte_4;
-       sizetab[type_SimpleArrayUnsignedByte8] = size_vector_unsigned_byte_8;
-       sizetab[type_SimpleArrayUnsignedByte16] = size_vector_unsigned_byte_16;
-       sizetab[type_SimpleArrayUnsignedByte32] = size_vector_unsigned_byte_32;
-#ifdef type_SimpleArraySignedByte8
-       sizetab[type_SimpleArraySignedByte8] = size_vector_unsigned_byte_8;
-#endif
-#ifdef type_SimpleArraySignedByte16
-       sizetab[type_SimpleArraySignedByte16] = size_vector_unsigned_byte_16;
-#endif
-#ifdef type_SimpleArraySignedByte30
-       sizetab[type_SimpleArraySignedByte30] = size_vector_unsigned_byte_32;
-#endif
-#ifdef type_SimpleArraySignedByte32
-       sizetab[type_SimpleArraySignedByte32] = size_vector_unsigned_byte_32;
-#endif
-       sizetab[type_SimpleArraySingleFloat] = size_vector_single_float;
-       sizetab[type_SimpleArrayDoubleFloat] = size_vector_double_float;
-#ifdef type_SimpleArrayLongFloat
-       sizetab[type_SimpleArrayLongFloat] = size_vector_long_float;
-#endif
-#ifdef type_SimpleArrayComplexSingleFloat
-       sizetab[type_SimpleArrayComplexSingleFloat] = size_vector_complex_single_float;
-#endif
-#ifdef type_SimpleArrayComplexDoubleFloat
-       sizetab[type_SimpleArrayComplexDoubleFloat] = size_vector_complex_double_float;
-#endif
-#ifdef type_SimpleArrayComplexLongFloat
-       sizetab[type_SimpleArrayComplexLongFloat] = size_vector_complex_long_float;
-#endif
-       sizetab[type_ComplexString] = size_boxed;
-       sizetab[type_ComplexBitVector] = size_boxed;
-       sizetab[type_ComplexVector] = size_boxed;
-       sizetab[type_ComplexArray] = size_boxed;
-       sizetab[type_CodeHeader] = size_code_header;
+    sizetab[BIGNUM_WIDETAG] = size_unboxed;
+    sizetab[RATIO_WIDETAG] = size_boxed;
+    sizetab[SINGLE_FLOAT_WIDETAG] = size_unboxed;
+    sizetab[DOUBLE_FLOAT_WIDETAG] = size_unboxed;
+#ifdef LONG_FLOAT_WIDETAG
+    sizetab[LONG_FLOAT_WIDETAG] = size_unboxed;
+#endif
+    sizetab[COMPLEX_WIDETAG] = size_boxed;
+#ifdef COMPLEX_SINGLE_FLOAT_WIDETAG
+    sizetab[COMPLEX_SINGLE_FLOAT_WIDETAG] = size_unboxed;
+#endif
+#ifdef COMPLEX_DOUBLE_FLOAT_WIDETAG
+    sizetab[COMPLEX_DOUBLE_FLOAT_WIDETAG] = size_unboxed;
+#endif
+#ifdef COMPLEX_LONG_FLOAT_WIDETAG
+    sizetab[COMPLEX_LONG_FLOAT_WIDETAG] = size_unboxed;
+#endif
+    sizetab[SIMPLE_ARRAY_WIDETAG] = size_boxed;
+    sizetab[SIMPLE_STRING_WIDETAG] = size_string;
+    sizetab[SIMPLE_BIT_VECTOR_WIDETAG] = size_vector_bit;
+    sizetab[SIMPLE_VECTOR_WIDETAG] = size_vector;
+    sizetab[SIMPLE_ARRAY_UNSIGNED_BYTE_2_WIDETAG] =
+       size_vector_unsigned_byte_2;
+    sizetab[SIMPLE_ARRAY_UNSIGNED_BYTE_4_WIDETAG] =
+       size_vector_unsigned_byte_4;
+    sizetab[SIMPLE_ARRAY_UNSIGNED_BYTE_8_WIDETAG] =
+       size_vector_unsigned_byte_8;
+    sizetab[SIMPLE_ARRAY_UNSIGNED_BYTE_16_WIDETAG] =
+       size_vector_unsigned_byte_16;
+    sizetab[SIMPLE_ARRAY_UNSIGNED_BYTE_32_WIDETAG] =
+       size_vector_unsigned_byte_32;
+#ifdef SIMPLE_ARRAY_SIGNED_BYTE_8_WIDETAG
+    sizetab[SIMPLE_ARRAY_SIGNED_BYTE_8_WIDETAG] =
+       size_vector_unsigned_byte_8;
+#endif
+#ifdef SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG
+    sizetab[SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG] =
+       size_vector_unsigned_byte_16;
+#endif
+#ifdef SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG
+    sizetab[SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG] =
+       size_vector_unsigned_byte_32;
+#endif
+#ifdef SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG
+    sizetab[SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG] =
+       size_vector_unsigned_byte_32;
+#endif
+    sizetab[SIMPLE_ARRAY_SINGLE_FLOAT_WIDETAG] = size_vector_single_float;
+    sizetab[SIMPLE_ARRAY_DOUBLE_FLOAT_WIDETAG] = size_vector_double_float;
+#ifdef SIMPLE_ARRAY_LONG_FLOAT_WIDETAG
+    sizetab[SIMPLE_ARRAY_LONG_FLOAT_WIDETAG] = size_vector_long_float;
+#endif
+#ifdef SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG
+    sizetab[SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG] =
+       size_vector_complex_single_float;
+#endif
+#ifdef SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG
+    sizetab[SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG] =
+       size_vector_complex_double_float;
+#endif
+#ifdef SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG
+    sizetab[SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG] =
+       size_vector_complex_long_float;
+#endif
+    sizetab[COMPLEX_STRING_WIDETAG] = size_boxed;
+    sizetab[COMPLEX_BIT_VECTOR_WIDETAG] = size_boxed;
+    sizetab[COMPLEX_VECTOR_WIDETAG] = size_boxed;
+    sizetab[COMPLEX_ARRAY_WIDETAG] = size_boxed;
+    sizetab[CODE_HEADER_WIDETAG] = size_code_header;
 #if 0
-       /* Shouldn't see these so just lose if it happens */
-       sizetab[type_SimpleFunHeader] = size_function_header;
-       sizetab[type_ClosureFunHeader] = size_function_header;
-       sizetab[type_ReturnPcHeader] = size_return_pc_header;
-#endif
-       sizetab[type_ClosureHeader] = size_boxed;
-       sizetab[type_FuncallableInstanceHeader] = size_boxed;
-       sizetab[type_ValueCellHeader] = size_boxed;
-       sizetab[type_SymbolHeader] = size_boxed;
-       sizetab[type_BaseChar] = size_immediate;
-       sizetab[type_Sap] = size_unboxed;
-       sizetab[type_UnboundMarker] = size_immediate;
-       sizetab[type_WeakPointer] = size_weak_pointer;
-        sizetab[type_InstanceHeader] = size_boxed;
-       sizetab[type_Fdefn] = size_boxed;
+    /* Shouldn't see these so just lose if it happens */
+    sizetab[SIMPLE_FUN_HEADER_WIDETAG] = size_function_header;
+    sizetab[CLOSURE_FUN_HEADER_WIDETAG] = size_function_header;
+    sizetab[RETURN_PC_HEADER_WIDETAG] = size_return_pc_header;
+#endif
+    sizetab[CLOSURE_HEADER_WIDETAG] = size_boxed;
+    sizetab[FUNCALLABLE_INSTANCE_HEADER_WIDETAG] = size_boxed;
+    sizetab[VALUE_CELL_HEADER_WIDETAG] = size_boxed;
+    sizetab[SYMBOL_HEADER_WIDETAG] = size_boxed;
+    sizetab[BASE_CHAR_WIDETAG] = size_immediate;
+    sizetab[SAP_WIDETAG] = size_unboxed;
+    sizetab[UNBOUND_MARKER_WIDETAG] = size_immediate;
+    sizetab[WEAK_POINTER_WIDETAG] = size_weak_pointer;
+    sizetab[INSTANCE_HEADER_WIDETAG] = size_boxed;
+    sizetab[FDEFN_WIDETAG] = size_boxed;
 }
 \f
 /* noise to manipulate the gc trigger stuff */
 
 void set_auto_gc_trigger(os_vm_size_t dynamic_usage)
 {
-    os_vm_address_t addr=(os_vm_address_t)current_dynamic_space +
-       dynamic_usage;
-    long length =
-       DYNAMIC_SPACE_SIZE + (os_vm_address_t)current_dynamic_space - addr;
+    os_vm_address_t addr=(os_vm_address_t)current_dynamic_space 
+       + dynamic_usage;
+       
+    long length = DYNAMIC_SPACE_SIZE - dynamic_usage;
 
-    if(addr < (os_vm_address_t)dynamic_space_free_pointer) {
+    if (addr < (os_vm_address_t)dynamic_space_free_pointer) {
        fprintf(stderr,
           "set_auto_gc_trigger: tried to set gc trigger too low! (%d < %p)\n",
                (unsigned int)dynamic_usage,
                (os_vm_address_t)dynamic_space_free_pointer
                - (os_vm_address_t)current_dynamic_space);
-       return;
+       lose("lost");
     }
     else if (length < 0) {
        fprintf(stderr,
                "set_auto_gc_trigger: tried to set gc trigger too high! (%p)\n",
                dynamic_usage);
-       return;
+       lose("lost");
     }
 
     addr=os_round_up_to_page(addr);
@@ -2195,7 +2287,7 @@ void set_auto_gc_trigger(os_vm_size_t dynamic_usage)
 
 void clear_auto_gc_trigger(void)
 {
-    if(current_auto_gc_trigger!=NULL){
+    if (current_auto_gc_trigger!=NULL){
 #if defined(SUNOS) || defined(SOLARIS)/* don't want to force whole space into swapping mode... */
        os_vm_address_t addr=(os_vm_address_t)current_auto_gc_trigger;
        os_vm_size_t length=