(n)
(let* ((name (intern (format nil "BYTE-VECTOR-REF-~A" n)))
(number-octets (/ n 8))
- (ash-list
+ (ash-list-le
(loop for i from 0 to (1- number-octets)
collect `(ash (aref byte-vector (+ byte-index ,i))
,(* i 8))))
- (setf-list
+ (ash-list-be
+ (loop for i from 0 to (1- number-octets)
+ collect `(ash (aref byte-vector (+ byte-index
+ ,(- number-octets 1 i)))
+ ,(* i 8))))
+ (setf-list-le
(loop for i from 0 to (1- number-octets)
append
`((aref byte-vector (+ byte-index ,i))
- (ldb (byte 8 ,(* i 8)) new-value)))))
+ (ldb (byte 8 ,(* i 8)) new-value))))
+ (setf-list-be
+ (loop for i from 0 to (1- number-octets)
+ append
+ `((aref byte-vector (+ byte-index ,i))
+ (ldb (byte 8 ,(- n 8 (* i 8))) new-value)))))
`(progn
(defun ,name (byte-vector byte-index)
- (aver (= sb!vm:n-word-bits 32))
- (aver (= sb!vm:n-byte-bits 8))
- (ecase sb!c:*backend-byte-order*
- (:little-endian
- (logior ,@ash-list))
- (:big-endian
- (error "stub: no big-endian ports of SBCL (yet?)"))))
- (defun (setf ,name) (new-value byte-vector byte-index)
- (aver (= sb!vm:n-word-bits 32))
- (aver (= sb!vm:n-byte-bits 8))
- (ecase sb!c:*backend-byte-order*
- (:little-endian
- (setf ,@setf-list))
- (:big-endian
- (error "stub: no big-endian ports of SBCL (yet?)"))))))))
+ (aver (= sb!vm:n-word-bits 32))
+ (aver (= sb!vm:n-byte-bits 8))
+ (logior ,@(ecase sb!c:*backend-byte-order*
+ (:little-endian ash-list-le)
+ (:big-endian ash-list-be))))
+ (defun (setf ,name) (new-value byte-vector byte-index)
+ (aver (= sb!vm:n-word-bits 32))
+ (aver (= sb!vm:n-byte-bits 8))
+ (setf ,@(ecase sb!c:*backend-byte-order*
+ (:little-endian setf-list-le)
+ (:big-endian setf-list-be))))))))
(make-byte-vector-ref-n 8)
(make-byte-vector-ref-n 16)
(make-byte-vector-ref-n 32))
(read-wordindexed address 0))
;;; (Note: In CMU CL, this function expected a SAP-typed ADDRESS
-;;; value, instead of the SAPINT we use here.)
-(declaim (ftype (function (sb!vm:word descriptor) (values)) note-load-time-value-reference))
+;;; value, instead of the SAP-INT we use here.)
+(declaim (ftype (function (sb!vm:word descriptor) (values))
+ note-load-time-value-reference))
(defun note-load-time-value-reference (address marker)
(cold-push (cold-cons
(cold-intern :load-time-value-fixup)
- (cold-cons (sapint-to-core address)
+ (cold-cons (sap-int-to-core address)
(cold-cons
(number-to-core (descriptor-word-offset marker))
*nil-descriptor*)))
(float (float-to-core number))
(t (error "~S isn't a cold-loadable number at all!" number))))
-(declaim (ftype (function (sb!vm:word) descriptor) sap-to-core))
-(defun sapint-to-core (sapint)
+(declaim (ftype (function (sb!vm:word) descriptor) sap-int-to-core))
+(defun sap-int-to-core (sap-int)
(let ((des (allocate-unboxed-object *dynamic*
sb!vm:n-word-bits
(1- sb!vm:sap-size)
sb!vm:sap-widetag)))
(write-wordindexed des
sb!vm:sap-pointer-slot
- (make-random-descriptor sapint))
+ (make-random-descriptor sap-int))
des))
;;; Allocate a cons cell in GSPACE and fill it in with CAR and CDR.
(write-wordindexed symbol
sb!vm:symbol-hash-slot
(make-fixnum-descriptor
- (1+ (random sb!vm:*target-most-positive-fixnum*))))
+ (1+ (random sb!xc:most-positive-fixnum))))
(write-wordindexed symbol sb!vm:symbol-plist-slot *nil-descriptor*)
(write-wordindexed symbol sb!vm:symbol-name-slot
(string-to-core name *dynamic*))
(defvar *cold-package-symbols*)
(declaim (type list *cold-package-symbols*))
-;;; a map from descriptors to symbols, so that we can back up. The key is the
-;;; address in the target core.
+;;; a map from descriptors to symbols, so that we can back up. The key
+;;; is the address in the target core.
(defvar *cold-symbols*)
(declaim (type hash-table *cold-symbols*))
;; need is SB!KERNEL:%BYTE-BLT.
(let ((package-name (package-name package)))
(cond ((find package-name '("COMMON-LISP" "KEYWORD") :test #'string=)
- ;; That's OK then.
+ ;; Cold interning things in these standard packages is OK.
+ ;; (Cold interning things in the other standard package,
+ ;; CL-USER, isn't OK. We just use CL-USER to expose symbols
+ ;; whose homes are in other packages. Thus, trying to cold
+ ;; intern a symbol whose home package is CL-USER probably
+ ;; means that a coding error has been made somewhere.)
(values))
((string= package-name "SB!" :end1 3 :end2 3)
;; That looks OK, too. (All the target-code packages
(t
;; looks bad: maybe COMMON-LISP-USER? maybe an extension
;; package in the xc host? something we can't think of
- ;; a valid reason to dump, anyway...
- (bug "internal error: PACKAGE-NAME=~S looks too much like a typo."
- package-name))))
+ ;; a valid reason to cold intern, anyway...
+ (error ; not #'BUG, because #'BUG isn't defined yet
+ "internal error: PACKAGE-NAME=~S looks too much like a typo."
+ package-name))))
(let (;; Information about each cold-interned symbol is stored
;; in COLD-INTERN-INFO.
(:alpha
(ecase kind
(:jmp-hint
- (assert (zerop (ldb (byte 2 0) value)))
- #+nil ;; was commented out in cmucl source too. Don't know what
- ;; it does -dan 2001.05.03
- (setf (sap-ref-16 sap 0)
- (logior (sap-ref-16 sap 0) (ldb (byte 14 0) (ash value -2)))))
+ (assert (zerop (ldb (byte 2 0) value))))
(:bits-63-48
(let* ((value (if (logbitp 15 value) (+ value (ash 1 16)) value))
(value (if (logbitp 31 value) (+ value (ash 1 32)) value))
(ldb (byte 8 0) value)
(byte-vector-ref-8 gspace-bytes (1+ gspace-byte-offset))
(ldb (byte 8 8) value)))))
+ (:ppc
+ (ecase kind
+ (:ba
+ (setf (byte-vector-ref-32 gspace-bytes gspace-byte-offset)
+ (dpb (ash value -2) (byte 24 2)
+ (byte-vector-ref-32 gspace-bytes gspace-byte-offset))))
+ (:ha
+ (let* ((h (ldb (byte 16 16) value))
+ (l (ldb (byte 16 0) value)))
+ (setf (byte-vector-ref-16 gspace-bytes (+ gspace-byte-offset 2))
+ (if (logbitp 15 l) (ldb (byte 16 0) (1+ h)) h))))
+ (:l
+ (setf (byte-vector-ref-16 gspace-bytes (+ gspace-byte-offset 2))
+ (ldb (byte 16 0) value)))))
+ (:sparc
+ (ecase kind
+ (:call
+ (error "Can't deal with call fixups yet."))
+ (:sethi
+ (setf (byte-vector-ref-32 gspace-bytes gspace-byte-offset)
+ (dpb (ldb (byte 22 10) value)
+ (byte 22 0)
+ (byte-vector-ref-32 gspace-bytes gspace-byte-offset))))
+ (:add
+ (setf (byte-vector-ref-32 gspace-bytes gspace-byte-offset)
+ (dpb (ldb (byte 10 0) value)
+ (byte 10 0)
+ (byte-vector-ref-32 gspace-bytes gspace-byte-offset))))))
(:x86
(let* ((un-fixed-up (byte-vector-ref-32 gspace-bytes
gspace-byte-offset))
(format t " /* 0x~X */~@[ /* ~A */~]~%" value doc))))
(terpri))
- ;; writing codes/strings for internal errors
- (format t "#define ERRORS { \\~%")
+ ;; writing information about internal errors
(let ((internal-errors sb!c:*backend-internal-errors*))
(dotimes (i (length internal-errors))
- (format t " ~S, /*~D*/ \\~%" (cdr (aref internal-errors i)) i)))
- (format t " NULL \\~%}~%")
+ (let ((current-error (aref internal-errors i)))
+ ;; FIXME: this UNLESS should go away (see also FIXME in
+ ;; interr.lisp) -- APD, 2002-03-05
+ (unless (eq nil (car current-error))
+ (format t "#define ~A ~D~%"
+ (substitute #\_ #\- (symbol-name (car current-error)))
+ i)))))
(terpri)
+ ;; FIXME: The SPARC has a PSEUDO-ATOMIC-TRAP that differs between
+ ;; platforms. If we export this from the SB!VM package, it gets
+ ;; written out as #define trap_PseudoAtomic, which is confusing as
+ ;; the runtime treats trap_ as the prefix for illegal instruction
+ ;; type things. We therefore don't export it, but instead do
+ (when (boundp 'sb!vm::pseudo-atomic-trap)
+ (format t "#define PSEUDO_ATOMIC_TRAP ~D /* 0x~:*~X */~%" sb!vm::pseudo-atomic-trap)
+ (terpri))
+ ;; possibly this is another candidate for a rename (to
+ ;; pseudo-atomic-trap-number or pseudo-atomic-magic-constant
+ ;; [possibly applicable to other platforms])
+
;; writing primitive object layouts
(let ((structs (sort (copy-list sb!vm:*primitive-objects*) #'string<
:key (lambda (obj)
sb!vm:static-space-start))
(*dynamic* (make-gspace :dynamic
dynamic-space-id
- sb!vm:dynamic-space-start))
+ #!+gencgc sb!vm:dynamic-space-start
+ #!-gencgc sb!vm:dynamic-0-space-start))
(*nil-descriptor* (make-nil-descriptor))
(*current-reversed-cold-toplevels* *nil-descriptor*)
(*unbound-marker* (make-other-immediate-descriptor
projects / sbcl.git / blobdiff