bigvec)
\f
;;;; 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.
;; 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
(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*)
sb!vm:fdefn-raw-addr-slot
(ecase type
(#.sb!vm:simple-fun-header-widetag
+ (/show0 "static-fset (simple-fun)")
#!+sparc
defn
#!-sparc
(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"))))))
(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*))
(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*)
;;; 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)))
+
\f
;;;; general machinery for cold-loading FASL files
(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.
(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))
(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)
(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)
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)
(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))
+ (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)
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
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
#!+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)
sb!vm:array-elements-slot
(make-fixnum-descriptor total-elements)))
result))
+
\f
;;;; cold fops for loading numbers
(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
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.")))
;;;; 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)
(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)
(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)
(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))
(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.
(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))
(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))
(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"
(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
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
;; 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
;; 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)