X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fgc-common.c;h=c0a7119d14c7cfcb8be23dfe563f71ace488a6b8;hb=37d3828773e2f847bb1ed7522b0af4fb8e736fc8;hp=6db65fc592bb6db9857955f813c63fe320fdb496;hpb=3cd198ea8fb1635057038934730624e68b5da012;p=sbcl.git diff --git a/src/runtime/gc-common.c b/src/runtime/gc-common.c index 6db65fc..c0a7119 100644 --- a/src/runtime/gc-common.c +++ b/src/runtime/gc-common.c @@ -52,8 +52,8 @@ #endif #endif -size_t dynamic_space_size = DEFAULT_DYNAMIC_SPACE_SIZE; -size_t thread_control_stack_size = DEFAULT_CONTROL_STACK_SIZE; +os_vm_size_t dynamic_space_size = DEFAULT_DYNAMIC_SPACE_SIZE; +os_vm_size_t thread_control_stack_size = DEFAULT_CONTROL_STACK_SIZE; inline static boolean forwarding_pointer_p(lispobj *pointer) { @@ -85,9 +85,9 @@ set_forwarding_pointer(lispobj * pointer, lispobj newspace_copy) { return newspace_copy; } -long (*scavtab[256])(lispobj *where, lispobj object); +sword_t (*scavtab[256])(lispobj *where, lispobj object); lispobj (*transother[256])(lispobj object); -long (*sizetab[256])(lispobj *where); +sword_t (*sizetab[256])(lispobj *where); struct weak_pointer *weak_pointers; os_vm_size_t bytes_consed_between_gcs = 12*1024*1024; @@ -95,52 +95,33 @@ os_vm_size_t bytes_consed_between_gcs = 12*1024*1024; /* * copying objects */ -static -lispobj -gc_general_copy_object(lispobj object, long nwords, int page_type_flag) -{ - int tag; - lispobj *new; - - gc_assert(is_lisp_pointer(object)); - gc_assert(from_space_p(object)); - gc_assert((nwords & 0x01) == 0); - /* Get tag of object. */ - tag = lowtag_of(object); - - /* Allocate space. */ - new = gc_general_alloc(nwords*N_WORD_BYTES, page_type_flag, ALLOC_QUICK); - - /* Copy the object. */ - memcpy(new,native_pointer(object),nwords*N_WORD_BYTES); - return make_lispobj(new,tag); -} +/* gc_general_copy_object is inline from gc-internal.h */ /* to copy a boxed object */ lispobj -copy_object(lispobj object, long nwords) +copy_object(lispobj object, sword_t nwords) { return gc_general_copy_object(object, nwords, BOXED_PAGE_FLAG); } lispobj -copy_code_object(lispobj object, long nwords) +copy_code_object(lispobj object, sword_t nwords) { return gc_general_copy_object(object, nwords, CODE_PAGE_FLAG); } -static long scav_lose(lispobj *where, lispobj object); /* forward decl */ +static sword_t scav_lose(lispobj *where, lispobj object); /* forward decl */ /* FIXME: Most calls end up going to some trouble to compute an * 'n_words' value for this function. The system might be a little * simpler if this function used an 'end' parameter instead. */ void -scavenge(lispobj *start, long n_words) +scavenge(lispobj *start, sword_t n_words) { lispobj *end = start + n_words; lispobj *object_ptr; - long n_words_scavenged; + sword_t n_words_scavenged; for (object_ptr = start; object_ptr < end; @@ -213,7 +194,7 @@ If you can reproduce this warning, please send a bug report\n\ static lispobj trans_fun_header(lispobj object); /* forward decls */ static lispobj trans_boxed(lispobj object); -static long +static sword_t scav_fun_pointer(lispobj *where, lispobj object) { lispobj *first_pointer; @@ -255,8 +236,8 @@ trans_code(struct code *code) { struct code *new_code; lispobj first, l_code, l_new_code; - long nheader_words, ncode_words, nwords; - unsigned long displacement; + uword_t nheader_words, ncode_words, nwords; + uword_t displacement; lispobj fheaderl, *prev_pointer; /* if object has already been transported, just return pointer */ @@ -284,7 +265,7 @@ trans_code(struct code *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); + (uword_t) code, (uword_t) new_code); printf("Code object is %d words long.\n", nwords); #endif @@ -336,8 +317,8 @@ trans_code(struct code *code) #ifdef LISP_FEATURE_GENCGC /* Cheneygc doesn't need this os_flush_icache, it flushes the whole spaces once when all copying is done. */ - os_flush_icache((os_vm_address_t) (((long *)new_code) + nheader_words), - ncode_words * sizeof(long)); + os_flush_icache((os_vm_address_t) (((sword_t *)new_code) + nheader_words), + ncode_words * sizeof(sword_t)); #endif @@ -348,11 +329,11 @@ trans_code(struct code *code) return new_code; } -static long +static sword_t scav_code_header(lispobj *where, lispobj object) { struct code *code; - long n_header_words, n_code_words, n_words; + sword_t n_header_words, n_code_words, n_words; lispobj entry_point; /* tagged pointer to entry point */ struct simple_fun *function_ptr; /* untagged pointer to entry point */ @@ -373,7 +354,7 @@ scav_code_header(lispobj *where, lispobj object) gc_assert_verbose(is_lisp_pointer(entry_point), "Entry point %lx\n is not a lisp pointer.", - (long)entry_point); + (sword_t)entry_point); function_ptr = (struct simple_fun *) native_pointer(entry_point); gc_assert(widetag_of(function_ptr->header)==SIMPLE_FUN_HEADER_WIDETAG); @@ -397,11 +378,11 @@ trans_code_header(lispobj object) } -static long +static sword_t size_code_header(lispobj *where) { struct code *code; - long nheader_words, ncode_words, nwords; + sword_t nheader_words, ncode_words, nwords; code = (struct code *) where; @@ -414,12 +395,12 @@ size_code_header(lispobj *where) } #if !defined(LISP_FEATURE_X86) && ! defined(LISP_FEATURE_X86_64) -static long +static sword_t scav_return_pc_header(lispobj *where, lispobj object) { lose("attempted to scavenge a return PC header where=0x%08x object=0x%08x\n", - (unsigned long) where, - (unsigned long) object); + (uword_t) where, + (uword_t) object); return 0; /* bogus return value to satisfy static type checking */ } #endif /* LISP_FEATURE_X86 */ @@ -428,7 +409,7 @@ static lispobj trans_return_pc_header(lispobj object) { struct simple_fun *return_pc; - unsigned long offset; + uword_t offset; struct code *code, *ncode; return_pc = (struct simple_fun *) native_pointer(object); @@ -436,7 +417,7 @@ trans_return_pc_header(lispobj object) offset = HeaderValue(return_pc->header) * N_WORD_BYTES; /* Transport the whole code object */ - code = (struct code *) ((unsigned long) return_pc - offset); + code = (struct code *) ((uword_t) return_pc - offset); ncode = trans_code(code); return ((lispobj) LOW_WORD(ncode) + offset) | OTHER_POINTER_LOWTAG; @@ -449,7 +430,7 @@ trans_return_pc_header(lispobj object) * have to figure out that the function is still live. */ #if defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64) -static long +static sword_t scav_closure_header(lispobj *where, lispobj object) { struct closure *closure; @@ -469,12 +450,12 @@ scav_closure_header(lispobj *where, lispobj object) #endif #if !(defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64)) -static long +static sword_t scav_fun_header(lispobj *where, lispobj object) { lose("attempted to scavenge a function header where=0x%08x object=0x%08x\n", - (unsigned long) where, - (unsigned long) object); + (uword_t) where, + (uword_t) object); return 0; /* bogus return value to satisfy static type checking */ } #endif /* LISP_FEATURE_X86 */ @@ -483,7 +464,7 @@ static lispobj trans_fun_header(lispobj object) { struct simple_fun *fheader; - unsigned long offset; + uword_t offset; struct code *code, *ncode; fheader = (struct simple_fun *) native_pointer(object); @@ -491,7 +472,7 @@ trans_fun_header(lispobj object) offset = HeaderValue(fheader->header) * N_WORD_BYTES; /* Transport the whole code object */ - code = (struct code *) ((unsigned long) fheader - offset); + code = (struct code *) ((uword_t) fheader - offset); ncode = trans_code(code); return ((lispobj) LOW_WORD(ncode) + offset) | FUN_POINTER_LOWTAG; @@ -502,7 +483,7 @@ trans_fun_header(lispobj object) * instances */ -static long +static sword_t scav_instance_pointer(lispobj *where, lispobj object) { lispobj copy, *first_pointer; @@ -528,7 +509,7 @@ scav_instance_pointer(lispobj *where, lispobj object) static lispobj trans_list(lispobj object); -static long +static sword_t scav_list_pointer(lispobj *where, lispobj object) { lispobj first, *first_pointer; @@ -612,7 +593,7 @@ trans_list(lispobj object) * scavenging and transporting other pointers */ -static long +static sword_t scav_other_pointer(lispobj *where, lispobj object) { lispobj first, *first_pointer; @@ -642,13 +623,13 @@ scav_other_pointer(lispobj *where, lispobj object) * immediate, boxed, and unboxed objects */ -static long +static sword_t size_pointer(lispobj *where) { return 1; } -static long +static sword_t scav_immediate(lispobj *where, lispobj object) { return 1; @@ -661,24 +642,24 @@ trans_immediate(lispobj object) return NIL; /* bogus return value to satisfy static type checking */ } -static long +static sword_t size_immediate(lispobj *where) { return 1; } -static long +static sword_t scav_boxed(lispobj *where, lispobj object) { return 1; } -static long +static sword_t scav_instance(lispobj *where, lispobj object) { lispobj nuntagged; - long ntotal = HeaderValue(object); + sword_t ntotal = HeaderValue(object); lispobj layout = ((struct instance *)where)->slots[0]; if (!layout) @@ -696,7 +677,7 @@ static lispobj trans_boxed(lispobj object) { lispobj header; - unsigned long length; + uword_t length; gc_assert(is_lisp_pointer(object)); @@ -708,11 +689,11 @@ trans_boxed(lispobj object) } -static long +static sword_t size_boxed(lispobj *where) { lispobj header; - unsigned long length; + uword_t length; header = *where; length = HeaderValue(header) + 1; @@ -724,7 +705,7 @@ size_boxed(lispobj *where) /* Note: on the sparc we don't have to do anything special for fdefns, */ /* 'cause the raw-addr has a function lowtag. */ #if !defined(LISP_FEATURE_SPARC) -static long +static sword_t scav_fdefn(lispobj *where, lispobj object) { struct fdefn *fdefn; @@ -751,10 +732,10 @@ scav_fdefn(lispobj *where, lispobj object) } #endif -static long +static sword_t scav_unboxed(lispobj *where, lispobj object) { - unsigned long length; + uword_t length; length = HeaderValue(object) + 1; length = CEILING(length, 2); @@ -766,7 +747,7 @@ static lispobj trans_unboxed(lispobj object) { lispobj header; - unsigned long length; + uword_t length; gc_assert(is_lisp_pointer(object)); @@ -778,11 +759,11 @@ trans_unboxed(lispobj object) return copy_unboxed_object(object, length); } -static long +static sword_t size_unboxed(lispobj *where) { lispobj header; - unsigned long length; + uword_t length; header = *where; length = HeaderValue(header) + 1; @@ -793,11 +774,11 @@ size_unboxed(lispobj *where) /* vector-like objects */ -static long +static sword_t scav_base_string(lispobj *where, lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; /* NOTE: Strings contain one more byte of data than the length */ /* slot indicates. */ @@ -812,7 +793,7 @@ static lispobj trans_base_string(lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; gc_assert(is_lisp_pointer(object)); @@ -827,11 +808,11 @@ trans_base_string(lispobj object) return copy_large_unboxed_object(object, nwords); } -static long +static sword_t size_base_string(lispobj *where) { struct vector *vector; - long length, nwords; + sword_t length, nwords; /* NOTE: A string contains one more byte of data (a terminating * '\0' to help when interfacing with C functions) than indicated @@ -844,7 +825,7 @@ size_base_string(lispobj *where) return nwords; } -static long +static sword_t scav_character_string(lispobj *where, lispobj object) { struct vector *vector; @@ -878,7 +859,7 @@ trans_character_string(lispobj object) return copy_large_unboxed_object(object, nwords); } -static long +static sword_t size_character_string(lispobj *where) { struct vector *vector; @@ -899,7 +880,7 @@ static lispobj trans_vector(lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; gc_assert(is_lisp_pointer(object)); @@ -911,11 +892,11 @@ trans_vector(lispobj object) return copy_large_object(object, nwords); } -static long +static sword_t size_vector(lispobj *where) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -924,7 +905,7 @@ size_vector(lispobj *where) return nwords; } -static long +static sword_t scav_vector_nil(lispobj *where, lispobj object) { return 2; @@ -937,18 +918,18 @@ trans_vector_nil(lispobj object) return copy_unboxed_object(object, 2); } -static long +static sword_t size_vector_nil(lispobj *where) { /* Just the header word and the length word */ return 2; } -static long +static sword_t scav_vector_bit(lispobj *where, lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -961,7 +942,7 @@ static lispobj trans_vector_bit(lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; gc_assert(is_lisp_pointer(object)); @@ -972,11 +953,11 @@ trans_vector_bit(lispobj object) return copy_large_unboxed_object(object, nwords); } -static long +static sword_t size_vector_bit(lispobj *where) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -985,11 +966,11 @@ size_vector_bit(lispobj *where) return nwords; } -static long +static sword_t scav_vector_unsigned_byte_2(lispobj *where, lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1002,7 +983,7 @@ static lispobj trans_vector_unsigned_byte_2(lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; gc_assert(is_lisp_pointer(object)); @@ -1013,11 +994,11 @@ trans_vector_unsigned_byte_2(lispobj object) return copy_large_unboxed_object(object, nwords); } -static long +static sword_t size_vector_unsigned_byte_2(lispobj *where) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1026,11 +1007,11 @@ size_vector_unsigned_byte_2(lispobj *where) return nwords; } -static long +static sword_t scav_vector_unsigned_byte_4(lispobj *where, lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1043,7 +1024,7 @@ static lispobj trans_vector_unsigned_byte_4(lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; gc_assert(is_lisp_pointer(object)); @@ -1053,11 +1034,11 @@ trans_vector_unsigned_byte_4(lispobj object) return copy_large_unboxed_object(object, nwords); } -static long +static sword_t size_vector_unsigned_byte_4(lispobj *where) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1067,11 +1048,11 @@ size_vector_unsigned_byte_4(lispobj *where) } -static long +static sword_t scav_vector_unsigned_byte_8(lispobj *where, lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1088,7 +1069,7 @@ static lispobj trans_vector_unsigned_byte_8(lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; gc_assert(is_lisp_pointer(object)); @@ -1099,11 +1080,11 @@ trans_vector_unsigned_byte_8(lispobj object) return copy_large_unboxed_object(object, nwords); } -static long +static sword_t size_vector_unsigned_byte_8(lispobj *where) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1113,11 +1094,11 @@ size_vector_unsigned_byte_8(lispobj *where) } -static long +static sword_t scav_vector_unsigned_byte_16(lispobj *where, lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1130,7 +1111,7 @@ static lispobj trans_vector_unsigned_byte_16(lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; gc_assert(is_lisp_pointer(object)); @@ -1141,11 +1122,11 @@ trans_vector_unsigned_byte_16(lispobj object) return copy_large_unboxed_object(object, nwords); } -static long +static sword_t size_vector_unsigned_byte_16(lispobj *where) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1154,11 +1135,11 @@ size_vector_unsigned_byte_16(lispobj *where) return nwords; } -static long +static sword_t scav_vector_unsigned_byte_32(lispobj *where, lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1171,7 +1152,7 @@ static lispobj trans_vector_unsigned_byte_32(lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; gc_assert(is_lisp_pointer(object)); @@ -1182,11 +1163,11 @@ trans_vector_unsigned_byte_32(lispobj object) return copy_large_unboxed_object(object, nwords); } -static long +static sword_t size_vector_unsigned_byte_32(lispobj *where) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1196,11 +1177,11 @@ size_vector_unsigned_byte_32(lispobj *where) } #if N_WORD_BITS == 64 -static long +static sword_t scav_vector_unsigned_byte_64(lispobj *where, lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1213,7 +1194,7 @@ static lispobj trans_vector_unsigned_byte_64(lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; gc_assert(is_lisp_pointer(object)); @@ -1224,11 +1205,11 @@ trans_vector_unsigned_byte_64(lispobj object) return copy_large_unboxed_object(object, nwords); } -static long +static sword_t size_vector_unsigned_byte_64(lispobj *where) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1238,11 +1219,11 @@ size_vector_unsigned_byte_64(lispobj *where) } #endif -static long +static sword_t scav_vector_single_float(lispobj *where, lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1255,7 +1236,7 @@ static lispobj trans_vector_single_float(lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; gc_assert(is_lisp_pointer(object)); @@ -1266,11 +1247,11 @@ trans_vector_single_float(lispobj object) return copy_large_unboxed_object(object, nwords); } -static long +static sword_t size_vector_single_float(lispobj *where) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1279,11 +1260,11 @@ size_vector_single_float(lispobj *where) return nwords; } -static long +static sword_t scav_vector_double_float(lispobj *where, lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1296,7 +1277,7 @@ static lispobj trans_vector_double_float(lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; gc_assert(is_lisp_pointer(object)); @@ -1307,11 +1288,11 @@ trans_vector_double_float(lispobj object) return copy_large_unboxed_object(object, nwords); } -static long +static sword_t size_vector_double_float(lispobj *where) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1354,7 +1335,7 @@ static long size_vector_long_float(lispobj *where) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1366,11 +1347,11 @@ size_vector_long_float(lispobj *where) #ifdef SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG -static long +static sword_t scav_vector_complex_single_float(lispobj *where, lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1383,7 +1364,7 @@ static lispobj trans_vector_complex_single_float(lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; gc_assert(is_lisp_pointer(object)); @@ -1394,11 +1375,11 @@ trans_vector_complex_single_float(lispobj object) return copy_large_unboxed_object(object, nwords); } -static long +static sword_t size_vector_complex_single_float(lispobj *where) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1409,11 +1390,11 @@ size_vector_complex_single_float(lispobj *where) #endif #ifdef SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG -static long +static sword_t scav_vector_complex_double_float(lispobj *where, lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1426,7 +1407,7 @@ static lispobj trans_vector_complex_double_float(lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; gc_assert(is_lisp_pointer(object)); @@ -1437,11 +1418,11 @@ trans_vector_complex_double_float(lispobj object) return copy_large_unboxed_object(object, nwords); } -static long +static sword_t size_vector_complex_double_float(lispobj *where) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1457,7 +1438,7 @@ static long scav_vector_complex_long_float(lispobj *where, lispobj object) { struct vector *vector; - long length, nwords; + sword_t length, nwords; vector = (struct vector *) where; length = fixnum_value(vector->length); @@ -1526,7 +1507,7 @@ trans_weak_pointer(lispobj object) return copy; } -static long +static sword_t size_weak_pointer(lispobj *where) { return WEAK_POINTER_NWORDS; @@ -1620,7 +1601,7 @@ weak_hash_entry_alivep (lispobj weakness, lispobj key, lispobj value) * length) or NULL if it isn't an array of the specified widetag after * all. */ static inline lispobj * -get_array_data (lispobj array, int widetag, unsigned long *length) +get_array_data (lispobj array, int widetag, uword_t *length) { if (is_lisp_pointer(array) && (widetag_of(*(lispobj *)native_pointer(array)) == widetag)) { @@ -1641,16 +1622,16 @@ static void scav_hash_table_entries (struct hash_table *hash_table) { lispobj *kv_vector; - unsigned long kv_length; + uword_t kv_length; lispobj *index_vector; - unsigned long length; + uword_t length; lispobj *next_vector; - unsigned long next_vector_length; + uword_t next_vector_length; lispobj *hash_vector; - unsigned long hash_vector_length; + uword_t hash_vector_length; lispobj empty_symbol; lispobj weakness = hash_table->weakness; - unsigned long i; + uword_t i; kv_vector = get_array_data(hash_table->table, SIMPLE_VECTOR_WIDETAG, &kv_length); @@ -1710,10 +1691,10 @@ scav_hash_table_entries (struct hash_table *hash_table) } } -long +sword_t scav_vector (lispobj *where, lispobj object) { - unsigned long kv_length; + uword_t kv_length; lispobj *kv_vector; struct hash_table *hash_table; @@ -1735,11 +1716,11 @@ scav_vector (lispobj *where, lispobj object) * sets the header in %%PUTHASH. */ fprintf(stderr, - "Warning: no pointer at %lx in hash table: this indicates " + "Warning: no pointer at %p in hash table: this indicates " "non-fatal corruption caused by concurrent access to a " "hash-table from multiple threads. Any accesses to " "hash-tables shared between threads should be protected " - "by locks.\n", (unsigned long)&where[2]); + "by locks.\n", (uword_t)&where[2]); // We've scavenged three words. return 3; } @@ -1833,13 +1814,13 @@ scan_weak_hash_table (struct hash_table *hash_table) { lispobj *kv_vector; lispobj *index_vector; - unsigned long length = 0; /* prevent warning */ + uword_t length = 0; /* prevent warning */ lispobj *next_vector; - unsigned long next_vector_length = 0; /* prevent warning */ + uword_t next_vector_length = 0; /* prevent warning */ lispobj *hash_vector; lispobj empty_symbol; lispobj weakness = hash_table->weakness; - unsigned long i; + uword_t i; kv_vector = get_array_data(hash_table->table, SIMPLE_VECTOR_WIDETAG, NULL); @@ -1879,11 +1860,11 @@ scan_weak_hash_tables (void) * initialization */ -static long +static sword_t scav_lose(lispobj *where, lispobj object) { lose("no scavenge function for object 0x%08x (widetag 0x%x)\n", - (unsigned long)object, + (uword_t)object, widetag_of(*where)); return 0; /* bogus return value to satisfy static type checking */ @@ -1893,16 +1874,16 @@ static lispobj trans_lose(lispobj object) { lose("no transport function for object 0x%08x (widetag 0x%x)\n", - (unsigned long)object, + (uword_t)object, widetag_of(*(lispobj*)native_pointer(object))); return NIL; /* bogus return value to satisfy static type checking */ } -static long +static sword_t size_lose(lispobj *where) { lose("no size function for object at 0x%08x (widetag 0x%x)\n", - (unsigned long)where, + (uword_t)where, widetag_of(*where)); return 1; /* bogus return value to satisfy static type checking */ } @@ -1915,7 +1896,7 @@ size_lose(lispobj *where) void gc_init_tables(void) { - unsigned long i, j; + uword_t i, j; /* Set default value in all slots of scavenge table. FIXME * replace this gnarly sizeof with something based on @@ -2415,30 +2396,29 @@ gc_search_space(lispobj *start, size_t words, lispobj *pointer) * of the enclosing object. */ int -looks_like_valid_lisp_pointer_p(lispobj *pointer, lispobj *start_addr) +looks_like_valid_lisp_pointer_p(lispobj pointer, lispobj *start_addr) { - if (!is_lisp_pointer((lispobj)pointer)) { + if (!is_lisp_pointer(pointer)) { return 0; } /* Check that the object pointed to is consistent with the pointer * low tag. */ - switch (lowtag_of((lispobj)pointer)) { + switch (lowtag_of(pointer)) { case FUN_POINTER_LOWTAG: /* Start_addr should be the enclosing code object, or a closure * header. */ switch (widetag_of(*start_addr)) { case CODE_HEADER_WIDETAG: - /* Make sure we actually point to a function in the code object, - * as opposed to a random point there. */ - if (SIMPLE_FUN_HEADER_WIDETAG==widetag_of(*((lispobj *)(((unsigned long)pointer)-FUN_POINTER_LOWTAG)))) - return 1; - else - return 0; + /* Make sure we actually point to a function in the code object, + * as opposed to a random point there. */ + if (SIMPLE_FUN_HEADER_WIDETAG==widetag_of(native_pointer(pointer)[0])) + return 1; + else + return 0; case CLOSURE_HEADER_WIDETAG: case FUNCALLABLE_INSTANCE_HEADER_WIDETAG: - if ((unsigned long)pointer != - ((unsigned long)start_addr+FUN_POINTER_LOWTAG)) { + if (pointer != make_lispobj(start_addr, FUN_POINTER_LOWTAG)) { return 0; } break; @@ -2447,8 +2427,7 @@ looks_like_valid_lisp_pointer_p(lispobj *pointer, lispobj *start_addr) } break; case LIST_POINTER_LOWTAG: - if ((unsigned long)pointer != - ((unsigned long)start_addr+LIST_POINTER_LOWTAG)) { + if (pointer != make_lispobj(start_addr, LIST_POINTER_LOWTAG)) { return 0; } /* Is it plausible cons? */ @@ -2461,8 +2440,7 @@ looks_like_valid_lisp_pointer_p(lispobj *pointer, lispobj *start_addr) return 0; } case INSTANCE_POINTER_LOWTAG: - if ((unsigned long)pointer != - ((unsigned long)start_addr+INSTANCE_POINTER_LOWTAG)) { + if (pointer != make_lispobj(start_addr, INSTANCE_POINTER_LOWTAG)) { return 0; } if (widetag_of(start_addr[0]) != INSTANCE_HEADER_WIDETAG) { @@ -2478,8 +2456,7 @@ looks_like_valid_lisp_pointer_p(lispobj *pointer, lispobj *start_addr) * cannot be found by simply walking the heap, therefore we * need to check for it. -- AB, 2010-Jun-04 */ if ((widetag_of(start_addr[0]) == CODE_HEADER_WIDETAG)) { - lispobj *potential_lra = - (lispobj *)(((unsigned long)pointer) - OTHER_POINTER_LOWTAG); + lispobj *potential_lra = native_pointer(pointer); if ((widetag_of(potential_lra[0]) == RETURN_PC_HEADER_WIDETAG) && ((potential_lra - HeaderValue(potential_lra[0])) == start_addr)) { return 1; /* It's as good as we can verify. */ @@ -2487,8 +2464,7 @@ looks_like_valid_lisp_pointer_p(lispobj *pointer, lispobj *start_addr) } #endif - if ((unsigned long)pointer != - ((unsigned long)start_addr+OTHER_POINTER_LOWTAG)) { + if (pointer != make_lispobj(start_addr, OTHER_POINTER_LOWTAG)) { return 0; } /* Is it plausible? Not a cons. XXX should check the headers. */ @@ -2633,7 +2609,7 @@ valid_lisp_pointer_p(lispobj *pointer) if (((start=search_dynamic_space(pointer))!=NULL) || ((start=search_static_space(pointer))!=NULL) || ((start=search_read_only_space(pointer))!=NULL)) - return looks_like_valid_lisp_pointer_p(pointer, start); + return looks_like_valid_lisp_pointer_p((lispobj)pointer, start); else return 0; } @@ -2667,7 +2643,7 @@ maybe_gc(os_context_t *context) * A kludgy alternative is to propagate the sigmask change to the * outer context. */ -#ifndef LISP_FEATURE_WIN32 +#if !(defined(LISP_FEATURE_WIN32) || defined(LISP_FEATURE_SB_SAFEPOINT)) check_gc_signals_unblocked_or_lose(os_context_sigmask_addr(context)); unblock_gc_signals(0, 0); #endif @@ -2692,8 +2668,10 @@ maybe_gc(os_context_t *context) sigset_t *context_sigmask = os_context_sigmask_addr(context); if (!deferrables_blocked_p(context_sigmask)) { thread_sigmask(SIG_SETMASK, context_sigmask, 0); +#ifndef LISP_FEATURE_SB_SAFEPOINT check_gc_signals_unblocked_or_lose(0); #endif +#endif FSHOW((stderr, "/maybe_gc: calling POST_GC\n")); funcall0(StaticSymbolFunction(POST_GC)); #ifndef LISP_FEATURE_WIN32 @@ -2740,17 +2718,23 @@ maybe_gc(os_context_t *context) * may be what the "lame" adjective in the above comment is for. In * this case, exact gc may lose badly. */ void -scrub_control_stack(void) +scrub_control_stack() +{ + scrub_thread_control_stack(arch_os_get_current_thread()); +} + +void +scrub_thread_control_stack(struct thread *th) { - struct thread *th = arch_os_get_current_thread(); os_vm_address_t guard_page_address = CONTROL_STACK_GUARD_PAGE(th); os_vm_address_t hard_guard_page_address = CONTROL_STACK_HARD_GUARD_PAGE(th); - lispobj *sp; #ifdef LISP_FEATURE_C_STACK_IS_CONTROL_STACK - sp = (lispobj *)&sp - 1; + /* On these targets scrubbing from C is a bad idea, so we punt to + * a routine in $ARCH-assem.S. */ + extern void arch_scrub_control_stack(struct thread *, os_vm_address_t, os_vm_address_t); + arch_scrub_control_stack(th, guard_page_address, hard_guard_page_address); #else - sp = access_control_stack_pointer(th); -#endif + lispobj *sp = access_control_stack_pointer(th); scrub: if ((((os_vm_address_t)sp < (hard_guard_page_address + os_vm_page_size)) && ((os_vm_address_t)sp >= hard_guard_page_address)) || @@ -2761,28 +2745,75 @@ scrub_control_stack(void) #ifdef LISP_FEATURE_STACK_GROWS_DOWNWARD_NOT_UPWARD do { *sp = 0; - } while (((unsigned long)sp--) & (BYTES_ZERO_BEFORE_END - 1)); + } while (((uword_t)sp--) & (BYTES_ZERO_BEFORE_END - 1)); if ((os_vm_address_t)sp < (hard_guard_page_address + os_vm_page_size)) return; do { if (*sp) goto scrub; - } while (((unsigned long)sp--) & (BYTES_ZERO_BEFORE_END - 1)); + } while (((uword_t)sp--) & (BYTES_ZERO_BEFORE_END - 1)); #else do { *sp = 0; - } while (((unsigned long)++sp) & (BYTES_ZERO_BEFORE_END - 1)); + } while (((uword_t)++sp) & (BYTES_ZERO_BEFORE_END - 1)); if ((os_vm_address_t)sp >= hard_guard_page_address) return; do { if (*sp) goto scrub; - } while (((unsigned long)++sp) & (BYTES_ZERO_BEFORE_END - 1)); + } while (((uword_t)++sp) & (BYTES_ZERO_BEFORE_END - 1)); #endif +#endif /* LISP_FEATURE_C_STACK_IS_CONTROL_STACK */ } #if !defined(LISP_FEATURE_X86) && !defined(LISP_FEATURE_X86_64) +void +scavenge_control_stack(struct thread *th) +{ + lispobj *object_ptr; + + /* In order to properly support dynamic-extent allocation of + * non-CONS objects, the control stack requires special handling. + * Rather than calling scavenge() directly, grovel over it fixing + * broken hearts, scavenging pointers to oldspace, and pitching a + * fit when encountering unboxed data. This prevents stray object + * headers from causing the scavenger to blow past the end of the + * stack (an error case checked in scavenge()). We don't worry + * about treating unboxed words as boxed or vice versa, because + * the compiler isn't allowed to store unboxed objects on the + * control stack. -- AB, 2011-Dec-02 */ + + for (object_ptr = th->control_stack_start; + object_ptr < access_control_stack_pointer(th); + object_ptr++) { + + lispobj object = *object_ptr; +#ifdef LISP_FEATURE_GENCGC + if (forwarding_pointer_p(object_ptr)) + lose("unexpected forwarding pointer in scavenge_control_stack: %p, start=%p, end=%p\n", + object_ptr, th->control_stack_start, access_control_stack_pointer(th)); +#endif + if (is_lisp_pointer(object) && from_space_p(object)) { + /* It currently points to old space. Check for a + * forwarding pointer. */ + lispobj *ptr = native_pointer(object); + if (forwarding_pointer_p(ptr)) { + /* Yes, there's a forwarding pointer. */ + *object_ptr = LOW_WORD(forwarding_pointer_value(ptr)); + } else { + /* Scavenge that pointer. */ + long n_words_scavenged = + (scavtab[widetag_of(object)])(object_ptr, object); + gc_assert(n_words_scavenged == 1); + } + } else if (scavtab[widetag_of(object)] == scav_lose) { + lose("unboxed object in scavenge_control_stack: %p->%x, start=%p, end=%p\n", + object_ptr, object, th->control_stack_start, access_control_stack_pointer(th)); + } + } +} + /* Scavenging Interrupt Contexts */ static int boxed_registers[] = BOXED_REGISTERS; @@ -2815,7 +2846,7 @@ static int boxed_registers[] = BOXED_REGISTERS; *os_context_ctr_addr(context) #define INTERIOR_POINTER_VARS(name) \ - unsigned long name##_offset; \ + uword_t name##_offset; \ int name##_register_pair #define PAIR_INTERIOR_POINTER(name) \ @@ -2844,8 +2875,8 @@ static int boxed_registers[] = BOXED_REGISTERS; static void -pair_interior_pointer(os_context_t *context, unsigned long pointer, - unsigned long *saved_offset, int *register_pair) +pair_interior_pointer(os_context_t *context, uword_t pointer, + uword_t *saved_offset, int *register_pair) { int i; @@ -2856,11 +2887,11 @@ pair_interior_pointer(os_context_t *context, unsigned long pointer, */ /* 0x7FFFFFFF on 32-bit platforms; 0x7FFFFFFFFFFFFFFF on 64-bit platforms */ - *saved_offset = (((unsigned long)1) << (N_WORD_BITS - 1)) - 1; + *saved_offset = (((uword_t)1) << (N_WORD_BITS - 1)) - 1; *register_pair = -1; for (i = 0; i < (sizeof(boxed_registers) / sizeof(int)); i++) { - unsigned long reg; - long offset; + uword_t reg; + sword_t offset; int index; index = boxed_registers[i];