0.8.9.6.netbsd.2:

[sbcl.git] / src / code / x86-vm.lisp

diff --git a/src/code/x86-vm.lisp b/src/code/x86-vm.lisp
index 833460c..bd1935f 100644 (file)
--- a/src/code/x86-vm.lisp
+++ b/src/code/x86-vm.lisp
@@ -41,10 +41,25 @@
   "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
 
@@ -52,6 +67,13 @@
 (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 ((length (length array))
+        (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.
 ;;;
@@ -69,8 +91,7 @@
           (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)))
@@ -80,7 +101,7 @@
                                (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)))))))
@@ -89,11 +110,12 @@
                            (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
@@ -113,7 +135,7 @@
            (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))))))
@@ -132,8 +154,7 @@
           (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)))
@@ -143,7 +164,7 @@
                                (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)))))))
@@ -155,7 +176,7 @@
           (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.