From 96efac1b849bc34a65657199c5eba7c3c5a84361 Mon Sep 17 00:00:00 2001 From: Douglas Katzman Date: Thu, 17 Aug 2017 18:40:57 -0400 Subject: [PATCH] Change immobile space free pointers to alien vars --- contrib/sb-introspect/introspect.lisp | 3 +- src/code/alloc.lisp | 22 +++++++------ src/code/early-impl.lisp | 2 -- src/code/misc-aliens.lisp | 2 +- src/code/room.lisp | 2 +- src/compiler/generic/genesis.lisp | 13 -------- src/compiler/generic/parms.lisp | 8 +---- src/compiler/x86-64/target-insts.lisp | 2 +- src/runtime/coreparse.c | 24 +++++++------- src/runtime/gc-common.c | 4 +-- src/runtime/gencgc.c | 12 +++---- src/runtime/globals.c | 4 +++ src/runtime/globals.h | 4 +++ src/runtime/marknsweepgc.c | 59 +++++++++++++++++------------------ src/runtime/parse.c | 2 +- src/runtime/save.c | 4 +-- src/runtime/traceroot.c | 9 ++---- 17 files changed, 78 insertions(+), 98 deletions(-) diff --git a/contrib/sb-introspect/introspect.lisp b/contrib/sb-introspect/introspect.lisp index 187e50f2b..c081b6d79 100644 --- a/contrib/sb-introspect/introspect.lisp +++ b/contrib/sb-introspect/introspect.lisp @@ -812,8 +812,7 @@ Experimental: interface subject to change." :static) #+immobile-space ((< sb-vm:immobile-space-start addr - (ash sb-vm:*immobile-space-free-pointer* - sb-vm:n-fixnum-tag-bits)) + (sb-sys:sap-int sb-vm:*immobile-space-free-pointer*)) :immobile) ((< (sb-kernel:current-dynamic-space-start) addr (sb-sys:sap-int (sb-kernel:dynamic-space-free-pointer))) diff --git a/src/code/alloc.lisp b/src/code/alloc.lisp index d371063ce..9256fdc3b 100644 --- a/src/code/alloc.lisp +++ b/src/code/alloc.lisp @@ -169,7 +169,7 @@ (defun set-immobile-space-free-pointer (free-ptr) (declare (type (and fixnum unsigned-byte) free-ptr)) - (setq *immobile-space-free-pointer* (ash free-ptr (- n-fixnum-tag-bits))) + (setq *immobile-space-free-pointer* (int-sap free-ptr)) ;; When the free pointer is not page-aligned - it usually won't be - ;; then we create an unboxed array from the pointer to the page end ;; so that it appears as one contiguous object when scavenging. @@ -187,8 +187,7 @@ #!+immobile-space-debug (awhen *in-use-bits* (mark-range it hole (hole-size hole) nil)) (let* ((hole-end (hole-end-address hole)) - (end-is-free-ptr (eql (ash hole-end (- n-fixnum-tag-bits)) - *immobile-space-free-pointer*))) + (end-is-free-ptr (eql hole-end (sap-int *immobile-space-free-pointer*)))) ;; First, ensure that no page's scan-start points to this hole. ;; For smaller-than-page objects, this will do nothing if the hole ;; was not the scan-start. For larger-than-page, we have to update @@ -292,7 +291,7 @@ (add-to-freelist found) (+ found remaining)))))) ; Consume the upper piece ;; 3. Extend the frontier. - (let* ((addr (ash *immobile-space-free-pointer* n-fixnum-tag-bits)) + (let* ((addr (sap-int *immobile-space-free-pointer*)) (free-ptr (+ addr n-bytes))) ;; The last page can't be used, because GC uses it as scratch space. (when (> free-ptr (- immobile-space-end immobile-card-bytes)) @@ -374,12 +373,15 @@ (declaim (inline immobile-subspace-bounds)) (defun immobile-subspace-bounds (subspace) - (case subspace - (:fixed (values immobile-space-start - *immobile-fixedobj-free-pointer*)) - (:variable (values (+ immobile-space-start - immobile-fixedobj-subspace-size) - *immobile-space-free-pointer*)))) + ;; FIXME: this is a goofy return convention - primary value is sane, + ;; secondary has funny bit-shifted representation. + (macrolet ((munge-sap (sym) + `(ash (sap-int ,sym) (- n-fixnum-tag-bits)))) + (case subspace + (:fixed (values immobile-space-start + (munge-sap *immobile-fixedobj-free-pointer*))) + (:variable (values (+ immobile-space-start immobile-fixedobj-subspace-size) + (munge-sap *immobile-space-free-pointer*)))))) (declaim (ftype (sfunction (function &rest immobile-subspaces) null) map-immobile-objects)) diff --git a/src/code/early-impl.lisp b/src/code/early-impl.lisp index c1f895ee9..943b2ce75 100644 --- a/src/code/early-impl.lisp +++ b/src/code/early-impl.lisp @@ -21,8 +21,6 @@ *stdout* *stderr* *tty* - #!+immobile-space sb!vm:*immobile-fixedobj-free-pointer* - #!+immobile-space sb!vm:*immobile-space-free-pointer* sb!vm:*current-catch-block* sb!vm::*current-unwind-protect-block* sb!vm::*alien-stack-pointer* diff --git a/src/code/misc-aliens.lisp b/src/code/misc-aliens.lisp index 451efbc87..b390670e0 100644 --- a/src/code/misc-aliens.lisp +++ b/src/code/misc-aliens.lisp @@ -17,7 +17,7 @@ system-area-pointer) (define-alien-variable ("static_space_free_pointer" sb!vm:*static-space-free-pointer*) system-area-pointer) -#+nil ;; TODO: should be #!+immobile-space +#!+immobile-space (progn (define-alien-variable ("immobile_space_free_pointer" sb!vm:*immobile-space-free-pointer*) system-area-pointer) diff --git a/src/code/room.lisp b/src/code/room.lisp index 11b05d8df..9aa068f38 100644 --- a/src/code/room.lisp +++ b/src/code/room.lisp @@ -171,7 +171,7 @@ #!+immobile-space (:immobile (values (int-sap immobile-space-start) - (int-sap (ash *immobile-space-free-pointer* n-fixnum-tag-bits)))) + *immobile-space-free-pointer*)) (:dynamic (values (int-sap (current-dynamic-space-start)) (dynamic-space-free-pointer))))) diff --git a/src/compiler/generic/genesis.lisp b/src/compiler/generic/genesis.lisp index 3b501f00e..ed74b1ad2 100644 --- a/src/compiler/generic/genesis.lisp +++ b/src/compiler/generic/genesis.lisp @@ -3751,19 +3751,6 @@ initially undefined function references:~2%") (/show "back from FINISH-SYMBOLS") (finalize-load-time-value-noise) - ;; Tell the target Lisp how much stuff we've allocated. - (flet ((free-pointer (space) - (make-random-descriptor - (+ (ash (gspace-free-word-index space) sb!vm:word-shift) - (gspace-byte-address space))))) - #!+immobile-space - (progn (cold-set 'sb!vm:*immobile-fixedobj-free-pointer* - (free-pointer *immobile-fixedobj*)) - (cold-set 'sb!vm:*immobile-space-free-pointer* - (free-pointer *immobile-varyobj*)))) - - (/show "done setting free pointers") - ;; Write results to files. (when map-file-name (with-open-file (stream map-file-name :direction :output :if-exists :supersede) diff --git a/src/compiler/generic/parms.lisp b/src/compiler/generic/parms.lisp index 33a33a12b..964b144ad 100644 --- a/src/compiler/generic/parms.lisp +++ b/src/compiler/generic/parms.lisp @@ -146,13 +146,7 @@ (defconstant-eqx +common-static-symbols+ `(t - ;; free pointers. Note that these are FIXNUM word counts, not (as - ;; one might expect) byte counts or SAPs. The reason seems to be - ;; that by representing them this way, we can avoid consing - ;; bignums. -- WHN 2000-10-02 - *immobile-fixedobj-free-pointer* - *immobile-space-free-pointer* - *immobile-freelist* + #!+immobile-space *immobile-freelist* ;; things needed for non-local-exit *current-catch-block* diff --git a/src/compiler/x86-64/target-insts.lisp b/src/compiler/x86-64/target-insts.lisp index 2cef238dd..5f70deb6d 100644 --- a/src/compiler/x86-64/target-insts.lisp +++ b/src/compiler/x86-64/target-insts.lisp @@ -490,7 +490,7 @@ ;; so skip right over all fixedobj pages. (ash (+ immobile-space-start immobile-fixedobj-subspace-size) (- n-fixnum-tag-bits)) - *immobile-space-free-pointer*))) + (%make-lisp-obj (sap-int *immobile-space-free-pointer*))))) (defun sb!vm::statically-link-core (&key callers exclude-callers callees exclude-callees diff --git a/src/runtime/coreparse.c b/src/runtime/coreparse.c index ac6e8445b..02a2daedf 100644 --- a/src/runtime/coreparse.c +++ b/src/runtime/coreparse.c @@ -566,21 +566,22 @@ process_directory(int fd, lispobj *ptr, int count, os_vm_offset_t file_offset) struct ndir_entry *entry; struct { - uword_t len; + uword_t len; // length in pages uword_t base; + lispobj** pfree_pointer; // pointer to x_free_pointer } spaces[MAX_CORE_SPACE_ID+1] = { - {0, 0}, // blank for space ID 0 + {0, 0, 0}, // blank for space ID 0 #ifdef LISP_FEATURE_GENCGC - {0, DYNAMIC_SPACE_START}, + {0, DYNAMIC_SPACE_START, 0}, #else - {0, 0}, + {0, 0, 0}, #endif // This order is determined by constants in compiler/generic/genesis - {0, STATIC_SPACE_START}, - {0, READ_ONLY_SPACE_START}, + {0, STATIC_SPACE_START, &static_space_free_pointer}, + {0, READ_ONLY_SPACE_START, &read_only_space_free_pointer}, #ifdef LISP_FEATURE_IMMOBILE_SPACE - {0, IMMOBILE_SPACE_START}, - {0, IMMOBILE_VARYOBJ_SUBSPACE_START} + {0, IMMOBILE_SPACE_START, &immobile_fixedobj_free_pointer}, + {0, IMMOBILE_VARYOBJ_SUBSPACE_START, &immobile_space_free_pointer} #endif }; @@ -660,10 +661,9 @@ process_directory(int fd, lispobj *ptr, int count, os_vm_offset_t file_offset) lispobj *free_pointer = (lispobj *) addr + entry->nwords; switch (id) { - case READ_ONLY_CORE_SPACE_ID: - read_only_space_free_pointer = free_pointer; break; - case STATIC_CORE_SPACE_ID: - static_space_free_pointer = free_pointer; break; + default: + *spaces[id].pfree_pointer = free_pointer; + break; case DYNAMIC_CORE_SPACE_ID: /* 'addr' is the actual address if relocatable. * For cheneygc, this will be whatever the GC was using diff --git a/src/runtime/gc-common.c b/src/runtime/gc-common.c index f7f49e2c9..a18fb3bd7 100644 --- a/src/runtime/gc-common.c +++ b/src/runtime/gc-common.c @@ -2085,10 +2085,10 @@ void coalesce_similar_objects() #endif #ifdef LISP_FEATURE_IMMOBILE_SPACE coalesce_range((lispobj*)IMMOBILE_SPACE_START, - (lispobj*)SYMBOL(IMMOBILE_FIXEDOBJ_FREE_POINTER)->value, + immobile_fixedobj_free_pointer, (uword_t)&ht); coalesce_range((lispobj*)IMMOBILE_VARYOBJ_SUBSPACE_START, - (lispobj*)SYMBOL(IMMOBILE_SPACE_FREE_POINTER)->value, + immobile_space_free_pointer, (uword_t)&ht); #endif #ifdef LISP_FEATURE_GENCGC diff --git a/src/runtime/gencgc.c b/src/runtime/gencgc.c index dafa4dab5..5ce0ae25d 100644 --- a/src/runtime/gencgc.c +++ b/src/runtime/gencgc.c @@ -2783,7 +2783,7 @@ verify_range(lispobj *start, size_t words) #ifdef LISP_FEATURE_IMMOBILE_SPACE int is_in_immobile_space = (IMMOBILE_SPACE_START <= (uword_t)start && - (uword_t)start < SymbolValue(IMMOBILE_SPACE_FREE_POINTER,0)); + start < immobile_space_free_pointer); #endif lispobj *end = start + words; @@ -2804,9 +2804,9 @@ verify_range(lispobj *start, size_t words) #ifdef LISP_FEATURE_IMMOBILE_SPACE sword_t to_immobile_space = (IMMOBILE_SPACE_START <= thing && - thing < SymbolValue(IMMOBILE_FIXEDOBJ_FREE_POINTER,0)) || + thing < (lispobj)immobile_fixedobj_free_pointer) || (IMMOBILE_VARYOBJ_SUBSPACE_START <= thing && - thing < SymbolValue(IMMOBILE_SPACE_FREE_POINTER,0)); + thing < (lispobj)immobile_space_free_pointer); #endif /* Does it point to the dynamic space? */ @@ -2929,10 +2929,8 @@ verify_gc(void) extern void __attribute__((weak)) check_varyobj_pages(); if (&check_varyobj_pages) check_varyobj_pages(); # endif - verify_space(IMMOBILE_SPACE_START, - (lispobj*)SymbolValue(IMMOBILE_FIXEDOBJ_FREE_POINTER,0)); - verify_space(IMMOBILE_VARYOBJ_SUBSPACE_START, - (lispobj*)SymbolValue(IMMOBILE_SPACE_FREE_POINTER,0)); + verify_space(IMMOBILE_SPACE_START, immobile_fixedobj_free_pointer); + verify_space(IMMOBILE_VARYOBJ_SUBSPACE_START, immobile_space_free_pointer); #endif struct thread *th; for_each_thread(th) { diff --git a/src/runtime/globals.c b/src/runtime/globals.c index 817254511..207646fa4 100644 --- a/src/runtime/globals.c +++ b/src/runtime/globals.c @@ -44,6 +44,10 @@ lispobj *dynamic_space_free_pointer; #endif lispobj* read_only_space_free_pointer; lispobj* static_space_free_pointer; +#ifdef LISP_FEATURE_IMMOBILE_SPACE +lispobj* immobile_space_free_pointer; +lispobj* immobile_fixedobj_free_pointer; +#endif os_vm_address_t anon_dynamic_space_start; #ifndef LISP_FEATURE_GENCGC /* GENCGC has its own way to record trigger */ diff --git a/src/runtime/globals.h b/src/runtime/globals.h index 8a6d25f58..cddb0c019 100644 --- a/src/runtime/globals.h +++ b/src/runtime/globals.h @@ -70,6 +70,10 @@ extern lispobj *dynamic_space_free_pointer; #endif extern lispobj* read_only_space_free_pointer; extern lispobj* static_space_free_pointer; +#ifdef LISP_FEATURE_IMMOBILE_SPACE +extern lispobj* immobile_space_free_pointer; +extern lispobj* immobile_fixedobj_free_pointer; +#endif extern os_vm_address_t anon_dynamic_space_start; # ifndef LISP_FEATURE_GENCGC diff --git a/src/runtime/marknsweepgc.c b/src/runtime/marknsweepgc.c index d1fc71ba0..43b214a03 100644 --- a/src/runtime/marknsweepgc.c +++ b/src/runtime/marknsweepgc.c @@ -227,8 +227,7 @@ unsigned char varyobj_page_gens_augmented(low_page_index_t page_index) static int get_freeish_page(int hint_page, int attributes) { int page = hint_page; - lispobj new_free_pointer, old_free_pointer, actual_old; - struct symbol * free_pointer_sym; + lispobj *new_free_pointer, *old_free_pointer, *actual_old; int page_attr_packed; unsigned char best_genmask = 0xff; int best_page = -1; @@ -245,12 +244,11 @@ static int get_freeish_page(int hint_page, int attributes) 0, attributes)) == 0) { // Atomically assign MAX(old_free_pointer, new_free_pointer) // into the free pointer. - free_pointer_sym = SYMBOL(IMMOBILE_FIXEDOBJ_FREE_POINTER); - new_free_pointer = (lispobj)low_page_address(page+1); - old_free_pointer = free_pointer_sym->value; + new_free_pointer = low_page_address(page+1); + old_free_pointer = immobile_fixedobj_free_pointer; while (new_free_pointer > old_free_pointer) { actual_old = - __sync_val_compare_and_swap(&free_pointer_sym->value, + __sync_val_compare_and_swap(&immobile_fixedobj_free_pointer, old_free_pointer, new_free_pointer); if (actual_old == old_free_pointer) @@ -311,7 +309,7 @@ lispobj alloc_immobile_obj(int page_attributes, lispobj header, int* hint) int spacing_in_bytes = OBJ_SPACING(page_attributes) << WORD_SHIFT; page = *hint; - gc_dcheck(low_page_address(page) < (void*)SYMBOL(IMMOBILE_FIXEDOBJ_FREE_POINTER)->value); + gc_dcheck(low_page_address(page) < immobile_fixedobj_free_pointer); do { page_data = low_page_address(page); obj_ptr = page_data + fixedobj_pages[page].free_index; @@ -363,8 +361,8 @@ Threads A, and B, and C each want to claim index 6. void update_immobile_nursery_bits() { low_page_index_t page; - lispobj fixedobj_free_ptr = SYMBOL(IMMOBILE_FIXEDOBJ_FREE_POINTER)->value; - lispobj varyobj_free_ptr = SYMBOL(IMMOBILE_SPACE_FREE_POINTER)->value; + lispobj fixedobj_free_ptr = (lispobj)immobile_fixedobj_free_pointer; + lispobj varyobj_free_ptr = (lispobj)immobile_space_free_pointer; // Find the high water marks for this GC scavenge phase // [avoid passing exactly IMMOBILE_SPACE_END, which has no page index] @@ -465,7 +463,7 @@ void immobile_space_preserve_pointer(void* addr) // a final array acting as filler on the remainder of the // final page, we won't accidentally find that. lispobj* scan_start; - valid = (lispobj)addr < SYMBOL(IMMOBILE_SPACE_FREE_POINTER)->value + valid = addr < (void*)immobile_space_free_pointer && (varyobj_page_gens_augmented(page_index) & (1<value; + lispobj* free_pointer = immobile_space_free_pointer; low_page_index_t page; for (page = FIRST_VARYOBJ_PAGE; page <= max_used_varyobj_page; ++page) { int genmask = VARYOBJ_PAGE_GENS(page); @@ -1159,8 +1157,8 @@ static void compute_immobile_space_bound() if (fixedobj_pages[max].attr.parts.obj_size) break; max_used_fixedobj_page = max; // this is a page index, not the number of pages. - SYMBOL(IMMOBILE_FIXEDOBJ_FREE_POINTER)->value = - IMMOBILE_SPACE_START + IMMOBILE_CARD_BYTES*(1+max); + immobile_fixedobj_free_pointer = + (lispobj*)(IMMOBILE_SPACE_START + IMMOBILE_CARD_BYTES*(1+max)); for (max = (IMMOBILE_SPACE_SIZE/IMMOBILE_CARD_BYTES)-1 ; max >= FIRST_VARYOBJ_PAGE ; --max) @@ -1255,9 +1253,8 @@ void immobile_space_coreparse(uword_t fixedobj_len, uword_t varyobj_len) lispobj* space_limit = (lispobj*)(address + varyobj_len); int n_words; low_page_index_t last_page = 0; - // IMMOBILE_SPACE_FREE_POINTER should be current - // since static space is mmapped already. - lispobj* limit = (lispobj*)SYMBOL(IMMOBILE_SPACE_FREE_POINTER)->value; + // coreparse() already set immobile_space_free_pointer + lispobj* limit = immobile_space_free_pointer; gc_assert(limit != 0 /* would be zero if not mmapped yet */ && limit < space_limit); for ( ; obj < limit ; obj += n_words ) { @@ -1317,7 +1314,7 @@ void prepare_immobile_space_for_final_gc() { int page; char* page_base; - char* page_end = (char*)SYMBOL(IMMOBILE_FIXEDOBJ_FREE_POINTER)->value; + char* page_end = (char*)immobile_fixedobj_free_pointer; // The list of holes need not be saved. SYMBOL(IMMOBILE_FREELIST)->value = NIL; @@ -1341,7 +1338,7 @@ void prepare_immobile_space_for_final_gc() } lispobj* obj = (lispobj*)IMMOBILE_VARYOBJ_SUBSPACE_START; - lispobj* limit = (lispobj*)SYMBOL(IMMOBILE_SPACE_FREE_POINTER)->value; + lispobj* limit = immobile_space_free_pointer; for ( ; obj < limit ; obj += sizetab[widetag_of(*obj)](obj) ) { if (__immobile_obj_gen_bits(obj) == PSEUDO_STATIC_GENERATION) assign_generation(obj, HIGHEST_NORMAL_GENERATION); @@ -1365,7 +1362,7 @@ void prepare_immobile_space_for_save() { // Don't use the page attributes now - defrag doesn't update them. lispobj* obj = (lispobj*)IMMOBILE_SPACE_START; - lispobj* limit = (lispobj*)SYMBOL(IMMOBILE_FIXEDOBJ_FREE_POINTER)->value; + lispobj* limit = immobile_fixedobj_free_pointer; while (obj < limit) { if (other_immediate_lowtag_p(*obj)) assign_generation(obj, PSEUDO_STATIC_GENERATION); @@ -1373,7 +1370,7 @@ void prepare_immobile_space_for_save() } obj = (lispobj*)IMMOBILE_VARYOBJ_SUBSPACE_START; - limit = (lispobj*)SYMBOL(IMMOBILE_SPACE_FREE_POINTER)->value; + limit = immobile_space_free_pointer; for ( varyobj_holes = 0 ; obj < limit ; obj += sizetab[widetag_of(*obj)](obj) ) { if (immobile_filler_p(obj)) { struct code* code = (struct code*)obj; @@ -1423,7 +1420,7 @@ search_immobile_space(void *pointer) lispobj *start; if ((lispobj)pointer >= IMMOBILE_SPACE_START - && (lispobj)pointer < SYMBOL(IMMOBILE_SPACE_FREE_POINTER)->value) { + && pointer < (void*)immobile_space_free_pointer) { low_page_index_t page_index = find_immobile_page_index(pointer); if ((lispobj)pointer >= IMMOBILE_VARYOBJ_SUBSPACE_START) { if (page_attributes_valid) { @@ -1434,7 +1431,7 @@ search_immobile_space(void *pointer) } lispobj* found = gc_search_space(start, pointer); return (found && immobile_filler_p(found)) ? 0 : found; - } else if ((lispobj)pointer < SYMBOL(IMMOBILE_FIXEDOBJ_FREE_POINTER)->value) { + } else if (pointer < (void*)immobile_fixedobj_free_pointer) { char *page_base = (char*)((lispobj)pointer & ~(IMMOBILE_CARD_BYTES-1)); if (page_attributes_valid) { int spacing = page_obj_align(page_index) << WORD_SHIFT; @@ -2177,20 +2174,20 @@ void defrag_immobile_space(int* components, boolean verbose) fixedobj_tempspace.start + n_static_bytes, fixedobj_tempspace.n_bytes - n_static_bytes); // Zero-fill the unused remainder - old_free_ptr = SYMBOL(IMMOBILE_FIXEDOBJ_FREE_POINTER)->value; + old_free_ptr = (lispobj)immobile_fixedobj_free_pointer; free_ptr = IMMOBILE_SPACE_START + fixedobj_tempspace.n_bytes; bzero((char*)free_ptr, old_free_ptr - free_ptr); - SYMBOL(IMMOBILE_FIXEDOBJ_FREE_POINTER)->value = free_ptr; + immobile_fixedobj_free_pointer = (lispobj*)free_ptr; #endif // Variable-size object pages. memcpy((char*)IMMOBILE_VARYOBJ_SUBSPACE_START, varyobj_tempspace.start, varyobj_tempspace.n_bytes); // Zero-fill the unused remainder - old_free_ptr = SYMBOL(IMMOBILE_SPACE_FREE_POINTER)->value; + old_free_ptr = (lispobj)immobile_space_free_pointer; free_ptr = IMMOBILE_VARYOBJ_SUBSPACE_START + varyobj_tempspace.n_bytes; bzero((char*)free_ptr, old_free_ptr - free_ptr); - SYMBOL(IMMOBILE_SPACE_FREE_POINTER)->value = free_ptr; + immobile_space_free_pointer = (lispobj*)free_ptr; free(components); #if 0 // It's easy to mess things up, so assert correctness before saving a core. @@ -2207,7 +2204,7 @@ void defrag_immobile_space(int* components, boolean verbose) void verify_immobile_page_protection(int keep_gen, int new_gen) { low_page_index_t page; - lispobj* end = (lispobj*)SYMBOL(IMMOBILE_SPACE_FREE_POINTER)->value; + lispobj* end = immobile_space_free_pointer; low_page_index_t end_page = find_immobile_page_index((char*)end-1); lispobj* obj; @@ -2221,7 +2218,7 @@ void verify_immobile_page_protection(int keep_gen, int new_gen) // FIXME: It is is supposed to work to scan past the free pointer // on the last page, but the allocator needs to plop an array header there, // and sometimes it doesn't. - lispobj* varyobj_free_ptr = (lispobj*)(SYMBOL(IMMOBILE_SPACE_FREE_POINTER)->value); + lispobj* varyobj_free_ptr = immobile_space_free_pointer; if (page_end > varyobj_free_ptr) page_end = varyobj_free_ptr; for ( ; obj < page_end ; obj += sizetab[widetag_of(*obj)](obj) ) { if (!immobile_filler_p(obj) @@ -2362,7 +2359,7 @@ void check_varyobj_pages() // 1. Check that a linear scan sees only valid object headers, // and that it terminates exactly at IMMOBILE_CODE_FREE_POINTER. lispobj* obj = (lispobj*)IMMOBILE_VARYOBJ_SUBSPACE_START; - lispobj* end = (lispobj*)SYMBOL(IMMOBILE_SPACE_FREE_POINTER)->value; + lispobj* end = immobile_space_free_pointer; low_page_index_t end_page = find_immobile_page_index((char*)end-1); n_immobile_objects = 0; @@ -2412,7 +2409,7 @@ void check_varyobj_pages() break; // If you hit the free pointer, or run off the page, // then the page is completely empty. - if (scan_start_obj == (lispobj*)SYMBOL(IMMOBILE_SPACE_FREE_POINTER)->value + if (scan_start_obj == immobile_space_free_pointer || scan_start_obj >= (lispobj*)low_page_address(page+1)) { scan_start_obj = low_page_address(page+1); break; @@ -2444,7 +2441,7 @@ void check_varyobj_pages() // Skip the first object if it doesn't start on this page. if (obj < (lispobj*)low_page_address(page)) obj += n_words; lispobj* limit = (lispobj*)low_page_address(page) + WORDS_PER_PAGE; - lispobj* freeptr = (lispobj*)SYMBOL(IMMOBILE_SPACE_FREE_POINTER)->value; + lispobj* freeptr = immobile_space_free_pointer; if (limit > freeptr) limit = freeptr; int mask = 0; for ( ; obj < limit ; obj += sizetab[widetag_of(*obj)](obj) ) { diff --git a/src/runtime/parse.c b/src/runtime/parse.c index 4d4db32af..9b111e8bc 100644 --- a/src/runtime/parse.c +++ b/src/runtime/parse.c @@ -218,7 +218,7 @@ static lispobj lookup_symbol(char *name) /* Search immobile space. */ if ((headerptr = search_for_symbol(name, IMMOBILE_SPACE_START, - SymbolValue(IMMOBILE_FIXEDOBJ_FREE_POINTER,0)))) + (uword_t)immobile_fixedobj_free_pointer))) return make_lispobj(headerptr, OTHER_POINTER_LOWTAG); #endif diff --git a/src/runtime/save.c b/src/runtime/save.c index aaf1f452e..d8224ede6 100644 --- a/src/runtime/save.c +++ b/src/runtime/save.c @@ -323,13 +323,13 @@ save_to_filehandle(FILE *file, char *filename, lispobj init_function, output_space(file, IMMOBILE_FIXEDOBJ_CORE_SPACE_ID, (lispobj *)IMMOBILE_SPACE_START, - (lispobj *)SymbolValue(IMMOBILE_FIXEDOBJ_FREE_POINTER,0), + immobile_fixedobj_free_pointer, core_start_pos, core_compression_level); output_space(file, IMMOBILE_VARYOBJ_CORE_SPACE_ID, (lispobj *)IMMOBILE_VARYOBJ_SUBSPACE_START, - (lispobj *)SymbolValue(IMMOBILE_SPACE_FREE_POINTER,0), + immobile_space_free_pointer, core_start_pos, core_compression_level); #endif diff --git a/src/runtime/traceroot.c b/src/runtime/traceroot.c index 657d78a82..e2c12cede 100644 --- a/src/runtime/traceroot.c +++ b/src/runtime/traceroot.c @@ -190,7 +190,7 @@ static lispobj* find_sym_by_tls_index(unsigned int tls_index) lispobj* end = 0; #ifdef LISP_FEATURE_IMMOBILE_SPACE where = (lispobj*)IMMOBILE_SPACE_START; - end = (lispobj*)SYMBOL(IMMOBILE_FIXEDOBJ_FREE_POINTER)->value; + end = immobile_fixedobj_free_pointer; #endif while (1) { while (where < end) { @@ -749,12 +749,9 @@ static void scan_spaces(struct scan_state* ss) { build_refs((lispobj*)STATIC_SPACE_START, static_space_free_pointer, ss); #ifdef LISP_FEATURE_IMMOBILE_SPACE - build_refs((lispobj*)IMMOBILE_SPACE_START, - (lispobj*)SYMBOL(IMMOBILE_FIXEDOBJ_FREE_POINTER)->value, - ss); + build_refs((lispobj*)IMMOBILE_SPACE_START, immobile_fixedobj_free_pointer, ss); build_refs((lispobj*)IMMOBILE_VARYOBJ_SUBSPACE_START, - (lispobj*)SYMBOL(IMMOBILE_SPACE_FREE_POINTER)->value, - ss); + immobile_space_free_pointer, ss); #endif walk_generation((uword_t(*)(lispobj*,lispobj*,uword_t))build_refs, -1, (uword_t)ss); -- 2.11.4.GIT