1 ;;;; the instruction set definition for the Sparc
3 ;;;; This software is part of the SBCL system. See the README file for
6 ;;;; This software is derived from the CMU CL system, which was
7 ;;;; written at Carnegie Mellon University and released into the
8 ;;;; public domain. The software is in the public domain and is
9 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
10 ;;;; files for more information.
14 ;;;FIXME: the analogue is commented out in alpha/insts.lisp
15 ;;;(def-assembler-params
17 ;;; :max-locations 100)
18 (eval-when (:compile-toplevel :load-toplevel :execute)
19 (setf sb!assem:*assem-scheduler-p* t)
20 (setf sb!assem:*assem-max-locations* 100))
22 ;;; Constants, types, conversion functions, some disassembler stuff.
23 (defun reg-tn-encoding (tn)
24 (declare (type tn tn))
29 (if (eq (sb-name (sc-sb (tn-sc tn))) 'registers)
31 (error "~S isn't a register." tn)))))
33 (defun fp-reg-tn-encoding (tn)
34 (declare (type tn tn))
35 (unless (eq (sb-name (sc-sb (tn-sc tn))) 'float-registers)
36 (error "~S isn't a floating-point register." tn))
37 (let ((offset (tn-offset tn)))
39 (assert (member :sparc-v9 *backend-subfeatures*))
40 ;; No single register encoding greater than reg 31.
41 (assert (zerop (mod offset 2)))
42 ;; Upper bit of the register number is encoded in the low bit.
47 ;;;(sb!disassem:set-disassem-params :instruction-alignment 32
48 ;;; :opcode-column-width 11)
50 (defvar *disassem-use-lisp-reg-names* t
52 "If non-NIL, print registers using the Lisp register names.
53 Otherwise, use the Sparc register names")
55 (!def-vm-support-routine location-number (loc)
61 (ecase (sb-name (sc-sb (tn-sc loc)))
63 (unless (zerop (tn-offset loc))
68 (+ (tn-offset loc) 32))
70 (let ((offset (tn-offset loc)))
71 (assert (zerop (mod offset 2)))
72 (values (+ offset 32) 2)))
75 (let ((offset (tn-offset loc)))
76 (assert (zerop (mod offset 4)))
77 (values (+ offset 32) 4)))))
89 ;;; symbols used for disassembly printing
90 (defparameter reg-symbols
93 (cond ((null name) nil)
94 (t (make-symbol (concatenate 'string "%" name)))))
96 #!+sb-doc "The Lisp names for the Sparc integer registers")
98 (defparameter sparc-reg-symbols
99 #("%G0" "%G1" "%G2" "%G3" "%G4" "%G5" NIL NIL
100 "%O0" "%O1" "%O2" "%O3" "%O4" "%O5" "%O6" "%O7"
101 "%L0" "%L1" "%L2" "%L3" "%L4" "%L5" "%L6" "%L7"
102 "%I0" "%I1" "%I2" "%I3" "%I4" "%I5" NIL "%I7")
103 #!+sb-doc "The standard names for the Sparc integer registers")
105 (defun get-reg-name (index)
106 (if *disassem-use-lisp-reg-names*
107 (aref reg-symbols index)
108 (aref sparc-reg-symbols index)))
110 (defvar *note-sethi-inst* nil
111 "An alist for the disassembler indicating the target register and
112 value used in a SETHI instruction. This is used to make annotations
113 about function addresses and register values.")
115 (defvar *pseudo-atomic-set* nil)
117 (defun sign-extend-immed-value (val)
118 ;; val is a 13-bit signed number. Extend the sign appropriately.
123 ;;; Oh, come on, this is ridiculous. I'm not going to solve
124 ;;; bootstrapping issues for a disassembly note. Does this make me
125 ;;; lazy? Christophe, 2001-09-02. FIXME
129 (let ((results (mapcar (lambda (n)
130 (let ((nn (intern (concatenate 'string (string n)
134 `(eval-when (:compile-toplevel :load-toplevel :execute)
135 (def!constant header-word-type-alist
137 ;; This is the same list as in objdefs.
142 #!+long-float long-float
146 #!+long-float complex-long-float
152 simple-array-unsigned-byte-2
153 simple-array-unsigned-byte-4
154 simple-array-unsigned-byte-8
155 simple-array-unsigned-byte-16
156 simple-array-unsigned-byte-32
157 simple-array-signed-byte-8
158 simple-array-signed-byte-16
159 simple-array-signed-byte-30
160 simple-array-signed-byte-32
161 simple-array-single-float
162 simple-array-double-float
163 #!+long-float simple-array-long-float
164 simple-array-complex-single-float
165 simple-array-complex-double-float
166 #!+long-float simple-array-complex-long-float
175 funcallable-instance-header
178 closure-function-header
179 #!-gengc return-pc-header
180 #!+gengc forwarding-pointer
189 #!+(or gengc gencgc) scavenger-hook))
191 ;; Look at the current instruction and see if we can't add some notes
192 ;; about what's happening.
194 (defun maybe-add-notes (reg dstate)
195 (let* ((word (sb!disassem::sap-ref-int (sb!disassem::dstate-segment-sap dstate)
196 (sb!disassem::dstate-cur-offs dstate)
198 (sb!disassem::dstate-byte-order dstate)))
199 (format (ldb (byte 2 30) word))
200 (op3 (ldb (byte 6 19) word))
201 (rs1 (ldb (byte 5 14) word))
202 (rd (ldb (byte 5 25) word))
203 (immed-p (not (zerop (ldb (byte 1 13) word))))
204 (immed-val (sign-extend-immed-value (ldb (byte 13 0) word))))
205 ;; Only the value of format and rd are guaranteed to be correct
206 ;; because the disassembler is trying to print out the value of a
207 ;; register. The other values may not be right.
213 (handle-add-inst rs1 immed-val rd dstate)))
216 (handle-jmpl-inst rs1 immed-val rd dstate)))
219 (handle-andcc-inst rs1 immed-val rd dstate)))))
224 (handle-ld/st-inst rs1 immed-val rd dstate))))))
225 ;; If this is not a SETHI instruction, and RD is the same as some
226 ;; register used by SETHI, we delete the entry. (In case we have
227 ;; a SETHI without any additional instruction because the low bits
229 (unless (and (zerop format) (= #b100 (ldb (byte 3 22) word)))
230 (let ((sethi (assoc rd *note-sethi-inst*)))
232 (setf *note-sethi-inst* (delete sethi *note-sethi-inst*)))))))
234 (defun handle-add-inst (rs1 immed-val rd dstate)
235 (let* ((sethi (assoc rs1 *note-sethi-inst*)))
238 ;; RS1 was used in a SETHI instruction. Assume that
239 ;; this is the offset part of the SETHI instruction for
240 ;; a full 32-bit address of something. Make a note
241 ;; about this usage as a Lisp assembly routine or
242 ;; foreign routine, if possible. If not, just note the
244 (let ((addr (+ immed-val (ash (cdr sethi) 10))))
245 (or (sb!disassem::note-code-constant-absolute addr dstate)
246 (sb!disassem:maybe-note-assembler-routine addr t dstate)
247 (sb!disassem:note (format nil "~A = #x~8,'0X"
248 (get-reg-name rd) addr)
250 (setf *note-sethi-inst* (delete sethi *note-sethi-inst*)))
252 ;; We have an ADD %NULL, <n>, RD instruction. This is a
253 ;; reference to a static symbol.
254 (sb!disassem:maybe-note-nil-indexed-object immed-val
256 ((= rs1 alloc-offset)
257 ;; ADD %ALLOC, n. This must be some allocation or
258 ;; pseudo-atomic stuff
259 (cond ((and (= immed-val 4) (= rd alloc-offset)
260 (not *pseudo-atomic-set*))
261 ;; "ADD 4, %ALLOC" sets the flag
262 (sb!disassem::note "Set pseudo-atomic flag" dstate)
263 (setf *pseudo-atomic-set* t))
265 ;; "ADD n, %ALLOC" is reseting the flag, with extra
268 (format nil "Reset pseudo-atomic, allocated ~D bytes"
269 (+ immed-val 4)) dstate)
270 (setf *pseudo-atomic-set* nil))))
271 #+nil ((and (= rs1 zero-offset) *pseudo-atomic-set*)
272 ;; "ADD %ZERO, num, RD" inside a pseudo-atomic is very
273 ;; likely loading up a header word. Make a note to that
275 (let ((type (second (assoc (logand immed-val #xff) header-word-type-alist)))
276 (size (ldb (byte 24 8) immed-val)))
278 (sb!disassem:note (format nil "Header word ~A, size ~D?" type size)
281 (defun handle-jmpl-inst (rs1 immed-val rd dstate)
282 (let* ((sethi (assoc rs1 *note-sethi-inst*)))
284 ;; RS1 was used in a SETHI instruction. Assume that
285 ;; this is the offset part of the SETHI instruction for
286 ;; a full 32-bit address of something. Make a note
287 ;; about this usage as a Lisp assembly routine or
288 ;; foreign routine, if possible. If not, just note the
290 (let ((addr (+ immed-val (ash (cdr sethi) 10))))
291 (sb!disassem:maybe-note-assembler-routine addr t dstate)
292 (setf *note-sethi-inst* (delete sethi *note-sethi-inst*))))))
294 (defun handle-ld/st-inst (rs1 immed-val rd dstate)
295 (declare (ignore rd))
296 ;; Got an LDUW/LD or STW instruction, with immediate offset.
299 ;; A reference to a code constant (reg = %CODE)
300 (sb!disassem:note-code-constant immed-val dstate))
302 ;; A reference to a static symbol or static function (reg =
304 (or (sb!disassem:maybe-note-nil-indexed-symbol-slot-ref immed-val
306 #+nil (sb!disassem::maybe-note-static-function immed-val dstate)))
308 (let ((sethi (assoc rs1 *note-sethi-inst*)))
310 (let ((addr (+ immed-val (ash (cdr sethi) 10))))
311 (sb!disassem:maybe-note-assembler-routine addr nil dstate)
312 (setf *note-sethi-inst* (delete sethi *note-sethi-inst*))))))))
314 (defun handle-andcc-inst (rs1 immed-val rd dstate)
315 ;; ANDCC %ALLOC, 3, %ZERO instruction
316 (when (and (= rs1 alloc-offset) (= rd zero-offset) (= immed-val 3))
317 (sb!disassem:note "pseudo-atomic interrupted?" dstate)))
319 (sb!disassem:define-arg-type reg
320 :printer (lambda (value stream dstate)
321 (declare (stream stream) (fixnum value))
322 (let ((regname (get-reg-name value)))
323 (princ regname stream)
324 (sb!disassem:maybe-note-associated-storage-ref value
328 (maybe-add-notes value dstate))))
330 (defparameter float-reg-symbols
332 (loop for n from 0 to 63 collect (make-symbol (format nil "%F~d" n)))
335 (sb!disassem:define-arg-type fp-reg
336 :printer (lambda (value stream dstate)
337 (declare (stream stream) (fixnum value))
338 (let ((regname (aref float-reg-symbols value)))
339 (princ regname stream)
340 (sb!disassem:maybe-note-associated-storage-ref
346 ;;; The extended 6 bit floating point register encoding for the double
347 ;;; and long instructions of the sparc v9.
348 (sb!disassem:define-arg-type fp-ext-reg
349 :printer (lambda (value stream dstate)
350 (declare (stream stream) (fixnum value))
351 (let* (;; Decode the register number.
352 (value (if (oddp value) (+ value 31) value))
353 (regname (aref float-reg-symbols value)))
354 (princ regname stream)
355 (sb!disassem:maybe-note-associated-storage-ref
361 (sb!disassem:define-arg-type relative-label
363 :use-label (lambda (value dstate)
364 (declare (type (signed-byte 22) value)
365 (type sb!disassem:disassem-state dstate))
366 (+ (ash value 2) (sb!disassem:dstate-cur-addr dstate))))
368 (defconstant-eqx branch-conditions
369 '(:f :eq :le :lt :leu :ltu :n :vs :t :ne :gt :ge :gtu :geu :p :vc)
372 ;;; Note that these aren't the standard names for branch-conditions, I
373 ;;; think they're a bit more readable (e.g., "eq" instead of "e").
374 ;;; You could just put a vector of the normal ones here too.
376 (sb!disassem:define-arg-type branch-condition
377 :printer (coerce branch-conditions 'vector))
379 (deftype branch-condition ()
380 `(member ,@branch-conditions))
382 (defun branch-condition (condition)
383 (or (position condition branch-conditions)
384 (error "Unknown branch condition: ~S~%Must be one of: ~S"
385 condition branch-conditions)))
387 (def!constant branch-cond-true
390 (defconstant-eqx branch-fp-conditions
391 '(:f :ne :lg :ul :l :ug :g :u :t :eq :ue :ge :uge :le :ule :o)
394 (sb!disassem:define-arg-type branch-fp-condition
395 :printer (coerce branch-fp-conditions 'vector))
397 (sb!disassem:define-arg-type call-fixup :use-label t)
399 (deftype fp-branch-condition ()
400 `(member ,@branch-fp-conditions))
402 (defun fp-branch-condition (condition)
403 (or (position condition branch-fp-conditions)
404 (error "Unknown fp-branch condition: ~S~%Must be one of: ~S"
405 condition branch-fp-conditions)))
408 ;;;; dissassem:define-instruction-formats
410 (sb!disassem:define-instruction-format
411 (format-1 32 :default-printer '(:name :tab disp))
412 (op :field (byte 2 30) :value 1)
413 (disp :field (byte 30 0)))
415 (sb!disassem:define-instruction-format
416 (format-2-immed 32 :default-printer '(:name :tab immed ", " rd))
417 (op :field (byte 2 30) :value 0)
418 (rd :field (byte 5 25) :type 'reg)
419 (op2 :field (byte 3 22))
420 (immed :field (byte 22 0)))
424 (sb!disassem:define-instruction-format
425 (format-2-branch 32 :default-printer `(:name (:unless (:constant ,branch-cond-true) cond)
426 (:unless (a :constant 0) "," 'A)
429 (op :field (byte 2 30) :value 0)
430 (a :field (byte 1 29) :value 0)
431 (cond :field (byte 4 25) :type 'branch-condition)
432 (op2 :field (byte 3 22))
433 (disp :field (byte 22 0) :type 'relative-label))
435 ;; Branch with prediction instruction for V9
437 ;; Currently only %icc and %xcc are used of the four possible values
439 (defconstant-eqx integer-condition-registers
440 '(:icc :reserved :xcc :reserved)
443 (defconstant-eqx integer-cond-reg-name-vec
444 (coerce integer-condition-registers 'vector)
447 (deftype integer-condition-register ()
448 `(member ,@(remove :reserved integer-condition-registers)))
450 (defparameter integer-condition-reg-symbols
453 (make-symbol (concatenate 'string "%" (string name))))
454 integer-condition-registers))
456 (sb!disassem:define-arg-type integer-condition-register
457 :printer (lambda (value stream dstate)
458 (declare (stream stream) (fixnum value) (ignore dstate))
459 (let ((regname (aref integer-condition-reg-symbols value)))
460 (princ regname stream))))
462 (defconstant-eqx branch-predictions
466 (sb!disassem:define-arg-type branch-prediction
467 :printer (coerce branch-predictions 'vector))
469 (defun integer-condition (condition-reg)
470 (declare (type (member :icc :xcc) condition-reg))
471 (or (position condition-reg integer-condition-registers)
472 (error "Unknown integer condition register: ~S~%"
475 (defun branch-prediction (pred)
476 (or (position pred branch-predictions)
477 (error "Unknown branch prediction: ~S~%Must be one of: ~S~%"
478 pred branch-predictions)))
480 (defconstant-eqx branch-pred-printer
481 `(:name (:unless (:constant ,branch-cond-true) cond)
482 (:unless (a :constant 0) "," 'A)
483 (:unless (p :constant 1) "," 'pn)
490 (sb!disassem:define-instruction-format
491 (format-2-branch-pred 32 :default-printer branch-pred-printer)
492 (op :field (byte 2 30) :value 0)
493 (a :field (byte 1 29) :value 0)
494 (cond :field (byte 4 25) :type 'branch-condition)
495 (op2 :field (byte 3 22))
496 (cc :field (byte 2 20) :type 'integer-condition-register)
497 (p :field (byte 1 19))
498 (disp :field (byte 19 0) :type 'relative-label))
500 (defconstant-eqx fp-condition-registers
501 '(:fcc0 :fcc1 :fcc2 :fcc3)
504 (defconstant-eqx fp-cond-reg-name-vec
505 (coerce fp-condition-registers 'vector)
508 (defparameter fp-condition-reg-symbols
511 (make-symbol (concatenate 'string "%" (string name))))
512 fp-condition-registers))
514 (sb!disassem:define-arg-type fp-condition-register
515 :printer (lambda (value stream dstate)
516 (declare (stream stream) (fixnum value) (ignore dstate))
517 (let ((regname (aref fp-condition-reg-symbols value)))
518 (princ regname stream))))
520 (sb!disassem:define-arg-type fp-condition-register-shifted
521 :printer (lambda (value stream dstate)
522 (declare (stream stream) (fixnum value) (ignore dstate))
523 (let ((regname (aref fp-condition-reg-symbols (ash value -1))))
524 (princ regname stream))))
526 (defun fp-condition (condition-reg)
527 (or (position condition-reg fp-condition-registers)
528 (error "Unknown integer condition register: ~S~%"
531 (defconstant-eqx fp-branch-pred-printer
532 `(:name (:unless (:constant ,branch-cond-true) cond)
533 (:unless (a :constant 0) "," 'A)
534 (:unless (p :constant 1) "," 'pn)
541 (sb!disassem:define-instruction-format
542 (format-2-fp-branch-pred 32 :default-printer fp-branch-pred-printer)
543 (op :field (byte 2 30) :value 0)
544 (a :field (byte 1 29) :value 0)
545 (cond :field (byte 4 25) :type 'branch-fp-condition)
546 (op2 :field (byte 3 22))
547 (fcc :field (byte 2 20) :type 'fp-condition-register)
548 (p :field (byte 1 19))
549 (disp :field (byte 19 0) :type 'relative-label))
553 (sb!disassem:define-instruction-format
554 (format-2-unimp 32 :default-printer '(:name :tab data))
555 (op :field (byte 2 30) :value 0)
556 (ignore :field (byte 5 25) :value 0)
557 (op2 :field (byte 3 22) :value 0)
558 (data :field (byte 22 0)))
560 (defconstant-eqx f3-printer
562 (:unless (:same-as rd) rs1 ", ")
563 (:choose rs2 immed) ", "
567 (sb!disassem:define-instruction-format
568 (format-3-reg 32 :default-printer f3-printer)
569 (op :field (byte 2 30))
570 (rd :field (byte 5 25) :type 'reg)
571 (op3 :field (byte 6 19))
572 (rs1 :field (byte 5 14) :type 'reg)
573 (i :field (byte 1 13) :value 0)
574 (asi :field (byte 8 5) :value 0)
575 (rs2 :field (byte 5 0) :type 'reg))
577 (sb!disassem:define-instruction-format
578 (format-3-immed 32 :default-printer f3-printer)
579 (op :field (byte 2 30))
580 (rd :field (byte 5 25) :type 'reg)
581 (op3 :field (byte 6 19))
582 (rs1 :field (byte 5 14) :type 'reg)
583 (i :field (byte 1 13) :value 1)
584 (immed :field (byte 13 0) :sign-extend t)) ; usually sign extended
586 (sb!disassem:define-instruction-format
587 (format-binary-fpop 32
588 :default-printer '(:name :tab rs1 ", " rs2 ", " rd))
589 (op :field (byte 2 30))
590 (rd :field (byte 5 25) :type 'fp-reg)
591 (op3 :field (byte 6 19))
592 (rs1 :field (byte 5 14) :type 'fp-reg)
593 (opf :field (byte 9 5))
594 (rs2 :field (byte 5 0) :type 'fp-reg))
596 ;;; Floating point load/save instructions encoding.
597 (sb!disassem:define-instruction-format
598 (format-unary-fpop 32 :default-printer '(:name :tab rs2 ", " rd))
599 (op :field (byte 2 30))
600 (rd :field (byte 5 25) :type 'fp-reg)
601 (op3 :field (byte 6 19))
602 (rs1 :field (byte 5 14) :value 0)
603 (opf :field (byte 9 5))
604 (rs2 :field (byte 5 0) :type 'fp-reg))
606 ;;; Floating point comparison instructions encoding.
608 ;; This is a merge of the instructions for FP comparison and FP
609 ;; conditional moves available in the Sparc V9. The main problem is
610 ;; that the new instructions use part of the opcode space used by the
611 ;; comparison instructions. In particular, the OPF field is arranged
616 ;; FMOVcc 0nn0000xx %fccn
622 ;; So we see that if we break up the OPF field into 4 pieces, opf0,
623 ;; opf1, opf2, and opf3, we can distinguish between these
624 ;; instructions. So bit 9 (opf2) can be used to distinguish between
625 ;; FCMP and the rest. Also note that the nn field overlaps with the
626 ;; ccc. We need to take this into account as well.
628 (sb!disassem:define-instruction-format
630 :default-printer #!-sparc-v9 '(:name :tab rs1 ", " rs2)
631 #!+sparc-v9 '(:name :tab rd ", " rs1 ", " rs2))
632 (op :field (byte 2 30))
633 (rd :field (byte 5 25) :value 0)
634 (op3 :field (byte 6 19))
635 (rs1 :field (byte 5 14))
636 (opf0 :field (byte 1 13))
637 (opf1 :field (byte 3 10))
638 (opf2 :field (byte 1 9))
639 (opf3 :field (byte 4 5))
640 (rs2 :field (byte 5 0) :type 'fp-reg))
642 ;;; Shift instructions
643 (sb!disassem:define-instruction-format
644 (format-3-shift-reg 32 :default-printer f3-printer)
645 (op :field (byte 2 30))
646 (rd :field (byte 5 25) :type 'reg)
647 (op3 :field (byte 6 19))
648 (rs1 :field (byte 5 14) :type 'reg)
649 (i :field (byte 1 13) :value 0)
650 (x :field (byte 1 12))
651 (asi :field (byte 7 5) :value 0)
652 (rs2 :field (byte 5 0) :type 'reg))
654 (sb!disassem:define-instruction-format
655 (format-3-shift-immed 32 :default-printer f3-printer)
656 (op :field (byte 2 30))
657 (rd :field (byte 5 25) :type 'reg)
658 (op3 :field (byte 6 19))
659 (rs1 :field (byte 5 14) :type 'reg)
660 (i :field (byte 1 13) :value 1)
661 (x :field (byte 1 12))
662 (immed :field (byte 12 0) :sign-extend nil))
665 ;;; Conditional moves (only available for Sparc V9 architectures)
667 ;; The names of all of the condition registers on the V9: 4 FP
668 ;; conditions, the original integer condition register and the new
669 ;; extended register. The :reserved register is reserved on the V9.
671 (defconstant-eqx cond-move-condition-registers
672 '(:fcc0 :fcc1 :fcc2 :fcc3 :icc :reserved :xcc :reserved)
675 (defconstant-eqx cond-move-cond-reg-name-vec
676 (coerce cond-move-condition-registers 'vector)
679 (deftype cond-move-condition-register ()
680 `(member ,@(remove :reserved cond-move-condition-registers)))
682 (defparameter cond-move-condition-reg-symbols
685 (make-symbol (concatenate 'string "%" (string name))))
686 cond-move-condition-registers))
688 (sb!disassem:define-arg-type cond-move-condition-register
689 :printer (lambda (value stream dstate)
690 (declare (stream stream) (fixnum value) (ignore dstate))
691 (let ((regname (aref cond-move-condition-reg-symbols value)))
692 (princ regname stream))))
694 ;; From the given condition register, figure out what the cc2, cc1,
695 ;; and cc0 bits should be. Return cc2 and cc1/cc0 concatenated.
696 (defun cond-move-condition-parts (condition-reg)
697 (let ((posn (position condition-reg cond-move-condition-registers)))
700 (error "Unknown conditional move condition register: ~S~%"
703 (defun cond-move-condition (condition-reg)
704 (or (position condition-reg cond-move-condition-registers)
705 (error "Unknown conditional move condition register: ~S~%")))
707 (defconstant-eqx cond-move-printer
709 cc ", " (:choose immed rs2) ", " rd)
712 ;; Conditional move integer register on integer or FP condition code
713 (sb!disassem:define-instruction-format
714 (format-4-cond-move 32 :default-printer cond-move-printer)
715 (op :field (byte 2 30))
716 (rd :field (byte 5 25) :type 'reg)
717 (op3 :field (byte 6 19))
718 (cc2 :field (byte 1 18) :value 1)
719 (cond :field (byte 4 14) :type 'branch-condition)
720 (i :field (byte 1 13) :value 0)
721 (cc :field (byte 2 11) :type 'integer-condition-register)
722 (empty :field (byte 6 5) :value 0)
723 (rs2 :field (byte 5 0) :type 'reg))
725 (sb!disassem:define-instruction-format
726 (format-4-cond-move-immed 32 :default-printer cond-move-printer)
727 (op :field (byte 2 30))
728 (rd :field (byte 5 25) :type 'reg)
729 (op3 :field (byte 6 19))
730 (cc2 :field (byte 1 18) :value 1)
731 (cond :field (byte 4 14) :type 'branch-condition)
732 (i :field (byte 1 13) :value 1)
733 (cc :field (byte 2 11) :type 'integer-condition-register)
734 (immed :field (byte 11 0) :sign-extend t))
736 ;; Floating-point versions of the above integer conditional moves
737 (defconstant-eqx cond-fp-move-printer
738 `(:name rs1 :tab opf1 ", " rs2 ", " rd)
741 ;;; Conditional move on integer register condition (only on Sparc
742 ;;; V9). That is, move an integer register if some other integer
743 ;;; register satisfies some condition.
745 (defconstant-eqx cond-move-integer-conditions
746 '(:reserved :z :lez :lz :reserved :nz :gz :gez)
749 (defconstant-eqx cond-move-integer-condition-vec
750 (coerce cond-move-integer-conditions 'vector)
753 (deftype cond-move-integer-condition ()
754 `(member ,@(remove :reserved cond-move-integer-conditions)))
756 (sb!disassem:define-arg-type register-condition
757 :printer (lambda (value stream dstate)
758 (declare (stream stream) (fixnum value) (ignore dstate))
759 (let ((regname (aref cond-move-integer-condition-vec value)))
760 (princ regname stream))))
762 (defconstant-eqx cond-move-integer-printer
763 `(:name rcond :tab rs1 ", " (:choose immed rs2) ", " rd)
766 (defun register-condition (rcond)
767 (or (position rcond cond-move-integer-conditions)
768 (error "Unknown register condition: ~S~%")))
770 (sb!disassem:define-instruction-format
771 (format-4-cond-move-integer 32 :default-printer cond-move-integer-printer)
772 (op :field (byte 2 30))
773 (rd :field (byte 5 25) :type 'reg)
774 (op3 :field (byte 6 19))
775 (rs1 :field (byte 5 14) :type 'reg)
776 (i :field (byte 1 13) :value 0)
777 (rcond :field (byte 3 10) :type 'register-condition)
778 (opf :field (byte 5 5))
779 (rs2 :field (byte 5 0) :type 'reg))
781 (sb!disassem:define-instruction-format
782 (format-4-cond-move-integer-immed 32 :default-printer cond-move-integer-printer)
783 (op :field (byte 2 30))
784 (rd :field (byte 5 25) :type 'reg)
785 (op3 :field (byte 6 19))
786 (rs1 :field (byte 5 14) :type 'reg)
787 (i :field (byte 1 13) :value 1)
788 (rcond :field (byte 3 10) :type 'register-condition)
789 (immed :field (byte 10 0) :sign-extend t))
791 (defconstant-eqx trap-printer
792 `(:name rd :tab cc ", " immed)
795 (sb!disassem:define-instruction-format
796 (format-4-trap 32 :default-printer trap-printer)
797 (op :field (byte 2 30))
798 (rd :field (byte 5 25) :type 'reg)
799 (op3 :field (byte 6 19))
800 (rs1 :field (byte 5 14) :type 'reg)
801 (i :field (byte 1 13) :value 1)
802 (cc :field (byte 2 11) :type 'integer-condition-register)
803 (immed :field (byte 11 0) :sign-extend t)) ; usually sign extended
806 (defconstant-eqx cond-fp-move-integer-printer
807 `(:name opf1 :tab rs1 ", " rs2 ", " rd)
811 ;;;; Primitive emitters.
813 (define-bitfield-emitter emit-word 32
816 (define-bitfield-emitter emit-short 16
819 (define-bitfield-emitter emit-format-1 32
820 (byte 2 30) (byte 30 0))
822 (define-bitfield-emitter emit-format-2-immed 32
823 (byte 2 30) (byte 5 25) (byte 3 22) (byte 22 0))
825 (define-bitfield-emitter emit-format-2-branch 32
826 (byte 2 30) (byte 1 29) (byte 4 25) (byte 3 22) (byte 22 0))
828 ;; Integer and FP branches with prediction for V9
829 (define-bitfield-emitter emit-format-2-branch-pred 32
830 (byte 2 30) (byte 1 29) (byte 4 25) (byte 3 22) (byte 2 20) (byte 1 19) (byte 19 0))
831 (define-bitfield-emitter emit-format-2-fp-branch-pred 32
832 (byte 2 30) (byte 1 29) (byte 4 25) (byte 3 22) (byte 2 20) (byte 1 19) (byte 19 0))
834 (define-bitfield-emitter emit-format-2-unimp 32
835 (byte 2 30) (byte 5 25) (byte 3 22) (byte 22 0))
837 (define-bitfield-emitter emit-format-3-reg 32
838 (byte 2 30) (byte 5 25) (byte 6 19) (byte 5 14) (byte 1 13) (byte 8 5)
841 (define-bitfield-emitter emit-format-3-immed 32
842 (byte 2 30) (byte 5 25) (byte 6 19) (byte 5 14) (byte 1 13) (byte 13 0))
844 (define-bitfield-emitter emit-format-3-fpop 32
845 (byte 2 30) (byte 5 25) (byte 6 19) (byte 5 14) (byte 9 5) (byte 5 0))
847 (define-bitfield-emitter emit-format-3-fpop2 32
848 (byte 2 30) (byte 5 25) (byte 6 19) (byte 5 14)
849 (byte 1 13) (byte 3 10) (byte 1 9) (byte 4 5)
852 ;;; Shift instructions
854 (define-bitfield-emitter emit-format-3-shift-reg 32
855 (byte 2 30) (byte 5 25) (byte 6 19) (byte 5 14) (byte 1 13) (byte 1 12) (byte 7 5)
858 (define-bitfield-emitter emit-format-3-shift-immed 32
859 (byte 2 30) (byte 5 25) (byte 6 19) (byte 5 14) (byte 1 13) (byte 1 12) (byte 12 0))
861 ;;; Conditional moves
863 ;; Conditional move in condition code
864 (define-bitfield-emitter emit-format-4-cond-move 32
865 (byte 2 30) (byte 5 25) (byte 6 19) (byte 1 18) (byte 4 14) (byte 1 13) (byte 2 11)
868 ;; Conditional move on integer condition
869 (define-bitfield-emitter emit-format-4-cond-move-integer 32
870 (byte 2 30) (byte 5 25) (byte 6 19) (byte 5 14) (byte 1 13) (byte 3 10) (byte 5 5)
873 (define-bitfield-emitter emit-format-4-cond-move-integer-immed 32
874 (byte 2 30) (byte 5 25) (byte 6 19) (byte 5 14) (byte 1 13) (byte 3 10)
877 (define-bitfield-emitter emit-format-4-trap 32
878 (byte 2 30) (byte 5 25) (byte 6 19) (byte 5 14) (byte 1 13) (byte 2 11)
882 ;;;; Most of the format-3-instructions.
884 (defun emit-format-3-inst (segment op op3 dst src1 src2
885 &key load-store fixup dest-kind)
887 (cond ((and (typep src1 'tn) load-store)
894 (emit-format-3-reg segment op
896 (fp-reg-tn-encoding dst)
897 (reg-tn-encoding dst))
898 op3 (reg-tn-encoding src1) 0 0 (reg-tn-encoding src2)))
900 (emit-format-3-immed segment op
902 (fp-reg-tn-encoding dst)
903 (reg-tn-encoding dst))
904 op3 (reg-tn-encoding src1) 1 src2))
906 (unless (or load-store fixup)
907 (error "Fixups aren't allowed."))
908 (note-fixup segment :add src2)
909 (emit-format-3-immed segment op
911 (fp-reg-tn-encoding dst)
912 (reg-tn-encoding dst))
913 op3 (reg-tn-encoding src1) 1 0))))
915 ;;; Shift instructions because an extra bit is used in Sparc V9's to
916 ;;; indicate whether the shift is a 32-bit or 64-bit shift.
918 (defun emit-format-3-shift-inst (segment op op3 dst src1 src2 &key extended)
924 (emit-format-3-shift-reg segment op (reg-tn-encoding dst)
925 op3 (reg-tn-encoding src1) 0 (if extended 1 0)
926 0 (reg-tn-encoding src2)))
928 (emit-format-3-shift-immed segment op (reg-tn-encoding dst)
929 op3 (reg-tn-encoding src1) 1
930 (if extended 1 0) src2))))
933 (eval-when (:compile-toplevel :execute)
935 ;;; have to do this because def!constant is evalutated in the null lex env.
936 (defmacro with-ref-format (printer)
938 '(:choose (:plus-integer immed) ("+" rs2)))
940 `("[" rs1 (:unless (:constant 0) ,addend) "]"
941 (:choose (:unless (:constant 0) asi) nil))))
944 (defconstant-eqx load-printer
945 (with-ref-format `(:NAME :TAB ,ref-format ", " rd))
948 (defconstant-eqx store-printer
949 (with-ref-format `(:NAME :TAB rd ", " ,ref-format))
954 (macrolet ((define-f3-inst (name op op3 &key fixup load-store (dest-kind 'reg)
955 (printer :default) reads writes flushable print-name)
957 (if (eq printer :default)
960 ((:load t) 'load-printer)
961 (:store 'store-printer))
963 (when (and (atom reads) (not (null reads)))
964 (setf reads (list reads)))
965 (when (and (atom writes) (not (null writes)))
966 (setf writes (list writes)))
967 `(define-instruction ,name (segment dst src1 &optional src2)
968 (:declare (type tn dst)
969 ,(if (or fixup load-store)
970 '(type (or tn (signed-byte 13) null fixup) src1 src2)
971 '(type (or tn (signed-byte 13) null) src1 src2)))
972 (:printer format-3-reg
973 ((op ,op) (op3 ,op3) (rd nil :type ',dest-kind))
975 ,@(when print-name `(:print-name ,print-name)))
976 (:printer format-3-immed
977 ((op ,op) (op3 ,op3) (rd nil :type ',dest-kind))
979 ,@(when print-name `(:print-name ,print-name)))
981 '((:attributes flushable)))
984 ,@(let ((reads-list nil))
986 (push (list 'reads read) reads-list))
988 ,@(cond ((eq load-store :store)
990 (if src2 (reads src2))))
994 (if src2 (reads src2))))
995 ((eq load-store :load)
997 (if src2 (reads src2) (reads dst))))
999 '((if src2 (reads src2) (reads dst)))))
1000 ,@(let ((writes-list nil))
1001 (dolist (write writes)
1002 (push (list 'writes write) writes-list))
1004 ,@(cond ((eq load-store :store)
1005 '((writes :memory :partially t)))
1007 '((writes :memory :partially t)
1009 ((eq load-store :load)
1014 (:emitter (emit-format-3-inst segment ,op ,op3 dst src1 src2
1015 :load-store ,load-store
1017 :dest-kind (not (eq ',dest-kind 'reg)))))))
1019 (define-f3-shift-inst (name op op3 &key extended)
1020 `(define-instruction ,name (segment dst src1 &optional src2)
1021 (:declare (type tn dst)
1022 (type (or tn (unsigned-byte 6) null) src1 src2))
1023 (:printer format-3-shift-reg
1024 ((op ,op) (op3 ,op3) (x ,(if extended 1 0)) (i 0)))
1025 (:printer format-3-shift-immed
1026 ((op ,op) (op3 ,op3) (x ,(if extended 1 0)) (i 1)))
1029 (if src2 (reads src2) (reads dst))
1032 (:emitter (emit-format-3-shift-inst segment ,op ,op3 dst src1 src2
1033 :extended ,extended)))))
1035 (define-f3-inst ldsb #b11 #b001001 :load-store :load)
1036 (define-f3-inst ldsh #b11 #b001010 :load-store :load)
1037 (define-f3-inst ldub #b11 #b000001 :load-store :load)
1038 (define-f3-inst lduh #b11 #b000010 :load-store :load)
1040 ;; This instruction is called lduw for V9 , but looks exactly like ld
1041 ;; on previous architectures.
1042 (define-f3-inst ld #b11 #b000000 :load-store :load
1043 #!+sparc-v9 :print-name #!+sparc-v9 'lduw)
1045 (define-f3-inst ldsw #b11 #b001000 :load-store :load) ; v9
1047 ;; ldd is deprecated on the Sparc V9.
1048 (define-f3-inst ldd #b11 #b000011 :load-store :load)
1050 (define-f3-inst ldx #b11 #b001011 :load-store :load) ; v9
1052 (define-f3-inst ldf #b11 #b100000 :dest-kind fp-reg :load-store :load)
1053 (define-f3-inst lddf #b11 #b100011 :dest-kind fp-reg :load-store :load)
1054 (define-f3-inst ldqf #b11 #b100010 :dest-kind fp-reg :load-store :load) ; v9
1055 (define-f3-inst stb #b11 #b000101 :load-store :store)
1056 (define-f3-inst sth #b11 #b000110 :load-store :store)
1057 (define-f3-inst st #b11 #b000100 :load-store :store)
1059 ;; std is deprecated on the Sparc V9.
1060 (define-f3-inst std #b11 #b000111 :load-store :store)
1062 (define-f3-inst stx #b11 #b001110 :load-store :store) ; v9
1064 (define-f3-inst stf #b11 #b100100 :dest-kind fp-reg :load-store :store)
1065 (define-f3-inst stdf #b11 #b100111 :dest-kind fp-reg :load-store :store)
1066 (define-f3-inst stqf #b11 #b100110 :dest-kind fp-reg :load-store :store) ; v9
1067 (define-f3-inst ldstub #b11 #b001101 :load-store t)
1069 ;; swap is deprecated on the Sparc V9
1070 (define-f3-inst swap #b11 #b001111 :load-store t)
1072 (define-f3-inst add #b10 #b000000 :fixup t)
1073 (define-f3-inst addcc #b10 #b010000 :writes :psr)
1074 (define-f3-inst addx #b10 #b001000 :reads :psr)
1075 (define-f3-inst addxcc #b10 #b011000 :reads :psr :writes :psr)
1076 (define-f3-inst taddcc #b10 #b100000 :writes :psr)
1078 ;; taddcctv is deprecated on the Sparc V9. Use taddcc and bpvs or
1079 ;; taddcc and trap to get a similar effect. (Requires changing the C
1081 ;;(define-f3-inst taddcctv #b10 #b100010 :writes :psr)
1083 (define-f3-inst sub #b10 #b000100)
1084 (define-f3-inst subcc #b10 #b010100 :writes :psr)
1085 (define-f3-inst subx #b10 #b001100 :reads :psr)
1086 (define-f3-inst subxcc #b10 #b011100 :reads :psr :writes :psr)
1087 (define-f3-inst tsubcc #b10 #b100001 :writes :psr)
1089 ;; tsubcctv is deprecated on the Sparc V9. Use tsubcc and bpvs or
1090 ;; tsubcc and trap to get a similar effect. (Requires changing the C
1092 ;;(define-f3-inst tsubcctv #b10 #b100011 :writes :psr)
1094 (define-f3-inst mulscc #b10 #b100100 :reads :y :writes (:psr :y))
1095 (define-f3-inst and #b10 #b000001)
1096 (define-f3-inst andcc #b10 #b010001 :writes :psr)
1097 (define-f3-inst andn #b10 #b000101)
1098 (define-f3-inst andncc #b10 #b010101 :writes :psr)
1099 (define-f3-inst or #b10 #b000010)
1100 (define-f3-inst orcc #b10 #b010010 :writes :psr)
1101 (define-f3-inst orn #b10 #b000110)
1102 (define-f3-inst orncc #b10 #b010110 :writes :psr)
1103 (define-f3-inst xor #b10 #b000011)
1104 (define-f3-inst xorcc #b10 #b010011 :writes :psr)
1105 (define-f3-inst xnor #b10 #b000111)
1106 (define-f3-inst xnorcc #b10 #b010111 :writes :psr)
1108 (define-f3-shift-inst sll #b10 #b100101)
1109 (define-f3-shift-inst srl #b10 #b100110)
1110 (define-f3-shift-inst sra #b10 #b100111)
1111 (define-f3-shift-inst sllx #b10 #b100101 :extended t) ; v9
1112 (define-f3-shift-inst srlx #b10 #b100110 :extended t) ; v9
1113 (define-f3-shift-inst srax #b10 #b100111 :extended t) ; v9
1115 (define-f3-inst save #b10 #b111100 :reads :psr :writes :psr)
1116 (define-f3-inst restore #b10 #b111101 :reads :psr :writes :psr)
1118 ;; smul, smulcc, umul, umulcc, sdiv, sdivcc, udiv, and udivcc are
1119 ;; deprecated on the Sparc V9. Use mulx, sdivx, and udivx instead.
1120 (define-f3-inst smul #b10 #b001011 :writes :y) ; v8
1121 (define-f3-inst smulcc #b10 #b011011 :writes (:psr :y)) ; v8
1122 (define-f3-inst umul #b10 #b001010 :writes :y) ; v8
1123 (define-f3-inst umulcc #b10 #b011010 :writes (:psr :y)) ; v8
1124 (define-f3-inst sdiv #b10 #b001111 :reads :y) ; v8
1125 (define-f3-inst sdivcc #b10 #b011111 :reads :y :writes :psr) ; v8
1126 (define-f3-inst udiv #b10 #b001110 :reads :y) ; v8
1127 (define-f3-inst udivcc #b10 #b011110 :reads :y :writes :psr) ; v8
1129 (define-f3-inst mulx #b10 #b001001) ; v9 for both signed and unsigned
1130 (define-f3-inst sdivx #b10 #b101101) ; v9
1131 (define-f3-inst udivx #b10 #b001101) ; v9
1133 (define-f3-inst popc #b10 #b101110) ; v9: count one bits
1138 ;;;; Random instructions.
1140 ;; ldfsr is deprecated on the Sparc V9. Use ldxfsr instead
1141 (define-instruction ldfsr (segment src1 src2)
1142 (:declare (type tn src1) (type (signed-byte 13) src2))
1143 (:printer format-3-immed ((op #b11) (op3 #b100001) (rd 0)))
1146 (:emitter (emit-format-3-immed segment #b11 0 #b100001
1147 (reg-tn-encoding src1) 1 src2)))
1150 (define-instruction ldxfsr (segment src1 src2)
1151 (:declare (type tn src1) (type (signed-byte 13) src2))
1152 (:printer format-3-immed ((op #b11) (op3 #b100001) (rd 1))
1153 '(:name :tab "[" rs1 (:unless (:constant 0) "+" immed) "], %FSR")
1157 (:emitter (emit-format-3-immed segment #b11 1 #b100001
1158 (reg-tn-encoding src1) 1 src2)))
1160 ;; stfsr is deprecated on the Sparc V9. Use stxfsr instead.
1161 (define-instruction stfsr (segment src1 src2)
1162 (:declare (type tn src1) (type (signed-byte 13) src2))
1163 (:printer format-3-immed ((op #b11) (op3 #b100101) (rd 0)))
1166 (:emitter (emit-format-3-immed segment #b11 0 #b100101
1167 (reg-tn-encoding src1) 1 src2)))
1170 (define-instruction stxfsr (segment src1 src2)
1171 (:declare (type tn src1) (type (signed-byte 13) src2))
1172 (:printer format-3-immed ((op #b11) (op3 #b100101) (rd 1))
1173 '(:name :tab "%FSR, [" rs1 "+" (:unless (:constant 0) "+" immed) "]")
1177 (:emitter (emit-format-3-immed segment #b11 1 #b100101
1178 (reg-tn-encoding src1) 1 src2)))
1180 (eval-when (#-sb-xc :compile-toplevel :load-toplevel :execute)
1181 (defun sethi-arg-printer (value stream dstate)
1182 (format stream "%hi(#x~8,'0x)" (ash value 10))
1183 ;; Save the immediate value and the destination register from this
1184 ;; sethi instruction. This is used later to print some possible
1185 ;; notes about the value loaded by sethi.
1186 (let* ((word (sb!disassem::sap-ref-int (sb!disassem::dstate-segment-sap dstate)
1187 (sb!disassem::dstate-cur-offs dstate)
1189 (sb!disassem::dstate-byte-order dstate)))
1190 (imm22 (ldb (byte 22 0) word))
1191 (rd (ldb (byte 5 25) word)))
1192 (push (cons rd imm22) *note-sethi-inst*)))
1196 (define-instruction sethi (segment dst src1)
1197 (:declare (type tn dst)
1198 (type (or (signed-byte 22) (unsigned-byte 22) fixup) src1))
1199 (:printer format-2-immed
1200 ((op2 #b100) (immed nil :printer #'sethi-arg-printer)))
1201 (:dependencies (writes dst))
1206 (emit-format-2-immed segment #b00 (reg-tn-encoding dst) #b100
1209 (note-fixup segment :sethi src1)
1210 (emit-format-2-immed segment #b00 (reg-tn-encoding dst) #b100 0)))))
1212 ;; rdy is deprecated on the Sparc V9. It's not needed with 64-bit
1214 (define-instruction rdy (segment dst)
1215 (:declare (type tn dst))
1216 (:printer format-3-immed ((op #b10) (op3 #b101000) (rs1 0) (immed 0))
1217 '('RD :tab '%Y ", " rd))
1218 (:dependencies (reads :y) (writes dst))
1220 (:emitter (emit-format-3-immed segment #b10 (reg-tn-encoding dst) #b101000
1223 (defconstant-eqx wry-printer
1224 '('WR :tab rs1 (:unless (:constant 0) ", " (:choose immed rs2)) ", " '%Y)
1227 ;; wry is deprecated on the Sparc V9. It's not needed with 64-bit
1229 (define-instruction wry (segment src1 &optional src2)
1230 (:declare (type tn src1) (type (or (signed-byte 13) tn null) src2))
1231 (:printer format-3-reg ((op #b10) (op3 #b110000) (rd 0)) wry-printer)
1232 (:printer format-3-immed ((op #b10) (op3 #b110000) (rd 0)) wry-printer)
1233 (:dependencies (reads src1) (if src2 (reads src2)) (writes :y))
1238 (emit-format-3-reg segment #b10 0 #b110000 (reg-tn-encoding src1) 0 0 0))
1240 (emit-format-3-reg segment #b10 0 #b110000 (reg-tn-encoding src1) 0 0
1241 (reg-tn-encoding src2)))
1243 (emit-format-3-immed segment #b10 0 #b110000 (reg-tn-encoding src1) 1
1246 (defun snarf-error-junk (sap offset &optional length-only)
1247 (let* ((length (sb!sys:sap-ref-8 sap offset))
1248 (vector (make-array length :element-type '(unsigned-byte 8))))
1249 (declare (type sb!sys:system-area-pointer sap)
1250 (type (unsigned-byte 8) length)
1251 (type (simple-array (unsigned-byte 8) (*)) vector))
1253 (values 0 (1+ length) nil nil))
1255 (sb!kernel:copy-from-system-area sap (* n-byte-bits (1+ offset))
1256 vector (* n-word-bits
1258 (* length n-byte-bits))
1259 (collect ((sc-offsets)
1261 (lengths 1) ; the length byte
1263 (error-number (sb!c:read-var-integer vector index)))
1266 (when (>= index length)
1268 (let ((old-index index))
1269 (sc-offsets (sb!c:read-var-integer vector index))
1270 (lengths (- index old-index))))
1271 (values error-number
1276 (defun unimp-control (chunk inst stream dstate)
1277 (declare (ignore inst))
1278 (flet ((nt (x) (if stream (sb!disassem:note x dstate))))
1279 (case (format-2-unimp-data chunk dstate)
1282 (sb!disassem:handle-break-args #'snarf-error-junk stream dstate))
1285 (sb!disassem:handle-break-args #'snarf-error-junk stream dstate))
1286 (#.object-not-list-trap
1287 (nt "Object not list trap"))
1289 (nt "Breakpoint trap"))
1290 (#.pending-interrupt-trap
1291 (nt "Pending interrupt trap"))
1294 (#.fun-end-breakpoint-trap
1295 (nt "Function end breakpoint trap"))
1296 (#.object-not-instance-trap
1297 (nt "Object not instance trap"))
1300 (define-instruction unimp (segment data)
1301 (:declare (type (unsigned-byte 22) data))
1302 (:printer format-2-unimp () :default :control #'unimp-control
1303 :print-name #!-sparc-v9 'unimp #!+sparc-v9 'illtrap)
1305 (:emitter (emit-format-2-unimp segment 0 0 0 data)))
1309 ;;;; Branch instructions.
1311 ;; The branch instruction is deprecated on the Sparc V9. Use the
1312 ;; branch with prediction instructions instead.
1313 (defun emit-relative-branch (segment a op2 cond-or-target target &optional fp)
1314 (emit-back-patch segment 4
1315 (lambda (segment posn)
1317 (setf target cond-or-target)
1318 (setf cond-or-target :t))
1319 (emit-format-2-branch
1322 (fp-branch-condition cond-or-target)
1323 (branch-condition cond-or-target))
1325 (let ((offset (ash (- (label-position target) posn) -2)))
1326 (when (and (= a 1) (> 0 offset))
1327 (error "Offset of BA must be positive"))
1330 (defun emit-relative-branch-integer (segment a op2 cond-or-target target &optional (cc :icc) (pred :pt))
1331 (declare (type integer-condition-register cc))
1332 (assert (member :sparc-v9 *backend-subfeatures*))
1333 (emit-back-patch segment 4
1334 (lambda (segment posn)
1336 (setf target cond-or-target)
1337 (setf cond-or-target :t))
1338 (emit-format-2-branch-pred
1340 (branch-condition cond-or-target)
1342 (integer-condition cc)
1343 (branch-prediction pred)
1344 (let ((offset (ash (- (label-position target) posn) -2)))
1345 (when (and (= a 1) (> 0 offset))
1346 (error "Offset of BA must be positive"))
1349 (defun emit-relative-branch-fp (segment a op2 cond-or-target target &optional (cc :fcc0) (pred :pt))
1350 (assert (member :sparc-v9 *backend-subfeatures*))
1351 (emit-back-patch segment 4
1352 (lambda (segment posn)
1354 (setf target cond-or-target)
1355 (setf cond-or-target :t))
1356 (emit-format-2-branch-pred
1358 (fp-branch-condition cond-or-target)
1361 (branch-prediction pred)
1362 (let ((offset (ash (- (label-position target) posn) -2)))
1363 (when (and (= a 1) (> 0 offset))
1364 (error "Offset of BA must be positive"))
1367 ;; So that I don't have to go change the syntax of every single use of
1368 ;; branches, I'm keeping the Lisp instruction names the same. They
1369 ;; just get translated to the branch with prediction
1370 ;; instructions. However, the disassembler uses the correct V9
1372 (define-instruction b (segment cond-or-target &rest args)
1373 (:declare (type (or label branch-condition) cond-or-target))
1374 (:printer format-2-branch ((op #b00) (op2 #b010)))
1375 (:attributes branch)
1376 (:dependencies (reads :psr))
1380 ((member :sparc-v9 *backend-subfeatures*)
1381 (destructuring-bind (&optional target pred cc) args
1382 (declare (type (or label null) target))
1383 (emit-relative-branch-integer segment 0 #b001 cond-or-target target (or cc :icc) (or pred :pt))))
1385 (destructuring-bind (&optional target) args
1386 (declare (type (or label null) target))
1387 (emit-relative-branch segment 0 #b010 cond-or-target target))))))
1389 (define-instruction bp (segment cond-or-target &optional target pred cc)
1390 (:declare (type (or label branch-condition) cond-or-target)
1391 (type (or label null) target))
1392 (:printer format-2-branch-pred ((op #b00) (op2 #b001))
1395 (:attributes branch)
1396 (:dependencies (reads :psr))
1399 (emit-relative-branch-integer segment 0 #b001 cond-or-target target (or cc :icc) (or pred :pt))))
1401 (define-instruction ba (segment cond-or-target &rest args)
1402 (:declare (type (or label branch-condition) cond-or-target))
1403 (:printer format-2-branch ((op #b00) (op2 #b010) (a 1))
1406 (:attributes branch)
1407 (:dependencies (reads :psr))
1411 ((member :sparc-v9 *backend-subfeatures*)
1412 (destructuring-bind (&optional target pred cc) args
1413 (declare (type (or label null) target))
1414 (emit-relative-branch-integer segment 1 #b001 cond-or-target target (or cc :icc) (or pred :pt))))
1416 (destructuring-bind (&optional target) args
1417 (declare (type (or label null) target))
1418 (emit-relative-branch segment 1 #b010 cond-or-target target))))))
1420 (define-instruction bpa (segment cond-or-target &optional target pred cc)
1421 (:declare (type (or label branch-condition) cond-or-target)
1422 (type (or label null) target))
1423 (:printer format-2-branch ((op #b00) (op2 #b001) (a 1))
1426 (:attributes branch)
1427 (:dependencies (reads :psr))
1430 (emit-relative-branch-integer segment 1 #b001 cond-or-target target (or cc :icc) (or pred :pt))))
1432 ;; This doesn't cover all of the possible formats for the trap
1433 ;; instruction. We really only want a trap with a immediate trap
1434 ;; value and with RS1 = register 0. Also, the Sparc Compliance
1435 ;; Definition 2.4.1 says only trap numbers 16-31 are allowed for user
1436 ;; code. All other trap numbers have other uses. The restriction on
1437 ;; target will prevent us from using bad trap numbers by mistake.
1439 (define-instruction t (segment condition target &optional cc)
1440 (:declare (type branch-condition condition)
1441 ;; KLUDGE: see comments in vm.lisp regarding
1442 ;; pseudo-atomic-trap.
1444 (type (integer 16 31) target))
1445 (:printer format-3-immed ((op #b10)
1446 (rd nil :type 'branch-condition)
1449 '(:name rd :tab immed))
1450 (:attributes branch)
1451 (:dependencies (reads :psr))
1455 ((member :sparc-v9 *backend-subfeatures*)
1458 (emit-format-4-trap segment
1460 (branch-condition condition)
1462 (integer-condition cc)
1466 (emit-format-3-immed segment #b10 (branch-condition condition)
1467 #b111010 0 1 target)))))
1469 ;;; KLUDGE: we leave this commented out, as these two (T and TCC)
1470 ;;; operations are actually indistinguishable from their bitfields,
1471 ;;; breaking the disassembler if these are left in. The printer isn't
1472 ;;; terribly smart, but the emitted code is right. - CSR, 2002-08-04
1474 (define-instruction tcc (segment condition target &optional (cc #!-sparc-64 :icc #!+sparc-64 :xcc))
1475 (:declare (type branch-condition condition)
1476 ;; KLUDGE: see above.
1478 (type (integer 16 31) target)
1479 (type integer-condition-register cc))
1480 (:printer format-4-trap ((op #b10)
1481 (rd nil :type 'branch-condition)
1485 (:attributes branch)
1486 (:dependencies (reads :psr))
1488 (:emitter (emit-format-4-trap segment
1490 (branch-condition condition)
1492 (integer-condition cc)
1495 ;; Same as for the branch instructions. On the Sparc V9, we will use
1496 ;; the FP branch with prediction instructions instead.
1498 (define-instruction fb (segment condition target &rest args)
1499 (:declare (type fp-branch-condition condition) (type label target))
1500 (:printer format-2-branch ((op #B00)
1501 (cond nil :type 'branch-fp-condition)
1503 (:attributes branch)
1504 (:dependencies (reads :fsr))
1508 ((member :sparc-v9 *backend-subfeatures*)
1509 (destructuring-bind (&optional fcc pred) args
1510 (emit-relative-branch-fp segment 0 #b101 condition target (or fcc :fcc0) (or pred :pt))))
1512 (assert (null args))
1513 (emit-relative-branch segment 0 #b110 condition target t)))))
1515 (define-instruction fbp (segment condition target &optional fcc pred)
1516 (:declare (type fp-branch-condition condition) (type label target))
1517 (:printer format-2-fp-branch-pred ((op #b00) (op2 #b101))
1518 fp-branch-pred-printer
1520 (:attributes branch)
1521 (:dependencies (reads :fsr))
1524 (emit-relative-branch-fp segment 0 #b101 condition target (or fcc :fcc0) (or pred :pt))))
1526 (defconstant-eqx jal-printer
1528 (:choose (rs1 (:unless (:constant 0) (:plus-integer immed)))
1529 (:cond ((rs2 :constant 0) rs1)
1530 ((rs1 :constant 0) rs2)
1532 (:unless (:constant 0) ", " rd))
1535 (define-instruction jal (segment dst src1 &optional src2)
1536 (:declare (type tn dst)
1537 (type (or tn integer) src1)
1538 (type (or null fixup tn (signed-byte 13)) src2))
1539 (:printer format-3-reg ((op #b10) (op3 #b111000)) jal-printer)
1540 (:printer format-3-immed ((op #b10) (op3 #b111000)) jal-printer)
1541 (:attributes branch)
1542 (:dependencies (reads src1) (if src2 (reads src2) (reads dst)) (writes dst))
1550 (emit-format-3-reg segment #b10 (reg-tn-encoding dst) #b111000
1553 (reg-tn-encoding src1))
1554 0 0 (reg-tn-encoding src2)))
1556 (emit-format-3-immed segment #b10 (reg-tn-encoding dst) #b111000
1557 (reg-tn-encoding src1) 1 src2))
1559 (note-fixup segment :add src2)
1560 (emit-format-3-immed segment #b10 (reg-tn-encoding dst)
1561 #b111000 (reg-tn-encoding src1) 1 0)))))
1563 (define-instruction j (segment src1 &optional src2)
1564 (:declare (type tn src1) (type (or tn (signed-byte 13) fixup null) src2))
1565 (:printer format-3-reg ((op #b10) (op3 #b111000) (rd 0)) jal-printer)
1566 (:printer format-3-immed ((op #b10) (op3 #b111000) (rd 0)) jal-printer)
1567 (:attributes branch)
1568 (:dependencies (reads src1) (if src2 (reads src2)))
1573 (emit-format-3-reg segment #b10 0 #b111000 (reg-tn-encoding src1) 0 0 0))
1575 (emit-format-3-reg segment #b10 0 #b111000 (reg-tn-encoding src1) 0 0
1576 (reg-tn-encoding src2)))
1578 (emit-format-3-immed segment #b10 0 #b111000 (reg-tn-encoding src1) 1
1581 (note-fixup segment :add src2)
1582 (emit-format-3-immed segment #b10 0 #b111000 (reg-tn-encoding src1) 1
1587 ;;;; Unary and binary fp insts.
1589 (macrolet ((define-unary-fp-inst (name opf &key reads extended)
1590 `(define-instruction ,name (segment dst src)
1591 (:declare (type tn dst src))
1592 (:printer format-unary-fpop
1593 ((op #b10) (op3 #b110100) (opf ,opf)
1595 (rs2 nil :type ',(if extended 'fp-ext-reg 'fp-reg))
1596 (rd nil :type ',(if extended 'fp-ext-reg 'fp-reg))))
1604 (:emitter (emit-format-3-fpop segment #b10 (fp-reg-tn-encoding dst)
1605 #b110100 0 ,opf (fp-reg-tn-encoding src)))))
1607 (define-binary-fp-inst (name opf &key (op3 #b110100)
1608 reads writes delay extended)
1609 `(define-instruction ,name (segment dst src1 src2)
1610 (:declare (type tn dst src1 src2))
1611 (:printer format-binary-fpop
1612 ((op #b10) (op3 ,op3) (opf ,opf)
1613 (rs1 nil :type ',(if extended 'fp-ext-reg 'fp-reg))
1614 (rs2 nil :type ',(if extended 'fp-ext-reg 'fp-reg))
1615 (rd nil :type ',(if extended 'fp-ext-reg 'fp-reg))
1623 `((writes ,writes)))
1628 (:emitter (emit-format-3-fpop segment #b10 (fp-reg-tn-encoding dst)
1629 ,op3 (fp-reg-tn-encoding src1) ,opf
1630 (fp-reg-tn-encoding src2)))))
1632 (define-cmp-fp-inst (name opf &key extended)
1636 `(define-instruction ,name (segment src1 src2 &optional (fcc :fcc0))
1637 (:declare (type tn src1 src2)
1638 (type (member :fcc0 :fcc1 :fcc2 :fcc3) fcc))
1639 (:printer format-fpop2
1646 (rs1 nil :type ',(if extended 'fp-ext-reg 'fp-reg))
1647 (rs2 nil :type ',(if extended 'fp-ext-reg 'fp-reg))
1651 (rd nil :type 'fp-condition-register))
1657 ;; The Sparc V9 doesn't need a delay after a FP compare.
1659 ;; KLUDGE FIXME YAARGH -- how to express that? I guess for now we
1660 ;; do the worst case, and hope to fix it.
1661 ;; (:delay #-sparc-v9 1 #+sparc-v9 0)
1664 (emit-format-3-fpop2 segment #b10
1665 (or (position fcc '(:fcc0 :fcc1 :fcc2 :fcc3))
1668 (fp-reg-tn-encoding src1)
1669 ,opf0 ,opf1 ,opf2 ,opf
1670 (fp-reg-tn-encoding src2)))))))
1672 (define-unary-fp-inst fitos #b011000100 :reads :fsr)
1673 (define-unary-fp-inst fitod #b011001000 :reads :fsr :extended t)
1674 (define-unary-fp-inst fitoq #b011001100 :reads :fsr :extended t) ; v8
1676 (define-unary-fp-inst fxtos #b010000100 :reads :fsr) ; v9
1677 (define-unary-fp-inst fxtod #b010001000 :reads :fsr :extended t) ; v9
1678 (define-unary-fp-inst fxtoq #b010001100 :reads :fsr :extended t) ; v9
1681 ;; I (Raymond Toy) don't think these f{sd}toir instructions exist on
1682 ;; any Ultrasparc, but I only have a V9 manual. The code in
1683 ;; float.lisp seems to indicate that they only existed on non-sun4
1684 ;; machines (sun3 68K machines?).
1685 (define-unary-fp-inst fstoir #b011000001 :reads :fsr)
1686 (define-unary-fp-inst fdtoir #b011000010 :reads :fsr)
1688 (define-unary-fp-inst fstoi #b011010001)
1689 (define-unary-fp-inst fdtoi #b011010010 :extended t)
1690 (define-unary-fp-inst fqtoi #b011010011 :extended t) ; v8
1692 (define-unary-fp-inst fstox #b010000001) ; v9
1693 (define-unary-fp-inst fdtox #b010000010 :extended t) ; v9
1694 (define-unary-fp-inst fqtox #b010000011 :extended t) ; v9
1696 (define-unary-fp-inst fstod #b011001001 :reads :fsr)
1697 (define-unary-fp-inst fstoq #b011001101 :reads :fsr) ; v8
1698 (define-unary-fp-inst fdtos #b011000110 :reads :fsr)
1699 (define-unary-fp-inst fdtoq #b011001110 :reads :fsr) ; v8
1700 (define-unary-fp-inst fqtos #b011000111 :reads :fsr) ; v8
1701 (define-unary-fp-inst fqtod #b011001011 :reads :fsr) ; v8
1703 (define-unary-fp-inst fmovs #b000000001)
1704 (define-unary-fp-inst fmovd #b000000010 :extended t) ; v9
1705 (define-unary-fp-inst fmovq #b000000011 :extended t) ; v9
1707 (define-unary-fp-inst fnegs #b000000101)
1708 (define-unary-fp-inst fnegd #b000000110 :extended t) ; v9
1709 (define-unary-fp-inst fnegq #b000000111 :extended t) ; v9
1711 (define-unary-fp-inst fabss #b000001001)
1712 (define-unary-fp-inst fabsd #b000001010 :extended t) ; v9
1713 (define-unary-fp-inst fabsq #b000001011 :extended t) ; v9
1715 (define-unary-fp-inst fsqrts #b000101001 :reads :fsr) ; V7
1716 (define-unary-fp-inst fsqrtd #b000101010 :reads :fsr :extended t) ; V7
1717 (define-unary-fp-inst fsqrtq #b000101011 :reads :fsr :extended t) ; v8
1719 (define-binary-fp-inst fadds #b001000001)
1720 (define-binary-fp-inst faddd #b001000010 :extended t)
1721 (define-binary-fp-inst faddq #b001000011 :extended t) ; v8
1722 (define-binary-fp-inst fsubs #b001000101)
1723 (define-binary-fp-inst fsubd #b001000110 :extended t)
1724 (define-binary-fp-inst fsubq #b001000111 :extended t) ; v8
1726 (define-binary-fp-inst fmuls #b001001001)
1727 (define-binary-fp-inst fmuld #b001001010 :extended t)
1728 (define-binary-fp-inst fmulq #b001001011 :extended t) ; v8
1729 (define-binary-fp-inst fdivs #b001001101)
1730 (define-binary-fp-inst fdivd #b001001110 :extended t)
1731 (define-binary-fp-inst fdivq #b001001111 :extended t) ; v8
1733 ;;; Float comparison instructions.
1735 (define-cmp-fp-inst fcmps #b0001)
1736 (define-cmp-fp-inst fcmpd #b0010 :extended t)
1737 (define-cmp-fp-inst fcmpq #b0011 :extended t) ;v8
1738 (define-cmp-fp-inst fcmpes #b0101)
1739 (define-cmp-fp-inst fcmped #b0110 :extended t)
1740 (define-cmp-fp-inst fcmpeq #b0111 :extended t) ; v8
1744 ;;;; li, jali, ji, nop, cmp, not, neg, move, and more
1746 (defun %li (reg value)
1749 (inst add reg zero-tn value))
1750 ((or (signed-byte 32) (unsigned-byte 32))
1751 (let ((hi (ldb (byte 22 10) value))
1752 (lo (ldb (byte 10 0) value)))
1755 (inst add reg lo))))
1757 (inst sethi reg value)
1758 (inst add reg value))))
1760 (define-instruction-macro li (reg value)
1763 ;;; Jal to a full 32-bit address. Tmpreg is trashed.
1764 (define-instruction jali (segment link tmpreg value)
1765 (:declare (type tn link tmpreg)
1766 (type (or (signed-byte 13) (signed-byte 32) (unsigned-byte 32)
1768 (:attributes variable-length)
1770 (:attributes branch)
1771 (:dependencies (writes link) (writes tmpreg))
1774 (assemble (segment vop)
1777 (inst jal link zero-tn value))
1778 ((or (signed-byte 32) (unsigned-byte 32))
1779 (let ((hi (ldb (byte 22 10) value))
1780 (lo (ldb (byte 10 0) value)))
1781 (inst sethi tmpreg hi)
1782 (inst jal link tmpreg lo)))
1784 (inst sethi tmpreg value)
1785 (inst jal link tmpreg value))))))
1787 ;;; Jump to a full 32-bit address. Tmpreg is trashed.
1788 (define-instruction ji (segment tmpreg value)
1789 (:declare (type tn tmpreg)
1790 (type (or (signed-byte 13) (signed-byte 32) (unsigned-byte 32)
1792 (:attributes variable-length)
1794 (:attributes branch)
1795 (:dependencies (writes tmpreg))
1798 (assemble (segment vop)
1799 (inst jali zero-tn tmpreg value))))
1801 (define-instruction nop (segment)
1802 (:printer format-2-immed ((rd 0) (op2 #b100) (immed 0)) '(:name))
1803 (:attributes flushable)
1805 (:emitter (emit-format-2-immed segment 0 0 #b100 0)))
1807 (!def-vm-support-routine emit-nop (segment)
1808 (emit-format-2-immed segment 0 0 #b100 0))
1810 (define-instruction cmp (segment src1 &optional src2)
1811 (:declare (type tn src1) (type (or null tn (signed-byte 13)) src2))
1812 (:printer format-3-reg ((op #b10) (op3 #b010100) (rd 0))
1813 '(:name :tab rs1 ", " rs2))
1814 (:printer format-3-immed ((op #b10) (op3 #b010100) (rd 0))
1815 '(:name :tab rs1 ", " immed))
1816 (:dependencies (reads src1) (if src2 (reads src2)) (writes :psr))
1821 (emit-format-3-reg segment #b10 0 #b010100 (reg-tn-encoding src1) 0 0 0))
1823 (emit-format-3-reg segment #b10 0 #b010100 (reg-tn-encoding src1) 0 0
1824 (reg-tn-encoding src2)))
1826 (emit-format-3-immed segment #b10 0 #b010100 (reg-tn-encoding src1) 1
1829 (define-instruction not (segment dst &optional src1)
1830 (:declare (type tn dst) (type (or tn null) src1))
1831 (:printer format-3-reg ((op #b10) (op3 #b000111) (rs2 0))
1832 '(:name :tab (:unless (:same-as rd) rs1 ", " ) rd))
1833 (:dependencies (if src1 (reads src1) (reads dst)) (writes dst))
1838 (emit-format-3-reg segment #b10 (reg-tn-encoding dst) #b000111
1839 (reg-tn-encoding src1) 0 0 0)))
1841 (define-instruction neg (segment dst &optional src1)
1842 (:declare (type tn dst) (type (or tn null) src1))
1843 (:printer format-3-reg ((op #b10) (op3 #b000100) (rs1 0))
1844 '(:name :tab (:unless (:same-as rd) rs2 ", " ) rd))
1845 (:dependencies (if src1 (reads src1) (reads dst)) (writes dst))
1850 (emit-format-3-reg segment #b10 (reg-tn-encoding dst) #b000100
1851 0 0 0 (reg-tn-encoding src1))))
1853 (define-instruction move (segment dst src1)
1854 (:declare (type tn dst src1))
1855 (:printer format-3-reg ((op #b10) (op3 #b000010) (rs1 0))
1856 '(:name :tab rs2 ", " rd)
1858 (:attributes flushable)
1859 (:dependencies (reads src1) (writes dst))
1861 (:emitter (emit-format-3-reg segment #b10 (reg-tn-encoding dst) #b000010
1862 0 0 0 (reg-tn-encoding src1))))
1866 ;;;; Instructions for dumping data and header objects.
1868 (define-instruction word (segment word)
1869 (:declare (type (or (unsigned-byte 32) (signed-byte 32)) word))
1873 (emit-word segment word)))
1875 (define-instruction short (segment short)
1876 (:declare (type (or (unsigned-byte 16) (signed-byte 16)) short))
1880 (emit-short segment short)))
1882 (define-instruction byte (segment byte)
1883 (:declare (type (or (unsigned-byte 8) (signed-byte 8)) byte))
1887 (emit-byte segment byte)))
1889 (define-bitfield-emitter emit-header-object 32
1890 (byte 24 8) (byte 8 0))
1892 (defun emit-header-data (segment type)
1895 (lambda (segment posn)
1898 (ash (+ posn (component-header-length))
1899 (- n-widetag-bits word-shift)))))))
1901 (define-instruction simple-fun-header-word (segment)
1905 (emit-header-data segment simple-fun-header-widetag)))
1907 (define-instruction lra-header-word (segment)
1911 (emit-header-data segment return-pc-header-widetag)))
1914 ;;;; Instructions for converting between code objects, functions, and lras.
1916 (defun emit-compute-inst (segment vop dst src label temp calc)
1918 ;; We emit either 12 or 4 bytes, so we maintain 8 byte alignments.
1920 (lambda (segment posn delta-if-after)
1921 (let ((delta (funcall calc label posn delta-if-after)))
1922 (when (<= (- (ash 1 12)) delta (1- (ash 1 12)))
1923 (emit-back-patch segment 4
1924 (lambda (segment posn)
1925 (assemble (segment vop)
1927 (funcall calc label posn 0)))))
1929 (lambda (segment posn)
1930 (let ((delta (funcall calc label posn 0)))
1931 (assemble (segment vop)
1932 (inst sethi temp (ldb (byte 22 10) delta))
1933 (inst or temp (ldb (byte 10 0) delta))
1934 (inst add dst src temp))))))
1936 ;; code = fn - fn-ptr-type - header - label-offset + other-pointer-tag
1937 (define-instruction compute-code-from-fn (segment dst src label temp)
1938 (:declare (type tn dst src temp) (type label label))
1939 (:attributes variable-length)
1940 (:dependencies (reads src) (writes dst) (writes temp))
1944 (emit-compute-inst segment vop dst src label temp
1945 (lambda (label posn delta-if-after)
1946 (- other-pointer-lowtag
1948 (label-position label posn delta-if-after)
1949 (component-header-length))))))
1951 ;; code = lra - other-pointer-tag - header - label-offset + other-pointer-tag
1952 (define-instruction compute-code-from-lra (segment dst src label temp)
1953 (:declare (type tn dst src temp) (type label label))
1954 (:attributes variable-length)
1955 (:dependencies (reads src) (writes dst) (writes temp))
1959 (emit-compute-inst segment vop dst src label temp
1960 (lambda (label posn delta-if-after)
1961 (- (+ (label-position label posn delta-if-after)
1962 (component-header-length)))))))
1964 ;; lra = code + other-pointer-tag + header + label-offset - other-pointer-tag
1965 (define-instruction compute-lra-from-code (segment dst src label temp)
1966 (:declare (type tn dst src temp) (type label label))
1967 (:attributes variable-length)
1968 (:dependencies (reads src) (writes dst) (writes temp))
1972 (emit-compute-inst segment vop dst src label temp
1973 (lambda (label posn delta-if-after)
1974 (+ (label-position label posn delta-if-after)
1975 (component-header-length))))))
1977 ;;; Sparc V9 additions
1981 ;; Conditional move integer on condition code
1982 (define-instruction cmove (segment condition dst src &optional (ccreg :icc))
1983 (:declare (type (or branch-condition fp-branch-condition) condition)
1984 (type cond-move-condition-register ccreg)
1986 (type (or (signed-byte 13) tn) src))
1987 (:printer format-4-cond-move
1992 (cc nil :type 'integer-condition-register))
1995 (:printer format-4-cond-move-immed
2000 (cc nil :type 'integer-condition-register))
2003 (:printer format-4-cond-move
2007 (cond nil :type 'branch-fp-condition)
2009 (cc nil :type 'fp-condition-register))
2012 (:printer format-4-cond-move-immed
2016 (cond nil :type 'branch-fp-condition)
2018 (cc nil :type 'fp-condition-register))
2023 (if (member ccreg '(:icc :xcc))
2032 (multiple-value-bind (cc2 cc01)
2033 (cond-move-condition-parts ccreg)
2036 (emit-format-4-cond-move segment
2038 (reg-tn-encoding dst)
2041 (if (member ccreg '(:icc :xcc))
2042 (branch-condition condition)
2043 (fp-branch-condition condition))
2046 (reg-tn-encoding src)))
2048 (emit-format-4-cond-move segment
2050 (reg-tn-encoding dst)
2053 (if (member ccreg '(:icc :xcc))
2054 (branch-condition condition)
2055 (fp-branch-condition condition))
2060 ;; Conditional move floating-point on condition codes
2061 (macrolet ((define-cond-fp-move (name print-name op op3 opf_low &key extended)
2062 `(define-instruction ,name (segment condition dst src &optional (ccreg :fcc0))
2063 (:declare (type (or branch-condition fp-branch-condition) condition)
2064 (type cond-move-condition-register ccreg)
2066 (:printer format-fpop2
2070 (opf1 nil :type 'fp-condition-register-shifted)
2073 (rs1 nil :type 'branch-fp-condition)
2074 (rs2 nil :type ',(if extended 'fp-ext-reg 'fp-reg))
2075 (rd nil :type ',(if extended 'fp-ext-reg 'fp-reg)))
2076 cond-fp-move-printer
2077 :print-name ',print-name)
2078 (:printer format-fpop2
2082 (opf1 nil :type 'integer-condition-register)
2084 (rs1 nil :type 'branch-condition)
2086 (rs2 nil :type ',(if extended 'fp-ext-reg 'fp-reg))
2087 (rd nil :type ',(if extended 'fp-ext-reg 'fp-reg)))
2088 cond-fp-move-printer
2089 :print-name ',print-name)
2092 (if (member ccreg '(:icc :xcc))
2099 (multiple-value-bind (opf_cc2 opf_cc01)
2100 (cond-move-condition-parts ccreg)
2101 (emit-format-3-fpop2 segment
2103 (fp-reg-tn-encoding dst)
2105 (if (member ccreg '(:icc :xcc))
2106 (branch-condition condition)
2107 (fp-branch-condition condition))
2112 (fp-reg-tn-encoding src)))))))
2113 (define-cond-fp-move cfmovs fmovs #b10 #b110101 #b0001)
2114 (define-cond-fp-move cfmovd fmovd #b10 #b110101 #b0010 :extended t)
2115 (define-cond-fp-move cfmovq fmovq #b10 #b110101 #b0011 :extended t))
2118 ;; Move on integer register condition
2120 ;; movr dst src reg reg-cond
2122 ;; This means if reg satisfies reg-cond, src is copied to dst. If the
2123 ;; condition is not satisfied, nothing is done.
2125 (define-instruction movr (segment dst src2 src1 reg-condition)
2126 (:declare (type cond-move-integer-condition reg-condition)
2128 (type (or (signed-byte 10) tn) src2))
2129 (:printer format-4-cond-move-integer
2133 (:printer format-4-cond-move-integer-immed
2147 (emit-format-4-cond-move-integer
2148 segment #b10 (reg-tn-encoding dst) #b101111 (reg-tn-encoding src1)
2149 0 (register-condition reg-condition)
2150 0 (reg-tn-encoding src2)))
2152 (emit-format-4-cond-move-integer-immed
2153 segment #b10 (reg-tn-encoding dst) #b101111 (reg-tn-encoding src1)
2154 1 (register-condition reg-condition) src2)))))
2157 ;; Same as MOVR, except we move FP registers depending on the value of
2158 ;; an integer register.
2160 ;; fmovr dst src reg cond
2162 ;; This means if REG satifies COND, SRC is COPIED to DST. Nothing
2163 ;; happens if the condition is not satisfied.
2164 (macrolet ((define-cond-fp-move-integer (name opf_low &key extended)
2165 `(define-instruction ,name (segment dst src2 src1 reg-condition)
2166 (:declare (type cond-move-integer-condition reg-condition)
2167 (type tn dst src1 src2))
2168 (:printer format-fpop2
2170 (rd nil :type ',(if extended 'fp-ext-reg 'fp-reg))
2172 (rs1 nil :type 'reg)
2174 (opf1 nil :type 'register-condition)
2177 (rs2 nil :type ',(if extended 'fp-ext-reg 'fp-reg))
2179 cond-fp-move-integer-printer)
2187 (emit-format-3-fpop2
2190 (fp-reg-tn-encoding dst)
2192 (reg-tn-encoding src1)
2194 (register-condition reg-condition)
2197 (fp-reg-tn-encoding src2))))))
2198 (define-cond-fp-move-integer fmovrs #b0101)
2199 (define-cond-fp-move-integer fmovrd #b0110 :extended t)
2200 (define-cond-fp-move-integer fmovrq #b0111 :extended t))