X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fgencgc.c;h=a90c60df42548bb3c756aa5215b7b780e29e1975;hb=94ac5b7c3ff37850210b6fc9a7593cf1c5752993;hp=b7f9cbb3b8443921343b8ea91bc1f5d7cea8bfe1;hpb=667ec9d494530079bef28e8589dd0d3274b935ec;p=sbcl.git diff --git a/src/runtime/gencgc.c b/src/runtime/gencgc.c index b7f9cbb..a90c60d 100644 --- a/src/runtime/gencgc.c +++ b/src/runtime/gencgc.c @@ -1414,7 +1414,7 @@ copy_object(lispobj object, int nwords) gc_assert((nwords & 0x01) == 0); /* Get tag of object. */ - tag = LowtagOf(object); + tag = lowtag_of(object); /* Allocate space. */ new = gc_quick_alloc(nwords*4); @@ -1549,7 +1549,7 @@ copy_large_object(lispobj object, int nwords) return(object); } else { /* Get tag of object. */ - tag = LowtagOf(object); + tag = lowtag_of(object); /* Allocate space. */ new = gc_quick_alloc_large(nwords*4); @@ -1584,7 +1584,7 @@ copy_unboxed_object(lispobj object, int nwords) gc_assert((nwords & 0x01) == 0); /* Get tag of object. */ - tag = LowtagOf(object); + tag = lowtag_of(object); /* Allocate space. */ new = gc_quick_alloc_unboxed(nwords*4); @@ -1713,7 +1713,7 @@ copy_large_unboxed_object(lispobj object, int nwords) } else { /* Get tag of object. */ - tag = LowtagOf(object); + tag = lowtag_of(object); /* Allocate space. */ new = gc_quick_alloc_large_unboxed(nwords*4); @@ -1770,7 +1770,7 @@ scavenge(lispobj *start, long n_words) } else { /* Scavenge that pointer. */ n_words_scavenged = - (scavtab[TypeOf(object)])(object_ptr, object); + (scavtab[widetag_of(object)])(object_ptr, object); } } else { /* It points somewhere other than oldspace. Leave it @@ -1783,7 +1783,7 @@ scavenge(lispobj *start, long n_words) } else { /* It's some sort of header object or another. */ n_words_scavenged = - (scavtab[TypeOf(object)])(object_ptr, object); + (scavtab[widetag_of(object)])(object_ptr, object); } } gc_assert(object_ptr == end); @@ -1793,13 +1793,14 @@ scavenge(lispobj *start, long n_words) * code and code-related objects */ -#define RAW_ADDR_OFFSET (6*sizeof(lispobj) - type_FunctionPointer) +/* FIXME: (1) Shouldn't this be defined in sbcl.h? */ +#define FUN_RAW_ADDR_OFFSET (6*sizeof(lispobj) - FUN_POINTER_LOWTAG) -static lispobj trans_function_header(lispobj object); +static lispobj trans_fun_header(lispobj object); static lispobj trans_boxed(lispobj object); static int -scav_function_pointer(lispobj *where, lispobj object) +scav_fun_pointer(lispobj *where, lispobj object) { lispobj *first_pointer; lispobj copy; @@ -1812,10 +1813,10 @@ scav_function_pointer(lispobj *where, lispobj object) /* must transport object -- object may point to either a function * header, a closure function header, or to a closure header. */ - switch (TypeOf(*first_pointer)) { - case type_FunctionHeader: - case type_ClosureFunctionHeader: - copy = trans_function_header(object); + switch (widetag_of(*first_pointer)) { + case SIMPLE_FUN_HEADER_WIDETAG: + case CLOSURE_FUN_HEADER_WIDETAG: + copy = trans_fun_header(object); break; default: copy = trans_boxed(object); @@ -2050,7 +2051,7 @@ apply_code_fixups(struct code *old_code, struct code *new_code) /* It will be 0 or the unbound-marker if there are no fixups, and * will be an other pointer if it is valid. */ - if ((fixups == 0) || (fixups == type_UnboundMarker) || + if ((fixups == 0) || (fixups == UNBOUND_MARKER_WIDETAG) || !is_lisp_pointer(fixups)) { /* Check for possible errors. */ if (check_code_fixups) @@ -2078,7 +2079,8 @@ apply_code_fixups(struct code *old_code, struct code *new_code) /*SHOW("got fixups");*/ - if (TypeOf(fixups_vector->header) == type_SimpleArrayUnsignedByte32) { + if (widetag_of(fixups_vector->header) == + SIMPLE_ARRAY_UNSIGNED_BYTE_32_WIDETAG) { /* Got the fixups for the code block. Now work through the vector, and apply a fixup at each address. */ int length = fixnum_value(fixups_vector->length); @@ -2128,10 +2130,10 @@ trans_code(struct code *code) if (*((lispobj *)code) == 0x01) return (struct code*)(((lispobj *)code)[1]); - gc_assert(TypeOf(code->header) == type_CodeHeader); + gc_assert(widetag_of(code->header) == CODE_HEADER_WIDETAG); /* Prepare to transport the code vector. */ - l_code = (lispobj) code | type_OtherPointer; + l_code = (lispobj) code | OTHER_POINTER_LOWTAG; ncode_words = fixnum_value(code->code_size); nheader_words = HeaderValue(code->header); @@ -2166,23 +2168,23 @@ trans_code(struct code *code) prev_pointer = &new_code->entry_points; while (fheaderl != NIL) { - struct function *fheaderp, *nfheaderp; + struct simple_fun *fheaderp, *nfheaderp; lispobj nfheaderl; - fheaderp = (struct function *) native_pointer(fheaderl); - gc_assert(TypeOf(fheaderp->header) == type_FunctionHeader); + fheaderp = (struct simple_fun *) native_pointer(fheaderl); + gc_assert(widetag_of(fheaderp->header) == SIMPLE_FUN_HEADER_WIDETAG); - /* Calculate the new function pointer and the new */ - /* function header. */ + /* Calculate the new function pointer and the new + * function header. */ nfheaderl = fheaderl + displacement; - nfheaderp = (struct function *) native_pointer(nfheaderl); + nfheaderp = (struct simple_fun *) native_pointer(nfheaderl); /* Set forwarding pointer. */ ((lispobj *)fheaderp)[0] = 0x01; ((lispobj *)fheaderp)[1] = nfheaderl; /* Fix self pointer. */ - nfheaderp->self = nfheaderl + RAW_ADDR_OFFSET; + nfheaderp->self = nfheaderl + FUN_RAW_ADDR_OFFSET; *prev_pointer = nfheaderl; @@ -2190,8 +2192,7 @@ trans_code(struct code *code) prev_pointer = &nfheaderp->next; } - /* sniff_code_object(new_code,displacement);*/ - apply_code_fixups(code,new_code); + apply_code_fixups(code, new_code); return new_code; } @@ -2202,7 +2203,7 @@ scav_code_header(lispobj *where, lispobj object) struct code *code; int n_header_words, n_code_words, n_words; lispobj entry_point; /* tagged pointer to entry point */ - struct function *function_ptr; /* untagged pointer to entry point */ + struct simple_fun *function_ptr; /* untagged pointer to entry point */ code = (struct code *) where; n_code_words = fixnum_value(code->code_size); @@ -2213,16 +2214,16 @@ scav_code_header(lispobj *where, lispobj object) /* Scavenge the boxed section of the code data block. */ scavenge(where + 1, n_header_words - 1); - /* Scavenge the boxed section of each function object in the */ - /* code data block. */ + /* Scavenge the boxed section of each function object in the + * code data block. */ for (entry_point = code->entry_points; entry_point != NIL; entry_point = function_ptr->next) { gc_assert(is_lisp_pointer(entry_point)); - function_ptr = (struct function *) native_pointer(entry_point); - gc_assert(TypeOf(function_ptr->header) == type_FunctionHeader); + function_ptr = (struct simple_fun *) native_pointer(entry_point); + gc_assert(widetag_of(function_ptr->header)==SIMPLE_FUN_HEADER_WIDETAG); scavenge(&function_ptr->name, 1); scavenge(&function_ptr->arglist, 1); @@ -2238,7 +2239,7 @@ trans_code_header(lispobj object) struct code *ncode; ncode = trans_code((struct code *) native_pointer(object)); - return (lispobj) ncode | type_OtherPointer; + return (lispobj) ncode | OTHER_POINTER_LOWTAG; } static int @@ -2269,20 +2270,20 @@ scav_return_pc_header(lispobj *where, lispobj object) static lispobj trans_return_pc_header(lispobj object) { - struct function *return_pc; + struct simple_fun *return_pc; unsigned long offset; struct code *code, *ncode; SHOW("/trans_return_pc_header: Will this work?"); - return_pc = (struct function *) native_pointer(object); + 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); ncode = trans_code(code); - return ((lispobj) ncode + offset) | type_OtherPointer; + return ((lispobj) ncode + offset) | OTHER_POINTER_LOWTAG; } /* On the 386, closures hold a pointer to the raw address instead of the @@ -2295,19 +2296,19 @@ scav_closure_header(lispobj *where, lispobj object) lispobj fun; closure = (struct closure *)where; - fun = closure->function - RAW_ADDR_OFFSET; + fun = closure->fun - FUN_RAW_ADDR_OFFSET; scavenge(&fun, 1); /* The function may have moved so update the raw address. But * don't write unnecessarily. */ - if (closure->function != fun + RAW_ADDR_OFFSET) - closure->function = fun + RAW_ADDR_OFFSET; + if (closure->fun != fun + FUN_RAW_ADDR_OFFSET) + closure->fun = fun + FUN_RAW_ADDR_OFFSET; return 2; } #endif static int -scav_function_header(lispobj *where, lispobj object) +scav_fun_header(lispobj *where, lispobj object) { lose("attempted to scavenge a function header where=0x%08x object=0x%08x", (unsigned long) where, @@ -2316,20 +2317,20 @@ scav_function_header(lispobj *where, lispobj object) } static lispobj -trans_function_header(lispobj object) +trans_fun_header(lispobj object) { - struct function *fheader; + struct simple_fun *fheader; unsigned long offset; struct code *code, *ncode; - fheader = (struct function *) native_pointer(object); + 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); - return ((lispobj) ncode + offset) | type_FunctionPointer; + return ((lispobj) ncode + offset) | FUN_POINTER_LOWTAG; } /* @@ -2401,7 +2402,7 @@ trans_list(lispobj object) new_cons = (struct cons *) gc_quick_alloc(sizeof(struct cons)); new_cons->car = cons->car; new_cons->cdr = cons->cdr; /* updated later */ - new_list_pointer = (lispobj)new_cons | LowtagOf(object); + new_list_pointer = (lispobj)new_cons | lowtag_of(object); /* Grab the cdr before it is clobbered. */ cdr = cons->cdr; @@ -2416,7 +2417,7 @@ trans_list(lispobj object) lispobj new_cdr; struct cons *cdr_cons, *new_cdr_cons; - if (LowtagOf(cdr) != type_ListPointer || !from_space_p(cdr) + if (lowtag_of(cdr) != LIST_POINTER_LOWTAG || !from_space_p(cdr) || (*((lispobj *)native_pointer(cdr)) == 0x01)) break; @@ -2426,7 +2427,7 @@ trans_list(lispobj object) new_cdr_cons = (struct cons*) gc_quick_alloc(sizeof(struct cons)); new_cdr_cons->car = cdr_cons->car; new_cdr_cons->cdr = cdr_cons->cdr; - new_cdr = (lispobj)new_cdr_cons | LowtagOf(cdr); + new_cdr = (lispobj)new_cdr_cons | lowtag_of(cdr); /* Grab the cdr before it is clobbered. */ cdr = cdr_cons->cdr; @@ -2460,7 +2461,7 @@ scav_other_pointer(lispobj *where, lispobj object) /* Object is a pointer into from space - not FP. */ first_pointer = (lispobj *) native_pointer(object); - first = (transother[TypeOf(*first_pointer)])(object); + first = (transother[widetag_of(*first_pointer)])(object); if (first != object) { /* Set forwarding pointer. */ @@ -2562,14 +2563,14 @@ scav_fdefn(lispobj *where, lispobj object) fdefn = (struct fdefn *)where; /* FSHOW((stderr, "scav_fdefn, function = %p, raw_addr = %p\n", - fdefn->function, fdefn->raw_addr)); */ + fdefn->fun, fdefn->raw_addr)); */ - if ((char *)(fdefn->function + RAW_ADDR_OFFSET) == fdefn->raw_addr) { + if ((char *)(fdefn->fun + FUN_RAW_ADDR_OFFSET) == fdefn->raw_addr) { scavenge(where + 1, sizeof(struct fdefn)/sizeof(lispobj) - 1); /* Don't write unnecessarily. */ - if (fdefn->raw_addr != (char *)(fdefn->function + RAW_ADDR_OFFSET)) - fdefn->raw_addr = (char *)(fdefn->function + RAW_ADDR_OFFSET); + if (fdefn->raw_addr != (char *)(fdefn->fun + FUN_RAW_ADDR_OFFSET)) + fdefn->raw_addr = (char *)(fdefn->fun + FUN_RAW_ADDR_OFFSET); return sizeof(struct fdefn) / sizeof(lispobj); } else { @@ -2717,7 +2718,8 @@ scav_vector(lispobj *where, lispobj object) if (!gencgc_hash) { /* This is set for backward compatibility. FIXME: Do we need * this any more? */ - *where = (subtype_VectorMustRehash << type_Bits) | type_SimpleVector; + *where = + (subtype_VectorMustRehash<value = first_pointer[1]; } else { /* Break it. */ - SHOW("broken"); wp->value = NIL; wp->broken = T; } @@ -3537,21 +3536,27 @@ void scan_weak_pointers(void) static int scav_lose(lispobj *where, lispobj object) { - lose("no scavenge function for object 0x%08x", (unsigned long) object); + lose("no scavenge function for object 0x%08x (widetag 0x%x)", + (unsigned long)object, + widetag_of(*(lispobj*)native_pointer(object))); return 0; /* bogus return value to satisfy static type checking */ } static lispobj trans_lose(lispobj object) { - lose("no transport function for object 0x%08x", (unsigned long) object); + lose("no transport function for object 0x%08x (widetag 0x%x)", + (unsigned long)object, + widetag_of(*(lispobj*)native_pointer(object))); return NIL; /* bogus return value to satisfy static type checking */ } static int size_lose(lispobj *where) { - lose("no size function for object at 0x%08x", (unsigned long) where); + lose("no size function for object at 0x%08x (widetag 0x%x)", + (unsigned long)where, + widetag_of(where)); return 1; /* bogus return value to satisfy static type checking */ } @@ -3565,258 +3570,297 @@ gc_init_tables(void) scavtab[i] = scav_lose; } - /* For each type which can be selected by the low 3 bits of the tag - * alone, set multiple entries in our 8-bit scavenge table (one for each - * possible value of the high 5 bits). */ - for (i = 0; i < 32; i++) { /* FIXME: bare constant length, ick! */ - scavtab[type_EvenFixnum|(i<<3)] = scav_immediate; - scavtab[type_FunctionPointer|(i<<3)] = scav_function_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; + /* For each type which can be selected by the lowtag alone, set + * multiple entries in our widetag scavenge table (one for each + * possible value of the high bits). + * + * FIXME: bare constant 32 and 3 here, ick! */ + 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; } - /* Other-pointer types (those selected by all eight bits of the tag) get - * one entry each in the scavenge table. */ - 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; + /* Other-pointer types (those selected by all eight bits of the + * tag) get one entry each in the scavenge table. */ + 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[type_Complex] = scav_boxed; -#ifdef type_ComplexSingleFloat - scavtab[type_ComplexSingleFloat] = scav_unboxed; + scavtab[COMPLEX_WIDETAG] = scav_boxed; +#ifdef COMPLEX_SINGLE_FLOAT_WIDETAG + scavtab[COMPLEX_SINGLE_FLOAT_WIDETAG] = scav_unboxed; #endif -#ifdef type_ComplexDoubleFloat - scavtab[type_ComplexDoubleFloat] = scav_unboxed; +#ifdef COMPLEX_DOUBLE_FLOAT_WIDETAG + scavtab[COMPLEX_DOUBLE_FLOAT_WIDETAG] = scav_unboxed; #endif -#ifdef type_ComplexLongFloat - scavtab[type_ComplexLongFloat] = scav_unboxed; +#ifdef COMPLEX_LONG_FLOAT_WIDETAG + scavtab[COMPLEX_LONG_FLOAT_WIDETAG] = 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; + 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 type_SimpleArraySignedByte16 - scavtab[type_SimpleArraySignedByte16] = scav_vector_unsigned_byte_16; +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG + scavtab[SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG] = + scav_vector_unsigned_byte_16; #endif -#ifdef type_SimpleArraySignedByte30 - scavtab[type_SimpleArraySignedByte30] = scav_vector_unsigned_byte_32; +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG + scavtab[SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG] = + scav_vector_unsigned_byte_32; #endif -#ifdef type_SimpleArraySignedByte32 - scavtab[type_SimpleArraySignedByte32] = scav_vector_unsigned_byte_32; +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG + scavtab[SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG] = + 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; + 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 type_SimpleArrayComplexSingleFloat - scavtab[type_SimpleArrayComplexSingleFloat] = scav_vector_complex_single_float; +#ifdef SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG + scavtab[SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG] = + scav_vector_complex_single_float; #endif -#ifdef type_SimpleArrayComplexDoubleFloat - scavtab[type_SimpleArrayComplexDoubleFloat] = scav_vector_complex_double_float; +#ifdef SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG + scavtab[SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG] = + scav_vector_complex_double_float; #endif -#ifdef type_SimpleArrayComplexLongFloat - scavtab[type_SimpleArrayComplexLongFloat] = scav_vector_complex_long_float; +#ifdef SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG + scavtab[SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG] = + 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_FunctionHeader] = scav_function_header;*/ - /*scavtab[type_ClosureFunctionHeader] = scav_function_header;*/ - /*scavtab[type_ReturnPcHeader] = scav_return_pc_header;*/ + 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; + scavtab[CLOSURE_HEADER_WIDETAG] = scav_boxed; + scavtab[FUNCALLABLE_INSTANCE_HEADER_WIDETAG] = 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[type_Fdefn] = scav_fdefn; + 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; + scavtab[FDEFN_WIDETAG] = scav_fdefn; /* transport other table, initialized same way as scavtab */ 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; + 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[type_Complex] = trans_boxed; -#ifdef type_ComplexSingleFloat - transother[type_ComplexSingleFloat] = trans_unboxed; + transother[COMPLEX_WIDETAG] = trans_boxed; +#ifdef COMPLEX_SINGLE_FLOAT_WIDETAG + transother[COMPLEX_SINGLE_FLOAT_WIDETAG] = trans_unboxed; #endif -#ifdef type_ComplexDoubleFloat - transother[type_ComplexDoubleFloat] = trans_unboxed; +#ifdef COMPLEX_DOUBLE_FLOAT_WIDETAG + transother[COMPLEX_DOUBLE_FLOAT_WIDETAG] = trans_unboxed; #endif -#ifdef type_ComplexLongFloat - transother[type_ComplexLongFloat] = trans_unboxed; +#ifdef COMPLEX_LONG_FLOAT_WIDETAG + transother[COMPLEX_LONG_FLOAT_WIDETAG] = trans_unboxed; #endif - transother[type_SimpleArray] = trans_boxed_large; - 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; + transother[SIMPLE_ARRAY_WIDETAG] = trans_boxed_large; + 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 type_SimpleArraySignedByte16 - transother[type_SimpleArraySignedByte16] = trans_vector_unsigned_byte_16; +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG + transother[SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG] = + trans_vector_unsigned_byte_16; #endif -#ifdef type_SimpleArraySignedByte30 - transother[type_SimpleArraySignedByte30] = trans_vector_unsigned_byte_32; +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG + transother[SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG] = + trans_vector_unsigned_byte_32; #endif -#ifdef type_SimpleArraySignedByte32 - transother[type_SimpleArraySignedByte32] = trans_vector_unsigned_byte_32; +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG + transother[SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG] = + 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; + 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 type_SimpleArrayComplexSingleFloat - transother[type_SimpleArrayComplexSingleFloat] = trans_vector_complex_single_float; +#ifdef SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG + transother[SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG] = + trans_vector_complex_single_float; #endif -#ifdef type_SimpleArrayComplexDoubleFloat - transother[type_SimpleArrayComplexDoubleFloat] = trans_vector_complex_double_float; +#ifdef SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG + transother[SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG] = + trans_vector_complex_double_float; #endif -#ifdef type_SimpleArrayComplexLongFloat - transother[type_SimpleArrayComplexLongFloat] = trans_vector_complex_long_float; +#ifdef SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG + transother[SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG] = + 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_FunctionHeader] = trans_function_header; - transother[type_ClosureFunctionHeader] = trans_function_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; + 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, initialized the same way as scavtab */ 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_FunctionPointer|(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; + 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; + 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[type_Complex] = size_boxed; -#ifdef type_ComplexSingleFloat - sizetab[type_ComplexSingleFloat] = size_unboxed; + sizetab[COMPLEX_WIDETAG] = size_boxed; +#ifdef COMPLEX_SINGLE_FLOAT_WIDETAG + sizetab[COMPLEX_SINGLE_FLOAT_WIDETAG] = size_unboxed; #endif -#ifdef type_ComplexDoubleFloat - sizetab[type_ComplexDoubleFloat] = size_unboxed; +#ifdef COMPLEX_DOUBLE_FLOAT_WIDETAG + sizetab[COMPLEX_DOUBLE_FLOAT_WIDETAG] = size_unboxed; #endif -#ifdef type_ComplexLongFloat - sizetab[type_ComplexLongFloat] = size_unboxed; +#ifdef COMPLEX_LONG_FLOAT_WIDETAG + sizetab[COMPLEX_LONG_FLOAT_WIDETAG] = 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; + 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 type_SimpleArraySignedByte16 - sizetab[type_SimpleArraySignedByte16] = size_vector_unsigned_byte_16; +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG + sizetab[SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG] = + size_vector_unsigned_byte_16; #endif -#ifdef type_SimpleArraySignedByte30 - sizetab[type_SimpleArraySignedByte30] = size_vector_unsigned_byte_32; +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG + sizetab[SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG] = + size_vector_unsigned_byte_32; #endif -#ifdef type_SimpleArraySignedByte32 - sizetab[type_SimpleArraySignedByte32] = size_vector_unsigned_byte_32; +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG + sizetab[SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG] = + 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; + 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 type_SimpleArrayComplexSingleFloat - sizetab[type_SimpleArrayComplexSingleFloat] = size_vector_complex_single_float; +#ifdef SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG + sizetab[SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG] = + size_vector_complex_single_float; #endif -#ifdef type_SimpleArrayComplexDoubleFloat - sizetab[type_SimpleArrayComplexDoubleFloat] = size_vector_complex_double_float; +#ifdef SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG + sizetab[SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG] = + size_vector_complex_double_float; #endif -#ifdef type_SimpleArrayComplexLongFloat - sizetab[type_SimpleArrayComplexLongFloat] = size_vector_complex_long_float; +#ifdef SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG + sizetab[SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG] = + 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[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 /* We shouldn't see these, so just lose if it happens. */ - sizetab[type_FunctionHeader] = size_function_header; - sizetab[type_ClosureFunctionHeader] = size_function_header; - sizetab[type_ReturnPcHeader] = size_return_pc_header; + 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[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; + 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; } /* Scan an area looking for an object which encloses the given pointer. @@ -3831,11 +3875,11 @@ search_space(lispobj *start, size_t words, lispobj *pointer) /* If thing is an immediate then this is a cons. */ if (is_lisp_pointer(thing) || ((thing & 3) == 0) /* fixnum */ - || (TypeOf(thing) == type_BaseChar) - || (TypeOf(thing) == type_UnboundMarker)) + || (widetag_of(thing) == BASE_CHAR_WIDETAG) + || (widetag_of(thing) == UNBOUND_MARKER_WIDETAG)) count = 2; else - count = (sizetab[TypeOf(thing)])(start); + count = (sizetab[widetag_of(thing)])(start); /* Check whether the pointer is within this object. */ if ((pointer >= start) && (pointer < (start+count))) { @@ -3905,7 +3949,7 @@ possibly_valid_dynamic_space_pointer(lispobj *pointer) /* We need to allow raw pointers into Code objects for return * addresses. This will also pick up pointers to functions in code * objects. */ - if (TypeOf(*start_addr) == type_CodeHeader) { + if (widetag_of(*start_addr) == CODE_HEADER_WIDETAG) { /* XXX could do some further checks here */ return 1; } @@ -3933,18 +3977,18 @@ possibly_valid_dynamic_space_pointer(lispobj *pointer) * recording the result of the last call to allocate-lisp-memory, * and returning true from this function when *pointer is * a reference to that result. */ - switch (LowtagOf((lispobj)pointer)) { - case type_FunctionPointer: + switch (lowtag_of((lispobj)pointer)) { + case FUN_POINTER_LOWTAG: /* Start_addr should be the enclosing code object, or a closure * header. */ - switch (TypeOf(*start_addr)) { - case type_CodeHeader: + switch (widetag_of(*start_addr)) { + case CODE_HEADER_WIDETAG: /* This case is probably caught above. */ break; - case type_ClosureHeader: - case type_FuncallableInstanceHeader: + case CLOSURE_HEADER_WIDETAG: + case FUNCALLABLE_INSTANCE_HEADER_WIDETAG: if ((unsigned)pointer != - ((unsigned)start_addr+type_FunctionPointer)) { + ((unsigned)start_addr+FUN_POINTER_LOWTAG)) { if (gencgc_verbose) FSHOW((stderr, "/Wf2: %x %x %x\n", @@ -3960,9 +4004,9 @@ possibly_valid_dynamic_space_pointer(lispobj *pointer) return 0; } break; - case type_ListPointer: + case LIST_POINTER_LOWTAG: if ((unsigned)pointer != - ((unsigned)start_addr+type_ListPointer)) { + ((unsigned)start_addr+LIST_POINTER_LOWTAG)) { if (gencgc_verbose) FSHOW((stderr, "/Wl1: %x %x %x\n", @@ -3972,12 +4016,12 @@ possibly_valid_dynamic_space_pointer(lispobj *pointer) /* Is it plausible cons? */ if ((is_lisp_pointer(start_addr[0]) || ((start_addr[0] & 3) == 0) /* fixnum */ - || (TypeOf(start_addr[0]) == type_BaseChar) - || (TypeOf(start_addr[0]) == type_UnboundMarker)) + || (widetag_of(start_addr[0]) == BASE_CHAR_WIDETAG) + || (widetag_of(start_addr[0]) == UNBOUND_MARKER_WIDETAG)) && (is_lisp_pointer(start_addr[1]) || ((start_addr[1] & 3) == 0) /* fixnum */ - || (TypeOf(start_addr[1]) == type_BaseChar) - || (TypeOf(start_addr[1]) == type_UnboundMarker))) + || (widetag_of(start_addr[1]) == BASE_CHAR_WIDETAG) + || (widetag_of(start_addr[1]) == UNBOUND_MARKER_WIDETAG))) break; else { if (gencgc_verbose) @@ -3986,16 +4030,16 @@ possibly_valid_dynamic_space_pointer(lispobj *pointer) pointer, start_addr, *start_addr)); return 0; } - case type_InstancePointer: + case INSTANCE_POINTER_LOWTAG: if ((unsigned)pointer != - ((unsigned)start_addr+type_InstancePointer)) { + ((unsigned)start_addr+INSTANCE_POINTER_LOWTAG)) { if (gencgc_verbose) FSHOW((stderr, "/Wi1: %x %x %x\n", pointer, start_addr, *start_addr)); return 0; } - if (TypeOf(start_addr[0]) != type_InstanceHeader) { + if (widetag_of(start_addr[0]) != INSTANCE_HEADER_WIDETAG) { if (gencgc_verbose) FSHOW((stderr, "/Wi2: %x %x %x\n", @@ -4003,9 +4047,9 @@ possibly_valid_dynamic_space_pointer(lispobj *pointer) return 0; } break; - case type_OtherPointer: + case OTHER_POINTER_LOWTAG: if ((unsigned)pointer != - ((int)start_addr+type_OtherPointer)) { + ((int)start_addr+OTHER_POINTER_LOWTAG)) { if (gencgc_verbose) FSHOW((stderr, "/Wo1: %x %x %x\n", @@ -4020,9 +4064,9 @@ possibly_valid_dynamic_space_pointer(lispobj *pointer) pointer, start_addr, *start_addr)); return 0; } - switch (TypeOf(start_addr[0])) { - case type_UnboundMarker: - case type_BaseChar: + switch (widetag_of(start_addr[0])) { + case UNBOUND_MARKER_WIDETAG: + case BASE_CHAR_WIDETAG: if (gencgc_verbose) FSHOW((stderr, "*Wo3: %x %x %x\n", @@ -4030,15 +4074,15 @@ possibly_valid_dynamic_space_pointer(lispobj *pointer) return 0; /* only pointed to by function pointers? */ - case type_ClosureHeader: - case type_FuncallableInstanceHeader: + case CLOSURE_HEADER_WIDETAG: + case FUNCALLABLE_INSTANCE_HEADER_WIDETAG: if (gencgc_verbose) FSHOW((stderr, "*Wo4: %x %x %x\n", pointer, start_addr, *start_addr)); return 0; - case type_InstanceHeader: + case INSTANCE_HEADER_WIDETAG: if (gencgc_verbose) FSHOW((stderr, "*Wo5: %x %x %x\n", @@ -4046,68 +4090,68 @@ possibly_valid_dynamic_space_pointer(lispobj *pointer) return 0; /* the valid other immediate pointer objects */ - case type_SimpleVector: - case type_Ratio: - case type_Complex: -#ifdef type_ComplexSingleFloat - case type_ComplexSingleFloat: + case SIMPLE_VECTOR_WIDETAG: + case RATIO_WIDETAG: + case COMPLEX_WIDETAG: +#ifdef COMPLEX_SINGLE_FLOAT_WIDETAG + case COMPLEX_SINGLE_FLOAT_WIDETAG: #endif -#ifdef type_ComplexDoubleFloat - case type_ComplexDoubleFloat: +#ifdef COMPLEX_DOUBLE_FLOAT_WIDETAG + case COMPLEX_DOUBLE_FLOAT_WIDETAG: #endif -#ifdef type_ComplexLongFloat - case type_ComplexLongFloat: +#ifdef COMPLEX_LONG_FLOAT_WIDETAG + case COMPLEX_LONG_FLOAT_WIDETAG: #endif - case type_SimpleArray: - case type_ComplexString: - case type_ComplexBitVector: - case type_ComplexVector: - case type_ComplexArray: - case type_ValueCellHeader: - case type_SymbolHeader: - case type_Fdefn: - case type_CodeHeader: - case type_Bignum: - case type_SingleFloat: - case type_DoubleFloat: -#ifdef type_LongFloat - case type_LongFloat: + case SIMPLE_ARRAY_WIDETAG: + case COMPLEX_STRING_WIDETAG: + case COMPLEX_BIT_VECTOR_WIDETAG: + case COMPLEX_VECTOR_WIDETAG: + case COMPLEX_ARRAY_WIDETAG: + case VALUE_CELL_HEADER_WIDETAG: + case SYMBOL_HEADER_WIDETAG: + case FDEFN_WIDETAG: + case CODE_HEADER_WIDETAG: + case BIGNUM_WIDETAG: + case SINGLE_FLOAT_WIDETAG: + case DOUBLE_FLOAT_WIDETAG: +#ifdef LONG_FLOAT_WIDETAG + case LONG_FLOAT_WIDETAG: #endif - case type_SimpleString: - case type_SimpleBitVector: - case type_SimpleArrayUnsignedByte2: - case type_SimpleArrayUnsignedByte4: - case type_SimpleArrayUnsignedByte8: - case type_SimpleArrayUnsignedByte16: - case type_SimpleArrayUnsignedByte32: -#ifdef type_SimpleArraySignedByte8 - case type_SimpleArraySignedByte8: + case SIMPLE_STRING_WIDETAG: + case SIMPLE_BIT_VECTOR_WIDETAG: + case SIMPLE_ARRAY_UNSIGNED_BYTE_2_WIDETAG: + case SIMPLE_ARRAY_UNSIGNED_BYTE_4_WIDETAG: + case SIMPLE_ARRAY_UNSIGNED_BYTE_8_WIDETAG: + case SIMPLE_ARRAY_UNSIGNED_BYTE_16_WIDETAG: + case SIMPLE_ARRAY_UNSIGNED_BYTE_32_WIDETAG: +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_8_WIDETAG + case SIMPLE_ARRAY_SIGNED_BYTE_8_WIDETAG: #endif -#ifdef type_SimpleArraySignedByte16 - case type_SimpleArraySignedByte16: +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG + case SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG: #endif -#ifdef type_SimpleArraySignedByte30 - case type_SimpleArraySignedByte30: +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG + case SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG: #endif -#ifdef type_SimpleArraySignedByte32 - case type_SimpleArraySignedByte32: +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG + case SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG: #endif - case type_SimpleArraySingleFloat: - case type_SimpleArrayDoubleFloat: -#ifdef type_SimpleArrayLongFloat - case type_SimpleArrayLongFloat: + case SIMPLE_ARRAY_SINGLE_FLOAT_WIDETAG: + case SIMPLE_ARRAY_DOUBLE_FLOAT_WIDETAG: +#ifdef SIMPLE_ARRAY_LONG_FLOAT_WIDETAG + case SIMPLE_ARRAY_LONG_FLOAT_WIDETAG: #endif -#ifdef type_SimpleArrayComplexSingleFloat - case type_SimpleArrayComplexSingleFloat: +#ifdef SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG + case SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG: #endif -#ifdef type_SimpleArrayComplexDoubleFloat - case type_SimpleArrayComplexDoubleFloat: +#ifdef SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG + case SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG: #endif -#ifdef type_SimpleArrayComplexLongFloat - case type_SimpleArrayComplexLongFloat: +#ifdef SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG + case SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG: #endif - case type_Sap: - case type_WeakPointer: + case SAP_WIDETAG: + case WEAK_POINTER_WIDETAG: break; default: @@ -4151,43 +4195,43 @@ maybe_adjust_large_object(lispobj *where) int boxed; /* Check whether it's a vector or bignum object. */ - switch (TypeOf(where[0])) { - case type_SimpleVector: + switch (widetag_of(where[0])) { + case SIMPLE_VECTOR_WIDETAG: boxed = BOXED_PAGE; break; - case type_Bignum: - case type_SimpleString: - case type_SimpleBitVector: - case type_SimpleArrayUnsignedByte2: - case type_SimpleArrayUnsignedByte4: - case type_SimpleArrayUnsignedByte8: - case type_SimpleArrayUnsignedByte16: - case type_SimpleArrayUnsignedByte32: -#ifdef type_SimpleArraySignedByte8 - case type_SimpleArraySignedByte8: + case BIGNUM_WIDETAG: + case SIMPLE_STRING_WIDETAG: + case SIMPLE_BIT_VECTOR_WIDETAG: + case SIMPLE_ARRAY_UNSIGNED_BYTE_2_WIDETAG: + case SIMPLE_ARRAY_UNSIGNED_BYTE_4_WIDETAG: + case SIMPLE_ARRAY_UNSIGNED_BYTE_8_WIDETAG: + case SIMPLE_ARRAY_UNSIGNED_BYTE_16_WIDETAG: + case SIMPLE_ARRAY_UNSIGNED_BYTE_32_WIDETAG: +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_8_WIDETAG + case SIMPLE_ARRAY_SIGNED_BYTE_8_WIDETAG: #endif -#ifdef type_SimpleArraySignedByte16 - case type_SimpleArraySignedByte16: +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG + case SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG: #endif -#ifdef type_SimpleArraySignedByte30 - case type_SimpleArraySignedByte30: +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG + case SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG: #endif -#ifdef type_SimpleArraySignedByte32 - case type_SimpleArraySignedByte32: +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG + case SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG: #endif - case type_SimpleArraySingleFloat: - case type_SimpleArrayDoubleFloat: -#ifdef type_SimpleArrayLongFloat - case type_SimpleArrayLongFloat: + case SIMPLE_ARRAY_SINGLE_FLOAT_WIDETAG: + case SIMPLE_ARRAY_DOUBLE_FLOAT_WIDETAG: +#ifdef SIMPLE_ARRAY_LONG_FLOAT_WIDETAG + case SIMPLE_ARRAY_LONG_FLOAT_WIDETAG: #endif -#ifdef type_SimpleArrayComplexSingleFloat - case type_SimpleArrayComplexSingleFloat: +#ifdef SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG + case SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG: #endif -#ifdef type_SimpleArrayComplexDoubleFloat - case type_SimpleArrayComplexDoubleFloat: +#ifdef SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG + case SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG: #endif -#ifdef type_SimpleArrayComplexLongFloat - case type_SimpleArrayComplexLongFloat: +#ifdef SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG + case SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG: #endif boxed = UNBOXED_PAGE; break; @@ -4196,7 +4240,7 @@ maybe_adjust_large_object(lispobj *where) } /* Find its current size. */ - nwords = (sizetab[TypeOf(where[0])])(where); + nwords = (sizetab[widetag_of(where[0])])(where); first_page = find_page_index((void *)where); gc_assert(first_page >= 0); @@ -5045,35 +5089,35 @@ verify_space(lispobj *start, size_t words) if (thing & 0x3) { /* Skip fixnums. FIXME: There should be an * is_fixnum for this. */ - switch(TypeOf(*start)) { + switch(widetag_of(*start)) { /* boxed objects */ - case type_SimpleVector: - case type_Ratio: - case type_Complex: - case type_SimpleArray: - case type_ComplexString: - case type_ComplexBitVector: - case type_ComplexVector: - case type_ComplexArray: - case type_ClosureHeader: - case type_FuncallableInstanceHeader: - case type_ValueCellHeader: - case type_SymbolHeader: - case type_BaseChar: - case type_UnboundMarker: - case type_InstanceHeader: - case type_Fdefn: + case SIMPLE_VECTOR_WIDETAG: + case RATIO_WIDETAG: + case COMPLEX_WIDETAG: + case SIMPLE_ARRAY_WIDETAG: + case COMPLEX_STRING_WIDETAG: + case COMPLEX_BIT_VECTOR_WIDETAG: + case COMPLEX_VECTOR_WIDETAG: + case COMPLEX_ARRAY_WIDETAG: + case CLOSURE_HEADER_WIDETAG: + case FUNCALLABLE_INSTANCE_HEADER_WIDETAG: + case VALUE_CELL_HEADER_WIDETAG: + case SYMBOL_HEADER_WIDETAG: + case BASE_CHAR_WIDETAG: + case UNBOUND_MARKER_WIDETAG: + case INSTANCE_HEADER_WIDETAG: + case FDEFN_WIDETAG: count = 1; break; - case type_CodeHeader: + case CODE_HEADER_WIDETAG: { lispobj object = *start; struct code *code; int nheader_words, ncode_words, nwords; lispobj fheaderl; - struct function *fheaderp; + struct simple_fun *fheaderp; code = (struct code *) start; @@ -5105,12 +5149,13 @@ verify_space(lispobj *start, size_t words) /* Scavenge the boxed section of the code data block */ verify_space(start + 1, nheader_words - 1); - /* Scavenge the boxed section of each function object in - * the code data block. */ + /* Scavenge the boxed section of each function + * object in the code data block. */ fheaderl = code->entry_points; while (fheaderl != NIL) { - fheaderp = (struct function *) native_pointer(fheaderl); - gc_assert(TypeOf(fheaderp->header) == type_FunctionHeader); + fheaderp = + (struct simple_fun *) native_pointer(fheaderl); + gc_assert(widetag_of(fheaderp->header) == SIMPLE_FUN_HEADER_WIDETAG); verify_space(&fheaderp->name, 1); verify_space(&fheaderp->arglist, 1); verify_space(&fheaderp->type, 1); @@ -5121,57 +5166,57 @@ verify_space(lispobj *start, size_t words) } /* unboxed objects */ - case type_Bignum: - case type_SingleFloat: - case type_DoubleFloat: -#ifdef type_ComplexLongFloat - case type_LongFloat: + case BIGNUM_WIDETAG: + case SINGLE_FLOAT_WIDETAG: + case DOUBLE_FLOAT_WIDETAG: +#ifdef COMPLEX_LONG_FLOAT_WIDETAG + case LONG_FLOAT_WIDETAG: #endif -#ifdef type_ComplexSingleFloat - case type_ComplexSingleFloat: +#ifdef COMPLEX_SINGLE_FLOAT_WIDETAG + case COMPLEX_SINGLE_FLOAT_WIDETAG: #endif -#ifdef type_ComplexDoubleFloat - case type_ComplexDoubleFloat: +#ifdef COMPLEX_DOUBLE_FLOAT_WIDETAG + case COMPLEX_DOUBLE_FLOAT_WIDETAG: #endif -#ifdef type_ComplexLongFloat - case type_ComplexLongFloat: +#ifdef COMPLEX_LONG_FLOAT_WIDETAG + case COMPLEX_LONG_FLOAT_WIDETAG: #endif - case type_SimpleString: - case type_SimpleBitVector: - case type_SimpleArrayUnsignedByte2: - case type_SimpleArrayUnsignedByte4: - case type_SimpleArrayUnsignedByte8: - case type_SimpleArrayUnsignedByte16: - case type_SimpleArrayUnsignedByte32: -#ifdef type_SimpleArraySignedByte8 - case type_SimpleArraySignedByte8: + case SIMPLE_STRING_WIDETAG: + case SIMPLE_BIT_VECTOR_WIDETAG: + case SIMPLE_ARRAY_UNSIGNED_BYTE_2_WIDETAG: + case SIMPLE_ARRAY_UNSIGNED_BYTE_4_WIDETAG: + case SIMPLE_ARRAY_UNSIGNED_BYTE_8_WIDETAG: + case SIMPLE_ARRAY_UNSIGNED_BYTE_16_WIDETAG: + case SIMPLE_ARRAY_UNSIGNED_BYTE_32_WIDETAG: +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_8_WIDETAG + case SIMPLE_ARRAY_SIGNED_BYTE_8_WIDETAG: #endif -#ifdef type_SimpleArraySignedByte16 - case type_SimpleArraySignedByte16: +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG + case SIMPLE_ARRAY_SIGNED_BYTE_16_WIDETAG: #endif -#ifdef type_SimpleArraySignedByte30 - case type_SimpleArraySignedByte30: +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG + case SIMPLE_ARRAY_SIGNED_BYTE_30_WIDETAG: #endif -#ifdef type_SimpleArraySignedByte32 - case type_SimpleArraySignedByte32: +#ifdef SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG + case SIMPLE_ARRAY_SIGNED_BYTE_32_WIDETAG: #endif - case type_SimpleArraySingleFloat: - case type_SimpleArrayDoubleFloat: -#ifdef type_SimpleArrayComplexLongFloat - case type_SimpleArrayLongFloat: + case SIMPLE_ARRAY_SINGLE_FLOAT_WIDETAG: + case SIMPLE_ARRAY_DOUBLE_FLOAT_WIDETAG: +#ifdef SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG + case SIMPLE_ARRAY_LONG_FLOAT_WIDETAG: #endif -#ifdef type_SimpleArrayComplexSingleFloat - case type_SimpleArrayComplexSingleFloat: +#ifdef SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG + case SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG: #endif -#ifdef type_SimpleArrayComplexDoubleFloat - case type_SimpleArrayComplexDoubleFloat: +#ifdef SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG + case SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG: #endif -#ifdef type_SimpleArrayComplexLongFloat - case type_SimpleArrayComplexLongFloat: +#ifdef SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG + case SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG: #endif - case type_Sap: - case type_WeakPointer: - count = (sizetab[TypeOf(*start)])(start); + case SAP_WIDETAG: + case WEAK_POINTER_WIDETAG: + count = (sizetab[widetag_of(*start)])(start); break; default: @@ -6081,7 +6126,7 @@ component_ptr_from_pc(lispobj *pc) object = search_dynamic_space(pc); if (object) /* if we found something */ - if (TypeOf(*object) == type_CodeHeader) /* if it's a code object */ + if (widetag_of(*object) == CODE_HEADER_WIDETAG) /* if it's a code object */ return(object); return (NULL);