0.9.4.71:

[sbcl.git] / src / compiler / mips / insts.lisp

diff --git a/src/compiler/mips/insts.lisp b/src/compiler/mips/insts.lisp
index d0a705c..a6b7c72 100644 (file)
--- a/src/compiler/mips/insts.lisp
+++ b/src/compiler/mips/insts.lisp
@@ -58,8 +58,7 @@
        (:hi-reg 64)
        (:low-reg 65)
        (:float-status 66)
        (:hi-reg 64)
        (:low-reg 65)
        (:float-status 66)

-       (:ctrl-stat-reg 67)
-       (:r31 31)))))
+       (:ctrl-stat-reg 67)))))

 
 (defparameter reg-symbols
   (map 'vector
 
 (defparameter reg-symbols
   (map 'vector

@@ -223,10 +222,10 @@
 
 (sb!disassem:define-instruction-format
     (break 32 :default-printer
 
 (sb!disassem:define-instruction-format
     (break 32 :default-printer

-           '(:name :tab code (:unless (:constant 0) subcode)))
+           '(:name :tab code (:unless (:constant 0) ", " subcode)))

   (op :field (byte 6 26) :value special-op)
   (code :field (byte 10 16))
   (op :field (byte 6 26) :value special-op)
   (code :field (byte 10 16))

-  (subcode :field (byte 10 6) :value 0)
+  (subcode :field (byte 10 6))

   (funct :field (byte 6 0) :value #b001101))
 
 (sb!disassem:define-instruction-format
   (funct :field (byte 6 0) :value #b001101))
 
 (sb!disassem:define-instruction-format

@@ -670,7 +669,7 @@
                        (immediate nil :type 'relative-label))
             '(:name :tab immediate))
   (:attributes branch)
                        (immediate nil :type 'relative-label))
             '(:name :tab immediate))
   (:attributes branch)

-  (:dependencies (writes :r31))
+  (:dependencies (writes lip-tn))

   (:delay 1)
   (:emitter
    (emit-relative-branch segment bcond-op 0 #b10001 target)))
   (:delay 1)
   (:emitter
    (emit-relative-branch segment bcond-op 0 #b10001 target)))

@@ -757,7 +756,7 @@
    immediate ((op bcond-op) (rt #b01000) (immediate nil :type 'relative-label))
             cond-branch-printer)
   (:attributes branch)
    immediate ((op bcond-op) (rt #b01000) (immediate nil :type 'relative-label))
             cond-branch-printer)
   (:attributes branch)

-  (:dependencies (reads reg) (writes :r31))
+  (:dependencies (reads reg) (writes lip-tn))

   (:delay 1)
   (:emitter
    (emit-relative-branch segment bcond-op reg #b10000 target)))
   (:delay 1)
   (:emitter
    (emit-relative-branch segment bcond-op reg #b10000 target)))

@@ -769,7 +768,7 @@
             cond-branch-printer)
   (:attributes branch)
   (:delay 1)
             cond-branch-printer)
   (:attributes branch)
   (:delay 1)

-  (:dependencies (reads reg) (writes :r31))
+  (:dependencies (reads reg) (writes lip-tn))

   (:emitter
    (emit-relative-branch segment bcond-op reg #b10001 target)))
 
   (:emitter
    (emit-relative-branch segment bcond-op reg #b10001 target)))
 

@@ -791,28 +790,41 @@
       (emit-register-inst segment special-op (reg-tn-encoding target)
                           0 0 0 #b001000))
      (fixup
       (emit-register-inst segment special-op (reg-tn-encoding target)
                           0 0 0 #b001000))
      (fixup

-      (note-fixup segment :jump target)
-      (emit-jump-inst segment #b000010 0)))))
+      (note-fixup segment :lui target)
+      (emit-immediate-inst segment #b001111 0 28 0)
+      (note-fixup segment :addi target)
+      (emit-immediate-inst segment #b001001 28 28 0)
+      (emit-register-inst segment special-op 28 0 0 0 #b001000)))))

 
 (define-instruction jal (segment reg-or-target &optional target)
   (:declare (type (or null tn fixup) target)
 
 (define-instruction jal (segment reg-or-target &optional target)
   (:declare (type (or null tn fixup) target)

-            (type (or tn fixup (integer -16 31)) reg-or-target))
+            (type (or tn fixup) reg-or-target))

   (:printer register ((op special-op) (rt 0) (funct #b001001)) j-printer)
   (:printer jump ((op #b000011)) j-printer)
   (:attributes branch)
   (:printer register ((op special-op) (rt 0) (funct #b001001)) j-printer)
   (:printer jump ((op #b000011)) j-printer)
   (:attributes branch)

-  (:dependencies (if target (writes reg-or-target) (writes :r31)))
+  (:dependencies (cond
+                   (target
+                    (writes reg-or-target) (reads target))
+                   (t
+                    (writes lip-tn)
+                    (when (tn-p reg-or-target)
+                      (reads reg-or-target)))))

   (:delay 1)
   (:emitter
    (unless target
   (:delay 1)
   (:emitter
    (unless target

-     (setf target reg-or-target)
-     (setf reg-or-target 31))
+     (setf target reg-or-target
+           reg-or-target lip-tn))

    (etypecase target
      (tn
       (emit-register-inst segment special-op (reg-tn-encoding target) 0
    (etypecase target
      (tn
       (emit-register-inst segment special-op (reg-tn-encoding target) 0

-                          reg-or-target 0 #b001001))
+                          (reg-tn-encoding reg-or-target) 0 #b001001))

      (fixup
      (fixup

-      (note-fixup segment :jump target)
-      (emit-jump-inst segment #b000011 0)))))
+      (note-fixup segment :lui target)
+      (emit-immediate-inst segment #b001111 0 28 0)
+      (note-fixup segment :addi target)
+      (emit-immediate-inst segment #b001001 28 28 0)
+      (emit-register-inst segment special-op 28 0
+                          (reg-tn-encoding reg-or-target) 0 #b001001)))))

 
 (define-instruction bc1f (segment target)
   (:declare (type label target))
 
 (define-instruction bc1f (segment target)
   (:declare (type label target))

@@ -1013,16 +1025,15 @@
   nil)
 
 (defun snarf-error-junk (sap offset &optional length-only)
   nil)
 
 (defun snarf-error-junk (sap offset &optional length-only)

-  (let* ((length (sb!sys:sap-ref-8 sap offset))
+  (let* ((length (sap-ref-8 sap offset))

          (vector (make-array length :element-type '(unsigned-byte 8))))
          (vector (make-array length :element-type '(unsigned-byte 8))))

-    (declare (type sb!sys:system-area-pointer sap)
+    (declare (type system-area-pointer sap)

              (type (unsigned-byte 8) length)
              (type (simple-array (unsigned-byte 8) (*)) vector))
     (cond (length-only
            (values 0 (1+ length) nil nil))
           (t
              (type (unsigned-byte 8) length)
              (type (simple-array (unsigned-byte 8) (*)) vector))
     (cond (length-only
            (values 0 (1+ length) nil nil))
           (t

-           (sb!kernel:copy-ub8-from-system-area sap (1+ offset)
-                                                vector 0 length)
+           (copy-ub8-from-system-area sap (1+ offset) vector 0 length)

            (collect ((sc-offsets)
                      (lengths))
              (lengths 1)                ; the length byte
            (collect ((sc-offsets)
                      (lengths))
              (lengths 1)                ; the length byte

@@ -1051,28 +1062,36 @@
 (defun break-control (chunk inst stream dstate)
   (declare (ignore inst))
   (flet ((nt (x) (if stream (sb!disassem:note x dstate))))
 (defun break-control (chunk inst stream dstate)
   (declare (ignore inst))
   (flet ((nt (x) (if stream (sb!disassem:note x dstate))))

-    (case (break-code chunk dstate)
-      (#.error-trap
-       (nt "Error trap")
-       (sb!disassem:handle-break-args #'snarf-error-junk stream dstate))
-      (#.cerror-trap
-       (nt "Cerror trap")
-       (sb!disassem:handle-break-args #'snarf-error-junk stream dstate))
-      (#.breakpoint-trap
-       (nt "Breakpoint trap"))
-      (#.pending-interrupt-trap
-       (nt "Pending interrupt trap"))
-      (#.halt-trap
-       (nt "Halt trap"))
-      (#.fun-end-breakpoint-trap
-       (nt "Function end breakpoint trap"))
-    )))
+    (when (= (break-code chunk dstate) 0)
+      (case (break-subcode chunk dstate)
+        (#.halt-trap
+         (nt "Halt trap"))
+        (#.pending-interrupt-trap
+         (nt "Pending interrupt trap"))
+        (#.error-trap
+         (nt "Error trap")
+         (sb!disassem:handle-break-args #'snarf-error-junk stream dstate))
+        (#.cerror-trap
+         (nt "Cerror trap")
+         (sb!disassem:handle-break-args #'snarf-error-junk stream dstate))
+        (#.breakpoint-trap
+         (nt "Breakpoint trap"))
+        (#.fun-end-breakpoint-trap
+         (nt "Function end breakpoint trap"))
+        (#.after-breakpoint-trap
+         (nt "After breakpoint trap"))
+        (#.pseudo-atomic-trap
+         (nt "Pseudo atomic trap"))
+        (#.object-not-list-trap
+         (nt "Object not list trap"))
+        (#.object-not-instance-trap
+         (nt "Object not instance trap"))))))

 
 (define-instruction break (segment code &optional (subcode 0))
   (:declare (type (unsigned-byte 10) code subcode))
   (:printer break ((op special-op) (funct #b001101))
 
 (define-instruction break (segment code &optional (subcode 0))
   (:declare (type (unsigned-byte 10) code subcode))
   (:printer break ((op special-op) (funct #b001101))

-            '(:name :tab code (:unless (:constant 0) subcode))
-            :control #'break-control )
+            '(:name :tab code (:unless (:constant 0) ", " subcode))
+            :control #'break-control)

   :pinned
   (:cost 0)
   (:delay 0)
   :pinned
   (:cost 0)
   (:delay 0)

@@ -1131,7 +1150,7 @@
                           (ash (+ posn (component-header-length))
                                (- n-widetag-bits word-shift)))))))
 
                           (ash (+ posn (component-header-length))
                                (- n-widetag-bits word-shift)))))))
 

-(define-instruction fun-header-word (segment)
+(define-instruction simple-fun-header-word (segment)

   :pinned
   (:cost 0)
   (:delay 0)
   :pinned
   (:cost 0)
   (:delay 0)

@@ -1152,7 +1171,7 @@
    segment 12 3
    #'(lambda (segment posn delta-if-after)
        (let ((delta (funcall calc label posn delta-if-after)))
    segment 12 3
    #'(lambda (segment posn delta-if-after)
        (let ((delta (funcall calc label posn delta-if-after)))

-          (when (<= (- (ash 1 15)) delta (1- (ash 1 15)))
+          (when (typep delta '(signed-byte 16))

             (emit-back-patch segment 4
                              #'(lambda (segment posn)
                                  (assemble (segment vop)
             (emit-back-patch segment 4
                              #'(lambda (segment posn)
                                  (assemble (segment vop)

@@ -1166,8 +1185,8 @@
                    (inst or temp (ldb (byte 16 0) delta))
                    (inst addu dst src temp))))))
 
                    (inst or temp (ldb (byte 16 0) delta))
                    (inst addu dst src temp))))))
 

-;; code = fn - header - label-offset + other-pointer-tag
-(define-instruction compute-code-from-fn (segment dst src label temp)
+;; code = lip - header - label-offset + other-pointer-lowtag
+(define-instruction compute-code-from-lip (segment dst src label temp)

   (:declare (type tn dst src temp) (type label label))
   (:attributes variable-length)
   (:dependencies (reads src) (writes dst) (writes temp))
   (:declare (type tn dst src temp) (type label label))
   (:attributes variable-length)
   (:dependencies (reads src) (writes dst) (writes temp))

@@ -1195,6 +1214,7 @@
                                 (component-header-length)))))))
 
 ;; lra = code + other-pointer-tag + header + label-offset - other-pointer-tag
                                 (component-header-length)))))))
 
 ;; lra = code + other-pointer-tag + header + label-offset - other-pointer-tag

+;;     = code + header + label-offset

 (define-instruction compute-lra-from-code (segment dst src label temp)
   (:declare (type tn dst src temp) (type label label))
   (:attributes variable-length)
 (define-instruction compute-lra-from-code (segment dst src label temp)
   (:declare (type tn dst src temp) (type label label))
   (:attributes variable-length)