;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
-\f
-(defvar *before-save-initializations* nil
- #!+sb-doc
- "This is a list of functions which are called before creating a saved core
- image. These functions are executed in the child process which has no ports,
- so they cannot do anything that tries to talk to the outside world.")
-
-(defvar *after-save-initializations* nil
- #!+sb-doc
- "This is a list of functions which are called when a saved core image starts
- up. The system itself should be initialized at this point, but applications
- might not be.")
\f
;;;; SAVE-LISP-AND-DIE itself
-(sb!alien:def-alien-routine "save" (sb!alien:boolean)
+(sb!alien:define-alien-routine "save" (sb!alien:boolean)
(file sb!c-call:c-string)
- (initial-function (sb!alien:unsigned #.sb!vm:word-bits)))
+ (initial-fun (sb!alien:unsigned #.sb!vm:n-word-bits)))
;;; FIXME: When this is run without the PURIFY option,
;;; it seems to save memory all the way up to the high-water mark,
;;; image to make a running Lisp, the memory never gets reclaimed.
;;; (But with the PURIFY option it seems to work OK.)
(defun save-lisp-and-die (core-file-name &key
- (toplevel #'toplevel)
- (purify nil)
+ (toplevel #'toplevel-init)
+ (purify t)
(root-structures ())
(environment-name "auxiliary"))
#!+sb-doc
killing the current Lisp invocation in the process (unless it bails
out early because of some argument error or something).
- The following keyword args are defined:
-
- :TOPLEVEL
- The function to run when the created core file is resumed.
- The default function handles command line toplevel option
- processing and runs the top level read-eval-print loop. This
- function should not return.
+ The following &KEY args are defined:
+ :TOPLEVEL
+ The function to run when the created core file is resumed.
+ The default function handles command line toplevel option
+ processing and runs the top level read-eval-print loop. This
+ function should not return.
+ :PURIFY
+ If true (the default), do a purifying GC which moves all dynamically
+ allocated objects into static space so that they stay pure. This takes
+ somewhat longer than the normal GC which is otherwise done, but it's
+ only done once, and subsequent GC's will be done less often and will
+ take less time in the resulting core file. See PURIFY.
+ :ROOT-STRUCTURES
+ This should be a list of the main entry points in any newly loaded
+ systems. This need not be supplied, but locality and/or GC performance
+ may be better if they are. Meaningless if :PURIFY is NIL. See PURIFY.
+ :ENVIRONMENT-NAME
+ This is also passed to PURIFY when :PURIFY is T. (rarely used)
- :PURIFY
- If true (the default), do a purifying GC which moves all dynamically
- allocated objects into static space so that they stay pure. This takes
- somewhat longer than the normal GC which is otherwise done, but it's only
- done once, and subsequent GC's will be done less often and will take less
- time in the resulting core file. See PURIFY.
-
- :ROOT-STRUCTURES
- This should be a list of the main entry points in any newly loaded
- systems. This need not be supplied, but locality and/or GC performance
- may be better if they are. Meaningless if :PURIFY is NIL. See PURIFY.
-
- :ENVIRONMENT-NAME
- This is also passed to PURIFY when :PURIFY is T. (rarely used)"
+ The save/load process changes the values of some global variables:
+ *STANDARD-OUTPUT*, *DEBUG-IO*, etc.
+ Everything related to open streams is necessarily changed, since
+ the OS won't let us preserve a stream across save and load.
+ *DEFAULT-PATHNAME-DEFAULTS*
+ This is reinitialized to reflect the working directory where the
+ saved core is loaded."
#!+mp (sb!mp::shutdown-multi-processing)
- (when (fboundp 'sb!eval:flush-interpreted-function-cache)
- (sb!eval:flush-interpreted-function-cache))
;; FIXME: What is this for? Explain.
(when (fboundp 'cancel-finalization)
(cancel-finalization sb!sys:*tty*))
(dolist (f *before-save-initializations*)
(funcall f))
(flet ((restart-lisp ()
- (sb!unix:unix-exit
- (catch '%end-of-the-world
- (reinit)
- ;; FIXME: Wouldn't it be more correct to do this running
- ;; backwards through the list, instead of forwards?
- (dolist (f *after-save-initializations*)
- (funcall f))
- (funcall toplevel)))))
+ (handling-end-of-the-world
+ (reinit)
+ (dolist (f *after-save-initializations*)
+ (funcall f))
+ (funcall toplevel))))
;; FIXME: Perhaps WITHOUT-GCING should be wrapped around the
;; LET as well, to avoid the off chance of an interrupt triggering
;; GC and making our saved RESTART-LISP address invalid?
(without-gcing
(save (unix-namestring core-file-name nil)
(get-lisp-obj-address #'restart-lisp)))))
-\f
-;;;; functions used by worldload.lisp in CMU CL bootstrapping
-
-;;; If Name has been byte-compiled, and :RUNTIME is a feature, then load the
-;;; byte-compiled version, otherwise just do normal load.
-#+nil ; no longer needed in SBCL.. I think.. -- WHN 19990814
-(defun maybe-byte-load (name &optional (load-native t))
- (let ((bname (make-pathname
- :defaults name
- :type #.(sb!c:backend-byte-fasl-file-type))))
- (cond ((and (featurep :runtime)
- (probe-file bname))
- (load bname))
- (load-native
- (load name)))))
-
-;;; Replace a cold-loaded native object file with a byte-compiled one, if it
-;;; exists.
-#+nil ; no longer needed in SBCL.. I think.. -- WHN 19990814
-(defun byte-load-over (name)
- (load (make-pathname
- :defaults name
- :type #.(sb!c:backend-byte-fasl-file-type))
- :if-does-not-exist nil))
projects / sbcl.git / blobdiff