"Return a string describing the type of the local machine."
"X86")
-(defun machine-version ()
- #!+sb-doc
- "Return a string describing the version of the local machine."
- "X86")
+;;; arch-specific support for CL:MACHINE-VERSION, defined OAOO elsewhere
+(defun get-machine-version ()
+ #!+linux
+ (with-open-file (stream "/proc/cpuinfo"
+ ;; Even on Linux it's an option to build
+ ;; kernels without /proc filesystems, so
+ ;; degrade gracefully.
+ :if-does-not-exist nil)
+ (loop with line while (setf line (read-line stream nil))
+ ;; The field "model name" exists on kernel 2.4.21-rc6-ac1
+ ;; anyway, with values e.g.
+ ;; "AMD Athlon(TM) XP 2000+"
+ ;; "Intel(R) Pentium(R) M processor 1300MHz"
+ ;; which seem comparable to the information in the example
+ ;; in the MACHINE-VERSION page of the ANSI spec.
+ when (eql (search "model name" line) 0)
+ return (string-trim " " (subseq line (1+ (position #\: line))))))
+ #!-linux
+ nil)
\f
;;;; :CODE-OBJECT fixups
(defvar *num-fixups* 0)
;;; FIXME: When the system runs, it'd be interesting to see what this is.
+(declaim (inline adjust-fixup-array))
+(defun adjust-fixup-array (array size)
+ (let ((new (make-array size :element-type '(unsigned-byte 32))))
+ (replace new array)
+ new))
+
;;; This gets called by LOAD to resolve newly positioned objects
;;; with things (like code instructions) that have to refer to them.
;;;
(let ((fixups (code-header-ref code code-constants-offset)))
(cond ((typep fixups '(simple-array (unsigned-byte 32) (*)))
(let ((new-fixups
- (adjust-array fixups (1+ (length fixups))
- :element-type '(unsigned-byte 32))))
+ (adjust-fixup-array fixups (1+ (length fixups)))))
(setf (aref new-fixups (length fixups)) offset)
(setf (code-header-ref code code-constants-offset)
new-fixups)))
(zerop fixups))
(format t "** Init. code FU = ~S~%" fixups)) ; FIXME
(setf (code-header-ref code code-constants-offset)
- (make-specializable-array
+ (make-array
1
:element-type '(unsigned-byte 32)
:initial-element offset)))))))
(sb!kernel:code-instructions code)))
(obj-start-addr (logand (sb!kernel:get-lisp-obj-address code)
#xfffffff8))
- #+nil (const-start-addr (+ obj-start-addr (* 5 4)))
+ ;; FIXME: what is this 5?
+ #+nil (const-start-addr (+ obj-start-addr (* 5 n-word-bytes)))
(code-start-addr (sb!sys:sap-int (sb!kernel:code-instructions
code)))
(ncode-words (sb!kernel:code-header-ref code 1))
- (code-end-addr (+ code-start-addr (* ncode-words 4))))
+ (code-end-addr (+ code-start-addr (* ncode-words n-word-bytes))))
(unless (member kind '(:absolute :relative))
(error "Unknown code-object-fixup kind ~S." kind))
(ecase kind
(add-fixup code offset))
;; Replace word with value to add to that loc to get there.
(let* ((loc-sap (+ (sap-int sap) offset))
- (rel-val (- fixup loc-sap 4)))
+ (rel-val (- fixup loc-sap n-word-bytes)))
(declare (type (unsigned-byte 32) loc-sap)
(type (signed-byte 32) rel-val))
(setf (signed-sap-ref-32 sap offset) rel-val))))))
(let ((fixups (code-header-ref code code-constants-offset)))
(cond ((typep fixups '(simple-array (unsigned-byte 32) (*)))
(let ((new-fixups
- (adjust-array fixups (1+ (length fixups))
- :element-type '(unsigned-byte 32))))
+ (adjust-fixup-array fixups (1+ (length fixups)))))
(setf (aref new-fixups (length fixups)) offset)
(setf (code-header-ref code code-constants-offset)
new-fixups)))
(zerop fixups))
(sb!impl::!cold-lose "Argh! can't process fixup"))
(setf (code-header-ref code code-constants-offset)
- (make-specializable-array
+ (make-array
1
:element-type '(unsigned-byte 32)
:initial-element offset)))))))
(code-start-addr (sb!sys:sap-int (sb!kernel:code-instructions
code)))
(ncode-words (sb!kernel:code-header-ref code 1))
- (code-end-addr (+ code-start-addr (* ncode-words 4))))
+ (code-end-addr (+ code-start-addr (* ncode-words n-word-bytes))))
(ecase kind
(:absolute
;; Record absolute fixups that point within the code object.
(/show0 "LENGTH,VECTOR,ERROR-NUMBER=..")
(/hexstr length)
(/hexstr vector)
- (copy-from-system-area pc (* n-byte-bits 2)
- vector (* n-word-bits vector-data-offset)
- (* length n-byte-bits))
+ (copy-ub8-from-system-area pc 2 vector 0 length)
(let* ((index 0)
- (error-number (sb!c::read-var-integer vector index)))
+ (error-number (sb!c:read-var-integer vector index)))
(/hexstr error-number)
(collect ((sc-offsets))
(loop
(/hexstr index)
(when (>= index length)
(return))
- (let ((sc-offset (sb!c::read-var-integer vector index)))
+ (let ((sc-offset (sb!c:read-var-integer vector index)))
(/show0 "SC-OFFSET=..")
(/hexstr sc-offset)
(sc-offsets sc-offset)))