(and (>= (length name) 2)
(string= name "*!" :end1 2 :end2 2)))
(/show0 "uninterning cold-init-only symbol..")
- #!+sb-show (%primitive print name)
+ (/primitive-print name)
(unintern symbol package)
(setf any-changes? t)))))
(unless any-changes?
;;; a list of toplevel things set by GENESIS
(defvar *!reversed-cold-toplevels*)
-;;; a SIMPLE-VECTOR set by genesis
+;;; a SIMPLE-VECTOR set by GENESIS
(defvar *!load-time-values*)
(defun !cold-lose (msg)
(%primitive print "too early in cold init to recover from errors")
(%halt))
-#!+gengc
-(defun do-load-time-value-fixup (object offset index)
- (declare (type index offset))
- (let ((value (svref *!load-time-values* index)))
- (typecase object
- (list
- (case offset
- (0 (setf (car object) value))
- (1 (setf (cdr object) value))
- (t (!cold-lose "bogus offset in cons cell"))))
- (instance
- (setf (%instance-ref object (- offset sb!vm:instance-slots-offset))
- value))
- (code-component
- (setf (code-header-ref object offset) value))
- (simple-vector
- (setf (svref object (- offset sb!vm:vector-data-offset)) value))
- (t
- (!cold-lose "unknown kind of object for load-time-value fixup")))))
-
(eval-when (:compile-toplevel :execute)
;; FIXME: Perhaps we should make SHOW-AND-CALL-AND-FMAKUNBOUND, too,
;; and use it for most of the cold-init functions. (Just be careful
;; not to use it for the COLD-INIT-OR-REINIT functions.)
(sb!xc:defmacro show-and-call (name)
`(progn
- #!+sb-show (%primitive print ,(symbol-name name))
+ (/primitive-print ,(symbol-name name))
(,name))))
;;; called when a cold system starts up
;; !UNIX-COLD-INIT. And *TYPE-SYSTEM-INITIALIZED* could be changed to
;; *TYPE-SYSTEM-INITIALIZED-WHEN-BOUND* so that it doesn't need to
;; be explicitly set in order to be meaningful.
- (setf *gc-verbose* nil)
- (setf *gc-notify-stream* nil)
- (setf *before-gc-hooks* nil)
- (setf *after-gc-hooks* nil)
- #!+gengc (setf *handler-clusters* nil)
- #!-gengc (setf *already-maybe-gcing* t
- *gc-inhibit* t
- *need-to-collect-garbage* nil
- sb!unix::*interrupts-enabled* t
- sb!unix::*interrupt-pending* nil)
- (setf *break-on-signals* nil)
- (setf *maximum-error-depth* 10)
- (setf *current-error-depth* 0)
- (setf *cold-init-complete-p* nil)
- (setf *type-system-initialized* nil)
+ (setf *gc-notify-stream* nil
+ *before-gc-hooks* nil
+ *after-gc-hooks* nil
+ *already-maybe-gcing* t
+ *gc-inhibit* t
+ *need-to-collect-garbage* nil
+ sb!unix::*interrupts-enabled* t
+ sb!unix::*interrupt-pending* nil
+ *break-on-signals* nil
+ *maximum-error-depth* 10
+ *current-error-depth* 0
+ *cold-init-complete-p* nil
+ *type-system-initialized* nil)
;; Anyone might call RANDOM to initialize a hash value or something;
;; and there's nothing which needs to be initialized in order for
;; -- WHN 19991204
(/show0 "doing cold toplevel forms and fixups")
(/show0 "(LISTP *!REVERSED-COLD-TOPLEVELS*)=..")
- #!+sb-show (%primitive print
- (if (listp *!reversed-cold-toplevels*) "true" "NIL"))
+ (/hexstr (if (listp *!reversed-cold-toplevels*) "true" "NIL"))
(/show0 "about to calculate (LENGTH *!REVERSED-COLD-TOPLEVELS*)")
(/show0 "(LENGTH *!REVERSED-COLD-TOPLEVELS*)=..")
#!+sb-show (let ((r-c-tl-length (length *!reversed-cold-toplevels*)))
(/show0 "(length calculated..)")
- (let ((hexstr (sb!impl::hexstr r-c-tl-length)))
+ (let ((hexstr (hexstr r-c-tl-length)))
(/show0 "(hexstr calculated..)")
- (%primitive print hexstr)))
+ (/primitive-print hexstr)))
(let (#!+sb-show (index-in-cold-toplevels 0))
#!+sb-show (declare (type fixnum index-in-cold-toplevels))
+
(dolist (toplevel-thing (prog1
(nreverse *!reversed-cold-toplevels*)
;; (Now that we've NREVERSEd it, it's
#!+sb-show
(when (zerop (mod index-in-cold-toplevels 1024))
(/show0 "INDEX-IN-COLD-TOPLEVELS=..")
- (%primitive print (sb!impl::hexstr index-in-cold-toplevels)))
+ (/hexstr index-in-cold-toplevels))
#!+sb-show
(setf index-in-cold-toplevels
(the fixnum (1+ index-in-cold-toplevels)))
#!-gengc
(setf (sap-ref-32 (second toplevel-thing) 0)
(get-lisp-obj-address
- (svref *!load-time-values* (third toplevel-thing))))
- #!+gengc
- (do-load-time-value-fixup (second toplevel-thing)
- (third toplevel-thing)
- (fourth toplevel-thing)))
+ (svref *!load-time-values* (third toplevel-thing)))))
#!+(and x86 gencgc)
(:load-time-code-fixup
- (sb!vm::do-load-time-code-fixup (second toplevel-thing)
- (third toplevel-thing)
- (fourth toplevel-thing)
- (fifth toplevel-thing)))
+ (sb!vm::!do-load-time-code-fixup (second toplevel-thing)
+ (third toplevel-thing)
+ (fourth toplevel-thing)
+ (fifth toplevel-thing)))
(t
(!cold-lose "bogus fixup code in *!REVERSED-COLD-TOPLEVELS*"))))
(t (!cold-lose "bogus function in *!REVERSED-COLD-TOPLEVELS*")))))
;; FIXME: This list of modes should be defined in one place and
;; explicitly shared between here and REINIT.
+ ;;
+ ;; FIXME: In CMU CL, this is done "here" (i.e. in the analogous
+ ;; lispinit.lisp code) for every processor architecture. But Daniel
+ ;; Barlow's Alpha patches suppress it for Alpha. Why the difference?
+ #!+alpha
(set-floating-point-modes :traps '(:overflow
#!-x86 :underflow
:invalid
;; could be typed directly, with no parentheses, at the debug prompt
;; the way that e.g. F or BACKTRACE can be?)
- (/show0 "done initializing")
+ (/show0 "done initializing, setting *COLD-INIT-COMPLETE-P*")
(setf *cold-init-complete-p* t)
;; The system is finally ready for GC.
(os-cold-init-or-reinit)
(stream-reinit)
(signal-cold-init-or-reinit)
- (gc-cold-init-or-reinit)
+ (gc-reinit)
(setf (sb!alien:extern-alien "internal_errors_enabled" boolean) t)
(set-floating-point-modes :traps
'(:overflow
;; reason.. (Perhaps we should do it anyway in case someone
;; manages to save an image from within a pseudo-atomic-atomic
;; operation?)
- #!+x86 (setf sb!impl::*pseudo-atomic-atomic* 0))
+ #!+x86 (setf *pseudo-atomic-atomic* 0))
(gc-on)))
\f
;;;; some support for any hapless wretches who end up debugging cold