X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fgeneric%2Fgenesis.lisp;h=4b9ce54a1288d2e262293394c05d2e1f47befdb2;hb=eb5265ab22a2b1cae18bbdf43c871dba9b5927ea;hp=dac29001f63e4e879aa816f2339c29fe5407812a;hpb=7646aefa188758e2892fea2ad02be4f29b3938f2;p=sbcl.git diff --git a/src/compiler/generic/genesis.lisp b/src/compiler/generic/genesis.lisp index dac2900..4b9ce54 100644 --- a/src/compiler/generic/genesis.lisp +++ b/src/compiler/generic/genesis.lisp @@ -156,7 +156,7 @@ bigvec) ;;;; looking up bytes and multi-byte values in a BIGVEC (considering -;;;; it as an image of machine memory) +;;;; it as an image of machine memory on the cross-compilation target) ;;; BVREF-32 and friends. These are like SAP-REF-n, except that ;;; instead of a SAP we use a BIGVEC. @@ -199,13 +199,21 @@ (make-bvref-n 64)) ;; lispobj-sized word, whatever that may be +;; hopefully nobody ever wants a 128-bit SBCL... +#!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or)) +(progn (defun bvref-word (bytes index) - #!+x86-64 (bvref-64 bytes index) - #!-x86-64 (bvref-32 bytes index)) + (bvref-64 bytes index)) +(defun (setf bvref-word) (new-val bytes index) + (setf (bvref-64 bytes index) new-val))) +#!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or)) +(progn +(defun bvref-word (bytes index) + (bvref-32 bytes index)) (defun (setf bvref-word) (new-val bytes index) - #!+x86-64 (setf (bvref-64 bytes index) new-val) - #!-x86-64 (setf (bvref-32 bytes index) new-val)) + (setf (bvref-32 bytes index) new-val))) + ;;;; representation of spaces in the core @@ -273,7 +281,7 @@ ;; the GSPACE that this descriptor is allocated in, or NIL if not set yet. (gspace nil :type (or gspace null)) ;; the offset in words from the start of GSPACE, or NIL if not set yet - (word-offset nil :type (or (unsigned-byte #.sb!vm:n-word-bits) null)) + (word-offset nil :type (or sb!vm:word null)) ;; the high and low halves of the descriptor ;; ;; KLUDGE: Judging from the comments in genesis.lisp of the CMU CL @@ -300,7 +308,11 @@ (- unsigned #x40000000) unsigned)))) ((or (= lowtag sb!vm:other-immediate-0-lowtag) - (= lowtag sb!vm:other-immediate-1-lowtag)) + (= lowtag sb!vm:other-immediate-1-lowtag) + #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or)) + (= lowtag sb!vm:other-immediate-2-lowtag) + #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or)) + (= lowtag sb!vm:other-immediate-3-lowtag)) (format stream "for other immediate: #X~X, type #b~8,'0B" (ash (descriptor-bits des) (- sb!vm:n-widetag-bits)) @@ -356,15 +368,15 @@ (defun descriptor-fixnum (des) (let ((bits (descriptor-bits des))) (if (logbitp (1- sb!vm:n-word-bits) bits) - ;; KLUDGE: The (- SB!VM:N-WORD-BITS 2) term here looks right to - ;; me, and it works, but in CMU CL it was (1- SB!VM:N-WORD-BITS), - ;; and although that doesn't make sense for me, or work for me, - ;; it's hard to see how it could have been wrong, since CMU CL - ;; genesis worked. It would be nice to understand how this came - ;; to be.. -- WHN 19990901 - (logior (ash bits (- 1 sb!vm:n-lowtag-bits)) - (ash -1 (- sb!vm:n-word-bits (1- sb!vm:n-lowtag-bits)))) - (ash bits (- 1 sb!vm:n-lowtag-bits))))) + ;; KLUDGE: The (- SB!VM:N-WORD-BITS 2) term here looks right to + ;; me, and it works, but in CMU CL it was (1- SB!VM:N-WORD-BITS), + ;; and although that doesn't make sense for me, or work for me, + ;; it's hard to see how it could have been wrong, since CMU CL + ;; genesis worked. It would be nice to understand how this came + ;; to be.. -- WHN 19990901 + (logior (ash bits (- 1 sb!vm:n-lowtag-bits)) + (ash -1 (1+ sb!vm:n-positive-fixnum-bits))) + (ash bits (- 1 sb!vm:n-lowtag-bits))))) ;;; common idioms (defun descriptor-bytes (des) @@ -798,11 +810,9 @@ (1- sb!vm:symbol-size) sb!vm:symbol-header-widetag))) (write-wordindexed symbol sb!vm:symbol-value-slot *unbound-marker*) - #!+x86 (write-wordindexed symbol sb!vm:symbol-hash-slot - (make-fixnum-descriptor - (1+ (random sb!xc:most-positive-fixnum)))) + (make-fixnum-descriptor 0)) (write-wordindexed symbol sb!vm:symbol-plist-slot *nil-descriptor*) (write-wordindexed symbol sb!vm:symbol-name-slot (string-to-core name *dynamic*)) @@ -1458,6 +1468,7 @@ (defun cold-fdefinition-object (cold-name &optional leave-fn-raw) (declare (type descriptor cold-name)) + (/show0 "/cold-fdefinition-object") (let ((warm-name (warm-fun-name cold-name))) (or (gethash warm-name *cold-fdefn-objects*) (let ((fdefn (allocate-boxed-object (or *cold-fdefn-gspace* *dynamic*) @@ -1489,6 +1500,7 @@ sb!vm:fdefn-raw-addr-slot (ecase type (#.sb!vm:simple-fun-header-widetag + (/show0 "static-fset (simple-fun)") #!+sparc defn #!-sparc @@ -1498,6 +1510,7 @@ (ash sb!vm:simple-fun-code-offset sb!vm:word-shift)))) (#.sb!vm:closure-header-widetag + (/show0 "/static-fset (closure)") (make-random-descriptor (cold-foreign-symbol-address-as-integer (sb!vm:extern-alien-name "closure_tramp")))))) @@ -1514,8 +1527,8 @@ (desired (sb!vm:static-fun-offset sym))) (unless (= offset desired) ;; FIXME: should be fatal - (warn "Offset from FDEFN ~S to ~S is ~W, not ~W." - sym nil offset desired)))))) + (error "Offset from FDEFN ~S to ~S is ~W, not ~W." + sym nil offset desired)))))) (defun list-all-fdefn-objects () (let ((result *nil-descriptor*)) @@ -1531,55 +1544,55 @@ (defvar *cold-foreign-symbol-table*) (declaim (type hash-table *cold-foreign-symbol-table*)) -;;; Read the sbcl.nm file to find the addresses for foreign-symbols in -;;; the C runtime. +;; Read the sbcl.nm file to find the addresses for foreign-symbols in +;; the C runtime. (defun load-cold-foreign-symbol-table (filename) + (/show "load-cold-foreign-symbol-table" filename) (with-open-file (file filename) - (loop - (let ((line (read-line file nil nil))) - (unless line - (return)) - ;; UNIX symbol tables might have tabs in them, and tabs are - ;; not in Common Lisp STANDARD-CHAR, so there seems to be no - ;; nice portable way to deal with them within Lisp, alas. - ;; Fortunately, it's easy to use UNIX command line tools like - ;; sed to remove the problem, so it's not too painful for us - ;; to push responsibility for converting tabs to spaces out to - ;; the caller. - ;; - ;; Other non-STANDARD-CHARs are problematic for the same reason. - ;; Make sure that there aren't any.. - (let ((ch (find-if (lambda (char) - (not (typep char 'standard-char))) - line))) - (when ch - (error "non-STANDARD-CHAR ~S found in foreign symbol table:~%~S" - ch - line))) - (setf line (string-trim '(#\space) line)) - (let ((p1 (position #\space line :from-end nil)) - (p2 (position #\space line :from-end t))) - (if (not (and p1 p2 (< p1 p2))) - ;; KLUDGE: It's too messy to try to understand all - ;; possible output from nm, so we just punt the lines we - ;; don't recognize. We realize that there's some chance - ;; that might get us in trouble someday, so we warn - ;; about it. - (warn "ignoring unrecognized line ~S in ~A" line filename) - (multiple-value-bind (value name) - (if (string= "0x" line :end2 2) - (values (parse-integer line :start 2 :end p1 :radix 16) - (subseq line (1+ p2))) - (values (parse-integer line :end p1 :radix 16) - (subseq line (1+ p2)))) - (multiple-value-bind (old-value found) - (gethash name *cold-foreign-symbol-table*) - (when (and found - (not (= old-value value))) - (warn "redefining ~S from #X~X to #X~X" - name old-value value))) - (setf (gethash name *cold-foreign-symbol-table*) value)))))) - (values))) + (loop for line = (read-line file nil nil) + while line do + ;; UNIX symbol tables might have tabs in them, and tabs are + ;; not in Common Lisp STANDARD-CHAR, so there seems to be no + ;; nice portable way to deal with them within Lisp, alas. + ;; Fortunately, it's easy to use UNIX command line tools like + ;; sed to remove the problem, so it's not too painful for us + ;; to push responsibility for converting tabs to spaces out to + ;; the caller. + ;; + ;; Other non-STANDARD-CHARs are problematic for the same reason. + ;; Make sure that there aren't any.. + (let ((ch (find-if (lambda (char) + (not (typep char 'standard-char))) + line))) + (when ch + (error "non-STANDARD-CHAR ~S found in foreign symbol table:~%~S" + ch + line))) + (setf line (string-trim '(#\space) line)) + (let ((p1 (position #\space line :from-end nil)) + (p2 (position #\space line :from-end t))) + (if (not (and p1 p2 (< p1 p2))) + ;; KLUDGE: It's too messy to try to understand all + ;; possible output from nm, so we just punt the lines we + ;; don't recognize. We realize that there's some chance + ;; that might get us in trouble someday, so we warn + ;; about it. + (warn "ignoring unrecognized line ~S in ~A" line filename) + (multiple-value-bind (value name) + (if (string= "0x" line :end2 2) + (values (parse-integer line :start 2 :end p1 :radix 16) + (subseq line (1+ p2))) + (values (parse-integer line :end p1 :radix 16) + (subseq line (1+ p2)))) + (multiple-value-bind (old-value found) + (gethash name *cold-foreign-symbol-table*) + (when (and found + (not (= old-value value))) + (warn "redefining ~S from #X~X to #X~X" + name old-value value))) + (/show "adding to *cold-foreign-symbol-table*:" name value) + (setf (gethash name *cold-foreign-symbol-table*) value)))))) + (values)) ;; PROGN (defun cold-foreign-symbol-address-as-integer (name) (or (find-foreign-symbol-in-table name *cold-foreign-symbol-table*) @@ -1827,7 +1840,7 @@ (note-load-time-code-fixup code-object after-header value - kind)))))) )) + kind)))))))) (values)) (defun resolve-assembler-fixups () @@ -1841,20 +1854,21 @@ ;;; the core. When the core is loaded, !LOADER-COLD-INIT uses this to ;;; create *STATIC-FOREIGN-SYMBOLS*, which the code in ;;; target-load.lisp refers to. -(defun linkage-info-to-core () +(defun foreign-symbols-to-core () (let ((result *nil-descriptor*)) (maphash (lambda (symbol value) (cold-push (cold-cons (string-to-core symbol) (number-to-core value)) result)) *cold-foreign-symbol-table*) - (cold-set (cold-intern '*!initial-foreign-symbols*) result)) + (cold-set (cold-intern 'sb!kernel:*!initial-foreign-symbols*) result)) (let ((result *nil-descriptor*)) (dolist (rtn *cold-assembler-routines*) (cold-push (cold-cons (cold-intern (car rtn)) (number-to-core (cdr rtn))) result)) (cold-set (cold-intern '*!initial-assembler-routines*) result))) + ;;;; general machinery for cold-loading FASL files @@ -1894,9 +1908,9 @@ (aver (member pushp '(nil t))) (aver (member stackp '(nil t))) `(progn - (macrolet ((clone-arg () '(read-arg 4))) + (macrolet ((clone-arg () '(read-word-arg))) (define-cold-fop (,name :pushp ,pushp :stackp ,stackp) ,@forms)) - (macrolet ((clone-arg () '(read-arg 1))) + (macrolet ((clone-arg () '(read-byte-arg))) (define-cold-fop (,small-name :pushp ,pushp :stackp ,stackp) ,@forms)))) ;;; Cause a fop to be undefined in cold load. @@ -1923,7 +1937,7 @@ (define-cold-fop (fop-misc-trap) *unbound-marker*) (define-cold-fop (fop-short-character) - (make-character-descriptor (read-arg 1))) + (make-character-descriptor (read-byte-arg))) (define-cold-fop (fop-empty-list) *nil-descriptor*) (define-cold-fop (fop-truth) (cold-intern t)) @@ -2021,9 +2035,9 @@ (push-fop-table (cold-load-symbol (read-arg ,pname-len) (svref *current-fop-table* index))))))) - (frob fop-symbol-in-package-save 4 4) - (frob fop-small-symbol-in-package-save 1 4) - (frob fop-symbol-in-byte-package-save 4 1) + (frob fop-symbol-in-package-save #.sb!vm:n-word-bytes #.sb!vm:n-word-bytes) + (frob fop-small-symbol-in-package-save 1 #.sb!vm:n-word-bytes) + (frob fop-symbol-in-byte-package-save #.sb!vm:n-word-bytes 1) (frob fop-small-symbol-in-byte-package-save 1 1)) (clone-cold-fop (fop-lisp-symbol-save) @@ -2053,9 +2067,9 @@ (declare (fixnum index)))) (define-cold-fop (fop-list) - (cold-stack-list (read-arg 1) *nil-descriptor*)) + (cold-stack-list (read-byte-arg) *nil-descriptor*)) (define-cold-fop (fop-list*) - (cold-stack-list (read-arg 1) (pop-stack))) + (cold-stack-list (read-byte-arg) (pop-stack))) (define-cold-fop (fop-list-1) (cold-stack-list 1 *nil-descriptor*)) (define-cold-fop (fop-list-2) @@ -2114,8 +2128,8 @@ result)) (define-cold-fop (fop-int-vector) - (let* ((len (read-arg 4)) - (sizebits (read-arg 1)) + (let* ((len (read-word-arg)) + (sizebits (read-byte-arg)) (type (case sizebits (0 sb!vm:simple-array-nil-widetag) (1 sb!vm:simple-bit-vector-widetag) @@ -2130,6 +2144,11 @@ (31 (prog1 sb!vm:simple-array-unsigned-byte-31-widetag (setf sizebits 32))) (32 sb!vm:simple-array-unsigned-byte-32-widetag) + #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or)) + (63 (prog1 sb!vm:simple-array-unsigned-byte-63-widetag + (setf sizebits 64))) + #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or)) + (64 sb!vm:simple-array-unsigned-byte-64-widetag) (t (error "losing element size: ~W" sizebits)))) (result (allocate-vector-object *dynamic* sizebits len type)) (start (+ (descriptor-byte-offset result) @@ -2144,7 +2163,7 @@ result)) (define-cold-fop (fop-single-float-vector) - (let* ((len (read-arg 4)) + (let* ((len (read-word-arg)) (result (allocate-vector-object *dynamic* sb!vm:n-word-bits @@ -2152,7 +2171,7 @@ sb!vm:simple-array-single-float-widetag)) (start (+ (descriptor-byte-offset result) (ash sb!vm:vector-data-offset sb!vm:word-shift))) - (end (+ start (* len sb!vm:n-word-bytes)))) + (end (+ start (* len 4)))) (read-bigvec-as-sequence-or-die (descriptor-bytes result) *fasl-input-stream* :start start @@ -2166,7 +2185,7 @@ #!+long-float (not-cold-fop fop-complex-long-float-vector) (define-cold-fop (fop-array) - (let* ((rank (read-arg 4)) + (let* ((rank (read-word-arg)) (data-vector (pop-stack)) (result (allocate-boxed-object *dynamic* (+ sb!vm:array-dimensions-offset rank) @@ -2198,6 +2217,7 @@ sb!vm:array-elements-slot (make-fixnum-descriptor total-elements))) result)) + ;;;; cold fops for loading numbers @@ -2237,7 +2257,7 @@ (defvar *load-time-value-counter*) (define-cold-fop (fop-funcall) - (unless (= (read-arg 1) 0) + (unless (= (read-byte-arg) 0) (error "You can't FOP-FUNCALL arbitrary stuff in cold load.")) (let ((counter *load-time-value-counter*)) (cold-push (cold-cons @@ -2259,7 +2279,7 @@ sb!vm:simple-vector-widetag))) (define-cold-fop (fop-funcall-for-effect :pushp nil) - (if (= (read-arg 1) 0) + (if (= (read-byte-arg) 0) (cold-push (pop-stack) *current-reversed-cold-toplevels*) (error "You can't FOP-FUNCALL arbitrary stuff in cold load."))) @@ -2267,18 +2287,18 @@ ;;;; cold fops for fixing up circularities (define-cold-fop (fop-rplaca :pushp nil) - (let ((obj (svref *current-fop-table* (read-arg 4))) - (idx (read-arg 4))) + (let ((obj (svref *current-fop-table* (read-word-arg))) + (idx (read-word-arg))) (write-memory (cold-nthcdr idx obj) (pop-stack)))) (define-cold-fop (fop-rplacd :pushp nil) - (let ((obj (svref *current-fop-table* (read-arg 4))) - (idx (read-arg 4))) + (let ((obj (svref *current-fop-table* (read-word-arg))) + (idx (read-word-arg))) (write-wordindexed (cold-nthcdr idx obj) 1 (pop-stack)))) (define-cold-fop (fop-svset :pushp nil) - (let ((obj (svref *current-fop-table* (read-arg 4))) - (idx (read-arg 4))) + (let ((obj (svref *current-fop-table* (read-word-arg))) + (idx (read-word-arg))) (write-wordindexed obj (+ idx (ecase (descriptor-lowtag obj) @@ -2287,14 +2307,14 @@ (pop-stack)))) (define-cold-fop (fop-structset :pushp nil) - (let ((obj (svref *current-fop-table* (read-arg 4))) - (idx (read-arg 4))) + (let ((obj (svref *current-fop-table* (read-word-arg))) + (idx (read-word-arg))) (write-wordindexed obj (1+ idx) (pop-stack)))) ;;; In the original CMUCL code, this actually explicitly declared PUSHP ;;; to be T, even though that's what it defaults to in DEFINE-COLD-FOP. (define-cold-fop (fop-nthcdr) - (cold-nthcdr (read-arg 4) (pop-stack))) + (cold-nthcdr (read-word-arg) (pop-stack))) (defun cold-nthcdr (index obj) (dotimes (i index) @@ -2387,9 +2407,9 @@ (bvref-32 (descriptor-bytes des) i))))) des))) -(define-cold-code-fop fop-code (read-arg 4) (read-arg 4)) +(define-cold-code-fop fop-code (read-word-arg) (read-word-arg)) -(define-cold-code-fop fop-small-code (read-arg 1) (read-arg 2)) +(define-cold-code-fop fop-small-code (read-byte-arg) (read-halfword-arg)) (clone-cold-fop (fop-alter-code :pushp nil) (fop-byte-alter-code) @@ -2403,7 +2423,7 @@ (arglist (pop-stack)) (name (pop-stack)) (code-object (pop-stack)) - (offset (calc-offset code-object (read-arg 4))) + (offset (calc-offset code-object (read-word-arg))) (fn (descriptor-beyond code-object offset sb!vm:fun-pointer-lowtag)) @@ -2461,16 +2481,28 @@ (define-cold-fop (fop-foreign-fixup) (let* ((kind (pop-stack)) (code-object (pop-stack)) - (len (read-arg 1)) + (len (read-byte-arg)) (sym (make-string len))) (read-string-as-bytes *fasl-input-stream* sym) - (let ((offset (read-arg 4)) + (let ((offset (read-word-arg)) (value (cold-foreign-symbol-address-as-integer sym))) (do-cold-fixup code-object offset value kind)) - code-object)) + code-object)) + +#!+linkage-table +(define-cold-fop (fop-foreign-dataref-fixup) + (let* ((kind (pop-stack)) + (code-object (pop-stack)) + (len (read-byte-arg)) + (sym (make-string len))) + (read-string-as-bytes *fasl-input-stream* sym) + (maphash (lambda (k v) + (format *error-output* "~&~S = #X~8X~%" k v)) + *cold-foreign-symbol-table*) + (error "shared foreign symbol in cold load: ~S (~S)" sym kind))) (define-cold-fop (fop-assembler-code) - (let* ((length (read-arg 4)) + (let* ((length (read-word-arg)) (header-n-words ;; Note: we round the number of constants up to ensure that ;; the code vector will be properly aligned. @@ -2503,7 +2535,7 @@ (define-cold-fop (fop-assembler-routine) (let* ((routine (pop-stack)) (des (pop-stack)) - (offset (calc-offset des (read-arg 4)))) + (offset (calc-offset des (read-word-arg)))) (record-cold-assembler-routine routine (+ (logandc2 (descriptor-bits des) sb!vm:lowtag-mask) offset)) @@ -2513,14 +2545,14 @@ (let* ((routine (pop-stack)) (kind (pop-stack)) (code-object (pop-stack)) - (offset (read-arg 4))) + (offset (read-word-arg))) (record-cold-assembler-fixup routine code-object offset kind) code-object)) (define-cold-fop (fop-code-object-fixup) (let* ((kind (pop-stack)) (code-object (pop-stack)) - (offset (read-arg 4)) + (offset (read-word-arg)) (value (descriptor-bits code-object))) (do-cold-fixup code-object offset value kind) code-object)) @@ -2535,6 +2567,7 @@ (format t "/*~%") (dolist (line '("This is a machine-generated file. Please do not edit it by hand." + "(As of sbcl-0.8.14, it came from WRITE-CONFIG-H in genesis.lisp.)" "" "This file contains low-level information about the" "internals of a particular version and configuration" @@ -2622,9 +2655,25 @@ (maybe-record-with-munged-name "-TRAP" "trap_" 3) (maybe-record-with-munged-name "-SUBTYPE" "subtype_" 4) (maybe-record-with-munged-name "-SC-NUMBER" "sc_" 5) - (maybe-record-with-translated-name '("-START" "-END") 6) + (maybe-record-with-translated-name '("-START" "-END" "-SIZE") 6) (maybe-record-with-translated-name '("-CORE-ENTRY-TYPE-CODE") 7) (maybe-record-with-translated-name '("-CORE-SPACE-ID") 8)))))) + ;; KLUDGE: these constants are sort of important, but there's no + ;; pleasing way to inform the code above about them. So we fake + ;; it for now. nikodemus on #lisp (2004-08-09) suggested simply + ;; exporting every numeric constant from SB!VM; that would work, + ;; but the C runtime would have to be altered to use Lisp-like names + ;; rather than the munged names currently exported. --njf, 2004-08-09 + (dolist (c '(sb!vm:n-word-bits sb!vm:n-word-bytes + sb!vm:n-lowtag-bits sb!vm:lowtag-mask + sb!vm:n-widetag-bits sb!vm:widetag-mask + sb!vm:n-fixnum-tag-bits sb!vm:fixnum-tag-mask)) + (push (list (substitute #\_ #\- (symbol-name c)) + -1 ; invent a new priority + (symbol-value c) + nil) + constants)) + (setf constants (sort constants (lambda (const1 const2) @@ -3001,10 +3050,6 @@ initially undefined function references:~2%") map-file-name c-header-dir-name) - (when (and core-file-name - (not symbol-table-file-name)) - (error "can't output a core file without symbol table file input")) - (format t "~&beginning GENESIS, ~A~%" (if core-file-name @@ -3014,11 +3059,13 @@ initially undefined function references:~2%") ;; create a core. (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))) - ;; Read symbol table, if any. - (when symbol-table-file-name - (load-cold-foreign-symbol-table symbol-table-file-name)) + (when core-file-name + (if symbol-table-file-name + (load-cold-foreign-symbol-table symbol-table-file-name) + (error "can't output a core file without symbol table file input"))) ;; Now that we've successfully read our only input file (by ;; loading the symbol table, if any), it's a good time to ensure @@ -3128,7 +3175,7 @@ initially undefined function references:~2%") ;; Tidy up loose ends left by cold loading. ("Postpare from cold load?") (resolve-assembler-fixups) #!+x86 (output-load-time-code-fixups) - (linkage-info-to-core) + (foreign-symbols-to-core) (finish-symbols) (/show "back from FINISH-SYMBOLS") (finalize-load-time-value-noise)