;;; way to do this in high level data like this (as opposed to e.g. in
;;; IP packets), and in fact the CMU CL version number never ended up
;;; being incremented past 0. A better approach might be to use a
-;;; string which is set from CVS data.
+;;; string which is set from CVS data. (Though now as of sbcl-0.7.8 or
+;;; so, we have another problem that the core incompatibility
+;;; detection mechanisms are on such a hair trigger -- with even
+;;; different builds from the same sources being considered
+;;; incompatible -- that any coarser-grained versioning mechanisms
+;;; like this are largely irrelevant as long as the hair-triggering
+;;; persists.)
;;;
;;; 0: inherited from CMU CL
;;; 1: rearranged static symbols for sbcl-0.6.8
;;; 2: eliminated non-ANSI %DEFCONSTANT/%%DEFCONSTANT support,
;;; deleted a slot from DEBUG-SOURCE structure
-(defconstant sbcl-core-version-integer 2)
+;;; 3: added build ID to cores to discourage sbcl/.core mismatch
+(defconstant sbcl-core-version-integer 3)
(defun round-up (number size)
#!+sb-doc
;;; copying GC is in use), then only the active dynamic space gets
;;; dumped to core.
(defvar *dynamic*)
-(defconstant dynamic-space-id 1)
+(defconstant dynamic-core-space-id 1)
(defvar *static*)
-(defconstant static-space-id 2)
+(defconstant static-core-space-id 2)
(defvar *read-only*)
-(defconstant read-only-space-id 3)
+(defconstant read-only-core-space-id 3)
(defconstant descriptor-low-bits 16
"the number of bits in the low half of the descriptor")
;;; <external-symbols>
;;; <imported-internal-symbols>
;;; <imported-external-symbols>
-;;; <shadowing-symbols>)
+;;; <shadowing-symbols>
+;;; <package-documentation>)
;;;
;;; KLUDGE: It would be nice to implement the sublists as instances of
;;; a DEFSTRUCT (:TYPE LIST). (They'd still be lists, but at least we'd be
(cold-fdefinition-object (cold-intern ',symbol)))))
(frob maybe-gc)
(frob internal-error)
+ (frob sb!kernel::control-stack-exhausted-error)
(frob sb!di::handle-breakpoint)
(frob sb!di::handle-fun-end-breakpoint))
(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)))
(internal *nil-descriptor*)
(external *nil-descriptor*)
(imported-internal *nil-descriptor*)
(cold-push handle imported-external)
(cold-push handle external)))))))
(let ((r *nil-descriptor*))
+ (cold-push documentation r)
(cold-push shadowing r)
(cold-push imported-external r)
(cold-push imported-internal r)
(warm-symbol cadr-des))))
(#.sb!vm:other-pointer-lowtag
(warm-symbol des)))))
- (unless (legal-fun-name-p result)
- (error "not a legal function name: ~S" result))
+ (legal-fun-name-or-type-error result)
result))
(defun cold-fdefinition-object (cold-name &optional leave-fn-raw)
(defun note-load-time-code-fixup (code-object offset value kind)
;; If CODE-OBJECT might be moved
(when (= (gspace-identifier (descriptor-intuit-gspace code-object))
- dynamic-space-id)
+ dynamic-core-space-id)
;; FIXME: pushed thing should be a structure, not just a list
(push (list code-object offset value kind) *load-time-code-fixups*))
(values))
(descriptor-gspace code-object))))
(ecase +backend-fasl-file-implementation+
;; See CMU CL source for other formerly-supported architectures
- ;; (and note that you have to rewrite them to use VECTOR-REF
- ;; unstead of SAP-REF).
+ ;; (and note that you have to rewrite them to use BVREF-X
+ ;; instead of SAP-REF).
(:alpha
(ecase kind
(:jmp-hint
(ldb (byte 8 0) value)
(bvref-8 gspace-bytes (1+ gspace-byte-offset))
(ldb (byte 8 8) value)))))
- (:ppc
+ (:hppa
+ (ecase kind
+ (:load
+ (setf (bvref-32 gspace-bytes gspace-byte-offset)
+ (logior (ash (ldb (byte 11 0) value) 1)
+ (logand (bvref-32 gspace-bytes gspace-byte-offset)
+ #xffffc000))))
+ (:load-short
+ (let ((low-bits (ldb (byte 11 0) value)))
+ (assert (<= 0 low-bits (1- (ash 1 4))))
+ (setf (bvref-32 gspace-bytes gspace-byte-offset)
+ (logior (ash low-bits 17)
+ (logand (bvref-32 gspace-bytes gspace-byte-offset)
+ #xffe0ffff)))))
+ (:hi
+ (setf (bvref-32 gspace-bytes gspace-byte-offset)
+ (logior (ash (ldb (byte 5 13) value) 16)
+ (ash (ldb (byte 2 18) value) 14)
+ (ash (ldb (byte 2 11) value) 12)
+ (ash (ldb (byte 11 20) value) 1)
+ (ldb (byte 1 31) value)
+ (logand (bvref-32 gspace-bytes gspace-byte-offset)
+ #xffe00000))))
+ (:branch
+ (let ((bits (ldb (byte 9 2) value)))
+ (assert (zerop (ldb (byte 2 0) value)))
+ (setf (bvref-32 gspace-bytes gspace-byte-offset)
+ (logior (ash bits 3)
+ (logand (bvref-32 gspace-bytes gspace-byte-offset)
+ #xffe0e002)))))))
+ (:mips
+ (ecase kind
+ (:jump
+ (assert (zerop (ash value -28)))
+ (setf (ldb (byte 26 0)
+ (bvref-32 gspace-bytes gspace-byte-offset))
+ (ash value -2)))
+ (:lui
+ (setf (bvref-32 gspace-bytes gspace-byte-offset)
+ (logior (mask-field (byte 16 16) (bvref-32 gspace-bytes gspace-byte-offset))
+ (+ (ash value -16)
+ (if (logbitp 15 value) 1 0)))))
+ (:addi
+ (setf (bvref-32 gspace-bytes gspace-byte-offset)
+ (logior (mask-field (byte 16 16) (bvref-32 gspace-bytes gspace-byte-offset))
+ (ldb (byte 16 0) value))))))
+ (:ppc
(ecase kind
(:ba
(setf (bvref-32 gspace-bytes gspace-byte-offset)
(sb!xc:lisp-implementation-version))
(format t "#define CORE_MAGIC 0x~X~%" core-magic)
(terpri)
- ;; FIXME: Other things from core.h should be defined here too:
- ;; #define CORE_END 3840
- ;; #define CORE_NDIRECTORY 3861
- ;; #define CORE_VALIDATE 3845
- ;; #define CORE_VERSION 3860
- ;; #define CORE_MACHINE_STATE 3862
- ;; (Except that some of them are obsolete and should be deleted instead.)
- ;; also
- ;; #define DYNAMIC_SPACE_ID (1)
- ;; #define STATIC_SPACE_ID (2)
- ;; #define READ_ONLY_SPACE_ID (3)
-
- ;; writing entire families of named constants from SB!VM
+
+ ;; writing entire families of named constants
(let ((constants nil))
- (do-external-symbols (symbol (find-package "SB!VM"))
- (when (constantp symbol)
- (let ((name (symbol-name symbol)))
- (labels (;; shared machinery
- (record (string priority)
- (push (list string
- priority
- (symbol-value symbol)
- (documentation symbol 'variable))
- constants))
- ;; machinery for old-style CMU CL Lisp-to-C
- ;; arbitrary renaming, being phased out in favor of
- ;; the newer systematic RECORD-WITH-TRANSLATED-NAME
- ;; renaming
- (record-with-munged-name (prefix string priority)
- (record (concatenate
- 'simple-string
- prefix
- (delete #\- (string-capitalize string)))
- priority))
- (maybe-record-with-munged-name (tail prefix priority)
- (when (tailwise-equal name tail)
- (record-with-munged-name prefix
- (subseq name 0
- (- (length name)
- (length tail)))
- priority)))
- ;; machinery for new-style SBCL Lisp-to-C naming
- (record-with-translated-name (priority)
- (record (substitute #\_ #\- name)
- priority))
- (maybe-record-with-translated-name (suffixes priority)
- (when (some (lambda (suffix)
- (tailwise-equal name suffix))
- suffixes)
- (record-with-translated-name priority))))
-
- (maybe-record-with-translated-name '("-LOWTAG") 0)
- (maybe-record-with-translated-name '("-WIDETAG") 1)
- (maybe-record-with-munged-name "-FLAG" "flag_" 2)
- (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)))))
+ (dolist (package-name '(;; Even in CMU CL, constants from VM
+ ;; were automatically propagated
+ ;; into the runtime.
+ "SB!VM"
+ ;; In SBCL, we also propagate various
+ ;; magic numbers related to file format,
+ ;; which live here instead of SB!VM.
+ "SB!FASL"))
+ (do-external-symbols (symbol (find-package package-name))
+ (when (constantp symbol)
+ (let ((name (symbol-name symbol)))
+ (labels (;; shared machinery
+ (record (string priority)
+ (push (list string
+ priority
+ (symbol-value symbol)
+ (documentation symbol 'variable))
+ constants))
+ ;; machinery for old-style CMU CL Lisp-to-C
+ ;; arbitrary renaming, being phased out in favor of
+ ;; the newer systematic RECORD-WITH-TRANSLATED-NAME
+ ;; renaming
+ (record-with-munged-name (prefix string priority)
+ (record (concatenate
+ 'simple-string
+ prefix
+ (delete #\- (string-capitalize string)))
+ priority))
+ (maybe-record-with-munged-name (tail prefix priority)
+ (when (tailwise-equal name tail)
+ (record-with-munged-name prefix
+ (subseq name 0
+ (- (length name)
+ (length tail)))
+ priority)))
+ ;; machinery for new-style SBCL Lisp-to-C naming
+ (record-with-translated-name (priority)
+ (record (substitute #\_ #\- name)
+ priority))
+ (maybe-record-with-translated-name (suffixes priority)
+ (when (some (lambda (suffix)
+ (tailwise-equal name suffix))
+ suffixes)
+ (record-with-translated-name priority))))
+
+ (maybe-record-with-translated-name '("-LOWTAG") 0)
+ (maybe-record-with-translated-name '("-WIDETAG") 1)
+ (maybe-record-with-munged-name "-FLAG" "flag_" 2)
+ (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 '("-CORE-ENTRY-TYPE-CODE") 7)
+ (maybe-record-with-translated-name '("-CORE-SPACE-ID") 8))))))
(setf constants
(sort constants
(lambda (const1 const2)
;; pseudo-atomic-trap-number or pseudo-atomic-magic-constant
;; [possibly applicable to other platforms])
+ (dolist (symbol '(sb!vm::float-traps-byte sb!vm::float-exceptions-byte sb!vm::float-sticky-bits sb!vm::float-rounding-mode))
+ (format t "#define ~A_POSITION ~A /* ~:*0x~X */~%"
+ (substitute #\_ #\- (symbol-name symbol))
+ (sb!xc:byte-position (symbol-value symbol)))
+ (format t "#define ~A_MASK 0x~X /* ~:*~A */~%"
+ (substitute #\_ #\- (symbol-name symbol))
+ (sb!xc:mask-field (symbol-value symbol) -1)))
+
;; writing primitive object layouts
(let ((structs (sort (copy-list sb!vm:*primitive-objects*) #'string<
:key (lambda (obj)
(defvar *core-file*)
(defvar *data-page*)
-;;; KLUDGE: These numbers correspond to values in core.h. If they're
-;;; documented anywhere, I haven't found it. (I haven't tried very
-;;; hard yet.) -- WHN 19990826
-(defparameter version-entry-type-code 3860)
-(defparameter validate-entry-type-code 3845)
-(defparameter directory-entry-type-code 3841)
-(defparameter new-directory-entry-type-code 3861)
-(defparameter initial-fun-entry-type-code 3863)
-(defparameter end-entry-type-code 3840)
+;;; magic numbers to identify entries in a core file
+;;;
+;;; (In case you were wondering: No, AFAIK there's no special magic about
+;;; these which requires them to be in the 38xx range. They're just
+;;; arbitrary words, tested not for being in a particular range but just
+;;; for equality. However, if you ever need to look at a .core file and
+;;; figure out what's going on, it's slightly convenient that they're
+;;; all in an easily recognizable range, and displacing the range away from
+;;; zero seems likely to reduce the chance that random garbage will be
+;;; misinterpreted as a .core file.)
+(defconstant version-core-entry-type-code 3860)
+(defconstant build-id-core-entry-type-code 3899)
+(defconstant new-directory-core-entry-type-code 3861)
+(defconstant initial-fun-core-entry-type-code 3863)
+(defconstant end-core-entry-type-code 3840)
(declaim (ftype (function (sb!vm:word) sb!vm:word) write-word))
(defun write-word (num)
(write-word core-magic)
;; Write the Version entry.
- (write-word version-entry-type-code)
+ (write-word version-core-entry-type-code)
(write-word 3)
(write-word sbcl-core-version-integer)
+ ;; Write the build ID.
+ (write-word build-id-core-entry-type-code)
+ (let ((build-id (with-open-file (s "output/build-id.tmp"
+ :direction :input)
+ (read s))))
+ (declare (type simple-string build-id))
+ (/show build-id (length build-id))
+ ;; Write length of build ID record: BUILD-ID-CORE-ENTRY-TYPE-CODE
+ ;; word, this length word, and one word for each char of BUILD-ID.
+ (write-word (+ 2 (length build-id)))
+ (dovector (char build-id)
+ ;; (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 the New Directory entry header.
- (write-word new-directory-entry-type-code)
+ (write-word new-directory-core-entry-type-code)
(write-word 17) ; length = (5 words/space) * 3 spaces + 2 for header.
(output-gspace *read-only*)
(output-gspace *dynamic*)
;; Write the initial function.
- (write-word initial-fun-entry-type-code)
+ (write-word initial-fun-core-entry-type-code)
(write-word 3)
(let* ((cold-name (cold-intern '!cold-init))
(cold-fdefn (cold-fdefinition-object cold-name))
(write-word (descriptor-bits initial-fun)))
;; Write the End entry.
- (write-word end-entry-type-code)
+ (write-word end-core-entry-type-code)
(write-word 2)))
(format t "done]~%")
(*cold-symbols* (make-hash-table :test 'equal))
(*cold-package-symbols* nil)
(*read-only* (make-gspace :read-only
- read-only-space-id
+ read-only-core-space-id
sb!vm:read-only-space-start))
(*static* (make-gspace :static
- static-space-id
+ static-core-space-id
sb!vm:static-space-start))
(*dynamic* (make-gspace :dynamic
- dynamic-space-id
+ dynamic-core-space-id
#!+gencgc sb!vm:dynamic-space-start
#!-gencgc sb!vm:dynamic-0-space-start))
(*nil-descriptor* (make-nil-descriptor))
(let ((package (find-package (sb-cold:package-data-name pd))))
(labels (;; Call FN on every node of the TREE.
(mapc-on-tree (fn tree)
+ (declare (type function fn))
(typecase tree
(cons (mapc-on-tree fn (car tree))
(mapc-on-tree fn (cdr tree)))