Re: master: Remove REQUIRED-FOREIGN-SYMBOLS static symbol
Stas Boukarev <[email protected]> Wed, 11 Feb 2026 16:35:06 +0300
| Newsgroups | gmane.lisp.steel-bank.cvs,gmane.lisp.steel-bank.devel |
|---|---|
| Message-ID | <CAF63=13PCF3uu8LBjB1eOY7ofR_bU3G=SDEr3Ls-=zScznsa6Q@mail.gmail.com> |
Win32 fails somewhere: make-target-2.sh: line 86: 1583 Segmentation fault ./src/runtime/sbcl --noinform --core output/sbcl.core --no-sysinit --no-userinit --noprint <<EOF (load "validate-float.lisp") (check-float-file "output/xfloat-math.lisp-expr") (ignore-errors (delete-file "output/reorg.core")) ;; * Lisp won't read compressed cores, and crashes on arm64 #+(and mark-region-gc x86-64 (not sb-core-compression)) (progn (load "tools-for-build/editcore") (funcall (intern "REORGANIZE-CORE" "SB-EDITCORE") "output/sbcl.core" "output/reorg.core")) EOF On Wed, Feb 11, 2026 at 7:32 AM snuglas via Sbcl-commits <[email protected]> wrote: > > The branch "master" has been updated in SBCL: > via 903f52c3f1d9e1714d38af013a9113dc06ce9b1a (commit) > from 5f9fa8c45a18798e9264d118a6c162b3c4b17d88 (commit) > > - Log ----------------------------------------------------------------- > commit 903f52c3f1d9e1714d38af013a9113dc06ce9b1a > Author: Douglas Katzman <[email protected]> > Date: Tue Feb 10 22:33:00 2026 -0500 > > Remove REQUIRED-FOREIGN-SYMBOLS static symbol > > It is basically redundant with SB-SYS:*LINKAGE-INFO* and os_link_runtime can > be a little more uniform regardless of doing early vs late C linkage. > The core header stores a pointer to the the k/v-pair vector of the hash-table > and the number of items to process. This also avoids a call to find_symbol() > on application startup of ELF cores. > --- > src/code/foreign.lisp | 13 +++++---- > src/compiler/generic/genesis.lisp | 37 +++++++++++++++---------- > src/compiler/generic/parms.lisp | 4 --- > src/runtime/core.h | 9 ++++-- > src/runtime/coreparse.c | 14 ++++++---- > src/runtime/os-common.c | 58 ++++++++++++++------------------------- > src/runtime/os.h | 3 +- > src/runtime/runtime.c | 13 ++++----- > src/runtime/save.c | 16 ++++++++++- > tests/compiler-2.pure.lisp | 6 ---- > tests/interface.pure.lisp | 2 +- > tools-for-build/editcore.lisp | 15 ++++++---- > tools-for-build/elftool.lisp | 9 ------ > 13 files changed, 99 insertions(+), 100 deletions(-) > > diff --git a/src/code/foreign.lisp b/src/code/foreign.lisp > index 7afc40efe..9d2280217 100644 > --- a/src/code/foreign.lisp > +++ b/src/code/foreign.lisp > @@ -211,16 +211,17 @@ symbol designates a variable. May enter the symbol into the linkage-table." > ;;; There 2 vars are not defglobal, as defglobal implies always-bound. > (declaim (global *runtime-dlhandle* *shared-objects*)) > (defun !foreign-cold-init () > - (loop for table-offset from 0 > - and reference across (symbol-value 'sb-vm::+required-foreign-symbols+) > - do (setf (gethash reference (car *linkage-info*)) table-offset)) > + (let ((pairvector (the simple-vector (cdr *linkage-info*))) > + (ht (make-hash-table :test 'equal :synchronized t))) > + (setf *linkage-info* (list ht)) > + (loop for j from 2 below (length pairvector) by 2 > + for linkage-index fixnum from 0 > + do (aver (eql (svref pairvector (1+ j)) linkage-index)) > + (setf (gethash (svref pairvector j) ht) linkage-index))) > #+os-provides-dlopen > (setf *runtime-dlhandle* (dlopen-or-lose)) > #+os-provides-dlopen > (setf *shared-objects* nil)) > -;;; Other than above, +required-foreign-symbols+ is not for Lisp to see. > -;;; But warn if you try to reassign it. > -(setf (info :variable :kind 'sb-vm::+required-foreign-symbols+) :constant) > > ;;; Helpers for defining error-signalling NOP's for "not supported > ;;; here" operations. > diff --git a/src/compiler/generic/genesis.lisp b/src/compiler/generic/genesis.lisp > index ec6dcecc6..c30f0a753 100644 > --- a/src/compiler/generic/genesis.lisp > +++ b/src/compiler/generic/genesis.lisp > @@ -2389,19 +2389,23 @@ Legal values for OFFSET are -4, -8, -12, ..." > (defun foreign-symbols-to-core () > (flet ((to-core (list transducer target-symbol) > (cold-set target-symbol (vector-in-core (mapcar transducer list))))) > - ;; Sort by index into alien linkage table > - (to-core (sort (%hash-table-alist *cold-foreign-symbol-table*) #'< :key #'cdr) > - (lambda (pair &aux (key (car pair)) > - (sym (string-literal-to-core > - (if (listp key) (car key) key)))) > - (if (listp key) (cold-list sym) sym)) > - 'sb-vm::+required-foreign-symbols+) > (cold-set (cold-intern '*assembler-routines*) *assembler-routines*) > (to-core *asm-routine-alist* > (lambda (rtn) > (cold-cons (cold-intern (first rtn)) (make-fixnum-descriptor (cdr rtn)))) > - '*!initial-assembler-routines*))) > - > + '*!initial-assembler-routines*)) > + (flet ((pair-to-core (pair &aux (key (car pair)) (idx (cdr pair))) > + (let ((str (string-literal-to-core (if (listp key) (car key) key)))) > + (list (if (listp key) (cold-list str) str) (make-fixnum-descriptor idx))))) > + (let* ((ht *cold-foreign-symbol-table*) > + (alist (sort (%hash-table-alist ht) #'< :key #'cdr)) ; sort by linkage index > + ;; V resembles HASH-TABLE-PAIRS of *LINKAGE-INFO*, without its table > + (v (vector-in-core (list* (make-fixnum-descriptor (hash-table-count ht)) > + (make-fixnum-descriptor 0) > + (mapcan #'pair-to-core alist))))) > + ;; C runtime reads the core header entry but cold-init reads the lisp symbol > + (cold-set (cold-intern 'sb-sys:*linkage-info*) (cold-cons *nil-descriptor* v)) > + v))) > > ;;;; general machinery for cold-loading FASL files > > @@ -4141,7 +4145,7 @@ INDEX LINK-ADDR FNAME FUNCTION NAME > ;;; the "initial core file" because core files could be created later > ;;; by executing SAVE-LISP-AND-DIE in a running system, perhaps after we've > ;;; added some functionality to the system.) > -(defun write-initial-core-file (filename build-id verbose) > +(defun write-initial-core-file (filename build-id foreign-symbols verbose) > (when verbose > (let ((*print-length* nil) > (*print-level* nil)) > @@ -4206,7 +4210,11 @@ INDEX LINK-ADDR FNAME FUNCTION NAME > ;; Write the initial function. > (let ((initial-fun (descriptor-bits (cold-symbol-function '!cold-init)))) > (when verbose (format t "~&/INITIAL-FUN=#X~X~%" initial-fun)) > - (write-words core-file initial-fun-core-entry-type-code 3 initial-fun)) > + ;; Write a 'struct initfunctions' > + (write-words core-file initial-fun-core-entry-type-code 5 > + (hash-table-count *cold-foreign-symbol-table*) > + (descriptor-bits foreign-symbols) > + initial-fun)) > > ;; Write the End entry. > (write-words core-file end-core-entry-type-code 2))) > @@ -4242,7 +4250,8 @@ INDEX LINK-ADDR FNAME FUNCTION NAME > (format nil "creating core ~S" core-file-name) > (format nil "creating headers in ~S" c-header-dir-name)))) > > - (let ((*cold-foreign-symbol-table* (make-hash-table :test 'equal))) > + (let ((*cold-foreign-symbol-table* (make-hash-table :test 'equal)) > + (foreign-symbols)) > > ;; Prefill some linkage table entries perhaps > (loop for (name datap) in sb-vm::*alien-linkage-table-predefined-entries* > @@ -4377,7 +4386,7 @@ INDEX LINK-ADDR FNAME FUNCTION NAME > (when core-file-name > (sort-initial-methods) > (resolve-deferred-known-funs) > - (foreign-symbols-to-core) > + (setq foreign-symbols (foreign-symbols-to-core)) > (finish-symbols) > (finalize-load-time-value-noise)) > > @@ -4407,7 +4416,7 @@ INDEX LINK-ADDR FNAME FUNCTION NAME > (with-open-file (stream map-file-name :direction :output :if-exists :supersede) > (write-map stream))) > (when core-file-name > - (write-initial-core-file core-file-name build-id verbose)) > + (write-initial-core-file core-file-name build-id foreign-symbols verbose)) > (unless c-header-dir-name > (return-from sb-cold:genesis)) > (let ((filename (format nil "~A/Makefile.features" c-header-dir-name))) > diff --git a/src/compiler/generic/parms.lisp b/src/compiler/generic/parms.lisp > index 24dd3df45..52c4e72d0 100644 > --- a/src/compiler/generic/parms.lisp > +++ b/src/compiler/generic/parms.lisp > @@ -237,10 +237,6 @@ > #+(and x86-64 sb-thread (not gs-seg)) > sb-aprof::*n-profile-sites* > > - ;; runtime linking of lisp->C calls (regardless of whether > - ;; the C function is in a dynamic shared object or not) > - +required-foreign-symbols+ > - > ;;; The following symbols aren't strictly required to be static > ;;; - they are not accessed from C - but we make them static in order > ;;; to (perhaps) micro-optimize access in Lisp. > diff --git a/src/runtime/core.h b/src/runtime/core.h > index 1aeb524ee..fdbc543d9 100644 > --- a/src/runtime/core.h > +++ b/src/runtime/core.h > @@ -44,8 +44,13 @@ struct memsize_options { > int present_in_core; > }; > > -extern lispobj load_core_file(char *file, os_vm_offset_t file_offset, > - int merge_core_pages); > +struct initfunctions { > + lispobj c_linkage_count; > + lispobj c_linkage_vector; > + lispobj lispfun; > +}; > +extern struct initfunctions load_core_file(char *file, os_vm_offset_t file_offset, > + int merge_core_pages); > extern os_vm_offset_t search_for_embedded_core(char *filename, > struct memsize_options *memsize_options); > > diff --git a/src/runtime/coreparse.c b/src/runtime/coreparse.c > index e216037e3..11996777d 100644 > --- a/src/runtime/coreparse.c > +++ b/src/runtime/coreparse.c > @@ -1387,7 +1387,7 @@ init_coreparse_spaces(int n, struct coreparse_space* input) > * 0: No > * -1: default, yes for compressed cores, no otherwise. > */ > -lispobj > +struct initfunctions > load_core_file(char *file, os_vm_offset_t file_offset, int merge_core_pages) > { > void *header; > @@ -1395,7 +1395,7 @@ load_core_file(char *file, os_vm_offset_t file_offset, int merge_core_pages) > os_vm_size_t len, remaining_len, stringlen; > int fd = open_binary(file, O_RDONLY); > ssize_t count; > - lispobj initial_function = NIL; > + struct initfunctions initfun = {0,0,0}; > struct heap_adjust adj; > memset(&adj, 0, sizeof adj); > sword_t linkage_table_data_page = -1; > @@ -1532,7 +1532,9 @@ load_core_file(char *file, os_vm_offset_t file_offset, int merge_core_pages) > spaces, &adj, patch_card_marking_instructions); > break; > case INITIAL_FUN_CORE_ENTRY_TYPE_CODE: > - initial_function = adjust_word(&adj, (lispobj)*ptr); > + memcpy(&initfun, ptr, sizeof initfun); > + initfun.c_linkage_vector = adjust_word(&adj, initfun.c_linkage_vector); > + initfun.lispfun = adjust_word(&adj, initfun.lispfun); > break; > case END_CORE_ENTRY_TYPE_CODE: > free(header); > @@ -1546,15 +1548,15 @@ load_core_file(char *file, os_vm_offset_t file_offset, int merge_core_pages) > SYMBOL(FREE_TLS_INDEX)->value = sizeof (struct thread); > #endif > // simple-fun implies cold-init, not a warm core (it would be a closure then) > - if (widetag_of(native_pointer(initial_function)) == SIMPLE_FUN_WIDETAG > + if (widetag_of(native_pointer(initfun.lispfun)) == SIMPLE_FUN_WIDETAG > && !lisp_startup_options.noinform) { > fprintf(stderr, "Initial page table:\n"); > extern void print_generation_stats(void); > print_generation_stats(); > } > - sanity_check_loaded_core(initial_function); > + sanity_check_loaded_core(initfun.lispfun); > free(spaces); > - return initial_function; > + return initfun; > case RUNTIME_OPTIONS_MAGIC: break; // already processed > default: > lose("unknown core header entry: %"OBJ_FMTX, (lispobj)val); > diff --git a/src/runtime/os-common.c b/src/runtime/os-common.c > index 382c8777a..d0c2b5a52 100644 > --- a/src/runtime/os-common.c > +++ b/src/runtime/os-common.c > @@ -179,29 +179,18 @@ os_dlsym_default(char *name) > #endif > > int alien_linkage_table_n_prelinked; > -struct vector* find_sb_sys_linkage_info() > -{ > - lispobj* sym = find_symbol("*LINKAGE-INFO*", get_package_by_id(PACKAGE_ID_SYS)); > - lispobj value = ((struct symbol*)sym)->value; > - gc_assert(instancep(CONS(value)->car)); > - struct hash_table* ht = (void*)native_pointer(CONS(value)->car); > - gc_assert(simple_vector_p(ht->pairs)); > - struct vector* kvv = (void*)native_pointer(ht->pairs); > - alien_linkage_table_n_prelinked = fixnum_value(kvv->data[0]); // high-water mark > - gc_assert(fixnum_value(ht->_count) == alien_linkage_table_n_prelinked); > - return kvv; > -} > - > extern lispobj* get_alien_linkage_table_initializer(); > -void os_link_runtime() > +void os_link_runtime(lispobj vector, lispobj count) > { > + // name_table is the vector that backs the SB-SYS:*LINKAGE-INFO* hash-table. > + // In genesis we create the vector as if it were a hash-table k/v vector. > + struct vector* name_table = VECTOR(vector); > + int name_index = 2, linkage_index = 0; > + // Table is the possibly nonexistent array of words filled in by the system linker. > lispobj* table = get_alien_linkage_table_initializer(); > if (table) { > - // Prefill the alien linkage table so that shrinkwrapped executables which > - // link in all their C library dependencies can avoid linking with -ldl > - // but extern-alien still works for newly compiled code. > - struct vector* name_table = find_sb_sys_linkage_info(); > - int n = alien_linkage_table_n_prelinked, linkage_index = 0, name_index = 2; > + // Every entry in sb-sys:*linkage-info* is considered pre-linked > + int n = alien_linkage_table_n_prelinked = fixnum_value(name_table->data[0]); > for ( ; n-- ; linkage_index++, name_index += 2, table++ ) { > lispobj name = name_table->data[name_index]; > gc_assert(fixnum_value(name_table->data[1+name_index]) == linkage_index); > @@ -211,24 +200,19 @@ void os_link_runtime() > gc_assert(simple_base_string_p(is_data ? CONS(name)->car : name)); > arch_write_linkage_table_entry(linkage_index, (void*)*table, is_data); > } > - return; > - } > - > - struct vector* symbols = VECTOR(SymbolValue(REQUIRED_FOREIGN_SYMBOLS,0)); > - int n = alien_linkage_table_n_prelinked = vector_len(symbols); > - int index; > - for (index = 0 ; index < n ; ++index) > - { > - lispobj item = symbols->data[index]; > - bool datap = listp(item); > - lispobj symbol_name = datap ? CONS(item)->car : item; > - char *namechars = vector_sap(symbol_name); > - void* result = os_dlsym_default(namechars); > - > - if (result) { > - arch_write_linkage_table_entry(index, result, datap); > - } else { // startup might or might not work. ymmv > - fprintf(stderr, "Missing required foreign symbol '%s'\n", namechars); > + } else { // Process only 'count' entries by looking them up > + int n = alien_linkage_table_n_prelinked = count; > + for ( ; n-- ; linkage_index++, name_index += 2 ) { > + lispobj item = name_table->data[name_index]; > + bool is_data = listp(item); > + lispobj c_symbol_name = is_data ? CONS(item)->car : item; > + char *namechars = vector_sap(c_symbol_name); > + void* result = os_dlsym_default(namechars); > + if (result) { > + arch_write_linkage_table_entry(linkage_index, result, is_data); > + } else { // startup might or might not work. ymmv > + fprintf(stderr, "Missing required foreign symbol '%s'\n", namechars); > + } > } > } > } > diff --git a/src/runtime/os.h b/src/runtime/os.h > index 730712528..9acf72e99 100644 > --- a/src/runtime/os.h > +++ b/src/runtime/os.h > @@ -79,8 +79,9 @@ int os_preinit(char *argv[], char *envp[]); > #else > #define os_preinit(dummy1,dummy2) (0) > #endif > -void os_link_runtime(); > +void os_link_runtime(lispobj, lispobj); > void os_unlink_runtime(); > +extern int alien_linkage_table_n_prelinked; > > /* Do anything we need to do when starting up the runtime environment > * in this OS. */ > diff --git a/src/runtime/runtime.c b/src/runtime/runtime.c > index 10d1652a6..4f92b9344 100644 > --- a/src/runtime/runtime.c > +++ b/src/runtime/runtime.c > @@ -642,7 +642,6 @@ initialize_lisp(int argc, char *argv[], char *envp[]) > > os_vm_offset_t embedded_core_offset = 0; > > - lispobj initial_function; > struct memsize_options memsize_options; > memsize_options.present_in_core = 0; > extern void sb_query_os_page_size(); > @@ -759,11 +758,9 @@ initialize_lisp(int argc, char *argv[], char *envp[]) > * and before any random malloc() calls occur improves the chance > * of mapping dynamic space at our preferred address (if movable). > * If not movable, it was already mapped in allocate_spaces(). */ > - initial_function = load_core_file(core, embedded_core_offset, > - options.merge_core_pages); > - if (initial_function == NIL) { > - lose("couldn't find initial function"); > - } > + struct initfunctions initfun > + = load_core_file(core, embedded_core_offset, options.merge_core_pages); > + if (!initfun.lispfun) lose("couldn't find initial function"); > > #if defined(SVR4) || defined(__linux__) || defined(__NetBSD__) || defined(__HAIKU__) > tzset(); > @@ -773,7 +770,7 @@ initialize_lisp(int argc, char *argv[], char *envp[]) > enable_lossage_handler(); > > ensure_undefined_alien(); > - os_link_runtime(); > + os_link_runtime(initfun.c_linkage_vector, initfun.c_linkage_count); > > #ifdef LISP_FEATURE_IMMOBILE_SPACE > /* Delayed until after dynamic space has been mapped, fixups made, > @@ -807,7 +804,7 @@ initialize_lisp(int argc, char *argv[], char *envp[]) > core_string = core; > posix_argv = options.argv; > > - create_main_lisp_thread(initial_function); > + create_main_lisp_thread(initfun.lispfun); > return 0; > } > > diff --git a/src/runtime/save.c b/src/runtime/save.c > index 662947c3d..e8463cde1 100644 > --- a/src/runtime/save.c > +++ b/src/runtime/save.c > @@ -270,6 +270,18 @@ static void write_static_space_constants(FILE *file) > } > #endif > > +static lispobj required_foreign_symbols() > +{ > + lispobj* sym = find_symbol("*LINKAGE-INFO*", get_package_by_id(PACKAGE_ID_SYS)); > + lispobj value = ((struct symbol*)sym)->value; > + gc_assert(instancep(CONS(value)->car)); > + struct hash_table* ht = (void*)native_pointer(CONS(value)->car); > + gc_assert(simple_vector_p(ht->pairs)); > + struct vector* kvv = (void*)native_pointer(ht->pairs); > + gc_assert(fixnum_value(ht->_count) == fixnum_value(kvv->data[0])); // high-water mark > + return ht->pairs; > +} > + > void save_to_filehandle(FILE *file, char *filename, lispobj init_function, > bool make_executable, > int save_runtime_options, > @@ -423,7 +435,9 @@ void save_to_filehandle(FILE *file, char *filename, lispobj init_function, > #endif > > write_lispobj(INITIAL_FUN_CORE_ENTRY_TYPE_CODE, file); > - write_lispobj(3, file); > + write_lispobj(5, file); > + write_lispobj(alien_linkage_table_n_prelinked, file); > + write_lispobj(required_foreign_symbols(), file); > write_lispobj(init_function, file); > > #ifdef LISP_FEATURE_GENERATIONAL > diff --git a/tests/compiler-2.pure.lisp b/tests/compiler-2.pure.lisp > index 9179cae1d..a283f828c 100644 > --- a/tests/compiler-2.pure.lisp > +++ b/tests/compiler-2.pure.lisp > @@ -213,12 +213,6 @@ > ;; Should not have a call to SET-SYMBOL-GLOBAL-VALUE> > (assert (not (ctu:find-code-constants f :type 'sb-kernel:fdefn)))))) > > -(with-test (:name :alien-linkage-table-bogosity) > - (let ((strings (map 'list (lambda (x) (if (consp x) (car x) x)) > - sb-vm::+required-foreign-symbols+))) > - (assert (= (length (remove-duplicates strings :test 'string=)) > - (length strings))))) > - > (with-test (:name (:no style-warning :for inline :cl-fun)) > (checked-compile '(lambda (x) > (declare (optimize (speed 3)) (inline length) > diff --git a/tests/interface.pure.lisp b/tests/interface.pure.lisp > index d346c11d9..678979650 100644 > --- a/tests/interface.pure.lisp > +++ b/tests/interface.pure.lisp > @@ -38,7 +38,7 @@ > > ;; Regression from R/O space change > (with-test (:name (apropos-list :smoke-test)) > - (assert (plusp (length (apropos-list "required-foreign"))))) > + (assert (plusp (length (apropos-list "**finalizer-store**"))))) > > ;;; APROPOS should accept a package designator, not just a package, and > ;;; furthermore do the right thing when it gets a package designator. > diff --git a/tools-for-build/editcore.lisp b/tools-for-build/editcore.lisp > index 80a3f0d74..106832b26 100644 > --- a/tools-for-build/editcore.lisp > +++ b/tools-for-build/editcore.lisp > @@ -999,7 +999,10 @@ > (setq constants (loop for i from (- ptr 2) repeat (+ len 2) > collect (%vector-raw-bits core-header i)))) > (#.initial-fun-core-entry-type-code > - (setq initfun (%vector-raw-bits core-header ptr))))) > + (aver (= len 3)) ; NOT including the entry type code + length itself > + (setq initfun (vector (%vector-raw-bits core-header ptr) > + (%vector-raw-bits core-header (+ ptr 1)) > + (%vector-raw-bits core-header (+ ptr 2))))))) > (let ((static (find static-core-space-id space-list :key 'space-id))) > (assert static) > (assert (= *nil-taggedptr* (+ (space-addr static) sb-vm::nil-value-offset)))) > @@ -1055,7 +1058,8 @@ > n-ptes (+ (* n-ptes *bitmap-bytes-per-page*) pte-bytes) > page-count)) > (setf (%vector-raw-bits core-header (incf offset)) word))) > - (dolist (word (list initial-fun-core-entry-type-code 3 initfun > + (dolist (word (list initial-fun-core-entry-type-code 5 > + (elt initfun 0) (elt initfun 1) (elt initfun 2) > end-core-entry-type-code 2)) > (setf (%vector-raw-bits core-header (incf offset)) word)) > (write-sequence core-header output) > @@ -2066,7 +2070,7 @@ > ;; FIXME: WITH-MAPPED-CORE should bind spacemap > (let* ((spacemap (cons sap (sort (copy-list space-list) #'> :key #'space-addr))) > (seen (visit-everything spacemap > - (core-header-initfun parsed-header) > + (elt (core-header-initfun parsed-header) 2) > (core-header-linkage-space-info parsed-header) > (core-header-static-constants parsed-header) > print)) > @@ -2107,8 +2111,9 @@ > (core-header-linkage-space-info parsed-header)) > (core-header-static-constants parsed-header) > spacemap new-spacemap seen) > - (setf (core-header-initfun parsed-header) > - (gethash (core-header-initfun parsed-header) seen)) > + (let ((init (core-header-initfun parsed-header))) > + (loop for i from 1 to 2 > + do (setf (elt init i) (the (not null) (gethash (elt init i) seen))))) > (flet ((n (spaces) > (space-next-free-page (get-space dynamic-core-space-id spaces)))) > (when print > diff --git a/tools-for-build/elftool.lisp b/tools-for-build/elftool.lisp > index e80409e0e..35b8d49e4 100644 > --- a/tools-for-build/elftool.lisp > +++ b/tools-for-build/elftool.lisp > @@ -1352,15 +1352,6 @@ lisp_fun_linkage_space: .zero ~:*~D > (if enable-pie +code-space-nominal-address+ 0)) > (write-sequence new-header output) > (force-output output) > - ;; ELF cores created from #-immobile-space cores use +required-foreign-symbols+. > - ;; But if #+immobile-space the alien-linkage-table values are computed > - ;; by 'ld' and we don't scan +required-foreign-symbols+. > - (when (get-space immobile-fixedobj-core-space-id spacemap) > - (let* ((sym (find-target-symbol (package-id "SB-VM") > - "+REQUIRED-FOREIGN-SYMBOLS+" spacemap :physical)) > - (vector (translate (symbol-global-value sym) spacemap))) > - (fill vector 0) > - (setf (%array-fill-pointer vector) 0))) > ;; Change SB-C::*COMPILE-FILE-TO-MEMORY-SPACE* to :DYNAMIC > ;; and SB-C::*COMPILE-TO-MEMORY-SPACE* to :AUTO > ;; in case the resulting executable needs to compile anything. > > ----------------------------------------------------------------------- > > > hooks/post-receive > -- > SBCL > > > _______________________________________________ > Sbcl-commits mailing list > [email protected] > https://lists.sourceforge.net/lists/listinfo/sbcl-commits _______________________________________________ Sbcl-commits mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/sbcl-commits