X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fgeneric%2Fgenesis.lisp;h=674db25f983ab6031f1a0c3cb35d33e991402c1c;hb=d334bb7db90f9f88b22cd4786083ba96d976ba33;hp=9e173373858f7883f941903555e983877960ddc6;hpb=d57319a52914c481d89415c0860dc6b7ad90ddce;p=sbcl.git diff --git a/src/compiler/generic/genesis.lisp b/src/compiler/generic/genesis.lisp index 9e17337..674db25 100644 --- a/src/compiler/generic/genesis.lisp +++ b/src/compiler/generic/genesis.lisp @@ -34,10 +34,10 @@ ;;; a magic number used to identify our core files (defconstant core-magic - (logior (ash (char-code #\S) 24) - (ash (char-code #\B) 16) - (ash (char-code #\C) 8) - (char-code #\L))) + (logior (ash (sb!xc:char-code #\S) 24) + (ash (sb!xc:char-code #\B) 16) + (ash (sb!xc:char-code #\C) 8) + (sb!xc:char-code #\L))) ;;; the current version of SBCL core files ;;; @@ -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. @@ -444,7 +444,7 @@ type))) (defun make-character-descriptor (data) - (make-other-immediate-descriptor data sb!vm:base-char-widetag)) + (make-other-immediate-descriptor data sb!vm:character-widetag)) (defun descriptor-beyond (des offset type) (let* ((low (logior (+ (logandc2 (descriptor-low des) sb!vm:lowtag-mask) @@ -608,9 +608,10 @@ ;;;; copying simple objects into the cold core -(defun string-to-core (string &optional (gspace *dynamic*)) +(defun base-string-to-core (string &optional (gspace *dynamic*)) #!+sb-doc - "Copy string into the cold core and return a descriptor to it." + "Copy STRING (which must only contain STANDARD-CHARs) into the cold +core and return a descriptor to it." ;; (Remember that the system convention for storage of strings leaves an ;; extra null byte at the end to aid in call-out to C.) (let* ((length (length string)) @@ -626,14 +627,7 @@ (make-fixnum-descriptor length)) (dotimes (i length) (setf (bvref bytes (+ offset i)) - ;; KLUDGE: There's no guarantee that the character - ;; encoding here will be the same as the character - ;; encoding on the target machine, so using CHAR-CODE as - ;; we do, or a bitwise copy as CMU CL code did, is sleazy. - ;; (To make this more portable, perhaps we could use - ;; indices into the sequence which is used to test whether - ;; a character is a STANDARD-CHAR?) -- WHN 19990817 - (char-code (aref string i)))) + (sb!xc:char-code (aref string i)))) (setf (bvref bytes (+ offset length)) 0) ; null string-termination character for C des)) @@ -815,7 +809,7 @@ (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*)) + (base-string-to-core name *dynamic*)) (write-wordindexed symbol sb!vm:symbol-package-slot *nil-descriptor*) symbol)) @@ -1201,7 +1195,7 @@ ;; because that's the way CMU CL did it; I'm ;; not sure whether there's an underlying ;; reason. -- WHN 1990826 - (string-to-core "NIL" *dynamic*)) + (base-string-to-core "NIL" *dynamic*)) (write-wordindexed des (+ 1 sb!vm:symbol-package-slot) result) @@ -1286,7 +1280,7 @@ (let* ((cold-package (car cold-package-symbols-entry)) (symbols (cdr cold-package-symbols-entry)) (shadows (package-shadowing-symbols cold-package)) - (documentation (string-to-core (documentation cold-package t))) + (documentation (base-string-to-core (documentation cold-package t))) (internal *nil-descriptor*) (external *nil-descriptor*) (imported-internal *nil-descriptor*) @@ -1366,7 +1360,7 @@ (res *nil-descriptor*)) (dolist (u (package-use-list pkg)) (when (assoc u *cold-package-symbols*) - (cold-push (string-to-core (package-name u)) use))) + (cold-push (base-string-to-core (package-name u)) use))) (let* ((pkg-name (package-name pkg)) ;; Make the package nickname lists for the standard packages ;; be the minimum specified by ANSI, regardless of what value @@ -1387,7 +1381,7 @@ (t (package-nicknames pkg))))) (dolist (warm-nickname warm-nicknames) - (cold-push (string-to-core warm-nickname) cold-nicknames))) + (cold-push (base-string-to-core warm-nickname) cold-nicknames))) (cold-push (number-to-core (truncate (package-internal-symbol-count pkg) 0.8)) @@ -1404,7 +1398,7 @@ (cold-push use res) (cold-push (cold-intern :use) res) - (cold-push (string-to-core (package-name pkg)) res) + (cold-push (base-string-to-core (package-name pkg)) res) res)) ;;;; functions and fdefinition objects @@ -1468,6 +1462,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*) @@ -1499,6 +1494,7 @@ sb!vm:fdefn-raw-addr-slot (ecase type (#.sb!vm:simple-fun-header-widetag + (/show0 "static-fset (simple-fun)") #!+sparc defn #!-sparc @@ -1508,6 +1504,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")))))) @@ -1524,8 +1521,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*)) @@ -1541,55 +1538,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*) @@ -1851,20 +1848,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) + (cold-push (cold-cons (base-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 @@ -1994,21 +1992,21 @@ (depthoid (descriptor-fixnum depthoid-des))) (unless (= length old-length) (error "cold loading a reference to class ~S when the compile~%~ - time length was ~S and current length is ~S" + time length was ~S and current length is ~S" name length old-length)) (unless (equal inherits-list old-inherits-list) (error "cold loading a reference to class ~S when the compile~%~ - time inherits were ~S~%~ - and current inherits are ~S" + time inherits were ~S~%~ + and current inherits are ~S" name inherits-list old-inherits-list)) (unless (= depthoid old-depthoid) (error "cold loading a reference to class ~S when the compile~%~ - time inheritance depthoid was ~S and current inheritance~%~ - depthoid is ~S" + time inheritance depthoid was ~S and current inheritance~%~ + depthoid is ~S" name depthoid old-depthoid))) @@ -2101,12 +2099,12 @@ ;;;; cold fops for loading vectors -(clone-cold-fop (fop-string) - (fop-small-string) +(clone-cold-fop (fop-base-string) + (fop-small-base-string) (let* ((len (clone-arg)) (string (make-string len))) (read-string-as-bytes *fasl-input-stream* string) - (string-to-core string))) + (base-string-to-core string))) (clone-cold-fop (fop-vector) (fop-small-vector) @@ -2213,6 +2211,7 @@ sb!vm:array-elements-slot (make-fixnum-descriptor total-elements))) result)) + ;;;; cold fops for loading numbers @@ -2482,7 +2481,19 @@ (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-word-arg)) @@ -2550,6 +2561,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" @@ -2637,7 +2649,7 @@ (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 @@ -2971,7 +2983,7 @@ initially undefined function references:~2%") ;; (We write each character as a word in order to avoid ;; having to think about word alignment issues in the ;; sbcl-0.7.8 version of coreparse.c.) - (write-word (char-code char)))) + (write-word (sb!xc:char-code char)))) ;; Write the New Directory entry header. (write-word new-directory-core-entry-type-code) @@ -3032,10 +3044,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 @@ -3045,11 +3053,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 @@ -3159,7 +3169,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)