(:hi-reg 64)
(:low-reg 65)
(:float-status 66)
- (:ctrl-stat-reg 67)
- (:r31 31)))))
+ (:ctrl-stat-reg 67)))))
(defparameter reg-symbols
(map 'vector
(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))
- (subcode :field (byte 10 6) :value 0)
+ (subcode :field (byte 10 6))
(funct :field (byte 6 0) :value #b001101))
(sb!disassem:define-instruction-format
(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)))
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)))
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)))
(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)
- (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)
- (: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
- (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
- reg-or-target 0 #b001001))
+ (reg-tn-encoding reg-or-target) 0 #b001001))
(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-macro entry-point ()
nil)
-#+nil
-(define-bitfield-emitter emit-break-inst 32
- (byte 6 26) (byte 10 16) (byte 10 6) (byte 6 0))
-
(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))))
- (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
- (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
(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))
- '(: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)
(emit-break-inst segment special-op code subcode #b001101)))
(define-instruction syscall (segment)
- (:printer register ((op special-op) (rd 0) (rt 0) (rs 0) (funct #b001100))
+ (:printer register ((op special-op) (rd 0) (rt 0) (rs 0) (funct #b001110))
'(:name))
:pinned
(:delay 0)
(:emitter
- (emit-register-inst segment special-op 0 0 0 0 #b001100)))
+ (emit-register-inst segment special-op 0 0 0 0 #b001110)))
(define-instruction nop (segment)
(:printer register ((op 0) (rd 0) (rd 0) (rs 0) (funct 0)) '(:name))
(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)
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)
(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))
(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)
projects / sbcl.git / blobdiff