(sb!disassem:dstate-put-inst-prop dstate 'operand-size-8))
value)
+;;; This prefilter is used solely for its side effect, namely to put
+;;; the property OPERAND-SIZE-16 into the DSTATE.
+(defun prefilter-x66 (value dstate)
+ (declare (type (eql #x66) value)
+ (ignore value)
+ (type sb!disassem:disassem-state dstate))
+ (sb!disassem:dstate-put-inst-prop dstate 'operand-size-16))
+
;;; A register field that can be extended by REX.R.
(defun prefilter-reg-r (value dstate)
(declare (type reg value)
(princ (schar (symbol-name (inst-operand-size dstate)) 0)
stream)))
+;;; Used to capture the effect of the #x66 operand size override prefix.
+(sb!disassem:define-arg-type x66
+ :prefilter #'prefilter-x66)
+
(sb!disassem:define-arg-type displacement
:sign-extend t
:use-label #'offset-next
:prefilter #'prefilter-reg-r
:printer #'print-xmmreg)
+(sb!disassem:define-arg-type xmmreg-b
+ :prefilter #'prefilter-reg-b
+ :printer #'print-xmmreg)
+
(sb!disassem:define-arg-type xmmreg/mem
:prefilter #'prefilter-reg/mem
:printer #'print-xmmreg/mem)
vec))
) ; EVAL-WHEN
+;;; SSE shuffle patterns. The names end in the number of bits of the
+;;; immediate byte that are used to encode the pattern and the radix
+;;; in which to print the value.
+(macrolet ((define-sse-shuffle-arg-type (name format-string)
+ `(sb!disassem:define-arg-type ,name
+ :type 'imm-byte
+ :printer (lambda (value stream dstate)
+ (declare (type (unsigned-byte 8) value)
+ (type stream stream)
+ (ignore dstate))
+ (format stream ,format-string value)))))
+ (define-sse-shuffle-arg-type sse-shuffle-pattern-2-2 "#b~2,'0B")
+ (define-sse-shuffle-arg-type sse-shuffle-pattern-8-4 "#4r~4,4,'0R"))
+
;;; Set assembler parameters. (In CMU CL, this was done with
;;; a call to a macro DEF-ASSEMBLER-PARAMS.)
(eval-when (:compile-toplevel :load-toplevel :execute)
(accum :type 'accum)
(imm))
+(sb!disassem:define-instruction-format (two-bytes 16
+ :default-printer '(:name))
+ (op :fields (list (byte 8 0) (byte 8 8))))
+
+(sb!disassem:define-instruction-format (three-bytes 24
+ :default-printer '(:name))
+ (op :fields (list (byte 8 0) (byte 8 8) (byte 8 16))))
+
;;; A one-byte instruction with a #x66 prefix, used to indicate an
;;; operand size of :word.
(sb!disassem:define-instruction-format (x66-byte 16
:default-printer '(:name :tab reg))
(reg :type 'reg-b-default-qword))
-(sb!disassem:define-instruction-format (modrm-reg-no-width 24
- :default-printer '(:name :tab reg))
- (rex :field (byte 4 4) :value #b0100)
- (wrxb :field (byte 4 0) :type 'wrxb)
- (ff :field (byte 8 8) :value #b11111111)
- (mod :field (byte 2 22))
- (modrm-reg :field (byte 3 19))
- (reg :field (byte 3 16) :type 'reg-b)
- ;; optional fields
- (accum :type 'accum)
- (imm))
-
;;; Adds a width field to reg-no-width. Note that we can't use
;;; :INCLUDE 'REG-NO-WIDTH here to save typing because that would put
;;; the WIDTH field last, but the prefilter for WIDTH must run before
(op :field (byte 6 10))
(dir :field (byte 1 9)))
+(sb!disassem:define-instruction-format (x66-reg-reg/mem-dir 24
+ :default-printer
+ `(:name
+ :tab
+ ,(swap-if 'dir 'reg/mem ", " 'reg)))
+ (x66 :field (byte 8 0) :type 'x66 :value #x66)
+ (op :field (byte 6 10))
+ (dir :field (byte 1 9))
+ (width :field (byte 1 8) :type 'width)
+ (reg/mem :fields (list (byte 2 22) (byte 3 16))
+ :type 'reg/mem)
+ (reg :field (byte 3 19) :type 'reg))
+
+(sb!disassem:define-instruction-format (x66-rex-reg-reg/mem-dir 32
+ :default-printer
+ `(:name
+ :tab
+ ,(swap-if 'dir 'reg/mem ", " 'reg)))
+ (x66 :field (byte 8 0) :type 'x66 :value #x66)
+ (rex :field (byte 4 12) :value #b0100)
+ (wrxb :field (byte 4 8) :type 'wrxb)
+ (op :field (byte 6 18))
+ (dir :field (byte 1 17))
+ (width :field (byte 1 16) :type 'width)
+ (reg/mem :fields (list (byte 2 30) (byte 3 24))
+ :type 'reg/mem)
+ (reg :field (byte 3 27) :type 'reg))
+
;;; Same as reg-reg/mem, but uses the reg field as a second op code.
(sb!disassem:define-instruction-format (reg/mem 16
:default-printer '(:name :tab reg/mem))
;; optional fields
(imm))
+(sb!disassem:define-instruction-format (x66-ext-reg-reg/mem 32
+ :default-printer
+ `(:name :tab reg ", " reg/mem))
+ (x66 :field (byte 8 0) :type 'x66 :value #x66)
+ (prefix :field (byte 8 8) :value #b00001111)
+ (op :field (byte 7 17))
+ (width :field (byte 1 16) :type 'width)
+ (reg/mem :fields (list (byte 2 30) (byte 3 24))
+ :type 'reg/mem)
+ (reg :field (byte 3 27) :type 'reg)
+ ;; optional fields
+ (imm))
+
+(sb!disassem:define-instruction-format (rex-ext-reg-reg/mem 32
+ :default-printer
+ `(:name :tab reg ", " reg/mem))
+ (rex :field (byte 4 4) :value #b0100)
+ (wrxb :field (byte 4 0) :type 'wrxb)
+ (prefix :field (byte 8 8) :value #b00001111)
+ (op :field (byte 7 17))
+ (width :field (byte 1 16) :type 'width)
+ (reg/mem :fields (list (byte 2 30) (byte 3 24))
+ :type 'reg/mem)
+ (reg :field (byte 3 27) :type 'reg)
+ ;; optional fields
+ (imm))
+
+(sb!disassem:define-instruction-format (x66-rex-ext-reg-reg/mem 40
+ :default-printer
+ `(:name :tab reg ", " reg/mem))
+ (x66 :field (byte 8 0) :type 'x66 :value #x66)
+ (rex :field (byte 4 12) :value #b0100)
+ (wrxb :field (byte 4 8) :type 'wrxb)
+ (prefix :field (byte 8 16) :value #b00001111)
+ (op :field (byte 7 25))
+ (width :field (byte 1 24) :type 'width)
+ (reg/mem :fields (list (byte 2 38) (byte 3 32))
+ :type 'reg/mem)
+ (reg :field (byte 3 35) :type 'reg)
+ ;; optional fields
+ (imm))
+
+(eval-when (:compile-toplevel :execute)
+ (defun ext-reg-reg/mem-printer-list (op &optional printer)
+ `((ext-reg-reg/mem ((op ,op)) ,@(when printer (list printer)))
+ (x66-ext-reg-reg/mem ((op ,op)) ,@(when printer (list printer)))
+ (rex-ext-reg-reg/mem ((op ,op)) ,@(when printer (list printer)))
+ (x66-rex-ext-reg-reg/mem ((op ,op)) ,@(when printer (list printer))))))
+
(sb!disassem:define-instruction-format (ext-reg-reg/mem-no-width 24
:default-printer
`(:name :tab reg ", " reg/mem))
:type 'reg/mem)
(reg :field (byte 3 27) :type 'reg))
+(sb!disassem:define-instruction-format (ext-reg/mem-no-width 24
+ :default-printer
+ `(:name :tab reg/mem))
+ (prefix :field (byte 8 0) :value #b00001111)
+ (op :fields (list (byte 8 8) (byte 3 19)))
+ (reg/mem :fields (list (byte 2 22) (byte 3 16))
+ :type 'reg/mem))
+
+(sb!disassem:define-instruction-format (rex-ext-reg/mem-no-width 32
+ :default-printer
+ `(:name :tab reg/mem))
+ (rex :field (byte 4 4) :value #b0100)
+ (wrxb :field (byte 4 0) :type 'wrxb)
+ (prefix :field (byte 8 8) :value #b00001111)
+ (op :fields (list (byte 8 16) (byte 3 27)))
+ (reg/mem :fields (list (byte 2 30) (byte 3 24))
+ :type 'reg/mem))
+
;;; reg-no-width with #x0f prefix
(sb!disassem:define-instruction-format (ext-reg-no-width 16
:default-printer '(:name :tab reg))
(op :field (byte 8 8))
(reg/mem :fields (list (byte 2 22) (byte 3 16))
:type 'xmmreg/mem)
- (reg :field (byte 3 19) :type 'xmmreg))
+ (reg :field (byte 3 19) :type 'xmmreg)
+ ;; optional fields
+ (imm))
(sb!disassem:define-instruction-format (rex-xmm-xmm/mem 32
:default-printer
'(:name :tab reg ", " reg/mem))
- (x0f :field (byte 8 0) :value #x0f)
- (rex :field (byte 4 12) :value #b0100)
- (wrxb :field (byte 4 8) :type 'wrxb)
+ (rex :field (byte 4 4) :value #b0100)
+ (wrxb :field (byte 4 0) :type 'wrxb)
+ (x0f :field (byte 8 8) :value #x0f)
(op :field (byte 8 16))
(reg/mem :fields (list (byte 2 30) (byte 3 24))
:type 'xmmreg/mem)
- (reg :field (byte 3 27) :type 'xmmreg))
+ (reg :field (byte 3 27) :type 'xmmreg)
+ (imm))
(sb!disassem:define-instruction-format (ext-xmm-xmm/mem 32
:default-printer
(op :field (byte 8 16))
(reg/mem :fields (list (byte 2 30) (byte 3 24))
:type 'xmmreg/mem)
- (reg :field (byte 3 27) :type 'xmmreg))
+ (reg :field (byte 3 27) :type 'xmmreg)
+ (imm))
(sb!disassem:define-instruction-format (ext-rex-xmm-xmm/mem 40
:default-printer
(op :field (byte 8 24))
(reg/mem :fields (list (byte 2 38) (byte 3 32))
:type 'xmmreg/mem)
- (reg :field (byte 3 35) :type 'xmmreg))
+ (reg :field (byte 3 35) :type 'xmmreg)
+ (imm))
;;; Same as xmm-xmm/mem etc., but with direction bit.
(op :field (byte 7 25))
(dir :field (byte 1 24)))
+;;; Instructions having an XMM register as one operand
+;;; and a constant (unsigned) byte as the other.
+
+(sb!disassem:define-instruction-format (ext-xmm-imm 32
+ :default-printer
+ '(:name :tab reg/mem ", " imm))
+ (prefix :field (byte 8 0))
+ (x0f :field (byte 8 8) :value #x0f)
+ (op :field (byte 8 16))
+ (/i :field (byte 3 27))
+ (b11 :field (byte 2 30) :value #b11)
+ (reg/mem :field (byte 3 24)
+ :type 'xmmreg-b)
+ (imm :type 'imm-byte))
+
+(sb!disassem:define-instruction-format (ext-rex-xmm-imm 40
+ :default-printer
+ '(:name :tab reg/mem ", " imm))
+ (prefix :field (byte 8 0))
+ (rex :field (byte 4 12) :value #b0100)
+ (wrxb :field (byte 4 8) :type 'wrxb)
+ (x0f :field (byte 8 16) :value #x0f)
+ (op :field (byte 8 24))
+ (/i :field (byte 3 35))
+ (b11 :field (byte 2 38) :value #b11)
+ (reg/mem :field (byte 3 32)
+ :type 'xmmreg-b)
+ (imm :type 'imm-byte))
+
;;; Instructions having an XMM register as one operand and a general-
;;; -purpose register or a memory location as the other operand.
+(sb!disassem:define-instruction-format (xmm-reg/mem 24
+ :default-printer
+ '(:name :tab reg ", " reg/mem))
+ (x0f :field (byte 8 0) :value #x0f)
+ (op :field (byte 8 8))
+ (reg/mem :fields (list (byte 2 22) (byte 3 16))
+ :type 'sized-reg/mem)
+ (reg :field (byte 3 19) :type 'xmmreg))
+
+(sb!disassem:define-instruction-format (rex-xmm-reg/mem 32
+ :default-printer
+ '(:name :tab reg ", " reg/mem))
+ (rex :field (byte 4 4) :value #b0100)
+ (wrxb :field (byte 4 0) :type 'wrxb)
+ (x0f :field (byte 8 8) :value #x0f)
+ (op :field (byte 8 16))
+ (reg/mem :fields (list (byte 2 30) (byte 3 24))
+ :type 'sized-reg/mem)
+ (reg :field (byte 3 27) :type 'xmmreg))
+
(sb!disassem:define-instruction-format (ext-xmm-reg/mem 32
:default-printer
'(:name :tab reg ", " reg/mem))
;;; Instructions having a general-purpose register as one operand and an
;;; XMM register or a memory location as the other operand.
+(sb!disassem:define-instruction-format (reg-xmm/mem 24
+ :default-printer
+ '(:name :tab reg ", " reg/mem))
+ (x0f :field (byte 8 0) :value #x0f)
+ (op :field (byte 8 8))
+ (reg/mem :fields (list (byte 2 22) (byte 3 16))
+ :type 'sized-xmmreg/mem)
+ (reg :field (byte 3 19) :type 'reg))
+
+(sb!disassem:define-instruction-format (rex-reg-xmm/mem 32
+ :default-printer
+ '(:name :tab reg ", " reg/mem))
+ (rex :field (byte 4 4) :value #b0100)
+ (wrxb :field (byte 4 0) :type 'wrxb)
+ (x0f :field (byte 8 8) :value #x0f)
+ (op :field (byte 8 16))
+ (reg/mem :fields (list (byte 2 30) (byte 3 24))
+ :type 'sized-xmmreg/mem)
+ (reg :field (byte 3 27) :type 'reg))
+
(sb!disassem:define-instruction-format (ext-reg-xmm/mem 32
:default-printer
'(:name :tab reg ", " reg/mem))
:type 'sized-xmmreg/mem)
(reg :field (byte 3 35) :type 'reg))
+;; XMM comparison instruction
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
+ (defparameter *sse-conditions* #(:eq :lt :le :unord :neq :nlt :nle :ord)))
+
+(sb!disassem:define-arg-type sse-condition-code
+ ;; Inherit the prefilter from IMM-BYTE to READ-SUFFIX the byte.
+ :type 'imm-byte
+ :printer *sse-conditions*)
+
(sb!disassem:define-instruction-format (string-op 8
:include 'simple
:default-printer '(:name width)))
:default-printer '(:name :tab code))
(op :field (byte 8 0))
(code :field (byte 8 8)))
+
+;;; Two byte instruction with an immediate byte argument.
+;;;
+(sb!disassem:define-instruction-format (word-imm 24
+ :default-printer '(:name :tab code))
+ (op :field (byte 16 0))
+ (code :field (byte 8 16)))
+
\f
;;;; primitive emitters
(format stream "+~A" (ea-disp ea))))
(write-char #\] stream))))
-(defun emit-constant-tn-rip (segment constant-tn reg)
+(defun emit-constant-tn-rip (segment constant-tn reg remaining-bytes)
;; AMD64 doesn't currently have a code object register to use as a
;; base register for constant access. Instead we use RIP-relative
;; addressing. The offset from the SIMPLE-FUN-HEADER to the instruction
;; The addressing is relative to end of instruction,
;; i.e. the end of this dword. Hence the + 4.
(emit-signed-dword segment
- (+ 4 (- (+ offset posn)))))))
+ (+ 4 remaining-bytes
+ (- (+ offset posn)))))))
(values))
-(defun emit-label-rip (segment fixup reg)
+(defun emit-label-rip (segment fixup reg remaining-bytes)
(let ((label (fixup-offset fixup)))
;; RIP-relative addressing
(emit-mod-reg-r/m-byte segment #b00 reg #b101)
(emit-back-patch segment
4
(lambda (segment posn)
- (emit-signed-dword segment (- (label-position label)
- (+ posn 4))))))
+ (emit-signed-dword segment
+ (- (label-position label)
+ (+ posn 4 remaining-bytes))))))
(values))
-(defun emit-ea (segment thing reg &optional allow-constants)
+(defun emit-ea (segment thing reg &key allow-constants (remaining-bytes 0))
(etypecase thing
(tn
;; this would be eleganter if we had a function that would create
(emit-mod-reg-r/m-byte segment #b11 reg (reg-tn-encoding thing)))
(stack
;; Convert stack tns into an index off RBP.
- (let ((disp (- (* (1+ (tn-offset thing)) n-word-bytes))))
- (cond ((< -128 disp 127)
+ (let ((disp (frame-byte-offset (tn-offset thing))))
+ (cond ((<= -128 disp 127)
(emit-mod-reg-r/m-byte segment #b01 reg #b101)
(emit-byte segment disp))
(t
;; Why?
(error
"Constant TNs can only be directly used in MOV, PUSH, and CMP."))
- (emit-constant-tn-rip segment thing reg))))
+ (emit-constant-tn-rip segment thing reg remaining-bytes))))
(ea
(let* ((base (ea-base thing))
(index (ea-index thing))
(r/m (cond (index #b100)
((null base) #b101)
(t (reg-tn-encoding base)))))
+ (when (and (fixup-p disp)
+ (label-p (fixup-offset disp)))
+ (aver (null base))
+ (aver (null index))
+ (return-from emit-ea (emit-ea segment disp reg
+ :allow-constants allow-constants
+ :remaining-bytes remaining-bytes)))
(when (and (= mod 0) (= r/m #b101))
;; this is rip-relative in amd64, so we'll use a sib instead
(setf r/m #b100 scale 1))
(fixup
(typecase (fixup-offset thing)
(label
- (emit-label-rip segment thing reg))
+ (emit-label-rip segment thing reg remaining-bytes))
(t
(emit-mod-reg-r/m-byte segment #b00 reg #b100)
(emit-sib-byte segment 0 #b100 #b101)
:float)
(#.*double-sc-names*
:double)
+ (#.*complex-sc-names*
+ :complex)
(t
(error "can't tell the size of ~S ~S" thing (sc-name (tn-sc thing))))))
(ea
;; register to/from register/memory
(:printer reg-reg/mem-dir ((op #b100010)))
(:printer rex-reg-reg/mem-dir ((op #b100010)))
+ (:printer x66-reg-reg/mem-dir ((op #b100010)))
+ (:printer x66-rex-reg-reg/mem-dir ((op #b100010)))
;; immediate to register/memory
(:printer reg/mem-imm ((op '(#b1100011 #b000))))
(:printer rex-reg/mem-imm ((op '(#b1100011 #b000))))
(if (eq size :byte)
#b10001010
#b10001011))
- (emit-ea segment src (reg-tn-encoding dst) t))))
+ (emit-ea segment src (reg-tn-encoding dst) :allow-constants t))))
((integerp src)
;; C7 only deals with 32 bit immediates even if the
;; destination is a 64-bit location. The value is
(cond (ea-p (ea-base src))
((tn-p src) src)
(t nil)))
- (emit-byte segment #x63) ;movsxd
+ (emit-byte segment (if signed-p #x63 #x8b)) ;movsxd or straight mov
;;(emit-byte segment opcode)
(emit-ea segment src (reg-tn-encoding dst)))))))))
(emit-byte-with-reg segment #b01010 (reg-tn-encoding src)))
(t
(emit-byte segment #b11111111)
- (emit-ea segment src #b110 t))))))))
+ (emit-ea segment src #b110 :allow-constants t))))))))
(define-instruction pop (segment dst)
(:printer reg-no-width-default-qword ((op #b01011)))
(emit-byte segment #b10001101)
(emit-ea segment src (reg-tn-encoding dst))))
-(define-instruction cmpxchg (segment dst src)
+(define-instruction cmpxchg (segment dst src &optional prefix)
;; Register/Memory with Register.
- (:printer ext-reg-reg/mem ((op #b1011000)) '(:name :tab reg/mem ", " reg))
+ (:printer-list (ext-reg-reg/mem-printer-list #b1011000
+ '(:name :tab reg/mem ", " reg)))
(:emitter
(aver (register-p src))
+ (emit-prefix segment prefix)
(let ((size (matching-operand-size src dst)))
(maybe-emit-operand-size-prefix segment size)
(maybe-emit-rex-for-ea segment dst src)
(emit-ea segment dst (reg-tn-encoding src)))))
\f
-
-(define-instruction fs-segment-prefix (segment)
- (:emitter
- (emit-byte segment #x64)))
-
;;;; flag control instructions
;;; CLC -- Clear Carry Flag.
(cond ((and (not (eq size :byte)) (<= -128 src 127))
(maybe-emit-rex-for-ea segment dst nil)
(emit-byte segment #b10000011)
- (emit-ea segment dst opcode allow-constants)
+ (emit-ea segment dst opcode :allow-constants allow-constants)
(emit-byte segment src))
((accumulator-p dst)
(maybe-emit-rex-for-ea segment dst nil)
(t
(maybe-emit-rex-for-ea segment dst nil)
(emit-byte segment (if (eq size :byte) #b10000000 #b10000001))
- (emit-ea segment dst opcode allow-constants)
+ (emit-ea segment dst opcode :allow-constants allow-constants)
(emit-sized-immediate segment size src))))
((register-p src)
(maybe-emit-rex-for-ea segment dst src)
(dpb opcode
(byte 3 3)
(if (eq size :byte) #b00000000 #b00000001)))
- (emit-ea segment dst (reg-tn-encoding src) allow-constants))
+ (emit-ea segment dst (reg-tn-encoding src) :allow-constants allow-constants))
((register-p dst)
(maybe-emit-rex-for-ea segment src dst)
(emit-byte segment
(dpb opcode
(byte 3 3)
(if (eq size :byte) #b00000010 #b00000011)))
- (emit-ea segment src (reg-tn-encoding dst) allow-constants))
+ (emit-ea segment src (reg-tn-encoding dst) :allow-constants allow-constants))
(t
(error "bogus operands to ~A" name)))))
(rex-reg-reg/mem-dir ((op ,(dpb subop (byte 3 1) #b000000))))))
)
-(define-instruction add (segment dst src)
+(define-instruction add (segment dst src &optional prefix)
(:printer-list (arith-inst-printer-list #b000))
- (:emitter (emit-random-arith-inst "ADD" segment dst src #b000)))
+ (:emitter
+ (emit-prefix segment prefix)
+ (emit-random-arith-inst "ADD" segment dst src #b000)))
(define-instruction adc (segment dst src)
(:printer-list (arith-inst-printer-list #b010))
(:printer-list (arith-inst-printer-list #b111))
(:emitter (emit-random-arith-inst "CMP" segment dst src #b111 t)))
+;;; The one-byte encodings for INC and DEC are used as REX prefixes
+;;; in 64-bit mode so we always use the two-byte form.
(define-instruction inc (segment dst)
- ;; Register
- (:printer modrm-reg-no-width ((modrm-reg #b000)))
- ;; Register/Memory
- ;; (:printer rex-reg/mem ((op '(#b11111111 #b001))))
(:printer reg/mem ((op '(#b1111111 #b000))))
+ (:printer rex-reg/mem ((op '(#b1111111 #b000))))
(:emitter
(let ((size (operand-size dst)))
(maybe-emit-operand-size-prefix segment size)
- (cond #+nil ; these opcodes become REX prefixes in x86-64
- ((and (not (eq size :byte)) (register-p dst))
- (emit-byte-with-reg segment #b01000 (reg-tn-encoding dst)))
- (t
- (maybe-emit-rex-for-ea segment dst nil)
- (emit-byte segment (if (eq size :byte) #b11111110 #b11111111))
- (emit-ea segment dst #b000))))))
+ (maybe-emit-rex-for-ea segment dst nil)
+ (emit-byte segment (if (eq size :byte) #b11111110 #b11111111))
+ (emit-ea segment dst #b000))))
(define-instruction dec (segment dst)
- ;; Register.
- (:printer modrm-reg-no-width ((modrm-reg #b001)))
- ;; Register/Memory
(:printer reg/mem ((op '(#b1111111 #b001))))
+ (:printer rex-reg/mem ((op '(#b1111111 #b001))))
(:emitter
(let ((size (operand-size dst)))
(maybe-emit-operand-size-prefix segment size)
- (cond #+nil
- ((and (not (eq size :byte)) (register-p dst))
- (emit-byte-with-reg segment #b01001 (reg-tn-encoding dst)))
- (t
- (maybe-emit-rex-for-ea segment dst nil)
- (emit-byte segment (if (eq size :byte) #b11111110 #b11111111))
- (emit-ea segment dst #b001))))))
+ (maybe-emit-rex-for-ea segment dst nil)
+ (emit-byte segment (if (eq size :byte) #b11111110 #b11111111))
+ (emit-ea segment dst #b001))))
(define-instruction neg (segment dst)
(:printer reg/mem ((op '(#b1111011 #b011))))
(maybe-emit-rex-prefix segment :qword nil nil nil)
(emit-byte segment #b10011001)))
-(define-instruction xadd (segment dst src)
+(define-instruction xadd (segment dst src &optional prefix)
;; Register/Memory with Register.
- (:printer ext-reg-reg/mem ((op #b1100000)) '(:name :tab reg/mem ", " reg))
+ (:printer-list (ext-reg-reg/mem-printer-list #b1100000
+ '(:name :tab reg/mem ", " reg)))
(:emitter
(aver (register-p src))
+ (emit-prefix segment prefix)
(let ((size (matching-operand-size src dst)))
(maybe-emit-operand-size-prefix segment size)
(maybe-emit-rex-for-ea segment dst src)
(ext-reg-reg/mem-imm ((op ,(logior op #b100))
(imm nil :type signed-imm-byte)))
(ext-reg-reg/mem ((op ,(logior op #b101)))
- (:name :tab reg/mem ", " 'cl)))))
+ (:name :tab reg/mem ", " reg ", " 'cl)))))
(define-instruction shld (segment dst src amt)
(:declare (type (or (member :cl) (mod 32)) amt))
(define-instruction rep (segment)
(:emitter
- (emit-byte segment #b11110010)))
+ (emit-byte segment #b11110011)))
(define-instruction repe (segment)
(:printer byte ((op #b11110011)))
(- (label-position where)
(+ posn 4))))))
(fixup
- (emit-byte segment #b11101000)
- (emit-relative-fixup segment where))
+ ;; There is no CALL rel64...
+ (error "Cannot CALL a fixup: ~S" where))
(t
(maybe-emit-rex-for-ea segment where nil :operand-size :do-not-set)
(emit-byte segment #b11111111)
(emit-byte segment #b11111111)
(emit-ea segment where #b100)))))
-(define-instruction jmp-short (segment label)
- (:emitter
- (emit-byte segment #b11101011)
- (emit-byte-displacement-backpatch segment label)))
-
(define-instruction ret (segment &optional stack-delta)
(:printer byte ((op #b11000011)))
(:printer byte ((op #b11000010) (imm nil :type 'imm-word-16))
'(:name :tab imm))
(:emitter
- (cond (stack-delta
+ (cond ((and stack-delta (not (zerop stack-delta)))
(emit-byte segment #b11000010)
(emit-word segment stack-delta))
(t
(emit-byte segment #b11000011)))))
-(define-instruction jecxz (segment target)
+(define-instruction jrcxz (segment target)
(:printer short-jump ((op #b0011)))
(:emitter
(emit-byte segment #b11100011)
(defun break-control (chunk inst stream dstate)
(declare (ignore inst))
(flet ((nt (x) (if stream (sb!disassem:note x dstate))))
- ;; FIXME: Make sure that BYTE-IMM-CODE is defined. The genesis
- ;; map has it undefined; and it should be easier to look in the target
- ;; Lisp (with (DESCRIBE 'BYTE-IMM-CODE)) than to definitively deduce
- ;; from first principles whether it's defined in some way that genesis
- ;; can't grok.
- (case (byte-imm-code chunk dstate)
+ ;; XXX: {BYTE,WORD}-IMM-CODE below is a macro defined by the
+ ;; DEFINE-INSTRUCTION-FORMAT for {BYTE,WORD}-IMM above. Due to
+ ;; the spectacular design for DEFINE-INSTRUCTION-FORMAT (involving
+ ;; a call to EVAL in order to define the macros at compile-time
+ ;; only) they do not even show up as symbols in the target core.
+ (case #!-ud2-breakpoints (byte-imm-code chunk dstate)
+ #!+ud2-breakpoints (word-imm-code chunk dstate)
(#.error-trap
(nt "error trap")
(sb!disassem:handle-break-args #'snarf-error-junk stream dstate))
(#.halt-trap
(nt "halt trap"))
(#.fun-end-breakpoint-trap
- (nt "function end breakpoint trap")))))
+ (nt "function end breakpoint trap"))
+ (#.single-step-around-trap
+ (nt "single-step trap (around)"))
+ (#.single-step-before-trap
+ (nt "single-step trap (before)")))))
(define-instruction break (segment code)
(:declare (type (unsigned-byte 8) code))
- (:printer byte-imm ((op #b11001100)) '(:name :tab code)
- :control #'break-control)
- (:emitter
- (emit-byte segment #b11001100)
+ #!-ud2-breakpoints (:printer byte-imm ((op #b11001100)) '(:name :tab code)
+ :control #'break-control)
+ #!+ud2-breakpoints (:printer word-imm ((op #b0000101100001111)) '(:name :tab code)
+ :control #'break-control)
+ (:emitter
+ #!-ud2-breakpoints (emit-byte segment #b11001100)
+ ;; On darwin, trap handling via SIGTRAP is unreliable, therefore we
+ ;; throw a sigill with 0x0b0f instead and check for this in the
+ ;; SIGILL handler and pass it on to the sigtrap handler if
+ ;; appropriate
+ #!+ud2-breakpoints (emit-word segment #b0000101100001111)
(emit-byte segment code)))
(define-instruction int (segment number)
(:emitter
(emit-byte segment #b10011011)))
+(defun emit-prefix (segment name)
+ (declare (ignorable segment))
+ (ecase name
+ ((nil))
+ (:lock
+ #!+sb-thread
+ (emit-byte segment #xf0))))
+
+;;; FIXME: It would be better to make the disassembler understand the prefix as part
+;;; of the instructions...
(define-instruction lock (segment)
(:printer byte ((op #b11110000)))
(:emitter
- (emit-byte segment #b11110000)))
+ (bug "LOCK prefix used as a standalone instruction")))
\f
;;;; miscellaneous hackery
\f
;;;; Instructions required to do floating point operations using SSE
-(defun emit-sse-inst (segment dst src prefix opcode &key operand-size)
+;; Return a two-element list of printers for SSE instructions. One
+;; printer is for the format without a REX prefix, the other one for the
+;; one with.
+(eval-when (:compile-toplevel :execute)
+ (defun sse-inst-printer-list (inst-format-stem prefix opcode
+ &key more-fields printer)
+ (let ((fields `(,@(when prefix
+ `((prefix ,prefix)))
+ (op ,opcode)
+ ,@more-fields))
+ (inst-formats (if prefix
+ (list (symbolicate "EXT-" inst-format-stem)
+ (symbolicate "EXT-REX-" inst-format-stem))
+ (list inst-format-stem
+ (symbolicate "REX-" inst-format-stem)))))
+ (mapcar (lambda (inst-format)
+ `(,inst-format ,fields ,@(when printer
+ (list printer))))
+ inst-formats))))
+
+(defun emit-sse-inst (segment dst src prefix opcode
+ &key operand-size (remaining-bytes 0))
(when prefix
(emit-byte segment prefix))
(if operand-size
(maybe-emit-rex-for-ea segment src dst))
(emit-byte segment #x0f)
(emit-byte segment opcode)
- (emit-ea segment src (reg-tn-encoding dst)))
+ (emit-ea segment src (reg-tn-encoding dst) :remaining-bytes remaining-bytes))
+
+;; 0110 0110:0000 1111:0111 00gg: 11 010 xmmreg:imm8
+
+(defun emit-sse-inst-with-imm (segment dst/src imm
+ prefix opcode /i
+ &key operand-size)
+ (aver (<= 0 /i 7))
+ (when prefix
+ (emit-byte segment prefix))
+ (maybe-emit-rex-prefix segment operand-size dst/src nil nil)
+ (emit-byte segment #x0F)
+ (emit-byte segment opcode)
+ (emit-byte segment (logior (ash (logior #b11000 /i) 3)
+ (reg-tn-encoding dst/src)))
+ (emit-byte segment imm))
+
+(macrolet
+ ((define-imm-sse-instruction (name opcode /i)
+ `(define-instruction ,name (segment dst/src imm)
+ (:printer-list
+ ',(sse-inst-printer-list 'xmm-imm #x66 opcode
+ :more-fields `((/i ,/i))))
+ (:emitter
+ (emit-sse-inst-with-imm segment dst/src imm
+ #x66 ,opcode ,/i
+ :operand-size :do-not-set)))))
+ (define-imm-sse-instruction pslldq #x73 7)
+ (define-imm-sse-instruction psllw-imm #x71 6)
+ (define-imm-sse-instruction pslld-imm #x72 6)
+ (define-imm-sse-instruction psllq-imm #x73 6)
+
+ (define-imm-sse-instruction psraw-imm #x71 4)
+ (define-imm-sse-instruction psrad-imm #x72 4)
+
+ (define-imm-sse-instruction psrldq #x73 3)
+ (define-imm-sse-instruction psrlw-imm #x71 2)
+ (define-imm-sse-instruction psrld-imm #x72 2)
+ (define-imm-sse-instruction psrlq-imm #x73 2))
;;; Emit an SSE instruction that has an XMM register as the destination
;;; operand and for which the size of the operands is implicitly given
;;; by the instruction.
-(defun emit-regular-sse-inst (segment dst src prefix opcode)
+(defun emit-regular-sse-inst (segment dst src prefix opcode
+ &key (remaining-bytes 0))
(aver (xmm-register-p dst))
(emit-sse-inst segment dst src prefix opcode
- :operand-size :do-not-set))
+ :operand-size :do-not-set
+ :remaining-bytes remaining-bytes))
;;; Instructions having an XMM register as the destination operand
;;; and an XMM register or a memory location as the source operand.
(macrolet ((define-regular-sse-inst (name prefix opcode)
`(define-instruction ,name (segment dst src)
- ,@(if prefix
- `((:printer ext-xmm-xmm/mem
- ((prefix ,prefix) (op ,opcode)))
- (:printer ext-rex-xmm-xmm/mem
- ((prefix ,prefix) (op ,opcode))))
- `((:printer xmm-xmm/mem ((op ,opcode)))
- (:printer rex-xmm-xmm/mem ((op ,opcode)))))
+ (:printer-list
+ ',(sse-inst-printer-list 'xmm-xmm/mem prefix opcode))
(:emitter
(emit-regular-sse-inst segment dst src ,prefix ,opcode)))))
;; logical
(define-regular-sse-inst andpd #x66 #x54)
(define-regular-sse-inst andps nil #x54)
+ (define-regular-sse-inst andnpd #x66 #x55)
+ (define-regular-sse-inst andnps nil #x55)
+ (define-regular-sse-inst orpd #x66 #x56)
+ (define-regular-sse-inst orps nil #x56)
+ (define-regular-sse-inst pand #x66 #xdb)
+ (define-regular-sse-inst pandn #x66 #xdf)
+ (define-regular-sse-inst por #x66 #xeb)
+ (define-regular-sse-inst pxor #x66 #xef)
(define-regular-sse-inst xorpd #x66 #x57)
(define-regular-sse-inst xorps nil #x57)
;; comparison
(define-regular-sse-inst comisd #x66 #x2f)
(define-regular-sse-inst comiss nil #x2f)
+ (define-regular-sse-inst ucomisd #x66 #x2e)
+ (define-regular-sse-inst ucomiss nil #x2e)
+ ;; integer comparison
+ (define-regular-sse-inst pcmpeqb #x66 #x74)
+ (define-regular-sse-inst pcmpeqw #x66 #x75)
+ (define-regular-sse-inst pcmpeqd #x66 #x76)
+ (define-regular-sse-inst pcmpgtb #x66 #x64)
+ (define-regular-sse-inst pcmpgtw #x66 #x65)
+ (define-regular-sse-inst pcmpgtd #x66 #x66)
+ ;; max/min
+ (define-regular-sse-inst maxpd #x66 #x5f)
+ (define-regular-sse-inst maxps nil #x5f)
+ (define-regular-sse-inst maxsd #xf2 #x5f)
+ (define-regular-sse-inst maxss #xf3 #x5f)
+ (define-regular-sse-inst minpd #x66 #x5d)
+ (define-regular-sse-inst minps nil #x5d)
+ (define-regular-sse-inst minsd #xf2 #x5d)
+ (define-regular-sse-inst minss #xf3 #x5d)
+ ;; integer max/min
+ (define-regular-sse-inst pmaxsw #x66 #xee)
+ (define-regular-sse-inst pmaxub #x66 #xde)
+ (define-regular-sse-inst pminsw #x66 #xea)
+ (define-regular-sse-inst pminub #x66 #xda)
;; arithmetic
+ (define-regular-sse-inst addpd #x66 #x58)
+ (define-regular-sse-inst addps nil #x58)
(define-regular-sse-inst addsd #xf2 #x58)
(define-regular-sse-inst addss #xf3 #x58)
+ (define-regular-sse-inst divpd #x66 #x5e)
+ (define-regular-sse-inst divps nil #x5e)
(define-regular-sse-inst divsd #xf2 #x5e)
(define-regular-sse-inst divss #xf3 #x5e)
+ (define-regular-sse-inst mulpd #x66 #x59)
+ (define-regular-sse-inst mulps nil #x59)
(define-regular-sse-inst mulsd #xf2 #x59)
(define-regular-sse-inst mulss #xf3 #x59)
- (define-regular-sse-inst subsd #xf2 #x5c)
- (define-regular-sse-inst subss #xf3 #x5c)
+ (define-regular-sse-inst rcpps nil #x53)
+ (define-regular-sse-inst rcpss #xf3 #x53)
+ (define-regular-sse-inst rsqrtps nil #x52)
+ (define-regular-sse-inst rsqrtss #xf3 #x52)
+ (define-regular-sse-inst sqrtpd #x66 #x51)
+ (define-regular-sse-inst sqrtps nil #x51)
(define-regular-sse-inst sqrtsd #xf2 #x51)
(define-regular-sse-inst sqrtss #xf3 #x51)
+ (define-regular-sse-inst subpd #x66 #x5c)
+ (define-regular-sse-inst subps nil #x5c)
+ (define-regular-sse-inst subsd #xf2 #x5c)
+ (define-regular-sse-inst subss #xf3 #x5c)
+ (define-regular-sse-inst unpckhpd #x66 #x15)
+ (define-regular-sse-inst unpckhps nil #x15)
+ (define-regular-sse-inst unpcklpd #x66 #x14)
+ (define-regular-sse-inst unpcklps nil #x14)
+ ;; integer arithmetic
+ (define-regular-sse-inst paddb #x66 #xfc)
+ (define-regular-sse-inst paddw #x66 #xfd)
+ (define-regular-sse-inst paddd #x66 #xfe)
+ (define-regular-sse-inst paddq #x66 #xd4)
+ (define-regular-sse-inst paddsb #x66 #xec)
+ (define-regular-sse-inst paddsw #x66 #xed)
+ (define-regular-sse-inst paddusb #x66 #xdc)
+ (define-regular-sse-inst paddusw #x66 #xdd)
+ (define-regular-sse-inst pavgb #x66 #xe0)
+ (define-regular-sse-inst pavgw #x66 #xe3)
+ (define-regular-sse-inst pmaddwd #x66 #xf5)
+ (define-regular-sse-inst pmulhuw #x66 #xe4)
+ (define-regular-sse-inst pmulhw #x66 #xe5)
+ (define-regular-sse-inst pmullw #x66 #xd5)
+ (define-regular-sse-inst pmuludq #x66 #xf4)
+ (define-regular-sse-inst psadbw #x66 #xf6)
+ (define-regular-sse-inst psllw #x66 #xf1)
+ (define-regular-sse-inst pslld #x66 #xf2)
+ (define-regular-sse-inst psllq #x66 #xf3)
+ (define-regular-sse-inst psraw #x66 #xe1)
+ (define-regular-sse-inst psrad #x66 #xe2)
+ (define-regular-sse-inst psrlw #x66 #xd1)
+ (define-regular-sse-inst psrld #x66 #xd2)
+ (define-regular-sse-inst psrlq #x66 #xd3)
+ (define-regular-sse-inst psubb #x66 #xf8)
+ (define-regular-sse-inst psubw #x66 #xf9)
+ (define-regular-sse-inst psubd #x66 #xfa)
+ (define-regular-sse-inst psubq #x66 #xfb)
+ (define-regular-sse-inst psubsb #x66 #xe8)
+ (define-regular-sse-inst psubsw #x66 #xe9)
+ (define-regular-sse-inst psubusb #x66 #xd8)
+ (define-regular-sse-inst psubusw #x66 #xd9)
;; conversion
+ (define-regular-sse-inst cvtdq2pd #xf3 #xe6)
+ (define-regular-sse-inst cvtdq2ps nil #x5b)
+ (define-regular-sse-inst cvtpd2dq #xf2 #xe6)
+ (define-regular-sse-inst cvtpd2ps #x66 #x5a)
+ (define-regular-sse-inst cvtps2dq #x66 #x5b)
+ (define-regular-sse-inst cvtps2pd nil #x5a)
(define-regular-sse-inst cvtsd2ss #xf2 #x5a)
(define-regular-sse-inst cvtss2sd #xf3 #x5a)
- (define-regular-sse-inst cvtdq2pd #xf3 #xe6)
- (define-regular-sse-inst cvtdq2ps nil #x5b))
+ (define-regular-sse-inst cvttpd2dq #x66 #xe6)
+ (define-regular-sse-inst cvttps2dq #xf3 #x5b)
+ ;; integer
+ (define-regular-sse-inst packsswb #x66 #x63)
+ (define-regular-sse-inst packssdw #x66 #x6b)
+ (define-regular-sse-inst packuswb #x66 #x67)
+ (define-regular-sse-inst punpckhbw #x66 #x68)
+ (define-regular-sse-inst punpckhwd #x66 #x69)
+ (define-regular-sse-inst punpckhdq #x66 #x6a)
+ (define-regular-sse-inst punpckhqdq #x66 #x6d)
+ (define-regular-sse-inst punpcklbw #x66 #x60)
+ (define-regular-sse-inst punpcklwd #x66 #x61)
+ (define-regular-sse-inst punpckldq #x66 #x62)
+ (define-regular-sse-inst punpcklqdq #x66 #x6c))
+
+(macrolet ((define-xmm-shuffle-sse-inst (name prefix opcode n-bits radix)
+ (let ((shuffle-pattern
+ (intern (format nil "SSE-SHUFFLE-PATTERN-~D-~D"
+ n-bits radix))))
+ `(define-instruction ,name (segment dst src pattern)
+ (:printer-list
+ ',(sse-inst-printer-list
+ 'xmm-xmm/mem prefix opcode
+ :more-fields `((imm nil :type ,shuffle-pattern))
+ :printer '(:name :tab reg ", " reg/mem ", " imm)))
+
+ (:emitter
+ (aver (typep pattern '(unsigned-byte ,n-bits)))
+ (emit-regular-sse-inst segment dst src ,prefix ,opcode
+ :remaining-bytes 1)
+ (emit-byte segment pattern))))))
+ (define-xmm-shuffle-sse-inst pshufd #x66 #x70 8 4)
+ (define-xmm-shuffle-sse-inst pshufhw #xf3 #x70 8 4)
+ (define-xmm-shuffle-sse-inst pshuflw #xf2 #x70 8 4)
+ (define-xmm-shuffle-sse-inst shufpd #x66 #xc6 2 2)
+ (define-xmm-shuffle-sse-inst shufps nil #xc6 8 4))
+
+;; MASKMOVDQU (dst is DS:RDI)
+(define-instruction maskmovdqu (segment src mask)
+ (:printer-list
+ (sse-inst-printer-list 'xmm-xmm/mem #x66 #xf7))
+ (:emitter
+ (aver (xmm-register-p src))
+ (aver (xmm-register-p mask))
+ (emit-regular-sse-inst segment src mask #x66 #xf7)))
+
+(macrolet ((define-comparison-sse-inst (name prefix opcode
+ name-prefix name-suffix)
+ `(define-instruction ,name (segment op x y)
+ (:printer-list
+ ',(sse-inst-printer-list
+ 'xmm-xmm/mem prefix opcode
+ :more-fields '((imm nil :type sse-condition-code))
+ :printer `(,name-prefix imm ,name-suffix
+ :tab reg ", " reg/mem)))
+ (:emitter
+ (let ((code (position op *sse-conditions*)))
+ (aver code)
+ (emit-regular-sse-inst segment x y ,prefix ,opcode
+ :remaining-bytes 1)
+ (emit-byte segment code))))))
+ (define-comparison-sse-inst cmppd #x66 #xc2 "CMP" "PD")
+ (define-comparison-sse-inst cmpps nil #xc2 "CMP" "PS")
+ (define-comparison-sse-inst cmpsd #xf2 #xc2 "CMP" "SD")
+ (define-comparison-sse-inst cmpss #xf3 #xc2 "CMP" "SS"))
;;; MOVSD, MOVSS
(macrolet ((define-movsd/ss-sse-inst (name prefix)
`(define-instruction ,name (segment dst src)
- (:printer ext-xmm-xmm/mem-dir ((prefix ,prefix)
- (op #b0001000)))
- (:printer ext-rex-xmm-xmm/mem-dir ((prefix ,prefix)
- (op #b0001000)))
+ (:printer-list
+ ',(sse-inst-printer-list 'xmm-xmm/mem-dir
+ prefix #b0001000))
(:emitter
(cond ((xmm-register-p dst)
(emit-sse-inst segment dst src ,prefix #x10
(define-movsd/ss-sse-inst movsd #xf2)
(define-movsd/ss-sse-inst movss #xf3))
+;;; Packed MOVs
+(macrolet ((define-mov-sse-inst (name prefix opcode-from opcode-to
+ &key force-to-mem reg-reg-name)
+ `(progn
+ ,(when reg-reg-name
+ `(define-instruction ,reg-reg-name (segment dst src)
+ (:emitter
+ (aver (xmm-register-p dst))
+ (aver (xmm-register-p src))
+ (emit-regular-sse-inst segment dst src
+ ,prefix ,opcode-from))))
+ (define-instruction ,name (segment dst src)
+ (:printer-list
+ '(,@(when opcode-from
+ (sse-inst-printer-list
+ 'xmm-xmm/mem prefix opcode-from))
+ ,@(sse-inst-printer-list
+ 'xmm-xmm/mem prefix opcode-to
+ :printer '(:name :tab reg/mem ", " reg))))
+ (:emitter
+ (cond ,@(when opcode-from
+ `(((xmm-register-p dst)
+ ,(when force-to-mem
+ `(aver (not (or (register-p src)
+ (xmm-register-p src)))))
+ (emit-regular-sse-inst
+ segment dst src ,prefix ,opcode-from))))
+ (t
+ (aver (xmm-register-p src))
+ ,(when force-to-mem
+ `(aver (not (or (register-p dst)
+ (xmm-register-p dst)))))
+ (emit-regular-sse-inst segment src dst
+ ,prefix ,opcode-to))))))))
+ ;; direction bit?
+ (define-mov-sse-inst movapd #x66 #x28 #x29)
+ (define-mov-sse-inst movaps nil #x28 #x29)
+ (define-mov-sse-inst movdqa #x66 #x6f #x7f)
+ (define-mov-sse-inst movdqu #xf3 #x6f #x7f)
+
+ ;; streaming
+ (define-mov-sse-inst movntdq #x66 nil #xe7 :force-to-mem t)
+ (define-mov-sse-inst movntpd #x66 nil #x2b :force-to-mem t)
+ (define-mov-sse-inst movntps nil nil #x2b :force-to-mem t)
+
+ ;; use movhps for movlhps and movlps for movhlps
+ (define-mov-sse-inst movhpd #x66 #x16 #x17 :force-to-mem t)
+ (define-mov-sse-inst movhps nil #x16 #x17 :reg-reg-name movlhps)
+ (define-mov-sse-inst movlpd #x66 #x12 #x13 :force-to-mem t)
+ (define-mov-sse-inst movlps nil #x12 #x13 :reg-reg-name movhlps)
+ (define-mov-sse-inst movupd #x66 #x10 #x11)
+ (define-mov-sse-inst movups nil #x10 #x11))
+
;;; MOVQ
(define-instruction movq (segment dst src)
- (:printer ext-xmm-xmm/mem ((prefix #xf3) (op #x7e)))
- (:printer ext-rex-xmm-xmm/mem ((prefix #xf3) (op #x7e)))
- (:printer ext-xmm-xmm/mem ((prefix #x66) (op #xd6))
- '(:name :tab reg/mem ", " reg))
- (:printer ext-rex-xmm-xmm/mem ((prefix #x66) (op #xd6))
- '(:name :tab reg/mem ", " reg))
+ (:printer-list
+ (append
+ (sse-inst-printer-list 'xmm-xmm/mem #xf3 #x7e)
+ (sse-inst-printer-list 'xmm-xmm/mem #x66 #xd6
+ :printer '(:name :tab reg/mem ", " reg))))
(:emitter
(cond ((xmm-register-p dst)
(emit-sse-inst segment dst src #xf3 #x7e
;;; with zero extension or vice versa.
;;; We do not support the MMX version of this instruction.
(define-instruction movd (segment dst src)
- (:printer ext-xmm-reg/mem ((prefix #x66) (op #x6e)))
- (:printer ext-rex-xmm-reg/mem ((prefix #x66) (op #x6e)))
- (:printer ext-xmm-reg/mem ((prefix #x66) (op #x7e))
- '(:name :tab reg/mem ", " reg))
- (:printer ext-rex-xmm-reg/mem ((prefix #x66) (op #x7e))
- '(:name :tab reg/mem ", " reg))
+ (:printer-list
+ (append
+ (sse-inst-printer-list 'xmm-reg/mem #x66 #x6e)
+ (sse-inst-printer-list 'xmm-reg/mem #x66 #x7e
+ :printer '(:name :tab reg/mem ", " reg))))
(:emitter
(cond ((xmm-register-p dst)
(emit-sse-inst segment dst src #x66 #x6e))
(aver (xmm-register-p src))
(emit-sse-inst segment src dst #x66 #x7e)))))
-(macrolet ((define-integer-source-sse-inst (name prefix opcode)
+(define-instruction pinsrw (segment dst src imm)
+ (:printer-list
+ (sse-inst-printer-list
+ 'xmm-reg/mem #x66 #xc4
+ :more-fields '((imm nil :type imm-byte))
+ :printer '(:name :tab reg ", " reg/mem ", " imm)))
+ (:emitter
+ (aver (xmm-register-p dst))
+ (let ((src-size (operand-size src)))
+ (aver (or (not (register-p src))
+ (eq src-size :qword) (eq src-size :dword)))
+ (emit-sse-inst segment dst src #x66 #xc4
+ :operand-size (if (register-p src) src-size :do-not-set)
+ :remaining-bytes 1))
+ (emit-byte segment imm)))
+
+(define-instruction pextrw (segment dst src imm)
+ (:printer-list
+ (sse-inst-printer-list
+ 'reg-xmm/mem #x66 #xc5
+ :more-fields '((imm nil :type imm-byte))
+ :printer '(:name :tab reg ", " reg/mem ", " imm)))
+ (:emitter
+ (aver (xmm-register-p src))
+ (aver (register-p dst))
+ (let ((dst-size (operand-size dst)))
+ (aver (or (eq dst-size :qword) (eq dst-size :dword)))
+ (emit-sse-inst segment dst src #x66 #xc5
+ :operand-size dst-size
+ :remaining-bytes 1))
+ (emit-byte segment imm)))
+
+(macrolet ((define-integer-source-sse-inst (name prefix opcode &key mem-only)
`(define-instruction ,name (segment dst src)
- (:printer ext-xmm-reg/mem ((prefix ,prefix) (op ,opcode)))
- (:printer ext-rex-xmm-reg/mem ((prefix ,prefix) (op ,opcode)))
+ (:printer-list
+ ',(sse-inst-printer-list 'xmm-reg/mem prefix opcode))
(:emitter
(aver (xmm-register-p dst))
+ ,(when mem-only
+ `(aver (not (or (register-p src)
+ (xmm-register-p src)))))
(let ((src-size (operand-size src)))
(aver (or (eq src-size :qword) (eq src-size :dword))))
(emit-sse-inst segment dst src ,prefix ,opcode)))))
(define-integer-source-sse-inst cvtsi2sd #xf2 #x2a)
- (define-integer-source-sse-inst cvtsi2ss #xf3 #x2a))
+ (define-integer-source-sse-inst cvtsi2ss #xf3 #x2a)
+ ;; FIXME: memory operand is always a QWORD
+ (define-integer-source-sse-inst cvtpi2pd #x66 #x2a :mem-only t)
+ (define-integer-source-sse-inst cvtpi2ps nil #x2a :mem-only t))
;;; Instructions having a general-purpose register as the destination
;;; operand and an XMM register or a memory location as the source
;;; operand. The operand size is calculated from the destination
;;; operand.
-(macrolet ((define-gpr-destination-sse-inst (name prefix opcode)
+(macrolet ((define-gpr-destination-sse-inst (name prefix opcode &key reg-only)
`(define-instruction ,name (segment dst src)
- (:printer ext-reg-xmm/mem ((prefix ,prefix) (op ,opcode)))
- (:printer ext-rex-reg-xmm/mem ((prefix ,prefix) (op ,opcode)))
+ (:printer-list
+ ',(sse-inst-printer-list 'reg-xmm/mem prefix opcode))
(:emitter
(aver (register-p dst))
+ ,(when reg-only
+ `(aver (xmm-register-p src)))
(let ((dst-size (operand-size dst)))
(aver (or (eq dst-size :qword) (eq dst-size :dword)))
(emit-sse-inst segment dst src ,prefix ,opcode
(define-gpr-destination-sse-inst cvtsd2si #xf2 #x2d)
(define-gpr-destination-sse-inst cvtss2si #xf3 #x2d)
(define-gpr-destination-sse-inst cvttsd2si #xf2 #x2c)
- (define-gpr-destination-sse-inst cvttss2si #xf3 #x2c))
+ (define-gpr-destination-sse-inst cvttss2si #xf3 #x2c)
+ (define-gpr-destination-sse-inst movmskpd #x66 #x50 :reg-only t)
+ (define-gpr-destination-sse-inst movmskps nil #x50 :reg-only t)
+ (define-gpr-destination-sse-inst pmovmskb #x66 #xd7 :reg-only t))
;;; Other SSE instructions
+;; FIXME: is that right!?
+(define-instruction movnti (segment dst src)
+ (:printer ext-reg-reg/mem-no-width ((op #xc3)))
+ (:printer rex-ext-reg-reg/mem-no-width ((op #xc3)))
+ (:emitter
+ (aver (not (or (register-p dst)
+ (xmm-register-p dst))))
+ (aver (register-p src))
+ (maybe-emit-rex-for-ea segment src dst)
+ (emit-byte segment #x0f)
+ (emit-byte segment #xc3)
+ (emit-ea segment dst (reg-tn-encoding src))))
+
+(define-instruction prefetch (segment type src)
+ (:printer ext-reg/mem-no-width ((op '(#x18 0)))
+ '("PREFETCHNTA" :tab reg/mem))
+ (:printer ext-reg/mem-no-width ((op '(#x18 1)))
+ '("PREFETCHT0" :tab reg/mem))
+ (:printer ext-reg/mem-no-width ((op '(#x18 2)))
+ '("PREFETCHT1" :tab reg/mem))
+ (:printer ext-reg/mem-no-width ((op '(#x18 3)))
+ '("PREFETCHT2" :tab reg/mem))
+ (:printer rex-ext-reg/mem-no-width ((op '(#x18 0)))
+ '("PREFETCHNTA" :tab reg/mem))
+ (:printer rex-ext-reg/mem-no-width ((op '(#x18 1)))
+ '("PREFETCHT0" :tab reg/mem))
+ (:printer rex-ext-reg/mem-no-width ((op '(#x18 2)))
+ '("PREFETCHT1" :tab reg/mem))
+ (:printer rex-ext-reg/mem-no-width ((op '(#x18 3)))
+ '("PREFETCHT2" :tab reg/mem))
+ (:emitter
+ (aver (not (or (register-p src)
+ (xmm-register-p src))))
+ (aver (eq (operand-size src) :byte))
+ (let ((type (position type #(:nta :t0 :t1 :t2))))
+ (aver type)
+ (maybe-emit-rex-for-ea segment src nil)
+ (emit-byte segment #x0f)
+ (emit-byte segment #x18)
+ (emit-ea segment src type))))
+
+(define-instruction clflush (segment src)
+ (:printer ext-reg/mem-no-width ((op '(#xae 7))))
+ (:printer rex-ext-reg/mem-no-width ((op '(#xae 7))))
+ (:emitter
+ (aver (not (or (register-p src)
+ (xmm-register-p src))))
+ (aver (eq (operand-size src) :byte))
+ (maybe-emit-rex-for-ea segment src nil)
+ (emit-byte segment #x0f)
+ (emit-byte segment #xae)
+ (emit-ea segment src 7)))
+
+(macrolet ((define-fence-instruction (name last-byte)
+ `(define-instruction ,name (segment)
+ (:printer three-bytes ((op '(#x0f #xae ,last-byte))))
+ (:emitter
+ (emit-byte segment #x0f)
+ (emit-byte segment #xae)
+ (emit-byte segment ,last-byte)))))
+ (define-fence-instruction lfence #b11101000)
+ (define-fence-instruction mfence #b11110000)
+ (define-fence-instruction sfence #b11111000))
+
+(define-instruction pause (segment)
+ (:printer two-bytes ((op '(#xf3 #x90))))
+ (:emitter
+ (emit-byte segment #xf3)
+ (emit-byte segment #x90)))
+
(define-instruction ldmxcsr (segment src)
+ (:printer ext-reg/mem-no-width ((op '(#xae 2))))
+ (:printer rex-ext-reg/mem-no-width ((op '(#xae 2))))
(:emitter
+ (aver (not (or (register-p src)
+ (xmm-register-p src))))
+ (aver (eq (operand-size src) :dword))
+ (maybe-emit-rex-for-ea segment src nil)
(emit-byte segment #x0f)
(emit-byte segment #xae)
(emit-ea segment src 2)))
(define-instruction stmxcsr (segment dst)
+ (:printer ext-reg/mem-no-width ((op '(#xae 3))))
+ (:printer rex-ext-reg/mem-no-width ((op '(#xae 3))))
(:emitter
+ (aver (not (or (register-p dst)
+ (xmm-register-p dst))))
+ (aver (eq (operand-size dst) :dword))
+ (maybe-emit-rex-for-ea segment dst nil)
(emit-byte segment #x0f)
(emit-byte segment #xae)
(emit-ea segment dst 3)))
+
+;;;; Miscellany
+
+(define-instruction cpuid (segment)
+ (:printer two-bytes ((op '(#b00001111 #b10100010))))
+ (:emitter
+ (emit-byte segment #b00001111)
+ (emit-byte segment #b10100010)))
+
+(define-instruction rdtsc (segment)
+ (:printer two-bytes ((op '(#b00001111 #b00110001))))
+ (:emitter
+ (emit-byte segment #b00001111)
+ (emit-byte segment #b00110001)))
+
+;;;; Late VM definitions
+
+(defun canonicalize-inline-constant (constant &aux (alignedp nil))
+ (let ((first (car constant)))
+ (when (eql first :aligned)
+ (setf alignedp t)
+ (pop constant)
+ (setf first (car constant)))
+ (typecase first
+ (single-float (setf constant (list :single-float first)))
+ (double-float (setf constant (list :double-float first)))
+ ((complex single-float)
+ (setf constant (list :complex-single-float first)))
+ ((complex double-float)
+ (setf constant (list :complex-double-float first)))))
+ (destructuring-bind (type value) constant
+ (ecase type
+ ((:byte :word :dword :qword)
+ (aver (integerp value))
+ (cons type value))
+ ((:base-char)
+ (aver (base-char-p value))
+ (cons :byte (char-code value)))
+ ((:character)
+ (aver (characterp value))
+ (cons :dword (char-code value)))
+ ((:single-float)
+ (aver (typep value 'single-float))
+ (cons (if alignedp :oword :dword)
+ (ldb (byte 32 0) (single-float-bits value))))
+ ((:double-float)
+ (aver (typep value 'double-float))
+ (cons (if alignedp :oword :qword)
+ (ldb (byte 64 0) (logior (ash (double-float-high-bits value) 32)
+ (double-float-low-bits value)))))
+ ((:complex-single-float)
+ (aver (typep value '(complex single-float)))
+ (cons (if alignedp :oword :qword)
+ (ldb (byte 64 0)
+ (logior (ash (single-float-bits (imagpart value)) 32)
+ (ldb (byte 32 0)
+ (single-float-bits (realpart value)))))))
+ ((:oword :sse)
+ (aver (integerp value))
+ (cons :oword value))
+ ((:complex-double-float)
+ (aver (typep value '(complex double-float)))
+ (cons :oword
+ (logior (ash (double-float-high-bits (imagpart value)) 96)
+ (ash (double-float-low-bits (imagpart value)) 64)
+ (ash (ldb (byte 32 0)
+ (double-float-high-bits (realpart value)))
+ 32)
+ (double-float-low-bits (realpart value))))))))
+
+(defun inline-constant-value (constant)
+ (let ((label (gen-label))
+ (size (ecase (car constant)
+ ((:byte :word :dword :qword) (car constant))
+ ((:oword) :qword))))
+ (values label (make-ea size
+ :disp (make-fixup nil :code-object label)))))
+
+(defun emit-constant-segment-header (constants optimize)
+ (declare (ignore constants))
+ (loop repeat (if optimize 64 16) do (inst byte #x90)))
+
+(defun size-nbyte (size)
+ (ecase size
+ (:byte 1)
+ (:word 2)
+ (:dword 4)
+ (:qword 8)
+ (:oword 16)))
+
+(defun sort-inline-constants (constants)
+ (stable-sort constants #'> :key (lambda (constant)
+ (size-nbyte (caar constant)))))
+
+(defun emit-inline-constant (constant label)
+ (let ((size (size-nbyte (car constant))))
+ (emit-alignment (integer-length (1- size)))
+ (emit-label label)
+ (let ((val (cdr constant)))
+ (loop repeat size
+ do (inst byte (ldb (byte 8 0) val))
+ (setf val (ash val -8))))))