1 ;;;; that part of the description of the x86 instruction set (for
2 ;;;; 80386 and above) which can live on the cross-compilation host
4 ;;;; This software is part of the SBCL system. See the README file for
7 ;;;; This software is derived from the CMU CL system, which was
8 ;;;; written at Carnegie Mellon University and released into the
9 ;;;; public domain. The software is in the public domain and is
10 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
11 ;;;; files for more information.
14 ;;; FIXME: SB!DISASSEM: prefixes are used so widely in this file that
15 ;;; I wonder whether the separation of the disassembler from the
16 ;;; virtual machine is valid or adds value.
18 ;;; Note: In CMU CL, this used to be a call to SET-DISASSEM-PARAMS.
19 (setf sb
!disassem
:*disassem-inst-alignment-bytes
* 1)
21 (deftype reg
() '(unsigned-byte 3))
23 (def!constant
+default-operand-size
+ :dword
)
25 (eval-when (#-sb-xc
:compile-toplevel
:load-toplevel
:execute
)
27 (defun offset-next (value dstate
)
28 (declare (type integer value
)
29 (type sb
!disassem
:disassem-state dstate
))
30 (+ (sb!disassem
:dstate-next-addr dstate
) value
))
32 (defparameter *default-address-size
*
33 ;; Actually, :DWORD is the only one really supported.
36 (defparameter *byte-reg-names
*
37 #(al cl dl bl ah ch dh bh
))
38 (defparameter *word-reg-names
*
39 #(ax cx dx bx sp bp si di
))
40 (defparameter *dword-reg-names
*
41 #(eax ecx edx ebx esp ebp esi edi
))
43 (defun print-reg-with-width (value width stream dstate
)
44 (declare (ignore dstate
))
45 (princ (aref (ecase width
46 (:byte
*byte-reg-names
*)
47 (:word
*word-reg-names
*)
48 (:dword
*dword-reg-names
*))
51 ;; XXX plus should do some source-var notes
54 (defun print-reg (value stream dstate
)
55 (declare (type reg value
)
57 (type sb
!disassem
:disassem-state dstate
))
58 (print-reg-with-width value
59 (sb!disassem
:dstate-get-prop dstate
'width
)
63 (defun print-word-reg (value stream dstate
)
64 (declare (type reg value
)
66 (type sb
!disassem
:disassem-state dstate
))
67 (print-reg-with-width value
68 (or (sb!disassem
:dstate-get-prop dstate
'word-width
)
69 +default-operand-size
+)
73 (defun print-byte-reg (value stream dstate
)
74 (declare (type reg value
)
76 (type sb
!disassem
:disassem-state dstate
))
77 (print-reg-with-width value
:byte stream dstate
))
79 (defun print-addr-reg (value stream dstate
)
80 (declare (type reg value
)
82 (type sb
!disassem
:disassem-state dstate
))
83 (print-reg-with-width value
*default-address-size
* stream dstate
))
85 (defun print-reg/mem
(value stream dstate
)
86 (declare (type (or list reg
) value
)
88 (type sb
!disassem
:disassem-state dstate
))
89 (if (typep value
'reg
)
90 (print-reg value stream dstate
)
91 (print-mem-access value stream nil dstate
)))
93 ;; Same as print-reg/mem, but prints an explicit size indicator for
95 (defun print-sized-reg/mem
(value stream dstate
)
96 (declare (type (or list reg
) value
)
98 (type sb
!disassem
:disassem-state dstate
))
99 (if (typep value
'reg
)
100 (print-reg value stream dstate
)
101 (print-mem-access value stream t dstate
)))
103 (defun print-byte-reg/mem
(value stream dstate
)
104 (declare (type (or list reg
) value
)
106 (type sb
!disassem
:disassem-state dstate
))
107 (if (typep value
'reg
)
108 (print-byte-reg value stream dstate
)
109 (print-mem-access value stream t dstate
)))
111 (defun print-word-reg/mem
(value stream dstate
)
112 (declare (type (or list reg
) value
)
114 (type sb
!disassem
:disassem-state dstate
))
115 (if (typep value
'reg
)
116 (print-word-reg value stream dstate
)
117 (print-mem-access value stream nil dstate
)))
119 (defun print-label (value stream dstate
)
120 (declare (ignore dstate
))
121 (sb!disassem
:princ16 value stream
))
123 ;;; Returns either an integer, meaning a register, or a list of
124 ;;; (BASE-REG OFFSET INDEX-REG INDEX-SCALE), where any component
125 ;;; may be missing or nil to indicate that it's not used or has the
126 ;;; obvious default value (e.g., 1 for the index-scale).
127 (defun prefilter-reg/mem
(value dstate
)
128 (declare (type list value
)
129 (type sb
!disassem
:disassem-state dstate
))
130 (let ((mod (car value
))
132 (declare (type (unsigned-byte 2) mod
)
133 (type (unsigned-byte 3) r
/m
))
139 (let ((sib (sb!disassem
:read-suffix
8 dstate
)))
140 (declare (type (unsigned-byte 8) sib
))
141 (let ((base-reg (ldb (byte 3 0) sib
))
142 (index-reg (ldb (byte 3 3) sib
))
143 (index-scale (ldb (byte 2 6) sib
)))
144 (declare (type (unsigned-byte 3) base-reg index-reg
)
145 (type (unsigned-byte 2) index-scale
))
149 (if (= base-reg
#b101
)
150 (sb!disassem
:read-signed-suffix
32 dstate
)
153 (sb!disassem
:read-signed-suffix
8 dstate
))
155 (sb!disassem
:read-signed-suffix
32 dstate
)))))
156 (list (if (and (= mod
#b00
) (= base-reg
#b101
)) nil base-reg
)
158 (if (= index-reg
#b100
) nil index-reg
)
159 (ash 1 index-scale
))))))
160 ((and (= mod
#b00
) (= r
/m
#b101
))
161 (list nil
(sb!disassem
:read-signed-suffix
32 dstate
)) )
165 (list r
/m
(sb!disassem
:read-signed-suffix
8 dstate
)))
167 (list r
/m
(sb!disassem
:read-signed-suffix
32 dstate
))))))
170 ;;; This is a sort of bogus prefilter that just stores the info globally for
171 ;;; other people to use; it probably never gets printed.
172 (defun prefilter-width (value dstate
)
173 (setf (sb!disassem
:dstate-get-prop dstate
'width
)
177 ;; set by a prefix instruction
178 (or (sb!disassem
:dstate-get-prop dstate
'word-width
)
179 +default-operand-size
+)))
180 (when (not (eql word-width
+default-operand-size
+))
182 (setf (sb!disassem
:dstate-get-prop dstate
'word-width
)
183 +default-operand-size
+))
186 (defun read-address (value dstate
)
187 (declare (ignore value
)) ; always nil anyway
188 (sb!disassem
:read-suffix
(width-bits *default-address-size
*) dstate
))
190 (defun width-bits (width)
202 ;;;; disassembler argument types
204 (sb!disassem
:define-arg-type displacement
206 :use-label
#'offset-next
207 :printer
(lambda (value stream dstate
)
208 (sb!disassem
:maybe-note-assembler-routine value nil dstate
)
209 (print-label value stream dstate
)))
211 (sb!disassem
:define-arg-type accum
212 :printer
(lambda (value stream dstate
)
213 (declare (ignore value
)
215 (type sb
!disassem
:disassem-state dstate
))
216 (print-reg 0 stream dstate
)))
218 (sb!disassem
:define-arg-type word-accum
219 :printer
(lambda (value stream dstate
)
220 (declare (ignore value
)
222 (type sb
!disassem
:disassem-state dstate
))
223 (print-word-reg 0 stream dstate
)))
225 (sb!disassem
:define-arg-type reg
226 :printer
#'print-reg
)
228 (sb!disassem
:define-arg-type addr-reg
229 :printer
#'print-addr-reg
)
231 (sb!disassem
:define-arg-type word-reg
232 :printer
#'print-word-reg
)
234 (sb!disassem
:define-arg-type imm-addr
235 :prefilter
#'read-address
236 :printer
#'print-label
)
238 (sb!disassem
:define-arg-type imm-data
239 :prefilter
(lambda (value dstate
)
240 (declare (ignore value
)) ; always nil anyway
241 (sb!disassem
:read-suffix
242 (width-bits (sb!disassem
:dstate-get-prop dstate
'width
))
245 (sb!disassem
:define-arg-type signed-imm-data
246 :prefilter
(lambda (value dstate
)
247 (declare (ignore value
)) ; always nil anyway
248 (let ((width (sb!disassem
:dstate-get-prop dstate
'width
)))
249 (sb!disassem
:read-signed-suffix
(width-bits width
) dstate
))))
251 (sb!disassem
:define-arg-type signed-imm-byte
252 :prefilter
(lambda (value dstate
)
253 (declare (ignore value
)) ; always nil anyway
254 (sb!disassem
:read-signed-suffix
8 dstate
)))
256 (sb!disassem
:define-arg-type signed-imm-dword
257 :prefilter
(lambda (value dstate
)
258 (declare (ignore value
)) ; always nil anyway
259 (sb!disassem
:read-signed-suffix
32 dstate
)))
261 (sb!disassem
:define-arg-type imm-word
262 :prefilter
(lambda (value dstate
)
263 (declare (ignore value
)) ; always nil anyway
265 (or (sb!disassem
:dstate-get-prop dstate
'word-width
)
266 +default-operand-size
+)))
267 (sb!disassem
:read-suffix
(width-bits width
) dstate
))))
269 (sb!disassem
:define-arg-type signed-imm-word
270 :prefilter
(lambda (value dstate
)
271 (declare (ignore value
)) ; always nil anyway
273 (or (sb!disassem
:dstate-get-prop dstate
'word-width
)
274 +default-operand-size
+)))
275 (sb!disassem
:read-signed-suffix
(width-bits width
) dstate
))))
277 ;;; needed for the ret imm16 instruction
278 (sb!disassem
:define-arg-type imm-word-16
279 :prefilter
(lambda (value dstate
)
280 (declare (ignore value
)) ; always nil anyway
281 (sb!disassem
:read-suffix
16 dstate
)))
283 (sb!disassem
:define-arg-type reg
/mem
284 :prefilter
#'prefilter-reg
/mem
285 :printer
#'print-reg
/mem
)
286 (sb!disassem
:define-arg-type sized-reg
/mem
287 ;; Same as reg/mem, but prints an explicit size indicator for
288 ;; memory references.
289 :prefilter
#'prefilter-reg
/mem
290 :printer
#'print-sized-reg
/mem
)
291 (sb!disassem
:define-arg-type byte-reg
/mem
292 :prefilter
#'prefilter-reg
/mem
293 :printer
#'print-byte-reg
/mem
)
294 (sb!disassem
:define-arg-type word-reg
/mem
295 :prefilter
#'prefilter-reg
/mem
296 :printer
#'print-word-reg
/mem
)
299 (eval-when (#-sb-xc
:compile-toplevel
:load-toplevel
:execute
)
300 (defun print-fp-reg (value stream dstate
)
301 (declare (ignore dstate
))
302 (format stream
"FR~D" value
))
303 (defun prefilter-fp-reg (value dstate
)
305 (declare (ignore dstate
))
308 (sb!disassem
:define-arg-type fp-reg
309 :prefilter
#'prefilter-fp-reg
310 :printer
#'print-fp-reg
)
312 (sb!disassem
:define-arg-type width
313 :prefilter
#'prefilter-width
314 :printer
(lambda (value stream dstate
)
317 (and (numberp value
) (zerop value
))) ; zzz jrd
320 ;; set by a prefix instruction
321 (or (sb!disassem
:dstate-get-prop dstate
'word-width
)
322 +default-operand-size
+)))
323 (princ (schar (symbol-name word-width
) 0) stream
)))))
325 (eval-when (:compile-toplevel
:load-toplevel
:execute
)
326 (defparameter *conditions
*
329 (:b .
2) (:nae .
2) (:c .
2)
330 (:nb .
3) (:ae .
3) (:nc .
3)
331 (:eq .
4) (:e .
4) (:z .
4)
338 (:np .
11) (:po .
11)
339 (:l .
12) (:nge .
12)
340 (:nl .
13) (:ge .
13)
341 (:le .
14) (:ng .
14)
342 (:nle .
15) (:g .
15)))
343 (defparameter *condition-name-vec
*
344 (let ((vec (make-array 16 :initial-element nil
)))
345 (dolist (cond *conditions
*)
346 (when (null (aref vec
(cdr cond
)))
347 (setf (aref vec
(cdr cond
)) (car cond
))))
351 ;;; Set assembler parameters. (In CMU CL, this was done with
352 ;;; a call to a macro DEF-ASSEMBLER-PARAMS.)
353 (eval-when (:compile-toplevel
:load-toplevel
:execute
)
354 (setf sb
!assem
:*assem-scheduler-p
* nil
))
356 (sb!disassem
:define-arg-type condition-code
357 :printer
*condition-name-vec
*)
359 (defun conditional-opcode (condition)
360 (cdr (assoc condition
*conditions
* :test
#'eq
)))
362 ;;;; disassembler instruction formats
364 (eval-when (:compile-toplevel
:execute
)
365 (defun swap-if (direction field1 separator field2
)
366 `(:if
(,direction
:constant
0)
367 (,field1
,separator
,field2
)
368 (,field2
,separator
,field1
))))
370 (sb!disassem
:define-instruction-format
(byte 8 :default-printer
'(:name
))
371 (op :field
(byte 8 0))
376 (sb!disassem
:define-instruction-format
(simple 8)
377 (op :field
(byte 7 1))
378 (width :field
(byte 1 0) :type
'width
)
383 ;;; Same as simple, but with direction bit
384 (sb!disassem
:define-instruction-format
(simple-dir 8 :include
'simple
)
385 (op :field
(byte 6 2))
386 (dir :field
(byte 1 1)))
388 ;;; Same as simple, but with the immediate value occurring by default,
389 ;;; and with an appropiate printer.
390 (sb!disassem
:define-instruction-format
(accum-imm 8
392 :default-printer
'(:name
393 :tab accum
", " imm
))
394 (imm :type
'imm-data
))
396 (sb!disassem
:define-instruction-format
(reg-no-width 8
397 :default-printer
'(:name
:tab reg
))
398 (op :field
(byte 5 3))
399 (reg :field
(byte 3 0) :type
'word-reg
)
401 (accum :type
'word-accum
)
404 ;;; adds a width field to reg-no-width
405 (sb!disassem
:define-instruction-format
(reg 8
406 :default-printer
'(:name
:tab reg
))
407 (op :field
(byte 4 4))
408 (width :field
(byte 1 3) :type
'width
)
409 (reg :field
(byte 3 0) :type
'reg
)
415 ;;; Same as reg, but with direction bit
416 (sb!disassem
:define-instruction-format
(reg-dir 8 :include
'reg
)
417 (op :field
(byte 3 5))
418 (dir :field
(byte 1 4)))
420 (sb!disassem
:define-instruction-format
(two-bytes 16
421 :default-printer
'(:name
))
422 (op :fields
(list (byte 8 0) (byte 8 8))))
424 (sb!disassem
:define-instruction-format
(reg-reg/mem
16
426 `(:name
:tab reg
", " reg
/mem
))
427 (op :field
(byte 7 1))
428 (width :field
(byte 1 0) :type
'width
)
429 (reg/mem
:fields
(list (byte 2 14) (byte 3 8))
431 (reg :field
(byte 3 11) :type
'reg
)
435 ;;; same as reg-reg/mem, but with direction bit
436 (sb!disassem
:define-instruction-format
(reg-reg/mem-dir
16
437 :include
'reg-reg
/mem
441 ,(swap-if 'dir
'reg
/mem
", " 'reg
)))
442 (op :field
(byte 6 2))
443 (dir :field
(byte 1 1)))
445 ;;; Same as reg-rem/mem, but uses the reg field as a second op code.
446 (sb!disassem
:define-instruction-format
(reg/mem
16
447 :default-printer
'(:name
:tab reg
/mem
))
448 (op :fields
(list (byte 7 1) (byte 3 11)))
449 (width :field
(byte 1 0) :type
'width
)
450 (reg/mem
:fields
(list (byte 2 14) (byte 3 8))
451 :type
'sized-reg
/mem
)
455 ;;; Same as reg/mem, but with the immediate value occurring by default,
456 ;;; and with an appropiate printer.
457 (sb!disassem
:define-instruction-format
(reg/mem-imm
16
460 '(:name
:tab reg
/mem
", " imm
))
461 (reg/mem
:type
'sized-reg
/mem
)
462 (imm :type
'imm-data
))
464 ;;; Same as reg/mem, but with using the accumulator in the default printer
465 (sb!disassem
:define-instruction-format
467 :include
'reg
/mem
:default-printer
'(:name
:tab accum
", " reg
/mem
))
468 (reg/mem
:type
'reg
/mem
) ; don't need a size
469 (accum :type
'accum
))
471 ;;; Same as reg-reg/mem, but with a prefix of #b00001111
472 (sb!disassem
:define-instruction-format
(ext-reg-reg/mem
24
474 `(:name
:tab reg
", " reg
/mem
))
475 (prefix :field
(byte 8 0) :value
#b00001111
)
476 (op :field
(byte 7 9))
477 (width :field
(byte 1 8) :type
'width
)
478 (reg/mem
:fields
(list (byte 2 22) (byte 3 16))
480 (reg :field
(byte 3 19) :type
'reg
)
484 ;;; Same as reg/mem, but with a prefix of #b00001111
485 (sb!disassem
:define-instruction-format
(ext-reg/mem
24
486 :default-printer
'(:name
:tab reg
/mem
))
487 (prefix :field
(byte 8 0) :value
#b00001111
)
488 (op :fields
(list (byte 7 9) (byte 3 19)))
489 (width :field
(byte 1 8) :type
'width
)
490 (reg/mem
:fields
(list (byte 2 22) (byte 3 16))
491 :type
'sized-reg
/mem
)
495 (sb!disassem
:define-instruction-format
(ext-reg/mem-imm
24
496 :include
'ext-reg
/mem
498 '(:name
:tab reg
/mem
", " imm
))
499 (imm :type
'imm-data
))
501 ;;;; This section was added by jrd, for fp instructions.
503 ;;; regular fp inst to/from registers/memory
504 (sb!disassem
:define-instruction-format
(floating-point 16
506 `(:name
:tab reg
/mem
))
507 (prefix :field
(byte 5 3) :value
#b11011
)
508 (op :fields
(list (byte 3 0) (byte 3 11)))
509 (reg/mem
:fields
(list (byte 2 14) (byte 3 8)) :type
'reg
/mem
))
511 ;;; fp insn to/from fp reg
512 (sb!disassem
:define-instruction-format
(floating-point-fp 16
513 :default-printer
`(:name
:tab fp-reg
))
514 (prefix :field
(byte 5 3) :value
#b11011
)
515 (suffix :field
(byte 2 14) :value
#b11
)
516 (op :fields
(list (byte 3 0) (byte 3 11)))
517 (fp-reg :field
(byte 3 8) :type
'fp-reg
))
519 ;;; fp insn to/from fp reg, with the reversed source/destination flag.
520 (sb!disassem
:define-instruction-format
521 (floating-point-fp-d 16
522 :default-printer
`(:name
:tab
,(swap-if 'd
"ST0" ", " 'fp-reg
)))
523 (prefix :field
(byte 5 3) :value
#b11011
)
524 (suffix :field
(byte 2 14) :value
#b11
)
525 (op :fields
(list (byte 2 0) (byte 3 11)))
526 (d :field
(byte 1 2))
527 (fp-reg :field
(byte 3 8) :type
'fp-reg
))
530 ;;; (added by (?) pfw)
531 ;;; fp no operand isns
532 (sb!disassem
:define-instruction-format
(floating-point-no 16
533 :default-printer
'(:name
))
534 (prefix :field
(byte 8 0) :value
#b11011001
)
535 (suffix :field
(byte 3 13) :value
#b111
)
536 (op :field
(byte 5 8)))
538 (sb!disassem
:define-instruction-format
(floating-point-3 16
539 :default-printer
'(:name
))
540 (prefix :field
(byte 5 3) :value
#b11011
)
541 (suffix :field
(byte 2 14) :value
#b11
)
542 (op :fields
(list (byte 3 0) (byte 6 8))))
544 (sb!disassem
:define-instruction-format
(floating-point-5 16
545 :default-printer
'(:name
))
546 (prefix :field
(byte 8 0) :value
#b11011011
)
547 (suffix :field
(byte 3 13) :value
#b111
)
548 (op :field
(byte 5 8)))
550 (sb!disassem
:define-instruction-format
(floating-point-st 16
551 :default-printer
'(:name
))
552 (prefix :field
(byte 8 0) :value
#b11011111
)
553 (suffix :field
(byte 3 13) :value
#b111
)
554 (op :field
(byte 5 8)))
556 (sb!disassem
:define-instruction-format
(string-op 8
558 :default-printer
'(:name width
)))
560 (sb!disassem
:define-instruction-format
(short-cond-jump 16)
561 (op :field
(byte 4 4))
562 (cc :field
(byte 4 0) :type
'condition-code
)
563 (label :field
(byte 8 8) :type
'displacement
))
565 (sb!disassem
:define-instruction-format
(short-jump 16
566 :default-printer
'(:name
:tab label
))
567 (const :field
(byte 4 4) :value
#b1110
)
568 (op :field
(byte 4 0))
569 (label :field
(byte 8 8) :type
'displacement
))
571 (sb!disassem
:define-instruction-format
(near-cond-jump 16)
572 (op :fields
(list (byte 8 0) (byte 4 12)) :value
'(#b00001111
#b1000
))
573 (cc :field
(byte 4 8) :type
'condition-code
)
574 ;; The disassembler currently doesn't let you have an instruction > 32 bits
575 ;; long, so we fake it by using a prefilter to read the offset.
576 (label :type
'displacement
577 :prefilter
(lambda (value dstate
)
578 (declare (ignore value
)) ; always nil anyway
579 (sb!disassem
:read-signed-suffix
32 dstate
))))
581 (sb!disassem
:define-instruction-format
(near-jump 8
582 :default-printer
'(:name
:tab label
))
583 (op :field
(byte 8 0))
584 ;; The disassembler currently doesn't let you have an instruction > 32 bits
585 ;; long, so we fake it by using a prefilter to read the address.
586 (label :type
'displacement
587 :prefilter
(lambda (value dstate
)
588 (declare (ignore value
)) ; always nil anyway
589 (sb!disassem
:read-signed-suffix
32 dstate
))))
592 (sb!disassem
:define-instruction-format
(cond-set 24
593 :default-printer
'('set cc
:tab reg
/mem
))
594 (prefix :field
(byte 8 0) :value
#b00001111
)
595 (op :field
(byte 4 12) :value
#b1001
)
596 (cc :field
(byte 4 8) :type
'condition-code
)
597 (reg/mem
:fields
(list (byte 2 22) (byte 3 16))
599 (reg :field
(byte 3 19) :value
#b000
))
601 (sb!disassem
:define-instruction-format
(cond-move 24
603 '('cmov cc
:tab reg
", " reg
/mem
))
604 (prefix :field
(byte 8 0) :value
#b00001111
)
605 (op :field
(byte 4 12) :value
#b0100
)
606 (cc :field
(byte 4 8) :type
'condition-code
)
607 (reg/mem
:fields
(list (byte 2 22) (byte 3 16))
609 (reg :field
(byte 3 19) :type
'reg
))
611 (sb!disassem
:define-instruction-format
(enter-format 32
612 :default-printer
'(:name
614 (:unless
(:constant
0)
616 (op :field
(byte 8 0))
617 (disp :field
(byte 16 8))
618 (level :field
(byte 8 24)))
620 (sb!disassem
:define-instruction-format
(prefetch 24
622 '(:name
", " reg
/mem
))
623 (prefix :field
(byte 8 0) :value
#b00001111
)
624 (op :field
(byte 8 8) :value
#b00011000
)
625 (reg/mem
:fields
(list (byte 2 22) (byte 3 16)) :type
'byte-reg
/mem
)
626 (reg :field
(byte 3 19) :type
'reg
))
628 ;;; Single byte instruction with an immediate byte argument.
629 (sb!disassem
:define-instruction-format
(byte-imm 16
630 :default-printer
'(:name
:tab code
))
631 (op :field
(byte 8 0))
632 (code :field
(byte 8 8)))
634 ;;;; primitive emitters
636 (define-bitfield-emitter emit-word
16
639 (define-bitfield-emitter emit-dword
32
642 (define-bitfield-emitter emit-byte-with-reg
8
643 (byte 5 3) (byte 3 0))
645 (define-bitfield-emitter emit-mod-reg-r
/m-byte
8
646 (byte 2 6) (byte 3 3) (byte 3 0))
648 (define-bitfield-emitter emit-sib-byte
8
649 (byte 2 6) (byte 3 3) (byte 3 0))
653 (defun emit-absolute-fixup (segment fixup
)
654 (note-fixup segment
:absolute fixup
)
655 (let ((offset (fixup-offset fixup
)))
657 (emit-back-patch segment
658 4 ; FIXME: n-word-bytes
659 (lambda (segment posn
)
660 (declare (ignore posn
))
662 (- (+ (component-header-length)
663 (or (label-position offset
)
665 other-pointer-lowtag
))))
666 (emit-dword segment
(or offset
0)))))
668 (defun emit-relative-fixup (segment fixup
)
669 (note-fixup segment
:relative fixup
)
670 (emit-dword segment
(or (fixup-offset fixup
) 0)))
672 ;;;; the effective-address (ea) structure
674 (defun reg-tn-encoding (tn)
675 (declare (type tn tn
))
676 ; (aver (eq (sb-name (sc-sb (tn-sc tn))) 'registers))
677 (let ((offset (tn-offset tn
)))
678 (logior (ash (logand offset
1) 2)
681 (defstruct (ea (:constructor make-ea
(size &key base index scale disp
))
683 (size nil
:type
(member :byte
:word
:dword
))
684 (base nil
:type
(or tn null
))
685 (index nil
:type
(or tn null
))
686 (scale 1 :type
(member 1 2 4 8))
687 (disp 0 :type
(or (unsigned-byte 32) (signed-byte 32) fixup
)))
688 (def!method print-object
((ea ea
) stream
)
689 (cond ((or *print-escape
* *print-readably
*)
690 (print-unreadable-object (ea stream
:type t
)
692 "~S~@[ base=~S~]~@[ index=~S~]~@[ scale=~S~]~@[ disp=~S~]"
696 (let ((scale (ea-scale ea
)))
697 (if (= scale
1) nil scale
))
700 (format stream
"~A PTR [" (symbol-name (ea-size ea
)))
702 (write-string (sb!c
::location-print-name
(ea-base ea
)) stream
)
704 (write-string "+" stream
)))
706 (write-string (sb!c
::location-print-name
(ea-index ea
)) stream
))
707 (unless (= (ea-scale ea
) 1)
708 (format stream
"*~A" (ea-scale ea
)))
709 (typecase (ea-disp ea
)
712 (format stream
"~@D" (ea-disp ea
)))
714 (format stream
"+~A" (ea-disp ea
))))
715 (write-char #\
] stream
))))
717 (defun emit-ea (segment thing reg
&optional allow-constants
)
720 (ecase (sb-name (sc-sb (tn-sc thing
)))
722 (emit-mod-reg-r/m-byte segment
#b11 reg
(reg-tn-encoding thing
)))
724 (emit-mod-reg-r/m-byte segment
#b11 reg
(reg-tn-encoding thing
)))
726 ;; Convert stack tns into an index off of EBP.
727 (let ((disp (- (* (1+ (tn-offset thing
)) n-word-bytes
))))
728 (cond ((< -
128 disp
127)
729 (emit-mod-reg-r/m-byte segment
#b01 reg
#b101
)
730 (emit-byte segment disp
))
732 (emit-mod-reg-r/m-byte segment
#b10 reg
#b101
)
733 (emit-dword segment disp
)))))
735 (unless allow-constants
737 "Constant TNs can only be directly used in MOV, PUSH, and CMP."))
738 (emit-mod-reg-r/m-byte segment
#b00 reg
#b101
)
739 (emit-absolute-fixup segment
742 (- (* (tn-offset thing
) n-word-bytes
)
743 other-pointer-lowtag
))))))
745 (let* ((base (ea-base thing
))
746 (index (ea-index thing
))
747 (scale (ea-scale thing
))
748 (disp (ea-disp thing
))
749 (mod (cond ((or (null base
)
751 (not (= (reg-tn-encoding base
) #b101
))))
753 ((and (fixnump disp
) (<= -
128 disp
127))
757 (r/m
(cond (index #b100
)
759 (t (reg-tn-encoding base
)))))
760 (emit-mod-reg-r/m-byte segment mod reg r
/m
)
762 (let ((ss (1- (integer-length scale
)))
763 (index (if (null index
)
765 (let ((index (reg-tn-encoding index
)))
767 (error "can't index off of ESP")
769 (base (if (null base
)
771 (reg-tn-encoding base
))))
772 (emit-sib-byte segment ss index base
)))
774 (emit-byte segment disp
))
775 ((or (= mod
#b10
) (null base
))
777 (emit-absolute-fixup segment disp
)
778 (emit-dword segment disp
))))))
780 (emit-mod-reg-r/m-byte segment
#b00 reg
#b101
)
781 (emit-absolute-fixup segment thing
))))
783 (defun fp-reg-tn-p (thing)
785 (eq (sb-name (sc-sb (tn-sc thing
))) 'float-registers
)))
787 ;;; like the above, but for fp-instructions--jrd
788 (defun emit-fp-op (segment thing op
)
789 (if (fp-reg-tn-p thing
)
790 (emit-byte segment
(dpb op
(byte 3 3) (dpb (tn-offset thing
)
793 (emit-ea segment thing op
)))
795 (defun byte-reg-p (thing)
797 (eq (sb-name (sc-sb (tn-sc thing
))) 'registers
)
798 (member (sc-name (tn-sc thing
)) *byte-sc-names
*)
801 (defun byte-ea-p (thing)
803 (ea (eq (ea-size thing
) :byte
))
805 (and (member (sc-name (tn-sc thing
)) *byte-sc-names
*) t
))
808 (defun word-reg-p (thing)
810 (eq (sb-name (sc-sb (tn-sc thing
))) 'registers
)
811 (member (sc-name (tn-sc thing
)) *word-sc-names
*)
814 (defun word-ea-p (thing)
816 (ea (eq (ea-size thing
) :word
))
817 (tn (and (member (sc-name (tn-sc thing
)) *word-sc-names
*) t
))
820 (defun dword-reg-p (thing)
822 (eq (sb-name (sc-sb (tn-sc thing
))) 'registers
)
823 (member (sc-name (tn-sc thing
)) *dword-sc-names
*)
826 (defun dword-ea-p (thing)
828 (ea (eq (ea-size thing
) :dword
))
830 (and (member (sc-name (tn-sc thing
)) *dword-sc-names
*) t
))
833 (defun register-p (thing)
835 (eq (sb-name (sc-sb (tn-sc thing
))) 'registers
)))
837 (defun sse-register-p (thing)
839 (eq (sb-name (sc-sb (tn-sc thing
))) 'sse-registers
)))
841 (defun accumulator-p (thing)
842 (and (register-p thing
)
843 (= (tn-offset thing
) 0)))
847 (def!constant
+operand-size-prefix-byte
+ #b01100110
)
849 (defun maybe-emit-operand-size-prefix (segment size
)
850 (unless (or (eq size
:byte
) (eq size
+default-operand-size
+))
851 (emit-byte segment
+operand-size-prefix-byte
+)))
853 (defun operand-size (thing)
856 ;; FIXME: might as well be COND instead of having to use #. readmacro
857 ;; to hack up the code
858 (case (sc-name (tn-sc thing
))
865 ;; added by jrd: float-registers is a separate size (?)
871 (error "can't tell the size of ~S ~S" thing
(sc-name (tn-sc thing
))))))
877 (defun matching-operand-size (dst src
)
878 (let ((dst-size (operand-size dst
))
879 (src-size (operand-size src
)))
882 (if (eq dst-size src-size
)
884 (error "size mismatch: ~S is a ~S and ~S is a ~S."
885 dst dst-size src src-size
))
889 (error "can't tell the size of either ~S or ~S" dst src
)))))
891 (defun emit-sized-immediate (segment size value
)
894 (emit-byte segment value
))
896 (emit-word segment value
))
898 (emit-dword segment value
))))
900 ;;;; general data transfer
902 (define-instruction mov
(segment dst src
)
903 ;; immediate to register
904 (:printer reg
((op #b1011
) (imm nil
:type
'imm-data
))
905 '(:name
:tab reg
", " imm
))
906 ;; absolute mem to/from accumulator
907 (:printer simple-dir
((op #b101000
) (imm nil
:type
'imm-addr
))
908 `(:name
:tab
,(swap-if 'dir
'accum
", " '("[" imm
"]"))))
909 ;; register to/from register/memory
910 (:printer reg-reg
/mem-dir
((op #b100010
)))
911 ;; immediate to register/memory
912 (:printer reg
/mem-imm
((op '(#b1100011
#b000
))))
915 (let ((size (matching-operand-size dst src
)))
916 (maybe-emit-operand-size-prefix segment size
)
917 (cond ((register-p dst
)
918 (cond ((integerp src
)
919 (emit-byte-with-reg segment
923 (reg-tn-encoding dst
))
924 (emit-sized-immediate segment size src
))
925 ((and (fixup-p src
) (accumulator-p dst
))
930 (emit-absolute-fixup segment src
))
936 (emit-ea segment src
(reg-tn-encoding dst
) t
))))
937 ((and (fixup-p dst
) (accumulator-p src
))
938 (emit-byte segment
(if (eq size
:byte
) #b10100010
#b10100011
))
939 (emit-absolute-fixup segment dst
))
941 (emit-byte segment
(if (eq size
:byte
) #b11000110
#b11000111
))
942 (emit-ea segment dst
#b000
)
943 (emit-sized-immediate segment size src
))
945 (emit-byte segment
(if (eq size
:byte
) #b10001000
#b10001001
))
946 (emit-ea segment dst
(reg-tn-encoding src
)))
948 (aver (eq size
:dword
))
949 (emit-byte segment
#b11000111
)
950 (emit-ea segment dst
#b000
)
951 (emit-absolute-fixup segment src
))
953 (error "bogus arguments to MOV: ~S ~S" dst src
))))))
955 (defun emit-move-with-extension (segment dst src opcode
)
956 (aver (register-p dst
))
957 (let ((dst-size (operand-size dst
))
958 (src-size (operand-size src
)))
961 (aver (eq src-size
:byte
))
962 (maybe-emit-operand-size-prefix segment
:word
)
963 (emit-byte segment
#b00001111
)
964 (emit-byte segment opcode
)
965 (emit-ea segment src
(reg-tn-encoding dst
)))
969 (maybe-emit-operand-size-prefix segment
:dword
)
970 (emit-byte segment
#b00001111
)
971 (emit-byte segment opcode
)
972 (emit-ea segment src
(reg-tn-encoding dst
)))
974 (emit-byte segment
#b00001111
)
975 (emit-byte segment
(logior opcode
1))
976 (emit-ea segment src
(reg-tn-encoding dst
))))))))
978 (define-instruction movsx
(segment dst src
)
979 (:printer ext-reg-reg
/mem
((op #b1011111
) (reg nil
:type
'word-reg
)))
980 (:emitter
(emit-move-with-extension segment dst src
#b10111110
)))
982 (define-instruction movzx
(segment dst src
)
983 (:printer ext-reg-reg
/mem
((op #b1011011
) (reg nil
:type
'word-reg
)))
984 (:emitter
(emit-move-with-extension segment dst src
#b10110110
)))
986 (define-instruction push
(segment src
)
988 (:printer reg-no-width
((op #b01010
)))
990 (:printer reg
/mem
((op '(#b1111111
#b110
)) (width 1)))
992 (:printer byte
((op #b01101010
) (imm nil
:type
'signed-imm-byte
))
994 (:printer byte
((op #b01101000
) (imm nil
:type
'imm-word
))
996 ;; ### segment registers?
999 (cond ((integerp src
)
1000 (cond ((<= -
128 src
127)
1001 (emit-byte segment
#b01101010
)
1002 (emit-byte segment src
))
1004 (emit-byte segment
#b01101000
)
1005 (emit-dword segment src
))))
1007 ;; Interpret the fixup as an immediate dword to push.
1008 (emit-byte segment
#b01101000
)
1009 (emit-absolute-fixup segment src
))
1011 (let ((size (operand-size src
)))
1012 (aver (not (eq size
:byte
)))
1013 (maybe-emit-operand-size-prefix segment size
)
1014 (cond ((register-p src
)
1015 (emit-byte-with-reg segment
#b01010
(reg-tn-encoding src
)))
1017 (emit-byte segment
#b11111111
)
1018 (emit-ea segment src
#b110 t
))))))))
1020 (define-instruction pusha
(segment)
1021 (:printer byte
((op #b01100000
)))
1023 (emit-byte segment
#b01100000
)))
1025 (define-instruction pop
(segment dst
)
1026 (:printer reg-no-width
((op #b01011
)))
1027 (:printer reg
/mem
((op '(#b1000111
#b000
)) (width 1)))
1029 (let ((size (operand-size dst
)))
1030 (aver (not (eq size
:byte
)))
1031 (maybe-emit-operand-size-prefix segment size
)
1032 (cond ((register-p dst
)
1033 (emit-byte-with-reg segment
#b01011
(reg-tn-encoding dst
)))
1035 (emit-byte segment
#b10001111
)
1036 (emit-ea segment dst
#b000
))))))
1038 (define-instruction popa
(segment)
1039 (:printer byte
((op #b01100001
)))
1041 (emit-byte segment
#b01100001
)))
1043 (define-instruction xchg
(segment operand1 operand2
)
1044 ;; Register with accumulator.
1045 (:printer reg-no-width
((op #b10010
)) '(:name
:tab accum
", " reg
))
1046 ;; Register/Memory with Register.
1047 (:printer reg-reg
/mem
((op #b1000011
)))
1049 (let ((size (matching-operand-size operand1 operand2
)))
1050 (maybe-emit-operand-size-prefix segment size
)
1051 (labels ((xchg-acc-with-something (acc something
)
1052 (if (and (not (eq size
:byte
)) (register-p something
))
1053 (emit-byte-with-reg segment
1055 (reg-tn-encoding something
))
1056 (xchg-reg-with-something acc something
)))
1057 (xchg-reg-with-something (reg something
)
1058 (emit-byte segment
(if (eq size
:byte
) #b10000110
#b10000111
))
1059 (emit-ea segment something
(reg-tn-encoding reg
))))
1060 (cond ((accumulator-p operand1
)
1061 (xchg-acc-with-something operand1 operand2
))
1062 ((accumulator-p operand2
)
1063 (xchg-acc-with-something operand2 operand1
))
1064 ((register-p operand1
)
1065 (xchg-reg-with-something operand1 operand2
))
1066 ((register-p operand2
)
1067 (xchg-reg-with-something operand2 operand1
))
1069 (error "bogus args to XCHG: ~S ~S" operand1 operand2
)))))))
1071 (define-instruction lea
(segment dst src
)
1072 (:printer reg-reg
/mem
((op #b1000110
) (width 1)))
1074 (aver (dword-reg-p dst
))
1075 (emit-byte segment
#b10001101
)
1076 (emit-ea segment src
(reg-tn-encoding dst
))))
1078 (define-instruction cmpxchg
(segment dst src
)
1079 ;; Register/Memory with Register.
1080 (:printer ext-reg-reg
/mem
((op #b1011000
)) '(:name
:tab reg
/mem
", " reg
))
1082 (aver (register-p src
))
1083 (let ((size (matching-operand-size src dst
)))
1084 (maybe-emit-operand-size-prefix segment size
)
1085 (emit-byte segment
#b00001111
)
1086 (emit-byte segment
(if (eq size
:byte
) #b10110000
#b10110001
))
1087 (emit-ea segment dst
(reg-tn-encoding src
)))))
1091 (define-instruction fs-segment-prefix
(segment)
1093 (emit-byte segment
#x64
)))
1095 ;;;; flag control instructions
1097 ;;; CLC -- Clear Carry Flag.
1098 (define-instruction clc
(segment)
1099 (:printer byte
((op #b11111000
)))
1101 (emit-byte segment
#b11111000
)))
1103 ;;; CLD -- Clear Direction Flag.
1104 (define-instruction cld
(segment)
1105 (:printer byte
((op #b11111100
)))
1107 (emit-byte segment
#b11111100
)))
1109 ;;; CLI -- Clear Iterrupt Enable Flag.
1110 (define-instruction cli
(segment)
1111 (:printer byte
((op #b11111010
)))
1113 (emit-byte segment
#b11111010
)))
1115 ;;; CMC -- Complement Carry Flag.
1116 (define-instruction cmc
(segment)
1117 (:printer byte
((op #b11110101
)))
1119 (emit-byte segment
#b11110101
)))
1121 ;;; LAHF -- Load AH into flags.
1122 (define-instruction lahf
(segment)
1123 (:printer byte
((op #b10011111
)))
1125 (emit-byte segment
#b10011111
)))
1127 ;;; POPF -- Pop flags.
1128 (define-instruction popf
(segment)
1129 (:printer byte
((op #b10011101
)))
1131 (emit-byte segment
#b10011101
)))
1133 ;;; PUSHF -- push flags.
1134 (define-instruction pushf
(segment)
1135 (:printer byte
((op #b10011100
)))
1137 (emit-byte segment
#b10011100
)))
1139 ;;; SAHF -- Store AH into flags.
1140 (define-instruction sahf
(segment)
1141 (:printer byte
((op #b10011110
)))
1143 (emit-byte segment
#b10011110
)))
1145 ;;; STC -- Set Carry Flag.
1146 (define-instruction stc
(segment)
1147 (:printer byte
((op #b11111001
)))
1149 (emit-byte segment
#b11111001
)))
1151 ;;; STD -- Set Direction Flag.
1152 (define-instruction std
(segment)
1153 (:printer byte
((op #b11111101
)))
1155 (emit-byte segment
#b11111101
)))
1157 ;;; STI -- Set Interrupt Enable Flag.
1158 (define-instruction sti
(segment)
1159 (:printer byte
((op #b11111011
)))
1161 (emit-byte segment
#b11111011
)))
1165 (defun emit-random-arith-inst (name segment dst src opcode
1166 &optional allow-constants
)
1167 (let ((size (matching-operand-size dst src
)))
1168 (maybe-emit-operand-size-prefix segment size
)
1171 (cond ((and (not (eq size
:byte
)) (<= -
128 src
127))
1172 (emit-byte segment
#b10000011
)
1173 (emit-ea segment dst opcode allow-constants
)
1174 (emit-byte segment src
))
1175 ((accumulator-p dst
)
1182 (emit-sized-immediate segment size src
))
1184 (emit-byte segment
(if (eq size
:byte
) #b10000000
#b10000001
))
1185 (emit-ea segment dst opcode allow-constants
)
1186 (emit-sized-immediate segment size src
))))
1191 (if (eq size
:byte
) #b00000000
#b00000001
)))
1192 (emit-ea segment dst
(reg-tn-encoding src
) allow-constants
))
1197 (if (eq size
:byte
) #b00000010
#b00000011
)))
1198 (emit-ea segment src
(reg-tn-encoding dst
) allow-constants
))
1200 (error "bogus operands to ~A" name
)))))
1202 (eval-when (:compile-toplevel
:execute
)
1203 (defun arith-inst-printer-list (subop)
1204 `((accum-imm ((op ,(dpb subop
(byte 3 2) #b0000010
))))
1205 (reg/mem-imm
((op (#b1000000
,subop
))))
1206 (reg/mem-imm
((op (#b1000001
,subop
))
1207 (imm nil
:type signed-imm-byte
)))
1208 (reg-reg/mem-dir
((op ,(dpb subop
(byte 3 1) #b000000
))))))
1211 (define-instruction add
(segment dst src
)
1212 (:printer-list
(arith-inst-printer-list #b000
))
1213 (:emitter
(emit-random-arith-inst "ADD" segment dst src
#b000
)))
1215 (define-instruction adc
(segment dst src
)
1216 (:printer-list
(arith-inst-printer-list #b010
))
1217 (:emitter
(emit-random-arith-inst "ADC" segment dst src
#b010
)))
1219 (define-instruction sub
(segment dst src
)
1220 (:printer-list
(arith-inst-printer-list #b101
))
1221 (:emitter
(emit-random-arith-inst "SUB" segment dst src
#b101
)))
1223 (define-instruction sbb
(segment dst src
)
1224 (:printer-list
(arith-inst-printer-list #b011
))
1225 (:emitter
(emit-random-arith-inst "SBB" segment dst src
#b011
)))
1227 (define-instruction cmp
(segment dst src
)
1228 (:printer-list
(arith-inst-printer-list #b111
))
1229 (:emitter
(emit-random-arith-inst "CMP" segment dst src
#b111 t
)))
1231 (define-instruction inc
(segment dst
)
1233 (:printer reg-no-width
((op #b01000
)))
1235 (:printer reg
/mem
((op '(#b1111111
#b000
))))
1237 (let ((size (operand-size dst
)))
1238 (maybe-emit-operand-size-prefix segment size
)
1239 (cond ((and (not (eq size
:byte
)) (register-p dst
))
1240 (emit-byte-with-reg segment
#b01000
(reg-tn-encoding dst
)))
1242 (emit-byte segment
(if (eq size
:byte
) #b11111110
#b11111111
))
1243 (emit-ea segment dst
#b000
))))))
1245 (define-instruction dec
(segment dst
)
1247 (:printer reg-no-width
((op #b01001
)))
1249 (:printer reg
/mem
((op '(#b1111111
#b001
))))
1251 (let ((size (operand-size dst
)))
1252 (maybe-emit-operand-size-prefix segment size
)
1253 (cond ((and (not (eq size
:byte
)) (register-p dst
))
1254 (emit-byte-with-reg segment
#b01001
(reg-tn-encoding dst
)))
1256 (emit-byte segment
(if (eq size
:byte
) #b11111110
#b11111111
))
1257 (emit-ea segment dst
#b001
))))))
1259 (define-instruction neg
(segment dst
)
1260 (:printer reg
/mem
((op '(#b1111011
#b011
))))
1262 (let ((size (operand-size dst
)))
1263 (maybe-emit-operand-size-prefix segment size
)
1264 (emit-byte segment
(if (eq size
:byte
) #b11110110
#b11110111
))
1265 (emit-ea segment dst
#b011
))))
1267 (define-instruction aaa
(segment)
1268 (:printer byte
((op #b00110111
)))
1270 (emit-byte segment
#b00110111
)))
1272 (define-instruction aas
(segment)
1273 (:printer byte
((op #b00111111
)))
1275 (emit-byte segment
#b00111111
)))
1277 (define-instruction daa
(segment)
1278 (:printer byte
((op #b00100111
)))
1280 (emit-byte segment
#b00100111
)))
1282 (define-instruction das
(segment)
1283 (:printer byte
((op #b00101111
)))
1285 (emit-byte segment
#b00101111
)))
1287 (define-instruction mul
(segment dst src
)
1288 (:printer accum-reg
/mem
((op '(#b1111011
#b100
))))
1290 (let ((size (matching-operand-size dst src
)))
1291 (aver (accumulator-p dst
))
1292 (maybe-emit-operand-size-prefix segment size
)
1293 (emit-byte segment
(if (eq size
:byte
) #b11110110
#b11110111
))
1294 (emit-ea segment src
#b100
))))
1296 (define-instruction imul
(segment dst
&optional src1 src2
)
1297 (:printer accum-reg
/mem
((op '(#b1111011
#b101
))))
1298 (:printer ext-reg-reg
/mem
((op #b1010111
)))
1299 (:printer reg-reg
/mem
((op #b0110100
) (width 1)
1300 (imm nil
:type
'signed-imm-word
))
1301 '(:name
:tab reg
", " reg
/mem
", " imm
))
1302 (:printer reg-reg
/mem
((op #b0110101
) (width 1)
1303 (imm nil
:type
'signed-imm-byte
))
1304 '(:name
:tab reg
", " reg
/mem
", " imm
))
1306 (flet ((r/m-with-immed-to-reg
(reg r
/m immed
)
1307 (let* ((size (matching-operand-size reg r
/m
))
1308 (sx (and (not (eq size
:byte
)) (<= -
128 immed
127))))
1309 (maybe-emit-operand-size-prefix segment size
)
1310 (emit-byte segment
(if sx
#b01101011
#b01101001
))
1311 (emit-ea segment r
/m
(reg-tn-encoding reg
))
1313 (emit-byte segment immed
)
1314 (emit-sized-immediate segment size immed
)))))
1316 (r/m-with-immed-to-reg dst src1 src2
))
1319 (r/m-with-immed-to-reg dst dst src1
)
1320 (let ((size (matching-operand-size dst src1
)))
1321 (maybe-emit-operand-size-prefix segment size
)
1322 (emit-byte segment
#b00001111
)
1323 (emit-byte segment
#b10101111
)
1324 (emit-ea segment src1
(reg-tn-encoding dst
)))))
1326 (let ((size (operand-size dst
)))
1327 (maybe-emit-operand-size-prefix segment size
)
1328 (emit-byte segment
(if (eq size
:byte
) #b11110110
#b11110111
))
1329 (emit-ea segment dst
#b101
)))))))
1331 (define-instruction div
(segment dst src
)
1332 (:printer accum-reg
/mem
((op '(#b1111011
#b110
))))
1334 (let ((size (matching-operand-size dst src
)))
1335 (aver (accumulator-p dst
))
1336 (maybe-emit-operand-size-prefix segment size
)
1337 (emit-byte segment
(if (eq size
:byte
) #b11110110
#b11110111
))
1338 (emit-ea segment src
#b110
))))
1340 (define-instruction idiv
(segment dst src
)
1341 (:printer accum-reg
/mem
((op '(#b1111011
#b111
))))
1343 (let ((size (matching-operand-size dst src
)))
1344 (aver (accumulator-p dst
))
1345 (maybe-emit-operand-size-prefix segment size
)
1346 (emit-byte segment
(if (eq size
:byte
) #b11110110
#b11110111
))
1347 (emit-ea segment src
#b111
))))
1349 (define-instruction aad
(segment)
1350 (:printer two-bytes
((op '(#b11010101
#b00001010
))))
1352 (emit-byte segment
#b11010101
)
1353 (emit-byte segment
#b00001010
)))
1355 (define-instruction aam
(segment)
1356 (:printer two-bytes
((op '(#b11010100
#b00001010
))))
1358 (emit-byte segment
#b11010100
)
1359 (emit-byte segment
#b00001010
)))
1361 ;;; CBW -- Convert Byte to Word. AX <- sign_xtnd(AL)
1362 (define-instruction cbw
(segment)
1364 (maybe-emit-operand-size-prefix segment
:word
)
1365 (emit-byte segment
#b10011000
)))
1367 ;;; CWDE -- Convert Word To Double Word Extened. EAX <- sign_xtnd(AX)
1368 (define-instruction cwde
(segment)
1370 (maybe-emit-operand-size-prefix segment
:dword
)
1371 (emit-byte segment
#b10011000
)))
1373 ;;; CWD -- Convert Word to Double Word. DX:AX <- sign_xtnd(AX)
1374 (define-instruction cwd
(segment)
1376 (maybe-emit-operand-size-prefix segment
:word
)
1377 (emit-byte segment
#b10011001
)))
1379 ;;; CDQ -- Convert Double Word to Quad Word. EDX:EAX <- sign_xtnd(EAX)
1380 (define-instruction cdq
(segment)
1381 (:printer byte
((op #b10011001
)))
1383 (maybe-emit-operand-size-prefix segment
:dword
)
1384 (emit-byte segment
#b10011001
)))
1386 (define-instruction xadd
(segment dst src
)
1387 ;; Register/Memory with Register.
1388 (:printer ext-reg-reg
/mem
((op #b1100000
)) '(:name
:tab reg
/mem
", " reg
))
1390 (aver (register-p src
))
1391 (let ((size (matching-operand-size src dst
)))
1392 (maybe-emit-operand-size-prefix segment size
)
1393 (emit-byte segment
#b00001111
)
1394 (emit-byte segment
(if (eq size
:byte
) #b11000000
#b11000001
))
1395 (emit-ea segment dst
(reg-tn-encoding src
)))))
1400 (defun emit-shift-inst (segment dst amount opcode
)
1401 (let ((size (operand-size dst
)))
1402 (maybe-emit-operand-size-prefix segment size
)
1403 (multiple-value-bind (major-opcode immed
)
1405 (:cl
(values #b11010010 nil
))
1406 (1 (values #b11010000 nil
))
1407 (t (values #b11000000 t
)))
1409 (if (eq size
:byte
) major-opcode
(logior major-opcode
1)))
1410 (emit-ea segment dst opcode
)
1412 (emit-byte segment amount
)))))
1414 (eval-when (:compile-toplevel
:execute
)
1415 (defun shift-inst-printer-list (subop)
1416 `((reg/mem
((op (#b1101000
,subop
)))
1417 (:name
:tab reg
/mem
", 1"))
1418 (reg/mem
((op (#b1101001
,subop
)))
1419 (:name
:tab reg
/mem
", " 'cl
))
1420 (reg/mem-imm
((op (#b1100000
,subop
))
1421 (imm nil
:type signed-imm-byte
))))))
1423 (define-instruction rol
(segment dst amount
)
1425 (shift-inst-printer-list #b000
))
1427 (emit-shift-inst segment dst amount
#b000
)))
1429 (define-instruction ror
(segment dst amount
)
1431 (shift-inst-printer-list #b001
))
1433 (emit-shift-inst segment dst amount
#b001
)))
1435 (define-instruction rcl
(segment dst amount
)
1437 (shift-inst-printer-list #b010
))
1439 (emit-shift-inst segment dst amount
#b010
)))
1441 (define-instruction rcr
(segment dst amount
)
1443 (shift-inst-printer-list #b011
))
1445 (emit-shift-inst segment dst amount
#b011
)))
1447 (define-instruction shl
(segment dst amount
)
1449 (shift-inst-printer-list #b100
))
1451 (emit-shift-inst segment dst amount
#b100
)))
1453 (define-instruction shr
(segment dst amount
)
1455 (shift-inst-printer-list #b101
))
1457 (emit-shift-inst segment dst amount
#b101
)))
1459 (define-instruction sar
(segment dst amount
)
1461 (shift-inst-printer-list #b111
))
1463 (emit-shift-inst segment dst amount
#b111
)))
1465 (defun emit-double-shift (segment opcode dst src amt
)
1466 (let ((size (matching-operand-size dst src
)))
1467 (when (eq size
:byte
)
1468 (error "Double shifts can only be used with words."))
1469 (maybe-emit-operand-size-prefix segment size
)
1470 (emit-byte segment
#b00001111
)
1471 (emit-byte segment
(dpb opcode
(byte 1 3)
1472 (if (eq amt
:cl
) #b10100101
#b10100100
)))
1474 (emit-ea segment dst src
)
1475 (emit-ea segment dst
(reg-tn-encoding src
)) ; pw tries this
1476 (unless (eq amt
:cl
)
1477 (emit-byte segment amt
))))
1479 (eval-when (:compile-toplevel
:execute
)
1480 (defun double-shift-inst-printer-list (op)
1482 (ext-reg-reg/mem-imm
((op ,(logior op
#b10
))
1483 (imm nil
:type signed-imm-byte
)))
1484 (ext-reg-reg/mem
((op ,(logior op
#b10
)))
1485 (:name
:tab reg
/mem
", " reg
", " 'cl
)))))
1487 (define-instruction shld
(segment dst src amt
)
1488 (:declare
(type (or (member :cl
) (mod 32)) amt
))
1489 (:printer-list
(double-shift-inst-printer-list #b1010000
))
1491 (emit-double-shift segment
#b0 dst src amt
)))
1493 (define-instruction shrd
(segment dst src amt
)
1494 (:declare
(type (or (member :cl
) (mod 32)) amt
))
1495 (:printer-list
(double-shift-inst-printer-list #b1010100
))
1497 (emit-double-shift segment
#b1 dst src amt
)))
1499 (define-instruction and
(segment dst src
)
1501 (arith-inst-printer-list #b100
))
1503 (emit-random-arith-inst "AND" segment dst src
#b100
)))
1505 (define-instruction test
(segment this that
)
1506 (:printer accum-imm
((op #b1010100
)))
1507 (:printer reg
/mem-imm
((op '(#b1111011
#b000
))))
1508 (:printer reg-reg
/mem
((op #b1000010
)))
1510 (let ((size (matching-operand-size this that
)))
1511 (maybe-emit-operand-size-prefix segment size
)
1512 (flet ((test-immed-and-something (immed something
)
1513 (cond ((accumulator-p something
)
1515 (if (eq size
:byte
) #b10101000
#b10101001
))
1516 (emit-sized-immediate segment size immed
))
1519 (if (eq size
:byte
) #b11110110
#b11110111
))
1520 (emit-ea segment something
#b000
)
1521 (emit-sized-immediate segment size immed
))))
1522 (test-reg-and-something (reg something
)
1523 (emit-byte segment
(if (eq size
:byte
) #b10000100
#b10000101
))
1524 (emit-ea segment something
(reg-tn-encoding reg
))))
1525 (cond ((integerp that
)
1526 (test-immed-and-something that this
))
1528 (test-immed-and-something this that
))
1530 (test-reg-and-something this that
))
1532 (test-reg-and-something that this
))
1534 (error "bogus operands for TEST: ~S and ~S" this that
)))))))
1536 (define-instruction or
(segment dst src
)
1538 (arith-inst-printer-list #b001
))
1540 (emit-random-arith-inst "OR" segment dst src
#b001
)))
1542 (define-instruction xor
(segment dst src
)
1544 (arith-inst-printer-list #b110
))
1546 (emit-random-arith-inst "XOR" segment dst src
#b110
)))
1548 (define-instruction not
(segment dst
)
1549 (:printer reg
/mem
((op '(#b1111011
#b010
))))
1551 (let ((size (operand-size dst
)))
1552 (maybe-emit-operand-size-prefix segment size
)
1553 (emit-byte segment
(if (eq size
:byte
) #b11110110
#b11110111
))
1554 (emit-ea segment dst
#b010
))))
1556 ;;;; string manipulation
1558 (define-instruction cmps
(segment size
)
1559 (:printer string-op
((op #b1010011
)))
1561 (maybe-emit-operand-size-prefix segment size
)
1562 (emit-byte segment
(if (eq size
:byte
) #b10100110
#b10100111
))))
1564 (define-instruction ins
(segment acc
)
1565 (:printer string-op
((op #b0110110
)))
1567 (let ((size (operand-size acc
)))
1568 (aver (accumulator-p acc
))
1569 (maybe-emit-operand-size-prefix segment size
)
1570 (emit-byte segment
(if (eq size
:byte
) #b01101100
#b01101101
)))))
1572 (define-instruction lods
(segment acc
)
1573 (:printer string-op
((op #b1010110
)))
1575 (let ((size (operand-size acc
)))
1576 (aver (accumulator-p acc
))
1577 (maybe-emit-operand-size-prefix segment size
)
1578 (emit-byte segment
(if (eq size
:byte
) #b10101100
#b10101101
)))))
1580 (define-instruction movs
(segment size
)
1581 (:printer string-op
((op #b1010010
)))
1583 (maybe-emit-operand-size-prefix segment size
)
1584 (emit-byte segment
(if (eq size
:byte
) #b10100100
#b10100101
))))
1586 (define-instruction outs
(segment acc
)
1587 (:printer string-op
((op #b0110111
)))
1589 (let ((size (operand-size acc
)))
1590 (aver (accumulator-p acc
))
1591 (maybe-emit-operand-size-prefix segment size
)
1592 (emit-byte segment
(if (eq size
:byte
) #b01101110
#b01101111
)))))
1594 (define-instruction scas
(segment acc
)
1595 (:printer string-op
((op #b1010111
)))
1597 (let ((size (operand-size acc
)))
1598 (aver (accumulator-p acc
))
1599 (maybe-emit-operand-size-prefix segment size
)
1600 (emit-byte segment
(if (eq size
:byte
) #b10101110
#b10101111
)))))
1602 (define-instruction stos
(segment acc
)
1603 (:printer string-op
((op #b1010101
)))
1605 (let ((size (operand-size acc
)))
1606 (aver (accumulator-p acc
))
1607 (maybe-emit-operand-size-prefix segment size
)
1608 (emit-byte segment
(if (eq size
:byte
) #b10101010
#b10101011
)))))
1610 (define-instruction xlat
(segment)
1611 (:printer byte
((op #b11010111
)))
1613 (emit-byte segment
#b11010111
)))
1615 (define-instruction rep
(segment)
1617 (emit-byte segment
#b11110010
)))
1619 (define-instruction repe
(segment)
1620 (:printer byte
((op #b11110011
)))
1622 (emit-byte segment
#b11110011
)))
1624 (define-instruction repne
(segment)
1625 (:printer byte
((op #b11110010
)))
1627 (emit-byte segment
#b11110010
)))
1630 ;;;; bit manipulation
1632 (define-instruction bsf
(segment dst src
)
1633 (:printer ext-reg-reg
/mem
((op #b1011110
) (width 0)))
1635 (let ((size (matching-operand-size dst src
)))
1636 (when (eq size
:byte
)
1637 (error "can't scan bytes: ~S" src
))
1638 (maybe-emit-operand-size-prefix segment size
)
1639 (emit-byte segment
#b00001111
)
1640 (emit-byte segment
#b10111100
)
1641 (emit-ea segment src
(reg-tn-encoding dst
)))))
1643 (define-instruction bsr
(segment dst src
)
1644 (:printer ext-reg-reg
/mem
((op #b1011110
) (width 1)))
1646 (let ((size (matching-operand-size dst src
)))
1647 (when (eq size
:byte
)
1648 (error "can't scan bytes: ~S" src
))
1649 (maybe-emit-operand-size-prefix segment size
)
1650 (emit-byte segment
#b00001111
)
1651 (emit-byte segment
#b10111101
)
1652 (emit-ea segment src
(reg-tn-encoding dst
)))))
1654 (defun emit-bit-test-and-mumble (segment src index opcode
)
1655 (let ((size (operand-size src
)))
1656 (when (eq size
:byte
)
1657 (error "can't scan bytes: ~S" src
))
1658 (maybe-emit-operand-size-prefix segment size
)
1659 (emit-byte segment
#b00001111
)
1660 (cond ((integerp index
)
1661 (emit-byte segment
#b10111010
)
1662 (emit-ea segment src opcode
)
1663 (emit-byte segment index
))
1665 (emit-byte segment
(dpb opcode
(byte 3 3) #b10000011
))
1666 (emit-ea segment src
(reg-tn-encoding index
))))))
1668 (eval-when (:compile-toplevel
:execute
)
1669 (defun bit-test-inst-printer-list (subop)
1670 `((ext-reg/mem-imm
((op (#b1011101
,subop
))
1671 (reg/mem nil
:type word-reg
/mem
)
1672 (imm nil
:type imm-data
)
1674 (ext-reg-reg/mem
((op ,(dpb subop
(byte 3 2) #b1000001
))
1676 (:name
:tab reg
/mem
", " reg
)))))
1678 (define-instruction bt
(segment src index
)
1679 (:printer-list
(bit-test-inst-printer-list #b100
))
1681 (emit-bit-test-and-mumble segment src index
#b100
)))
1683 (define-instruction btc
(segment src index
)
1684 (:printer-list
(bit-test-inst-printer-list #b111
))
1686 (emit-bit-test-and-mumble segment src index
#b111
)))
1688 (define-instruction btr
(segment src index
)
1689 (:printer-list
(bit-test-inst-printer-list #b110
))
1691 (emit-bit-test-and-mumble segment src index
#b110
)))
1693 (define-instruction bts
(segment src index
)
1694 (:printer-list
(bit-test-inst-printer-list #b101
))
1696 (emit-bit-test-and-mumble segment src index
#b101
)))
1699 ;;;; control transfer
1701 (define-instruction call
(segment where
)
1702 (:printer near-jump
((op #b11101000
)))
1703 (:printer reg
/mem
((op '(#b1111111
#b010
)) (width 1)))
1707 (emit-byte segment
#b11101000
)
1708 (emit-back-patch segment
1710 (lambda (segment posn
)
1712 (- (label-position where
)
1715 (emit-byte segment
#b11101000
)
1716 (emit-relative-fixup segment where
))
1718 (emit-byte segment
#b11111111
)
1719 (emit-ea segment where
#b010
)))))
1721 (defun emit-byte-displacement-backpatch (segment target
)
1722 (emit-back-patch segment
1724 (lambda (segment posn
)
1725 (let ((disp (- (label-position target
) (1+ posn
))))
1726 (aver (<= -
128 disp
127))
1727 (emit-byte segment disp
)))))
1729 (define-instruction jmp
(segment cond
&optional where
)
1730 ;; conditional jumps
1731 (:printer short-cond-jump
((op #b0111
)) '('j cc
:tab label
))
1732 (:printer near-cond-jump
() '('j cc
:tab label
))
1733 ;; unconditional jumps
1734 (:printer short-jump
((op #b1011
)))
1735 (:printer near-jump
((op #b11101001
)) )
1736 (:printer reg
/mem
((op '(#b1111111
#b100
)) (width 1)))
1741 (lambda (segment posn delta-if-after
)
1742 (let ((disp (- (label-position where posn delta-if-after
)
1744 (when (<= -
128 disp
127)
1746 (dpb (conditional-opcode cond
)
1749 (emit-byte-displacement-backpatch segment where
)
1751 (lambda (segment posn
)
1752 (let ((disp (- (label-position where
) (+ posn
6))))
1753 (emit-byte segment
#b00001111
)
1755 (dpb (conditional-opcode cond
)
1758 (emit-dword segment disp
)))))
1759 ((label-p (setq where cond
))
1762 (lambda (segment posn delta-if-after
)
1763 (let ((disp (- (label-position where posn delta-if-after
)
1765 (when (<= -
128 disp
127)
1766 (emit-byte segment
#b11101011
)
1767 (emit-byte-displacement-backpatch segment where
)
1769 (lambda (segment posn
)
1770 (let ((disp (- (label-position where
) (+ posn
5))))
1771 (emit-byte segment
#b11101001
)
1772 (emit-dword segment disp
)))))
1774 (emit-byte segment
#b11101001
)
1775 (emit-relative-fixup segment where
))
1777 (unless (or (ea-p where
) (tn-p where
))
1778 (error "don't know what to do with ~A" where
))
1779 (emit-byte segment
#b11111111
)
1780 (emit-ea segment where
#b100
)))))
1782 (define-instruction jmp-short
(segment label
)
1784 (emit-byte segment
#b11101011
)
1785 (emit-byte-displacement-backpatch segment label
)))
1787 (define-instruction ret
(segment &optional stack-delta
)
1788 (:printer byte
((op #b11000011
)))
1789 (:printer byte
((op #b11000010
) (imm nil
:type
'imm-word-16
))
1793 (emit-byte segment
#b11000010
)
1794 (emit-word segment stack-delta
))
1796 (emit-byte segment
#b11000011
)))))
1798 (define-instruction jecxz
(segment target
)
1799 (:printer short-jump
((op #b0011
)))
1801 (emit-byte segment
#b11100011
)
1802 (emit-byte-displacement-backpatch segment target
)))
1804 (define-instruction loop
(segment target
)
1805 (:printer short-jump
((op #b0010
)))
1807 (emit-byte segment
#b11100010
) ; pfw this was 11100011, or jecxz!!!!
1808 (emit-byte-displacement-backpatch segment target
)))
1810 (define-instruction loopz
(segment target
)
1811 (:printer short-jump
((op #b0001
)))
1813 (emit-byte segment
#b11100001
)
1814 (emit-byte-displacement-backpatch segment target
)))
1816 (define-instruction loopnz
(segment target
)
1817 (:printer short-jump
((op #b0000
)))
1819 (emit-byte segment
#b11100000
)
1820 (emit-byte-displacement-backpatch segment target
)))
1822 ;;;; conditional move
1823 (define-instruction cmov
(segment cond dst src
)
1824 (:printer cond-move
())
1826 (aver (register-p dst
))
1827 (let ((size (matching-operand-size dst src
)))
1828 (aver (or (eq size
:word
) (eq size
:dword
)))
1829 (maybe-emit-operand-size-prefix segment size
))
1830 (emit-byte segment
#b00001111
)
1831 (emit-byte segment
(dpb (conditional-opcode cond
) (byte 4 0) #b01000000
))
1832 (emit-ea segment src
(reg-tn-encoding dst
))))
1834 ;;;; conditional byte set
1836 (define-instruction set
(segment dst cond
)
1837 (:printer cond-set
())
1839 (emit-byte segment
#b00001111
)
1840 (emit-byte segment
(dpb (conditional-opcode cond
) (byte 4 0) #b10010000
))
1841 (emit-ea segment dst
#b000
)))
1845 (define-instruction enter
(segment disp
&optional
(level 0))
1846 (:declare
(type (unsigned-byte 16) disp
)
1847 (type (unsigned-byte 8) level
))
1848 (:printer enter-format
((op #b11001000
)))
1850 (emit-byte segment
#b11001000
)
1851 (emit-word segment disp
)
1852 (emit-byte segment level
)))
1854 (define-instruction leave
(segment)
1855 (:printer byte
((op #b11001001
)))
1857 (emit-byte segment
#b11001001
)))
1860 (define-instruction prefetchnta
(segment ea
)
1861 (:printer prefetch
((op #b00011000
) (reg #b000
)))
1863 (aver (typep ea
'ea
))
1864 (aver (eq :byte
(ea-size ea
)))
1865 (emit-byte segment
#b00001111
)
1866 (emit-byte segment
#b00011000
)
1867 (emit-ea segment ea
#b000
)))
1869 (define-instruction prefetcht0
(segment ea
)
1870 (:printer prefetch
((op #b00011000
) (reg #b001
)))
1872 (aver (typep ea
'ea
))
1873 (aver (eq :byte
(ea-size ea
)))
1874 (emit-byte segment
#b00001111
)
1875 (emit-byte segment
#b00011000
)
1876 (emit-ea segment ea
#b001
)))
1878 (define-instruction prefetcht1
(segment ea
)
1879 (:printer prefetch
((op #b00011000
) (reg #b010
)))
1881 (aver (typep ea
'ea
))
1882 (aver (eq :byte
(ea-size ea
)))
1883 (emit-byte segment
#b00001111
)
1884 (emit-byte segment
#b00011000
)
1885 (emit-ea segment ea
#b010
)))
1887 (define-instruction prefetcht2
(segment ea
)
1888 (:printer prefetch
((op #b00011000
) (reg #b011
)))
1890 (aver (typep ea
'ea
))
1891 (aver (eq :byte
(ea-size ea
)))
1892 (emit-byte segment
#b00001111
)
1893 (emit-byte segment
#b00011000
)
1894 (emit-ea segment ea
#b011
)))
1896 ;;;; interrupt instructions
1898 (defun snarf-error-junk (sap offset
&optional length-only
)
1899 (let* ((length (sb!sys
:sap-ref-8 sap offset
))
1900 (vector (make-array length
:element-type
'(unsigned-byte 8))))
1901 (declare (type sb
!sys
:system-area-pointer sap
)
1902 (type (unsigned-byte 8) length
)
1903 (type (simple-array (unsigned-byte 8) (*)) vector
))
1905 (values 0 (1+ length
) nil nil
))
1907 (sb!kernel
:copy-ub8-from-system-area sap
(1+ offset
)
1909 (collect ((sc-offsets)
1911 (lengths 1) ; the length byte
1913 (error-number (sb!c
:read-var-integer vector index
)))
1916 (when (>= index length
)
1918 (let ((old-index index
))
1919 (sc-offsets (sb!c
:read-var-integer vector index
))
1920 (lengths (- index old-index
))))
1921 (values error-number
1927 (defmacro break-cases
(breaknum &body cases
)
1928 (let ((bn-temp (gensym)))
1929 (collect ((clauses))
1930 (dolist (case cases
)
1931 (clauses `((= ,bn-temp
,(car case
)) ,@(cdr case
))))
1932 `(let ((,bn-temp
,breaknum
))
1933 (cond ,@(clauses))))))
1936 (defun break-control (chunk inst stream dstate
)
1937 (declare (ignore inst
))
1938 (flet ((nt (x) (if stream
(sb!disassem
:note x dstate
))))
1939 ;; FIXME: Make sure that BYTE-IMM-CODE is defined. The genesis
1940 ;; map has it undefined; and it should be easier to look in the target
1941 ;; Lisp (with (DESCRIBE 'BYTE-IMM-CODE)) than to definitively deduce
1942 ;; from first principles whether it's defined in some way that genesis
1944 (case (byte-imm-code chunk dstate
)
1947 (sb!disassem
:handle-break-args
#'snarf-error-junk stream dstate
))
1950 (sb!disassem
:handle-break-args
#'snarf-error-junk stream dstate
))
1952 (nt "breakpoint trap"))
1953 (#.pending-interrupt-trap
1954 (nt "pending interrupt trap"))
1957 (#.fun-end-breakpoint-trap
1958 (nt "function end breakpoint trap")))))
1960 (define-instruction break
(segment code
)
1961 (:declare
(type (unsigned-byte 8) code
))
1962 (:printer byte-imm
((op #b11001100
)) '(:name
:tab code
)
1963 :control
#'break-control
)
1965 (emit-byte segment
#b11001100
)
1966 (emit-byte segment code
)))
1968 (define-instruction int
(segment number
)
1969 (:declare
(type (unsigned-byte 8) number
))
1970 (:printer byte-imm
((op #b11001101
)))
1974 (emit-byte segment
#b11001100
))
1976 (emit-byte segment
#b11001101
)
1977 (emit-byte segment number
)))))
1979 (define-instruction into
(segment)
1980 (:printer byte
((op #b11001110
)))
1982 (emit-byte segment
#b11001110
)))
1984 (define-instruction bound
(segment reg bounds
)
1986 (let ((size (matching-operand-size reg bounds
)))
1987 (when (eq size
:byte
)
1988 (error "can't bounds-test bytes: ~S" reg
))
1989 (maybe-emit-operand-size-prefix segment size
)
1990 (emit-byte segment
#b01100010
)
1991 (emit-ea segment bounds
(reg-tn-encoding reg
)))))
1993 (define-instruction iret
(segment)
1994 (:printer byte
((op #b11001111
)))
1996 (emit-byte segment
#b11001111
)))
1998 ;;;; processor control
2000 (define-instruction hlt
(segment)
2001 (:printer byte
((op #b11110100
)))
2003 (emit-byte segment
#b11110100
)))
2005 (define-instruction nop
(segment)
2006 (:printer byte
((op #b10010000
)))
2008 (emit-byte segment
#b10010000
)))
2010 (define-instruction wait
(segment)
2011 (:printer byte
((op #b10011011
)))
2013 (emit-byte segment
#b10011011
)))
2015 (define-instruction lock
(segment)
2016 (:printer byte
((op #b11110000
)))
2018 (emit-byte segment
#b11110000
)))
2020 ;;;; miscellaneous hackery
2022 (define-instruction byte
(segment byte
)
2024 (emit-byte segment byte
)))
2026 (define-instruction word
(segment word
)
2028 (emit-word segment word
)))
2030 (define-instruction dword
(segment dword
)
2032 (emit-dword segment dword
)))
2034 (defun emit-header-data (segment type
)
2035 (emit-back-patch segment
2037 (lambda (segment posn
)
2041 (component-header-length))
2045 (define-instruction simple-fun-header-word
(segment)
2047 (emit-header-data segment simple-fun-header-widetag
)))
2049 (define-instruction lra-header-word
(segment)
2051 (emit-header-data segment return-pc-header-widetag
)))
2054 ;;;; SSE instructions
2056 ;;;; Automatically generated
2059 (DEFINE-INSTRUCTION ADDPS
2061 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2062 (EMIT-BYTE SEGMENT
88)
2063 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2065 (DEFINE-INSTRUCTION ADDSUBPS
2067 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2068 (EMIT-BYTE SEGMENT
15)
2069 (EMIT-BYTE SEGMENT
208)
2070 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2072 (DEFINE-INSTRUCTION ANDNPS
2074 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2075 (EMIT-BYTE SEGMENT
85)
2076 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2078 (DEFINE-INSTRUCTION ANDPS
2080 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2081 (EMIT-BYTE SEGMENT
84)
2082 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2084 (DEFINE-INSTRUCTION DIVPS
2086 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2087 (EMIT-BYTE SEGMENT
94)
2088 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2090 (DEFINE-INSTRUCTION HADDPS
2092 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2093 (EMIT-BYTE SEGMENT
15)
2094 (EMIT-BYTE SEGMENT
124)
2095 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2097 (DEFINE-INSTRUCTION HSUBPS
2099 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2100 (EMIT-BYTE SEGMENT
15)
2101 (EMIT-BYTE SEGMENT
125)
2102 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2104 (DEFINE-INSTRUCTION MAXPS
2106 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2107 (EMIT-BYTE SEGMENT
95)
2108 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2110 (DEFINE-INSTRUCTION MINPS
2112 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2113 (EMIT-BYTE SEGMENT
93)
2114 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2116 (DEFINE-INSTRUCTION MULPS
2118 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2119 (EMIT-BYTE SEGMENT
89)
2120 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2122 (DEFINE-INSTRUCTION ORPS
2124 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2125 (EMIT-BYTE SEGMENT
86)
2126 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2128 (DEFINE-INSTRUCTION RCPPS
2130 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2131 (EMIT-BYTE SEGMENT
83)
2132 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2134 (DEFINE-INSTRUCTION RSQRTPS
2136 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2137 (EMIT-BYTE SEGMENT
82)
2138 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2140 (DEFINE-INSTRUCTION SQRTPS
2142 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2143 (EMIT-BYTE SEGMENT
81)
2144 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2146 (DEFINE-INSTRUCTION SUBPS
2148 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2149 (EMIT-BYTE SEGMENT
92)
2150 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2152 (DEFINE-INSTRUCTION UNPCKHPS
2154 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2155 (EMIT-BYTE SEGMENT
21)
2156 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2158 (DEFINE-INSTRUCTION UNPCKLPS
2160 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2161 (EMIT-BYTE SEGMENT
20)
2162 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2164 (DEFINE-INSTRUCTION XORPS
2166 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2167 (EMIT-BYTE SEGMENT
87)
2168 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2170 (DEFINE-INSTRUCTION ADDPD
2172 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2173 (EMIT-BYTE SEGMENT
15)
2174 (EMIT-BYTE SEGMENT
88)
2175 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2177 (DEFINE-INSTRUCTION ADDSUBPD
2179 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2180 (EMIT-BYTE SEGMENT
15)
2181 (EMIT-BYTE SEGMENT
208)
2182 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2184 (DEFINE-INSTRUCTION ANDNPD
2186 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2187 (EMIT-BYTE SEGMENT
15)
2188 (EMIT-BYTE SEGMENT
85)
2189 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2191 (DEFINE-INSTRUCTION ANDPD
2193 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2194 (EMIT-BYTE SEGMENT
15)
2195 (EMIT-BYTE SEGMENT
84)
2196 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2198 (DEFINE-INSTRUCTION DIVPD
2200 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2201 (EMIT-BYTE SEGMENT
15)
2202 (EMIT-BYTE SEGMENT
94)
2203 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2205 (DEFINE-INSTRUCTION HADDPD
2207 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2208 (EMIT-BYTE SEGMENT
15)
2209 (EMIT-BYTE SEGMENT
124)
2210 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2212 (DEFINE-INSTRUCTION HSUBPD
2214 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2215 (EMIT-BYTE SEGMENT
15)
2216 (EMIT-BYTE SEGMENT
125)
2217 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2219 (DEFINE-INSTRUCTION MAXPD
2221 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2222 (EMIT-BYTE SEGMENT
15)
2223 (EMIT-BYTE SEGMENT
95)
2224 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2226 (DEFINE-INSTRUCTION MINPD
2228 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2229 (EMIT-BYTE SEGMENT
15)
2230 (EMIT-BYTE SEGMENT
93)
2231 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2233 (DEFINE-INSTRUCTION MULPD
2235 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2236 (EMIT-BYTE SEGMENT
15)
2237 (EMIT-BYTE SEGMENT
89)
2238 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2240 (DEFINE-INSTRUCTION ORPD
2242 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2243 (EMIT-BYTE SEGMENT
15)
2244 (EMIT-BYTE SEGMENT
86)
2245 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2247 (DEFINE-INSTRUCTION SQRTPD
2249 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2250 (EMIT-BYTE SEGMENT
15)
2251 (EMIT-BYTE SEGMENT
81)
2252 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2254 (DEFINE-INSTRUCTION SUBPD
2256 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2257 (EMIT-BYTE SEGMENT
15)
2258 (EMIT-BYTE SEGMENT
92)
2259 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2261 (DEFINE-INSTRUCTION UNPCKHPD
2263 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2264 (EMIT-BYTE SEGMENT
15)
2265 (EMIT-BYTE SEGMENT
21)
2266 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2268 (DEFINE-INSTRUCTION UNPCKLPD
2270 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2271 (EMIT-BYTE SEGMENT
15)
2272 (EMIT-BYTE SEGMENT
20)
2273 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2275 (DEFINE-INSTRUCTION XORPD
2277 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2278 (EMIT-BYTE SEGMENT
15)
2279 (EMIT-BYTE SEGMENT
87)
2280 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2282 (DEFINE-INSTRUCTION ADDSD
2284 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2285 (EMIT-BYTE SEGMENT
15)
2286 (EMIT-BYTE SEGMENT
88)
2287 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2289 (DEFINE-INSTRUCTION COMISD
2291 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2292 (EMIT-BYTE SEGMENT
15)
2293 (EMIT-BYTE SEGMENT
47)
2294 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2296 (DEFINE-INSTRUCTION DIVSD
2298 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2299 (EMIT-BYTE SEGMENT
15)
2300 (EMIT-BYTE SEGMENT
94)
2301 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2303 (DEFINE-INSTRUCTION MAXSD
2305 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2306 (EMIT-BYTE SEGMENT
15)
2307 (EMIT-BYTE SEGMENT
95)
2308 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2310 (DEFINE-INSTRUCTION MINSD
2312 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2313 (EMIT-BYTE SEGMENT
15)
2314 (EMIT-BYTE SEGMENT
93)
2315 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2317 (DEFINE-INSTRUCTION MULSD
2319 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2320 (EMIT-BYTE SEGMENT
15)
2321 (EMIT-BYTE SEGMENT
89)
2322 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2324 (DEFINE-INSTRUCTION SQRTSD
2326 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2327 (EMIT-BYTE SEGMENT
15)
2328 (EMIT-BYTE SEGMENT
81)
2329 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2331 (DEFINE-INSTRUCTION SUBSD
2333 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2334 (EMIT-BYTE SEGMENT
15)
2335 (EMIT-BYTE SEGMENT
92)
2336 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2338 (DEFINE-INSTRUCTION UCOMISD
2340 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2341 (EMIT-BYTE SEGMENT
15)
2342 (EMIT-BYTE SEGMENT
46)
2343 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2345 (DEFINE-INSTRUCTION ADDSS
2347 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2348 (EMIT-BYTE SEGMENT
15)
2349 (EMIT-BYTE SEGMENT
88)
2350 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2352 (DEFINE-INSTRUCTION COMISS
2354 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2355 (EMIT-BYTE SEGMENT
47)
2356 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2358 (DEFINE-INSTRUCTION DIVSS
2360 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2361 (EMIT-BYTE SEGMENT
15)
2362 (EMIT-BYTE SEGMENT
94)
2363 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2365 (DEFINE-INSTRUCTION MAXSS
2367 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2368 (EMIT-BYTE SEGMENT
15)
2369 (EMIT-BYTE SEGMENT
95)
2370 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2372 (DEFINE-INSTRUCTION MINSS
2374 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2375 (EMIT-BYTE SEGMENT
15)
2376 (EMIT-BYTE SEGMENT
93)
2377 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2379 (DEFINE-INSTRUCTION MULSS
2381 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2382 (EMIT-BYTE SEGMENT
15)
2383 (EMIT-BYTE SEGMENT
89)
2384 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2386 (DEFINE-INSTRUCTION RCPSS
2388 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2389 (EMIT-BYTE SEGMENT
15)
2390 (EMIT-BYTE SEGMENT
83)
2391 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2393 (DEFINE-INSTRUCTION RSQRTSS
2395 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2396 (EMIT-BYTE SEGMENT
15)
2397 (EMIT-BYTE SEGMENT
82)
2398 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2400 (DEFINE-INSTRUCTION SQRTSS
2402 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2403 (EMIT-BYTE SEGMENT
15)
2404 (EMIT-BYTE SEGMENT
81)
2405 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2407 (DEFINE-INSTRUCTION SUBSS
2409 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2410 (EMIT-BYTE SEGMENT
15)
2411 (EMIT-BYTE SEGMENT
92)
2412 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2414 (DEFINE-INSTRUCTION UCOMISS
2416 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2417 (EMIT-BYTE SEGMENT
46)
2418 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2420 (DEFINE-INSTRUCTION PACKSSDW
2422 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2423 (EMIT-BYTE SEGMENT
15)
2424 (EMIT-BYTE SEGMENT
107)
2425 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2427 (DEFINE-INSTRUCTION PACKSSWB
2429 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2430 (EMIT-BYTE SEGMENT
15)
2431 (EMIT-BYTE SEGMENT
99)
2432 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2434 (DEFINE-INSTRUCTION PACKUSWB
2436 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2437 (EMIT-BYTE SEGMENT
15)
2438 (EMIT-BYTE SEGMENT
103)
2439 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2441 (DEFINE-INSTRUCTION PADDB
2443 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2444 (EMIT-BYTE SEGMENT
15)
2445 (EMIT-BYTE SEGMENT
252)
2446 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2448 (DEFINE-INSTRUCTION PADDD
2450 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2451 (EMIT-BYTE SEGMENT
15)
2452 (EMIT-BYTE SEGMENT
254)
2453 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2455 (DEFINE-INSTRUCTION PADDQ
2457 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2458 (EMIT-BYTE SEGMENT
15)
2459 (EMIT-BYTE SEGMENT
212)
2460 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2462 (DEFINE-INSTRUCTION PADDSB
2464 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2465 (EMIT-BYTE SEGMENT
15)
2466 (EMIT-BYTE SEGMENT
236)
2467 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2469 (DEFINE-INSTRUCTION PADDSW
2471 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2472 (EMIT-BYTE SEGMENT
15)
2473 (EMIT-BYTE SEGMENT
237)
2474 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2476 (DEFINE-INSTRUCTION PADDUSB
2478 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2479 (EMIT-BYTE SEGMENT
15)
2480 (EMIT-BYTE SEGMENT
220)
2481 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2483 (DEFINE-INSTRUCTION PADDUSW
2485 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2486 (EMIT-BYTE SEGMENT
15)
2487 (EMIT-BYTE SEGMENT
221)
2488 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2490 (DEFINE-INSTRUCTION PADDW
2492 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2493 (EMIT-BYTE SEGMENT
15)
2494 (EMIT-BYTE SEGMENT
253)
2495 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2497 (DEFINE-INSTRUCTION PAND
2499 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2500 (EMIT-BYTE SEGMENT
15)
2501 (EMIT-BYTE SEGMENT
219)
2502 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2504 (DEFINE-INSTRUCTION PANDN
2506 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2507 (EMIT-BYTE SEGMENT
15)
2508 (EMIT-BYTE SEGMENT
223)
2509 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2511 (DEFINE-INSTRUCTION PAVGB
2513 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2514 (EMIT-BYTE SEGMENT
15)
2515 (EMIT-BYTE SEGMENT
224)
2516 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2518 (DEFINE-INSTRUCTION PAVGW
2520 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2521 (EMIT-BYTE SEGMENT
15)
2522 (EMIT-BYTE SEGMENT
227)
2523 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2525 (DEFINE-INSTRUCTION PCMPEQB
2527 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2528 (EMIT-BYTE SEGMENT
15)
2529 (EMIT-BYTE SEGMENT
116)
2530 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2532 (DEFINE-INSTRUCTION PCMPEQD
2534 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2535 (EMIT-BYTE SEGMENT
15)
2536 (EMIT-BYTE SEGMENT
118)
2537 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2539 (DEFINE-INSTRUCTION PCMPEQW
2541 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2542 (EMIT-BYTE SEGMENT
15)
2543 (EMIT-BYTE SEGMENT
117)
2544 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2546 (DEFINE-INSTRUCTION PCMPGTB
2548 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2549 (EMIT-BYTE SEGMENT
15)
2550 (EMIT-BYTE SEGMENT
100)
2551 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2553 (DEFINE-INSTRUCTION PCMPGTD
2555 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2556 (EMIT-BYTE SEGMENT
15)
2557 (EMIT-BYTE SEGMENT
102)
2558 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2560 (DEFINE-INSTRUCTION PCMPGTW
2562 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2563 (EMIT-BYTE SEGMENT
15)
2564 (EMIT-BYTE SEGMENT
101)
2565 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2567 (DEFINE-INSTRUCTION PMADDWD
2569 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2570 (EMIT-BYTE SEGMENT
15)
2571 (EMIT-BYTE SEGMENT
245)
2572 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2574 (DEFINE-INSTRUCTION PMAXSW
2576 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2577 (EMIT-BYTE SEGMENT
15)
2578 (EMIT-BYTE SEGMENT
238)
2579 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2581 (DEFINE-INSTRUCTION PMAXUB
2583 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2584 (EMIT-BYTE SEGMENT
15)
2585 (EMIT-BYTE SEGMENT
222)
2586 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2588 (DEFINE-INSTRUCTION PMINSW
2590 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2591 (EMIT-BYTE SEGMENT
15)
2592 (EMIT-BYTE SEGMENT
234)
2593 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2595 (DEFINE-INSTRUCTION PMINUB
2597 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2598 (EMIT-BYTE SEGMENT
15)
2599 (EMIT-BYTE SEGMENT
218)
2600 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2602 (DEFINE-INSTRUCTION PMOVMSKB
2604 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2605 (EMIT-BYTE SEGMENT
15)
2606 (EMIT-BYTE SEGMENT
215)
2607 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2609 (DEFINE-INSTRUCTION PMULHUW
2611 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2612 (EMIT-BYTE SEGMENT
15)
2613 (EMIT-BYTE SEGMENT
228)
2614 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2616 (DEFINE-INSTRUCTION PMULHW
2618 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2619 (EMIT-BYTE SEGMENT
15)
2620 (EMIT-BYTE SEGMENT
229)
2621 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2623 (DEFINE-INSTRUCTION PMULLW
2625 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2626 (EMIT-BYTE SEGMENT
15)
2627 (EMIT-BYTE SEGMENT
213)
2628 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2630 (DEFINE-INSTRUCTION PMULUDQ
2632 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2633 (EMIT-BYTE SEGMENT
15)
2634 (EMIT-BYTE SEGMENT
244)
2635 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2637 (DEFINE-INSTRUCTION POR
2639 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2640 (EMIT-BYTE SEGMENT
15)
2641 (EMIT-BYTE SEGMENT
235)
2642 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2644 (DEFINE-INSTRUCTION PSADBW
2646 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2647 (EMIT-BYTE SEGMENT
15)
2648 (EMIT-BYTE SEGMENT
246)
2649 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2651 (DEFINE-INSTRUCTION PSSLD
2653 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2654 (EMIT-BYTE SEGMENT
15)
2655 (EMIT-BYTE SEGMENT
242)
2656 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2658 (DEFINE-INSTRUCTION PSLLQ
2660 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2661 (EMIT-BYTE SEGMENT
15)
2662 (EMIT-BYTE SEGMENT
243)
2663 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2665 (DEFINE-INSTRUCTION PSLLW
2667 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2668 (EMIT-BYTE SEGMENT
15)
2669 (EMIT-BYTE SEGMENT
241)
2670 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2672 (DEFINE-INSTRUCTION PSRAD
2674 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2675 (EMIT-BYTE SEGMENT
15)
2676 (EMIT-BYTE SEGMENT
226)
2677 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2679 (DEFINE-INSTRUCTION PSRAW
2681 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2682 (EMIT-BYTE SEGMENT
15)
2683 (EMIT-BYTE SEGMENT
226)
2684 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2686 (DEFINE-INSTRUCTION PSRLD
2688 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2689 (EMIT-BYTE SEGMENT
15)
2690 (EMIT-BYTE SEGMENT
210)
2691 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2693 (DEFINE-INSTRUCTION PSRLQ
2695 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2696 (EMIT-BYTE SEGMENT
15)
2697 (EMIT-BYTE SEGMENT
211)
2698 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2700 (DEFINE-INSTRUCTION PSRLW
2702 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2703 (EMIT-BYTE SEGMENT
15)
2704 (EMIT-BYTE SEGMENT
209)
2705 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2707 (DEFINE-INSTRUCTION PSUBB
2709 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2710 (EMIT-BYTE SEGMENT
15)
2711 (EMIT-BYTE SEGMENT
248)
2712 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2714 (DEFINE-INSTRUCTION PSUBD
2716 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2717 (EMIT-BYTE SEGMENT
15)
2718 (EMIT-BYTE SEGMENT
250)
2719 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2721 (DEFINE-INSTRUCTION PSUBQ
2723 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2724 (EMIT-BYTE SEGMENT
15)
2725 (EMIT-BYTE SEGMENT
251)
2726 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2728 (DEFINE-INSTRUCTION PSUBSB
2730 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2731 (EMIT-BYTE SEGMENT
15)
2732 (EMIT-BYTE SEGMENT
232)
2733 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2735 (DEFINE-INSTRUCTION PSUBSW
2737 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2738 (EMIT-BYTE SEGMENT
15)
2739 (EMIT-BYTE SEGMENT
233)
2740 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2742 (DEFINE-INSTRUCTION PSUBUSB
2744 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2745 (EMIT-BYTE SEGMENT
15)
2746 (EMIT-BYTE SEGMENT
216)
2747 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2749 (DEFINE-INSTRUCTION PSUBUSW
2751 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2752 (EMIT-BYTE SEGMENT
15)
2753 (EMIT-BYTE SEGMENT
217)
2754 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2756 (DEFINE-INSTRUCTION PSUBW
2758 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2759 (EMIT-BYTE SEGMENT
15)
2760 (EMIT-BYTE SEGMENT
249)
2761 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2763 (DEFINE-INSTRUCTION PUNPCKHBW
2765 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2766 (EMIT-BYTE SEGMENT
15)
2767 (EMIT-BYTE SEGMENT
104)
2768 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2770 (DEFINE-INSTRUCTION PUNPCKHDQ
2772 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2773 (EMIT-BYTE SEGMENT
15)
2774 (EMIT-BYTE SEGMENT
106)
2775 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2777 (DEFINE-INSTRUCTION PUNPCKHQDQ
2779 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2780 (EMIT-BYTE SEGMENT
15)
2781 (EMIT-BYTE SEGMENT
109)
2782 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2784 (DEFINE-INSTRUCTION PUNPCKHWD
2786 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2787 (EMIT-BYTE SEGMENT
15)
2788 (EMIT-BYTE SEGMENT
105)
2789 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2791 (DEFINE-INSTRUCTION PUNPCKLBW
2793 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2794 (EMIT-BYTE SEGMENT
15)
2795 (EMIT-BYTE SEGMENT
96)
2796 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2798 (DEFINE-INSTRUCTION PUNPCKLDQ
2800 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2801 (EMIT-BYTE SEGMENT
15)
2802 (EMIT-BYTE SEGMENT
98)
2803 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2805 (DEFINE-INSTRUCTION PUNPCKLQDQ
2807 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2808 (EMIT-BYTE SEGMENT
15)
2809 (EMIT-BYTE SEGMENT
108)
2810 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2812 (DEFINE-INSTRUCTION PUNPCKLWD
2814 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2815 (EMIT-BYTE SEGMENT
15)
2816 (EMIT-BYTE SEGMENT
97)
2817 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2819 (DEFINE-INSTRUCTION PXOR
2821 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2822 (EMIT-BYTE SEGMENT
15)
2823 (EMIT-BYTE SEGMENT
239)
2824 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2826 (DEFINE-INSTRUCTION CVTDQ2PD
2828 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2829 (EMIT-BYTE SEGMENT
15)
2830 (EMIT-BYTE SEGMENT
230)
2831 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2833 (DEFINE-INSTRUCTION CVTDQ2PS
2835 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2836 (EMIT-BYTE SEGMENT
91)
2837 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2839 (DEFINE-INSTRUCTION CVTPD2DQ
2841 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2842 (EMIT-BYTE SEGMENT
15)
2843 (EMIT-BYTE SEGMENT
230)
2844 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2846 (DEFINE-INSTRUCTION CVTPD2PI
2848 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2849 (EMIT-BYTE SEGMENT
15)
2850 (EMIT-BYTE SEGMENT
45)
2851 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2853 (DEFINE-INSTRUCTION CVTPD2PS
2855 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2856 (EMIT-BYTE SEGMENT
15)
2857 (EMIT-BYTE SEGMENT
90)
2858 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2860 (DEFINE-INSTRUCTION CVTPI2PD
2862 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2863 (EMIT-BYTE SEGMENT
15)
2864 (EMIT-BYTE SEGMENT
42)
2865 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2867 (DEFINE-INSTRUCTION CVTPI2PS
2869 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2870 (EMIT-BYTE SEGMENT
42)
2871 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2873 (DEFINE-INSTRUCTION CVTPS2DQ
2875 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2876 (EMIT-BYTE SEGMENT
15)
2877 (EMIT-BYTE SEGMENT
91)
2878 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2880 (DEFINE-INSTRUCTION CVTPS2PD
2882 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2883 (EMIT-BYTE SEGMENT
90)
2884 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2886 (DEFINE-INSTRUCTION CVTPS2PI
2888 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2889 (EMIT-BYTE SEGMENT
45)
2890 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2892 (DEFINE-INSTRUCTION CVTSD2SI
2894 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2895 (EMIT-BYTE SEGMENT
15)
2896 (EMIT-BYTE SEGMENT
45)
2897 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2899 (DEFINE-INSTRUCTION CVTSD2SS
2901 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2902 (EMIT-BYTE SEGMENT
15)
2903 (EMIT-BYTE SEGMENT
90)
2904 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2906 (DEFINE-INSTRUCTION CVTSI2SD
2908 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2909 (EMIT-BYTE SEGMENT
15)
2910 (EMIT-BYTE SEGMENT
42)
2911 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2913 (DEFINE-INSTRUCTION CVTSI2SS
2915 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2916 (EMIT-BYTE SEGMENT
15)
2917 (EMIT-BYTE SEGMENT
42)
2918 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2920 (DEFINE-INSTRUCTION CVTSS2SD
2922 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2923 (EMIT-BYTE SEGMENT
15)
2924 (EMIT-BYTE SEGMENT
90)
2925 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2927 (DEFINE-INSTRUCTION CVTSS2SI
2929 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2930 (EMIT-BYTE SEGMENT
15)
2931 (EMIT-BYTE SEGMENT
45)
2932 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2934 (DEFINE-INSTRUCTION CVTTPD2DQ
2936 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2937 (EMIT-BYTE SEGMENT
15)
2938 (EMIT-BYTE SEGMENT
230)
2939 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2941 (DEFINE-INSTRUCTION CVTTPD2PI
2943 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2944 (EMIT-BYTE SEGMENT
15)
2945 (EMIT-BYTE SEGMENT
44)
2946 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2948 (DEFINE-INSTRUCTION CVTTPS2DQ
2950 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2951 (EMIT-BYTE SEGMENT
15)
2952 (EMIT-BYTE SEGMENT
91)
2953 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2955 (DEFINE-INSTRUCTION CVTTPS2PI
2957 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2958 (EMIT-BYTE SEGMENT
44)
2959 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2961 (DEFINE-INSTRUCTION CVTTSD2SI
2963 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2964 (EMIT-BYTE SEGMENT
15)
2965 (EMIT-BYTE SEGMENT
44)
2966 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2968 (DEFINE-INSTRUCTION CVTTSS2SI
2970 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2971 (EMIT-BYTE SEGMENT
15)
2972 (EMIT-BYTE SEGMENT
44)
2973 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2975 (DEFINE-INSTRUCTION LDDQU
2977 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2978 (EMIT-BYTE SEGMENT
15)
2979 (EMIT-BYTE SEGMENT
240)
2980 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2982 (DEFINE-INSTRUCTION MASKMOVDQU
2984 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2985 (EMIT-BYTE SEGMENT
15)
2986 (EMIT-BYTE SEGMENT
247)
2987 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2989 (DEFINE-INSTRUCTION MOVDDUP
2991 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2992 (EMIT-BYTE SEGMENT
15)
2993 (EMIT-BYTE SEGMENT
18)
2994 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2996 (DEFINE-INSTRUCTION MOVHLPS
2998 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2999 (EMIT-BYTE SEGMENT
18)
3000 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3002 (DEFINE-INSTRUCTION MOVLHPS
3004 (:EMITTER
(EMIT-BYTE SEGMENT
15)
3005 (EMIT-BYTE SEGMENT
22)
3006 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3008 (DEFINE-INSTRUCTION MOVMSKPD
3010 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3011 (EMIT-BYTE SEGMENT
15)
3012 (EMIT-BYTE SEGMENT
80)
3013 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3015 (DEFINE-INSTRUCTION MOVMSKPS
3017 (:EMITTER
(EMIT-BYTE SEGMENT
15)
3018 (EMIT-BYTE SEGMENT
80)
3019 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3021 (DEFINE-INSTRUCTION MOVNTDQ
3023 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3024 (EMIT-BYTE SEGMENT
15)
3025 (EMIT-BYTE SEGMENT
231)
3026 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3028 (DEFINE-INSTRUCTION MOVNTPD
3030 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3031 (EMIT-BYTE SEGMENT
15)
3032 (EMIT-BYTE SEGMENT
43)
3033 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3035 (DEFINE-INSTRUCTION MOVNTPS
3037 (:EMITTER
(EMIT-BYTE SEGMENT
15)
3038 (EMIT-BYTE SEGMENT
43)
3039 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3041 (DEFINE-INSTRUCTION MOVSHDUP
3043 (:EMITTER
(EMIT-BYTE SEGMENT
243)
3044 (EMIT-BYTE SEGMENT
15)
3045 (EMIT-BYTE SEGMENT
22)
3046 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3048 (DEFINE-INSTRUCTION MOVSLDUP
3050 (:EMITTER
(EMIT-BYTE SEGMENT
243)
3051 (EMIT-BYTE SEGMENT
15)
3052 (EMIT-BYTE SEGMENT
18)
3053 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3055 (DEFINE-INSTRUCTION PEXTRW
3056 (SEGMENT DST SRC BYTE
)
3057 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3058 (EMIT-BYTE SEGMENT
15)
3059 (EMIT-BYTE SEGMENT
197)
3060 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3061 (EMIT-SIZED-IMMEDIATE SEGMENT
:BYTE BYTE
)))
3063 (DEFINE-INSTRUCTION PINSRW
3064 (SEGMENT DST SRC BYTE
)
3065 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3066 (EMIT-BYTE SEGMENT
15)
3067 (EMIT-BYTE SEGMENT
196)
3068 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3069 (EMIT-SIZED-IMMEDIATE SEGMENT
:BYTE BYTE
)))
3071 (DEFINE-INSTRUCTION PSHUFD
3072 (SEGMENT DST SRC BYTE
)
3073 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3074 (EMIT-BYTE SEGMENT
15)
3075 (EMIT-BYTE SEGMENT
112)
3076 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3077 (EMIT-SIZED-IMMEDIATE SEGMENT
:BYTE BYTE
)))
3079 (DEFINE-INSTRUCTION PSHUFHW
3080 (SEGMENT DST SRC BYTE
)
3081 (:EMITTER
(EMIT-BYTE SEGMENT
243)
3082 (EMIT-BYTE SEGMENT
15)
3083 (EMIT-BYTE SEGMENT
112)
3084 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3085 (EMIT-SIZED-IMMEDIATE SEGMENT
:BYTE BYTE
)))
3087 (DEFINE-INSTRUCTION PSHUFLW
3088 (SEGMENT DST SRC BYTE
)
3089 (:EMITTER
(EMIT-BYTE SEGMENT
242)
3090 (EMIT-BYTE SEGMENT
15)
3091 (EMIT-BYTE SEGMENT
112)
3092 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3093 (EMIT-SIZED-IMMEDIATE SEGMENT
:BYTE BYTE
)))
3095 (DEFINE-INSTRUCTION SHUFPD
3096 (SEGMENT DST SRC BYTE
)
3097 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3098 (EMIT-BYTE SEGMENT
15)
3099 (EMIT-BYTE SEGMENT
198)
3100 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3101 (EMIT-SIZED-IMMEDIATE SEGMENT
:BYTE BYTE
)))
3103 (DEFINE-INSTRUCTION SHUFPS
3104 (SEGMENT DST SRC BYTE
)
3105 (:EMITTER
(EMIT-BYTE SEGMENT
15)
3106 (EMIT-BYTE SEGMENT
198)
3107 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3108 (EMIT-SIZED-IMMEDIATE SEGMENT
:BYTE BYTE
)))
3110 (DEFINE-INSTRUCTION CMPPD
3111 (SEGMENT DST SRC COND
)
3112 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3113 (EMIT-BYTE SEGMENT
15)
3114 (EMIT-BYTE SEGMENT
194)
3115 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3116 (EMIT-SIZED-IMMEDIATE SEGMENT
3135 (DEFINE-INSTRUCTION CMPPS
3136 (SEGMENT DST SRC COND
)
3137 (:EMITTER
(EMIT-BYTE SEGMENT
15)
3138 (EMIT-BYTE SEGMENT
194)
3139 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3140 (EMIT-SIZED-IMMEDIATE SEGMENT
3159 (DEFINE-INSTRUCTION CMPSD
3160 (SEGMENT DST SRC COND
)
3161 (:EMITTER
(EMIT-BYTE SEGMENT
242)
3162 (EMIT-BYTE SEGMENT
15)
3163 (EMIT-BYTE SEGMENT
194)
3164 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3165 (EMIT-SIZED-IMMEDIATE SEGMENT
3184 (DEFINE-INSTRUCTION CMPSS
3185 (SEGMENT DST SRC COND
)
3186 (:EMITTER
(EMIT-BYTE SEGMENT
243)
3187 (EMIT-BYTE SEGMENT
15)
3188 (EMIT-BYTE SEGMENT
194)
3189 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3190 (EMIT-SIZED-IMMEDIATE SEGMENT
3209 (DEFINE-INSTRUCTION MOVAPD
3213 ((SSE-REGISTER-P DST
) (EMIT-BYTE SEGMENT
102)
3214 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
40)
3215 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3216 (T (EMIT-BYTE SEGMENT
102)
3217 (EMIT-BYTE SEGMENT
15)
3218 (EMIT-BYTE SEGMENT
41)
3219 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3221 (DEFINE-INSTRUCTION MOVAPS
3225 ((SSE-REGISTER-P DST
) (EMIT-BYTE SEGMENT
15)
3226 (EMIT-BYTE SEGMENT
40)
3227 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3228 (T (EMIT-BYTE SEGMENT
15)
3229 (EMIT-BYTE SEGMENT
41)
3230 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3232 (DEFINE-INSTRUCTION MOVD
3236 ((SSE-REGISTER-P DST
) (EMIT-BYTE SEGMENT
102)
3237 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
110)
3238 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3239 (T (EMIT-BYTE SEGMENT
102)
3240 (EMIT-BYTE SEGMENT
15)
3241 (EMIT-BYTE SEGMENT
126)
3242 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3244 (DEFINE-INSTRUCTION MOVDQA
3248 ((SSE-REGISTER-P DST
) (EMIT-BYTE SEGMENT
102)
3249 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
111)
3250 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3251 (T (EMIT-BYTE SEGMENT
102)
3252 (EMIT-BYTE SEGMENT
15)
3253 (EMIT-BYTE SEGMENT
127)
3254 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3256 (DEFINE-INSTRUCTION MOVDQU
3260 ((SSE-REGISTER-P DST
) (EMIT-BYTE SEGMENT
243)
3261 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
111)
3262 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3263 (T (EMIT-BYTE SEGMENT
243)
3264 (EMIT-BYTE SEGMENT
15)
3265 (EMIT-BYTE SEGMENT
127)
3266 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3268 (DEFINE-INSTRUCTION MOVHPD
3272 ((SSE-REGISTER-P DST
) (EMIT-BYTE SEGMENT
102)
3273 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
22)
3274 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3275 (T (EMIT-BYTE SEGMENT
102)
3276 (EMIT-BYTE SEGMENT
15)
3277 (EMIT-BYTE SEGMENT
23)
3278 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3280 (DEFINE-INSTRUCTION MOVHPS
3284 ((SSE-REGISTER-P DST
) (EMIT-BYTE SEGMENT
15)
3285 (EMIT-BYTE SEGMENT
22)
3286 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3287 (T (EMIT-BYTE SEGMENT
15)
3288 (EMIT-BYTE SEGMENT
23)
3289 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3291 (DEFINE-INSTRUCTION MOVLPD
3295 ((SSE-REGISTER-P DST
) (EMIT-BYTE SEGMENT
102)
3296 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
18)
3297 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3298 (T (EMIT-BYTE SEGMENT
102)
3299 (EMIT-BYTE SEGMENT
15)
3300 (EMIT-BYTE SEGMENT
19)
3301 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3303 (DEFINE-INSTRUCTION MOVLPS
3307 ((SSE-REGISTER-P DST
) (EMIT-BYTE SEGMENT
15)
3308 (EMIT-BYTE SEGMENT
18)
3309 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3310 (T (EMIT-BYTE SEGMENT
15)
3311 (EMIT-BYTE SEGMENT
19)
3312 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3314 (DEFINE-INSTRUCTION MOVQ
3318 ((SSE-REGISTER-P DST
) (EMIT-BYTE SEGMENT
243)
3319 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
126)
3320 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3321 (T (EMIT-BYTE SEGMENT
102)
3322 (EMIT-BYTE SEGMENT
15)
3323 (EMIT-BYTE SEGMENT
214)
3324 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3326 (DEFINE-INSTRUCTION MOVSD
3330 ((SSE-REGISTER-P DST
) (EMIT-BYTE SEGMENT
242)
3331 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
16)
3332 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3333 (T (EMIT-BYTE SEGMENT
242)
3334 (EMIT-BYTE SEGMENT
15)
3335 (EMIT-BYTE SEGMENT
17)
3336 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3338 (DEFINE-INSTRUCTION MOVSS
3342 ((SSE-REGISTER-P DST
) (EMIT-BYTE SEGMENT
243)
3343 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
16)
3344 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3345 (T (EMIT-BYTE SEGMENT
243)
3346 (EMIT-BYTE SEGMENT
15)
3347 (EMIT-BYTE SEGMENT
17)
3348 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3350 (DEFINE-INSTRUCTION MOVUPD
3354 ((SSE-REGISTER-P DST
) (EMIT-BYTE SEGMENT
102)
3355 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
16)
3356 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3357 (T (EMIT-BYTE SEGMENT
102)
3358 (EMIT-BYTE SEGMENT
15)
3359 (EMIT-BYTE SEGMENT
17)
3360 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3362 (DEFINE-INSTRUCTION MOVUPS
3366 ((SSE-REGISTER-P DST
) (EMIT-BYTE SEGMENT
15)
3367 (EMIT-BYTE SEGMENT
16)
3368 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3369 (T (EMIT-BYTE SEGMENT
15)
3370 (EMIT-BYTE SEGMENT
17)
3371 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3378 (define-instruction cpuid
(segment)
3380 (emit-byte segment
#x0F
)
3381 (emit-byte segment
#xA2
)))
3386 ;;;; fp instructions
3388 ;;;; FIXME: This section said "added by jrd", which should end up in CREDITS.
3390 ;;;; Note: We treat the single-precision and double-precision variants
3391 ;;;; as separate instructions.
3393 ;;; Load single to st(0).
3394 (define-instruction fld
(segment source
)
3395 (:printer floating-point
((op '(#b001
#b000
))))
3397 (emit-byte segment
#b11011001
)
3398 (emit-fp-op segment source
#b000
)))
3400 ;;; Load double to st(0).
3401 (define-instruction fldd
(segment source
)
3402 (:printer floating-point
((op '(#b101
#b000
))))
3403 (:printer floating-point-fp
((op '(#b001
#b000
))))
3405 (if (fp-reg-tn-p source
)
3406 (emit-byte segment
#b11011001
)
3407 (emit-byte segment
#b11011101
))
3408 (emit-fp-op segment source
#b000
)))
3410 ;;; Load long to st(0).
3411 (define-instruction fldl
(segment source
)
3412 (:printer floating-point
((op '(#b011
#b101
))))
3414 (emit-byte segment
#b11011011
)
3415 (emit-fp-op segment source
#b101
)))
3417 ;;; Store single from st(0).
3418 (define-instruction fst
(segment dest
)
3419 (:printer floating-point
((op '(#b001
#b010
))))
3421 (cond ((fp-reg-tn-p dest
)
3422 (emit-byte segment
#b11011101
)
3423 (emit-fp-op segment dest
#b010
))
3425 (emit-byte segment
#b11011001
)
3426 (emit-fp-op segment dest
#b010
)))))
3428 ;;; Store double from st(0).
3429 (define-instruction fstd
(segment dest
)
3430 (:printer floating-point
((op '(#b101
#b010
))))
3431 (:printer floating-point-fp
((op '(#b101
#b010
))))
3433 (cond ((fp-reg-tn-p dest
)
3434 (emit-byte segment
#b11011101
)
3435 (emit-fp-op segment dest
#b010
))
3437 (emit-byte segment
#b11011101
)
3438 (emit-fp-op segment dest
#b010
)))))
3440 ;;; Arithmetic ops are all done with at least one operand at top of
3441 ;;; stack. The other operand is is another register or a 32/64 bit
3444 ;;; dtc: I've tried to follow the Intel ASM386 conventions, but note
3445 ;;; that these conflict with the Gdb conventions for binops. To reduce
3446 ;;; the confusion I've added comments showing the mathamatical
3447 ;;; operation and the two syntaxes. By the ASM386 convention the
3448 ;;; instruction syntax is:
3451 ;;; or Fop Destination, Source
3453 ;;; If only one operand is given then it is the source and the
3454 ;;; destination is ST(0). There are reversed forms of the fsub and
3455 ;;; fdiv instructions inducated by an 'R' suffix.
3457 ;;; The mathematical operation for the non-reverse form is always:
3458 ;;; destination = destination op source
3460 ;;; For the reversed form it is:
3461 ;;; destination = source op destination
3463 ;;; The instructions below only accept one operand at present which is
3464 ;;; usually the source. I've hack in extra instructions to implement
3465 ;;; the fops with a ST(i) destination, these have a -sti suffix and
3466 ;;; the operand is the destination with the source being ST(0).
3469 ;;; st(0) = st(0) + memory or st(i).
3470 (define-instruction fadd
(segment source
)
3471 (:printer floating-point
((op '(#b000
#b000
))))
3473 (emit-byte segment
#b11011000
)
3474 (emit-fp-op segment source
#b000
)))
3477 ;;; st(0) = st(0) + memory or st(i).
3478 (define-instruction faddd
(segment source
)
3479 (:printer floating-point
((op '(#b100
#b000
))))
3480 (:printer floating-point-fp
((op '(#b000
#b000
))))
3482 (if (fp-reg-tn-p source
)
3483 (emit-byte segment
#b11011000
)
3484 (emit-byte segment
#b11011100
))
3485 (emit-fp-op segment source
#b000
)))
3487 ;;; Add double destination st(i):
3488 ;;; st(i) = st(0) + st(i).
3489 (define-instruction fadd-sti
(segment destination
)
3490 (:printer floating-point-fp
((op '(#b100
#b000
))))
3492 (aver (fp-reg-tn-p destination
))
3493 (emit-byte segment
#b11011100
)
3494 (emit-fp-op segment destination
#b000
)))
3496 (define-instruction faddp-sti
(segment destination
)
3497 (:printer floating-point-fp
((op '(#b110
#b000
))))
3499 (aver (fp-reg-tn-p destination
))
3500 (emit-byte segment
#b11011110
)
3501 (emit-fp-op segment destination
#b000
)))
3503 ;;; Subtract single:
3504 ;;; st(0) = st(0) - memory or st(i).
3505 (define-instruction fsub
(segment source
)
3506 (:printer floating-point
((op '(#b000
#b100
))))
3508 (emit-byte segment
#b11011000
)
3509 (emit-fp-op segment source
#b100
)))
3511 ;;; Subtract single, reverse:
3512 ;;; st(0) = memory or st(i) - st(0).
3513 (define-instruction fsubr
(segment source
)
3514 (:printer floating-point
((op '(#b000
#b101
))))
3516 (emit-byte segment
#b11011000
)
3517 (emit-fp-op segment source
#b101
)))
3519 ;;; Subtract double:
3520 ;;; st(0) = st(0) - memory or st(i).
3521 (define-instruction fsubd
(segment source
)
3522 (:printer floating-point
((op '(#b100
#b100
))))
3523 (:printer floating-point-fp
((op '(#b000
#b100
))))
3525 (if (fp-reg-tn-p source
)
3526 (emit-byte segment
#b11011000
)
3527 (emit-byte segment
#b11011100
))
3528 (emit-fp-op segment source
#b100
)))
3530 ;;; Subtract double, reverse:
3531 ;;; st(0) = memory or st(i) - st(0).
3532 (define-instruction fsubrd
(segment source
)
3533 (:printer floating-point
((op '(#b100
#b101
))))
3534 (:printer floating-point-fp
((op '(#b000
#b101
))))
3536 (if (fp-reg-tn-p source
)
3537 (emit-byte segment
#b11011000
)
3538 (emit-byte segment
#b11011100
))
3539 (emit-fp-op segment source
#b101
)))
3541 ;;; Subtract double, destination st(i):
3542 ;;; st(i) = st(i) - st(0).
3544 ;;; ASM386 syntax: FSUB ST(i), ST
3545 ;;; Gdb syntax: fsubr %st,%st(i)
3546 (define-instruction fsub-sti
(segment destination
)
3547 (:printer floating-point-fp
((op '(#b100
#b101
))))
3549 (aver (fp-reg-tn-p destination
))
3550 (emit-byte segment
#b11011100
)
3551 (emit-fp-op segment destination
#b101
)))
3553 (define-instruction fsubp-sti
(segment destination
)
3554 (:printer floating-point-fp
((op '(#b110
#b101
))))
3556 (aver (fp-reg-tn-p destination
))
3557 (emit-byte segment
#b11011110
)
3558 (emit-fp-op segment destination
#b101
)))
3560 ;;; Subtract double, reverse, destination st(i):
3561 ;;; st(i) = st(0) - st(i).
3563 ;;; ASM386 syntax: FSUBR ST(i), ST
3564 ;;; Gdb syntax: fsub %st,%st(i)
3565 (define-instruction fsubr-sti
(segment destination
)
3566 (:printer floating-point-fp
((op '(#b100
#b100
))))
3568 (aver (fp-reg-tn-p destination
))
3569 (emit-byte segment
#b11011100
)
3570 (emit-fp-op segment destination
#b100
)))
3572 (define-instruction fsubrp-sti
(segment destination
)
3573 (:printer floating-point-fp
((op '(#b110
#b100
))))
3575 (aver (fp-reg-tn-p destination
))
3576 (emit-byte segment
#b11011110
)
3577 (emit-fp-op segment destination
#b100
)))
3579 ;;; Multiply single:
3580 ;;; st(0) = st(0) * memory or st(i).
3581 (define-instruction fmul
(segment source
)
3582 (:printer floating-point
((op '(#b000
#b001
))))
3584 (emit-byte segment
#b11011000
)
3585 (emit-fp-op segment source
#b001
)))
3587 ;;; Multiply double:
3588 ;;; st(0) = st(0) * memory or st(i).
3589 (define-instruction fmuld
(segment source
)
3590 (:printer floating-point
((op '(#b100
#b001
))))
3591 (:printer floating-point-fp
((op '(#b000
#b001
))))
3593 (if (fp-reg-tn-p source
)
3594 (emit-byte segment
#b11011000
)
3595 (emit-byte segment
#b11011100
))
3596 (emit-fp-op segment source
#b001
)))
3598 ;;; Multiply double, destination st(i):
3599 ;;; st(i) = st(i) * st(0).
3600 (define-instruction fmul-sti
(segment destination
)
3601 (:printer floating-point-fp
((op '(#b100
#b001
))))
3603 (aver (fp-reg-tn-p destination
))
3604 (emit-byte segment
#b11011100
)
3605 (emit-fp-op segment destination
#b001
)))
3608 ;;; st(0) = st(0) / memory or st(i).
3609 (define-instruction fdiv
(segment source
)
3610 (:printer floating-point
((op '(#b000
#b110
))))
3612 (emit-byte segment
#b11011000
)
3613 (emit-fp-op segment source
#b110
)))
3615 ;;; Divide single, reverse:
3616 ;;; st(0) = memory or st(i) / st(0).
3617 (define-instruction fdivr
(segment source
)
3618 (:printer floating-point
((op '(#b000
#b111
))))
3620 (emit-byte segment
#b11011000
)
3621 (emit-fp-op segment source
#b111
)))
3624 ;;; st(0) = st(0) / memory or st(i).
3625 (define-instruction fdivd
(segment source
)
3626 (:printer floating-point
((op '(#b100
#b110
))))
3627 (:printer floating-point-fp
((op '(#b000
#b110
))))
3629 (if (fp-reg-tn-p source
)
3630 (emit-byte segment
#b11011000
)
3631 (emit-byte segment
#b11011100
))
3632 (emit-fp-op segment source
#b110
)))
3634 ;;; Divide double, reverse:
3635 ;;; st(0) = memory or st(i) / st(0).
3636 (define-instruction fdivrd
(segment source
)
3637 (:printer floating-point
((op '(#b100
#b111
))))
3638 (:printer floating-point-fp
((op '(#b000
#b111
))))
3640 (if (fp-reg-tn-p source
)
3641 (emit-byte segment
#b11011000
)
3642 (emit-byte segment
#b11011100
))
3643 (emit-fp-op segment source
#b111
)))
3645 ;;; Divide double, destination st(i):
3646 ;;; st(i) = st(i) / st(0).
3648 ;;; ASM386 syntax: FDIV ST(i), ST
3649 ;;; Gdb syntax: fdivr %st,%st(i)
3650 (define-instruction fdiv-sti
(segment destination
)
3651 (:printer floating-point-fp
((op '(#b100
#b111
))))
3653 (aver (fp-reg-tn-p destination
))
3654 (emit-byte segment
#b11011100
)
3655 (emit-fp-op segment destination
#b111
)))
3657 ;;; Divide double, reverse, destination st(i):
3658 ;;; st(i) = st(0) / st(i).
3660 ;;; ASM386 syntax: FDIVR ST(i), ST
3661 ;;; Gdb syntax: fdiv %st,%st(i)
3662 (define-instruction fdivr-sti
(segment destination
)
3663 (:printer floating-point-fp
((op '(#b100
#b110
))))
3665 (aver (fp-reg-tn-p destination
))
3666 (emit-byte segment
#b11011100
)
3667 (emit-fp-op segment destination
#b110
)))
3669 ;;; Exchange fr0 with fr(n). (There is no double precision variant.)
3670 (define-instruction fxch
(segment source
)
3671 (:printer floating-point-fp
((op '(#b001
#b001
))))
3673 (unless (and (tn-p source
)
3674 (eq (sb-name (sc-sb (tn-sc source
))) 'float-registers
))
3676 (emit-byte segment
#b11011001
)
3677 (emit-fp-op segment source
#b001
)))
3679 ;;; Push 32-bit integer to st0.
3680 (define-instruction fild
(segment source
)
3681 (:printer floating-point
((op '(#b011
#b000
))))
3683 (emit-byte segment
#b11011011
)
3684 (emit-fp-op segment source
#b000
)))
3686 ;;; Push 64-bit integer to st0.
3687 (define-instruction fildl
(segment source
)
3688 (:printer floating-point
((op '(#b111
#b101
))))
3690 (emit-byte segment
#b11011111
)
3691 (emit-fp-op segment source
#b101
)))
3693 ;;; Store 32-bit integer.
3694 (define-instruction fist
(segment dest
)
3695 (:printer floating-point
((op '(#b011
#b010
))))
3697 (emit-byte segment
#b11011011
)
3698 (emit-fp-op segment dest
#b010
)))
3700 ;;; Store and pop 32-bit integer.
3701 (define-instruction fistp
(segment dest
)
3702 (:printer floating-point
((op '(#b011
#b011
))))
3704 (emit-byte segment
#b11011011
)
3705 (emit-fp-op segment dest
#b011
)))
3707 ;;; Store and pop 64-bit integer.
3708 (define-instruction fistpl
(segment dest
)
3709 (:printer floating-point
((op '(#b111
#b111
))))
3711 (emit-byte segment
#b11011111
)
3712 (emit-fp-op segment dest
#b111
)))
3714 ;;; Store single from st(0) and pop.
3715 (define-instruction fstp
(segment dest
)
3716 (:printer floating-point
((op '(#b001
#b011
))))
3718 (cond ((fp-reg-tn-p dest
)
3719 (emit-byte segment
#b11011101
)
3720 (emit-fp-op segment dest
#b011
))
3722 (emit-byte segment
#b11011001
)
3723 (emit-fp-op segment dest
#b011
)))))
3725 ;;; Store double from st(0) and pop.
3726 (define-instruction fstpd
(segment dest
)
3727 (:printer floating-point
((op '(#b101
#b011
))))
3728 (:printer floating-point-fp
((op '(#b101
#b011
))))
3730 (cond ((fp-reg-tn-p dest
)
3731 (emit-byte segment
#b11011101
)
3732 (emit-fp-op segment dest
#b011
))
3734 (emit-byte segment
#b11011101
)
3735 (emit-fp-op segment dest
#b011
)))))
3737 ;;; Store long from st(0) and pop.
3738 (define-instruction fstpl
(segment dest
)
3739 (:printer floating-point
((op '(#b011
#b111
))))
3741 (emit-byte segment
#b11011011
)
3742 (emit-fp-op segment dest
#b111
)))
3744 ;;; Decrement stack-top pointer.
3745 (define-instruction fdecstp
(segment)
3746 (:printer floating-point-no
((op #b10110
)))
3748 (emit-byte segment
#b11011001
)
3749 (emit-byte segment
#b11110110
)))
3751 ;;; Increment stack-top pointer.
3752 (define-instruction fincstp
(segment)
3753 (:printer floating-point-no
((op #b10111
)))
3755 (emit-byte segment
#b11011001
)
3756 (emit-byte segment
#b11110111
)))
3758 ;;; Free fp register.
3759 (define-instruction ffree
(segment dest
)
3760 (:printer floating-point-fp
((op '(#b101
#b000
))))
3762 (emit-byte segment
#b11011101
)
3763 (emit-fp-op segment dest
#b000
)))
3765 (define-instruction fabs
(segment)
3766 (:printer floating-point-no
((op #b00001
)))
3768 (emit-byte segment
#b11011001
)
3769 (emit-byte segment
#b11100001
)))
3771 (define-instruction fchs
(segment)
3772 (:printer floating-point-no
((op #b00000
)))
3774 (emit-byte segment
#b11011001
)
3775 (emit-byte segment
#b11100000
)))
3777 (define-instruction frndint
(segment)
3778 (:printer floating-point-no
((op #b11100
)))
3780 (emit-byte segment
#b11011001
)
3781 (emit-byte segment
#b11111100
)))
3784 (define-instruction fninit
(segment)
3785 (:printer floating-point-5
((op #b00011
)))
3787 (emit-byte segment
#b11011011
)
3788 (emit-byte segment
#b11100011
)))
3790 ;;; Store Status Word to AX.
3791 (define-instruction fnstsw
(segment)
3792 (:printer floating-point-st
((op #b00000
)))
3794 (emit-byte segment
#b11011111
)
3795 (emit-byte segment
#b11100000
)))
3797 ;;; Load Control Word.
3799 ;;; src must be a memory location
3800 (define-instruction fldcw
(segment src
)
3801 (:printer floating-point
((op '(#b001
#b101
))))
3803 (emit-byte segment
#b11011001
)
3804 (emit-fp-op segment src
#b101
)))
3806 ;;; Store Control Word.
3807 (define-instruction fnstcw
(segment dst
)
3808 (:printer floating-point
((op '(#b001
#b111
))))
3810 (emit-byte segment
#b11011001
)
3811 (emit-fp-op segment dst
#b111
)))
3813 ;;; Store FP Environment.
3814 (define-instruction fstenv
(segment dst
)
3815 (:printer floating-point
((op '(#b001
#b110
))))
3817 (emit-byte segment
#b11011001
)
3818 (emit-fp-op segment dst
#b110
)))
3820 ;;; Restore FP Environment.
3821 (define-instruction fldenv
(segment src
)
3822 (:printer floating-point
((op '(#b001
#b100
))))
3824 (emit-byte segment
#b11011001
)
3825 (emit-fp-op segment src
#b100
)))
3828 (define-instruction fsave
(segment dst
)
3829 (:printer floating-point
((op '(#b101
#b110
))))
3831 (emit-byte segment
#b11011101
)
3832 (emit-fp-op segment dst
#b110
)))
3834 ;;; Restore FP State.
3835 (define-instruction frstor
(segment src
)
3836 (:printer floating-point
((op '(#b101
#b100
))))
3838 (emit-byte segment
#b11011101
)
3839 (emit-fp-op segment src
#b100
)))
3841 ;;; Clear exceptions.
3842 (define-instruction fnclex
(segment)
3843 (:printer floating-point-5
((op #b00010
)))
3845 (emit-byte segment
#b11011011
)
3846 (emit-byte segment
#b11100010
)))
3849 (define-instruction fcom
(segment src
)
3850 (:printer floating-point
((op '(#b000
#b010
))))
3852 (emit-byte segment
#b11011000
)
3853 (emit-fp-op segment src
#b010
)))
3855 (define-instruction fcomd
(segment src
)
3856 (:printer floating-point
((op '(#b100
#b010
))))
3857 (:printer floating-point-fp
((op '(#b000
#b010
))))
3859 (if (fp-reg-tn-p src
)
3860 (emit-byte segment
#b11011000
)
3861 (emit-byte segment
#b11011100
))
3862 (emit-fp-op segment src
#b010
)))
3864 ;;; Compare ST1 to ST0, popping the stack twice.
3865 (define-instruction fcompp
(segment)
3866 (:printer floating-point-3
((op '(#b110
#b011001
))))
3868 (emit-byte segment
#b11011110
)
3869 (emit-byte segment
#b11011001
)))
3871 ;;; unordered comparison
3872 (define-instruction fucom
(segment src
)
3873 (:printer floating-point-fp
((op '(#b101
#b100
))))
3875 (aver (fp-reg-tn-p src
))
3876 (emit-byte segment
#b11011101
)
3877 (emit-fp-op segment src
#b100
)))
3879 (define-instruction ftst
(segment)
3880 (:printer floating-point-no
((op #b00100
)))
3882 (emit-byte segment
#b11011001
)
3883 (emit-byte segment
#b11100100
)))
3887 (define-instruction fsqrt
(segment)
3888 (:printer floating-point-no
((op #b11010
)))
3890 (emit-byte segment
#b11011001
)
3891 (emit-byte segment
#b11111010
)))
3893 (define-instruction fscale
(segment)
3894 (:printer floating-point-no
((op #b11101
)))
3896 (emit-byte segment
#b11011001
)
3897 (emit-byte segment
#b11111101
)))
3899 (define-instruction fxtract
(segment)
3900 (:printer floating-point-no
((op #b10100
)))
3902 (emit-byte segment
#b11011001
)
3903 (emit-byte segment
#b11110100
)))
3905 (define-instruction fsin
(segment)
3906 (:printer floating-point-no
((op #b11110
)))
3908 (emit-byte segment
#b11011001
)
3909 (emit-byte segment
#b11111110
)))
3911 (define-instruction fcos
(segment)
3912 (:printer floating-point-no
((op #b11111
)))
3914 (emit-byte segment
#b11011001
)
3915 (emit-byte segment
#b11111111
)))
3917 (define-instruction fprem1
(segment)
3918 (:printer floating-point-no
((op #b10101
)))
3920 (emit-byte segment
#b11011001
)
3921 (emit-byte segment
#b11110101
)))
3923 (define-instruction fprem
(segment)
3924 (:printer floating-point-no
((op #b11000
)))
3926 (emit-byte segment
#b11011001
)
3927 (emit-byte segment
#b11111000
)))
3929 (define-instruction fxam
(segment)
3930 (:printer floating-point-no
((op #b00101
)))
3932 (emit-byte segment
#b11011001
)
3933 (emit-byte segment
#b11100101
)))
3935 ;;; These do push/pop to stack and need special handling
3936 ;;; in any VOPs that use them. See the book.
3938 ;;; st0 <- st1*log2(st0)
3939 (define-instruction fyl2x
(segment) ; pops stack
3940 (:printer floating-point-no
((op #b10001
)))
3942 (emit-byte segment
#b11011001
)
3943 (emit-byte segment
#b11110001
)))
3945 (define-instruction fyl2xp1
(segment)
3946 (:printer floating-point-no
((op #b11001
)))
3948 (emit-byte segment
#b11011001
)
3949 (emit-byte segment
#b11111001
)))
3951 (define-instruction f2xm1
(segment)
3952 (:printer floating-point-no
((op #b10000
)))
3954 (emit-byte segment
#b11011001
)
3955 (emit-byte segment
#b11110000
)))
3957 (define-instruction fptan
(segment) ; st(0) <- 1; st(1) <- tan
3958 (:printer floating-point-no
((op #b10010
)))
3960 (emit-byte segment
#b11011001
)
3961 (emit-byte segment
#b11110010
)))
3963 (define-instruction fpatan
(segment) ; POPS STACK
3964 (:printer floating-point-no
((op #b10011
)))
3966 (emit-byte segment
#b11011001
)
3967 (emit-byte segment
#b11110011
)))
3969 ;;;; loading constants
3971 (define-instruction fldz
(segment)
3972 (:printer floating-point-no
((op #b01110
)))
3974 (emit-byte segment
#b11011001
)
3975 (emit-byte segment
#b11101110
)))
3977 (define-instruction fld1
(segment)
3978 (:printer floating-point-no
((op #b01000
)))
3980 (emit-byte segment
#b11011001
)
3981 (emit-byte segment
#b11101000
)))
3983 (define-instruction fldpi
(segment)
3984 (:printer floating-point-no
((op #b01011
)))
3986 (emit-byte segment
#b11011001
)
3987 (emit-byte segment
#b11101011
)))
3989 (define-instruction fldl2t
(segment)
3990 (:printer floating-point-no
((op #b01001
)))
3992 (emit-byte segment
#b11011001
)
3993 (emit-byte segment
#b11101001
)))
3995 (define-instruction fldl2e
(segment)
3996 (:printer floating-point-no
((op #b01010
)))
3998 (emit-byte segment
#b11011001
)
3999 (emit-byte segment
#b11101010
)))
4001 (define-instruction fldlg2
(segment)
4002 (:printer floating-point-no
((op #b01100
)))
4004 (emit-byte segment
#b11011001
)
4005 (emit-byte segment
#b11101100
)))
4007 (define-instruction fldln2
(segment)
4008 (:printer floating-point-no
((op #b01101
)))
4010 (emit-byte segment
#b11011001
)
4011 (emit-byte segment
#b11101101
)))