+;; 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 :operand-size 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) :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 ext-rex-xmm-imm ((prefix #x66) (op ,opcode) (/i ,/i)))
+ (:printer ext-xmm-imm ((prefix #x66) (op ,opcode) (/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 #x71 6)
+ (define-imm-sse-instruction pslld #x72 6)
+ (define-imm-sse-instruction psllq #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 #x71 2)
+ (define-imm-sse-instruction psrld #x72 2)
+ (define-imm-sse-instruction psrlq #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
+ &key (remaining-bytes 0))
+ (aver (xmm-register-p dst))
+ (emit-sse-inst segment dst src prefix opcode
+ :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.
+;;; The operand size is implicitly given by the instruction.
+
+(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)))))
+ (: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 rccps 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 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 padduwb #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 psraw #x66 #xe1)
+ (define-regular-sse-inst psrad #x66 #xe2)
+ (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 #xd8)
+ (define-regular-sse-inst psubsw #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 cvttpd2dq #x66 #xe6)
+ (define-regular-sse-inst cvttps2dq #xf3 #x5b)
+ ;; moves
+ (define-regular-sse-inst movntdq #x66 #xe7)
+ (define-regular-sse-inst movntpd #x66 #x2b)
+ (define-regular-sse-inst movntps nil #x2b)
+ ;; integer
+ (define-regular-sse-inst packsswb #x66 #x63)
+ (define-regular-sse-inst packssdw #x66 #x6b)
+ (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)
+ `(define-instruction ,name (segment dst src pattern)
+ ,@(if prefix
+ `((:printer ext-xmm-xmm/mem-imm ; suboptimal
+ ((prefix ,prefix) (op ,opcode)))
+ (:printer ext-rex-xmm-xmm/mem-imm
+ ((prefix ,prefix) (op ,opcode))))
+ `((:printer xmm-xmm/mem-imm ((op ,opcode)))
+ (:printer rex-xmm-xmm/mem-imm ((op ,opcode)))))
+ (:emitter
+ (aver (typep pattern '(unsigned-byte 8)))
+ (emit-regular-sse-inst segment dst src ,prefix ,opcode
+ :remaining-bytes 1)
+ (emit-byte segment pattern)))))
+ (define-xmm-shuffle-sse-inst pshufd #x66 #x70)
+ (define-xmm-shuffle-sse-inst pshufhw #xf3 #x70)
+ (define-xmm-shuffle-sse-inst pshuflw #xf2 #x70)
+ (define-xmm-shuffle-sse-inst shufpd #x66 #xc6)
+ (define-xmm-shuffle-sse-inst shufps nil #xc6))
+
+;; MASKMOVDQU (dst is DS:RDI)
+(define-instruction maskmovdqu (segment src mask)
+ (:printer ext-xmm-xmm/mem
+ ((prefix #x66) (op #xf7)))
+ (:printer ext-rex-xmm-xmm/mem
+ ((prefix #x66) (op #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-imm 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)))
+ (:emitter
+ (cond ((xmm-register-p dst)
+ (emit-sse-inst segment dst src ,prefix #x10
+ :operand-size :do-not-set))
+ (t
+ (aver (xmm-register-p src))
+ (emit-sse-inst segment src dst ,prefix #x11
+ :operand-size :do-not-set)))))))
+ (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)
+ ,@(if prefix
+ `((:printer ext-xmm-xmm/mem
+ ((prefix ,prefix) (op ,opcode-from)))
+ (:printer ext-rex-xmm-xmm/mem
+ ((prefix ,prefix) (op ,opcode-from)))
+ (:printer ext-xmm-xmm/mem
+ ((prefix ,prefix) (op ,opcode-to))
+ '(:name :tab reg/mem ", " reg))
+ (:printer ext-rex-xmm-xmm/mem
+ ((prefix ,prefix) (op ,opcode-to))
+ '(:name :tab reg/mem ", " reg)))
+ `((:printer xmm-xmm/mem
+ ((op ,opcode-from)))
+ (:printer rex-xmm-xmm/mem
+ ((op ,opcode-from)))
+ (:printer xmm-xmm/mem
+ ((op ,opcode-to))
+ '(:name :tab reg/mem ", " reg))
+ (:printer rex-xmm-xmm/mem
+ ((op ,opcode-to))
+ '(:name :tab reg/mem ", " reg))))
+ (:emitter
+ (cond ((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)
+
+ ;; 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))
+ (:emitter
+ (cond ((xmm-register-p dst)
+ (emit-sse-inst segment dst src #xf3 #x7e
+ :operand-size :do-not-set))
+ (t
+ (aver (xmm-register-p src))
+ (emit-sse-inst segment src dst #x66 #xd6
+ :operand-size :do-not-set)))))
+
+;;; Instructions having an XMM register as the destination operand
+;;; and a general-purpose register or a memory location as the source
+;;; operand. The operand size is calculated from the source operand.
+
+;;; MOVD - Move a 32- or 64-bit value from a general-purpose register or
+;;; a memory location to the low order 32 or 64 bits of an XMM register
+;;; 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))
+ (:emitter
+ (cond ((xmm-register-p dst)
+ (emit-sse-inst segment dst src #x66 #x6e))
+ (t
+ (aver (xmm-register-p src))
+ (emit-sse-inst segment src dst #x66 #x7e)))))
+
+(macrolet ((define-integer-source-sse-inst (name prefix opcode &key mem-only)
+ `(define-instruction ,name (segment dst src)
+ ,@(if prefix
+ `((:printer ext-xmm-reg/mem ((prefix ,prefix) (op ,opcode)))
+ (:printer ext-rex-xmm-reg/mem ((prefix ,prefix) (op ,opcode))))
+ `((:printer xmm-reg/mem ((op ,opcode)))
+ (:printer rex-xmm-reg/mem ((op ,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)
+ ;; 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 &key reg-only)
+ `(define-instruction ,name (segment dst src)
+ ,@(if prefix
+ `((:printer ext-reg-xmm/mem ((prefix ,prefix) (op ,opcode)))
+ (:printer ext-rex-reg-xmm/mem ((prefix ,prefix) (op ,opcode))))
+ `((:printer reg-xmm/mem ((op ,opcode)))
+ (:printer rex-reg-xmm/mem ((op ,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
+ :operand-size dst-size))))))
+ (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 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 #x18)
+ (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)))