s))))
(:copier nil))
;; the stream we dump to
- (stream (required-argument) :type stream)
+ (stream (missing-arg) :type stream)
;; hashtables we use to keep track of dumped constants so that we
;; can get them from the table rather than dumping them again. The
;; EQUAL-TABLE is used for lists and strings, and the EQ-TABLE is
;; an alist (PACKAGE . OFFSET) of the table offsets for each package
;; we have currently located.
(packages () :type list)
- ;; a table mapping from the Entry-Info structures for dumped XEPs to
+ ;; a table mapping from the ENTRY-INFO structures for dumped XEPs to
;; the table offsets of the corresponding code pointers
(entry-table (make-hash-table :test 'eq) :type hash-table)
;; a table holding back-patching info for forward references to XEPs.
- ;; The key is the Entry-Info structure for the XEP, and the value is
+ ;; The key is the ENTRY-INFO structure for the XEP, and the value is
;; a list of conses (<code-handle> . <offset>), where <code-handle>
;; is the offset in the table of the code object needing to be
;; patched, and <offset> is the offset that must be patched.
;;; This structure holds information about a circularity.
(defstruct (circularity (:copier nil))
;; the kind of modification to make to create circularity
- (type (required-argument) :type (member :rplaca :rplacd :svset :struct-set))
+ (type (missing-arg) :type (member :rplaca :rplacd :svset :struct-set))
;; the object containing circularity
object
;; index in object for circularity
- (index (required-argument) :type index)
+ (index (missing-arg) :type index)
;; the object to be stored at INDEX in OBJECT. This is that the key
;; that we were using when we discovered the circularity.
value
enclosing-object)
;;; a list of the CIRCULARITY structures for all of the circularities
-;;; detected in the current top-level call to DUMP-OBJECT. Setting
+;;; detected in the current top level call to DUMP-OBJECT. Setting
;;; this lobotomizes circularity detection as well, since circular
;;; dumping uses the table.
(defvar *circularities-detected*)
;; take a little more care while dumping these.
;; So if better list coalescing is needed, start here.
;; -- WHN 2000-11-07
- (if (circular-list-p x)
+ (if (cyclic-list-p x)
(progn
(dump-list x file)
(eq-save-object x file))
;;;
;;; This is the function used for recursive calls to the fasl dumper.
;;; We don't worry about creating circularities here, since it is
-;;; assumed that there is a top-level call to DUMP-OBJECT.
+;;; assumed that there is a top level call to DUMP-OBJECT.
(defun sub-dump-object (x file)
(cond ((listp x)
(if x
;;; We peek at the object type so that we only pay the circular
;;; detection overhead on types of objects that might be circular.
(defun dump-object (x file)
- (if (or (array-header-p x)
- (simple-vector-p x)
- (consp x)
- (typep x 'instance))
+ (if (compound-object-p x)
(let ((*circularities-detected* ())
(circ (fasl-output-circularity-table file)))
(clrhash circ)
;; argument and the number of bytes actually written. I added this
;; assertion while trying to debug portable genesis. -- WHN 19990902
(unless (= code-length nwritten)
- (error "internal error, code-length=~D, nwritten=~D"
+ (error "internal error, code-length=~W, nwritten=~W"
code-length
nwritten)))
(values))
;; far as I know no modern CMU CL does either -- WHN
;; 2001-10-05). So might we be able to get rid of trace tables?
- ;; Dump the constants, noting any :entries that have to be fixed up.
- (do ((i sb!vm:code-constants-offset (1+ i)))
- ((>= i header-length))
+ ;; Dump the constants, noting any :ENTRY constants that have to
+ ;; be patched.
+ (loop for i from sb!vm:code-constants-offset below header-length do
(let ((entry (aref constants i)))
(etypecase entry
(constant
(handle (gethash info
(fasl-output-entry-table
fasl-output))))
+ (declare (type sb!c::entry-info info))
(cond
(handle
(dump-push handle fasl-output))
(dump-fixups fixups fasl-output)
(dump-fop 'fop-sanctify-for-execution fasl-output)
+
(let ((handle (dump-pop fasl-output)))
(dolist (patch (patches))
(push (cons handle (cdr patch))
(dump-fop 'fop-sanctify-for-execution file)
(dump-pop file))
-;;; Dump a function-entry data structure corresponding to ENTRY to
+;;; Dump a function entry data structure corresponding to ENTRY to
;;; FILE. CODE-HANDLE is the table offset of the code object for the
;;; component.
(defun dump-one-entry (entry code-handle file)
(dump-object name file)
(dump-object (sb!c::entry-info-arguments entry) file)
(dump-object (sb!c::entry-info-type entry) file)
- (dump-fop 'fop-function-entry file)
+ (dump-fop 'fop-fun-entry file)
(dump-unsigned-32 (label-position (sb!c::entry-info-offset entry)) file)
(dump-pop file)))
(dolist (entry (sb!c::ir2-component-entries 2comp))
(let ((entry-handle (dump-one-entry entry code-handle file)))
(setf (gethash entry (fasl-output-entry-table file)) entry-handle)
-
(let ((old (gethash entry (fasl-output-patch-table file))))
- ;; FIXME: All this code is shared with
- ;; FASL-DUMP-BYTE-COMPONENT, and should probably be gathered
- ;; up into a named function (DUMP-PATCHES?) called from both
- ;; functions.
(when old
(dolist (patch old)
(dump-alter-code-object (car patch)
(dump-push handle fasl-output))
(values))
-;;; Dump a FOP-FUNCALL to call an already-dumped top-level lambda at
+;;; Dump a FOP-FUNCALL to call an already-dumped top level lambda at
;;; load time.
-(defun fasl-dump-top-level-lambda-call (fun fasl-output)
+(defun fasl-dump-toplevel-lambda-call (fun fasl-output)
(declare (type sb!c::clambda fun))
(dump-push-previously-dumped-fun fun fasl-output)
(dump-fop 'fop-funcall-for-effect fasl-output)
#+sb-xc-host
(defun fasl-dump-cold-fset (fun-name fun-dump-handle fasl-output)
(declare (type fixnum fun-dump-handle))
- (aver (legal-function-name-p fun-name))
+ (aver (legal-fun-name-p fun-name))
(dump-non-immediate-object fun-name fasl-output)
(dump-push fun-dump-handle fasl-output)
(dump-fop 'fop-fset fasl-output)
projects / sbcl.git / blobdiff