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
))
42 (defparameter *xmmword-reg-names
*
43 #(xmm0 xmm1 xmm2 xmm3 xmm4 xmm5 xmm6 xmm7
))
45 (defun print-reg-with-width (value width stream dstate
)
46 (declare (ignore dstate
))
47 (princ (aref (ecase width
48 (:byte
*byte-reg-names
*)
49 (:word
*word-reg-names
*)
50 (:dword
*dword-reg-names
*)
51 (:xmmword
*xmmword-reg-names
*))
54 ;; XXX plus should do some source-var notes
57 (defun print-reg (value stream dstate
)
58 (declare (type reg value
)
60 (type sb
!disassem
:disassem-state dstate
))
61 (print-reg-with-width value
62 (sb!disassem
:dstate-get-prop dstate
'width
)
66 (defun print-word-reg (value stream dstate
)
67 (declare (type reg value
)
69 (type sb
!disassem
:disassem-state dstate
))
70 (print-reg-with-width value
71 (or (sb!disassem
:dstate-get-prop dstate
'word-width
)
72 +default-operand-size
+)
76 (defun print-byte-reg (value stream dstate
)
77 (declare (type reg value
)
79 (type sb
!disassem
:disassem-state dstate
))
80 (print-reg-with-width value
:byte stream dstate
))
82 (defun print-addr-reg (value stream dstate
)
83 (declare (type reg value
)
85 (type sb
!disassem
:disassem-state dstate
))
86 (print-reg-with-width value
*default-address-size
* stream dstate
))
88 (defun print-reg/mem
(value stream dstate
)
89 (declare (type (or list reg
) value
)
91 (type sb
!disassem
:disassem-state dstate
))
92 (if (typep value
'reg
)
93 (print-reg value stream dstate
)
94 (print-mem-access value stream nil dstate
)))
96 ;; Same as print-reg/mem, but prints an explicit size indicator for
98 (defun print-sized-reg/mem
(value stream dstate
)
99 (declare (type (or list reg
) value
)
101 (type sb
!disassem
:disassem-state dstate
))
102 (if (typep value
'reg
)
103 (print-reg value stream dstate
)
104 (print-mem-access value stream t dstate
)))
106 (defun print-byte-reg/mem
(value stream dstate
)
107 (declare (type (or list reg
) value
)
109 (type sb
!disassem
:disassem-state dstate
))
110 (if (typep value
'reg
)
111 (print-byte-reg value stream dstate
)
112 (print-mem-access value stream t dstate
)))
114 (defun print-word-reg/mem
(value stream dstate
)
115 (declare (type (or list reg
) value
)
117 (type sb
!disassem
:disassem-state dstate
))
118 (if (typep value
'reg
)
119 (print-word-reg value stream dstate
)
120 (print-mem-access value stream nil dstate
)))
122 (defun print-label (value stream dstate
)
123 (declare (ignore dstate
))
124 (sb!disassem
:princ16 value stream
))
126 ;;; Returns either an integer, meaning a register, or a list of
127 ;;; (BASE-REG OFFSET INDEX-REG INDEX-SCALE), where any component
128 ;;; may be missing or nil to indicate that it's not used or has the
129 ;;; obvious default value (e.g., 1 for the index-scale).
130 (defun prefilter-reg/mem
(value dstate
)
131 (declare (type list value
)
132 (type sb
!disassem
:disassem-state dstate
))
133 (let ((mod (car value
))
135 (declare (type (unsigned-byte 2) mod
)
136 (type (unsigned-byte 3) r
/m
))
142 (let ((sib (sb!disassem
:read-suffix
8 dstate
)))
143 (declare (type (unsigned-byte 8) sib
))
144 (let ((base-reg (ldb (byte 3 0) sib
))
145 (index-reg (ldb (byte 3 3) sib
))
146 (index-scale (ldb (byte 2 6) sib
)))
147 (declare (type (unsigned-byte 3) base-reg index-reg
)
148 (type (unsigned-byte 2) index-scale
))
152 (if (= base-reg
#b101
)
153 (sb!disassem
:read-signed-suffix
32 dstate
)
156 (sb!disassem
:read-signed-suffix
8 dstate
))
158 (sb!disassem
:read-signed-suffix
32 dstate
)))))
159 (list (if (and (= mod
#b00
) (= base-reg
#b101
)) nil base-reg
)
161 (if (= index-reg
#b100
) nil index-reg
)
162 (ash 1 index-scale
))))))
163 ((and (= mod
#b00
) (= r
/m
#b101
))
164 (list nil
(sb!disassem
:read-signed-suffix
32 dstate
)) )
168 (list r
/m
(sb!disassem
:read-signed-suffix
8 dstate
)))
170 (list r
/m
(sb!disassem
:read-signed-suffix
32 dstate
))))))
173 ;;; This is a sort of bogus prefilter that just stores the info globally for
174 ;;; other people to use; it probably never gets printed.
175 (defun prefilter-width (value dstate
)
176 (setf (sb!disassem
:dstate-get-prop dstate
'width
)
180 ;; set by a prefix instruction
181 (or (sb!disassem
:dstate-get-prop dstate
'word-width
)
182 +default-operand-size
+)))
183 (when (not (eql word-width
+default-operand-size
+))
185 (setf (sb!disassem
:dstate-get-prop dstate
'word-width
)
186 +default-operand-size
+))
189 (defun read-address (value dstate
)
190 (declare (ignore value
)) ; always nil anyway
191 (sb!disassem
:read-suffix
(width-bits *default-address-size
*) dstate
))
193 (defun width-bits (width)
205 ;;;; disassembler argument types
207 (sb!disassem
:define-arg-type displacement
209 :use-label
#'offset-next
210 :printer
(lambda (value stream dstate
)
211 (sb!disassem
:maybe-note-assembler-routine value nil dstate
)
212 (print-label value stream dstate
)))
214 (sb!disassem
:define-arg-type accum
215 :printer
(lambda (value stream dstate
)
216 (declare (ignore value
)
218 (type sb
!disassem
:disassem-state dstate
))
219 (print-reg 0 stream dstate
)))
221 (sb!disassem
:define-arg-type word-accum
222 :printer
(lambda (value stream dstate
)
223 (declare (ignore value
)
225 (type sb
!disassem
:disassem-state dstate
))
226 (print-word-reg 0 stream dstate
)))
228 (sb!disassem
:define-arg-type reg
229 :printer
#'print-reg
)
231 (sb!disassem
:define-arg-type addr-reg
232 :printer
#'print-addr-reg
)
234 (sb!disassem
:define-arg-type word-reg
235 :printer
#'print-word-reg
)
237 (sb!disassem
:define-arg-type imm-addr
238 :prefilter
#'read-address
239 :printer
#'print-label
)
241 (sb!disassem
:define-arg-type imm-data
242 :prefilter
(lambda (value dstate
)
243 (declare (ignore value
)) ; always nil anyway
244 (sb!disassem
:read-suffix
245 (width-bits (sb!disassem
:dstate-get-prop dstate
'width
))
248 (sb!disassem
:define-arg-type signed-imm-data
249 :prefilter
(lambda (value dstate
)
250 (declare (ignore value
)) ; always nil anyway
251 (let ((width (sb!disassem
:dstate-get-prop dstate
'width
)))
252 (sb!disassem
:read-signed-suffix
(width-bits width
) dstate
))))
254 (sb!disassem
:define-arg-type signed-imm-byte
255 :prefilter
(lambda (value dstate
)
256 (declare (ignore value
)) ; always nil anyway
257 (sb!disassem
:read-signed-suffix
8 dstate
)))
259 (sb!disassem
:define-arg-type signed-imm-dword
260 :prefilter
(lambda (value dstate
)
261 (declare (ignore value
)) ; always nil anyway
262 (sb!disassem
:read-signed-suffix
32 dstate
)))
264 (sb!disassem
:define-arg-type imm-word
265 :prefilter
(lambda (value dstate
)
266 (declare (ignore value
)) ; always nil anyway
268 (or (sb!disassem
:dstate-get-prop dstate
'word-width
)
269 +default-operand-size
+)))
270 (sb!disassem
:read-suffix
(width-bits width
) dstate
))))
272 (sb!disassem
:define-arg-type signed-imm-word
273 :prefilter
(lambda (value dstate
)
274 (declare (ignore value
)) ; always nil anyway
276 (or (sb!disassem
:dstate-get-prop dstate
'word-width
)
277 +default-operand-size
+)))
278 (sb!disassem
:read-signed-suffix
(width-bits width
) dstate
))))
280 ;;; needed for the ret imm16 instruction
281 (sb!disassem
:define-arg-type imm-word-16
282 :prefilter
(lambda (value dstate
)
283 (declare (ignore value
)) ; always nil anyway
284 (sb!disassem
:read-suffix
16 dstate
)))
286 (sb!disassem
:define-arg-type reg
/mem
287 :prefilter
#'prefilter-reg
/mem
288 :printer
#'print-reg
/mem
)
289 (sb!disassem
:define-arg-type sized-reg
/mem
290 ;; Same as reg/mem, but prints an explicit size indicator for
291 ;; memory references.
292 :prefilter
#'prefilter-reg
/mem
293 :printer
#'print-sized-reg
/mem
)
294 (sb!disassem
:define-arg-type byte-reg
/mem
295 :prefilter
#'prefilter-reg
/mem
296 :printer
#'print-byte-reg
/mem
)
297 (sb!disassem
:define-arg-type word-reg
/mem
298 :prefilter
#'prefilter-reg
/mem
299 :printer
#'print-word-reg
/mem
)
302 (eval-when (#-sb-xc
:compile-toplevel
:load-toplevel
:execute
)
303 (defun print-fp-reg (value stream dstate
)
304 (declare (ignore dstate
))
305 (format stream
"FR~D" value
))
306 (defun prefilter-fp-reg (value dstate
)
308 (declare (ignore dstate
))
311 (sb!disassem
:define-arg-type fp-reg
312 :prefilter
#'prefilter-fp-reg
313 :printer
#'print-fp-reg
)
315 (sb!disassem
:define-arg-type width
316 :prefilter
#'prefilter-width
317 :printer
(lambda (value stream dstate
)
320 (and (numberp value
) (zerop value
))) ; zzz jrd
323 ;; set by a prefix instruction
324 (or (sb!disassem
:dstate-get-prop dstate
'word-width
)
325 +default-operand-size
+)))
326 (princ (schar (symbol-name word-width
) 0) stream
)))))
328 (eval-when (:compile-toplevel
:load-toplevel
:execute
)
329 (defparameter *conditions
*
332 (:b .
2) (:nae .
2) (:c .
2)
333 (:nb .
3) (:ae .
3) (:nc .
3)
334 (:eq .
4) (:e .
4) (:z .
4)
341 (:np .
11) (:po .
11)
342 (:l .
12) (:nge .
12)
343 (:nl .
13) (:ge .
13)
344 (:le .
14) (:ng .
14)
345 (:nle .
15) (:g .
15)))
346 (defparameter *condition-name-vec
*
347 (let ((vec (make-array 16 :initial-element nil
)))
348 (dolist (cond *conditions
*)
349 (when (null (aref vec
(cdr cond
)))
350 (setf (aref vec
(cdr cond
)) (car cond
))))
354 ;;; Set assembler parameters. (In CMU CL, this was done with
355 ;;; a call to a macro DEF-ASSEMBLER-PARAMS.)
356 (eval-when (:compile-toplevel
:load-toplevel
:execute
)
357 (setf sb
!assem
:*assem-scheduler-p
* nil
))
359 (sb!disassem
:define-arg-type condition-code
360 :printer
*condition-name-vec
*)
362 (defun conditional-opcode (condition)
363 (cdr (assoc condition
*conditions
* :test
#'eq
)))
365 ;;;; disassembler instruction formats
367 (eval-when (:compile-toplevel
:execute
)
368 (defun swap-if (direction field1 separator field2
)
369 `(:if
(,direction
:constant
0)
370 (,field1
,separator
,field2
)
371 (,field2
,separator
,field1
))))
373 (sb!disassem
:define-instruction-format
(byte 8 :default-printer
'(:name
))
374 (op :field
(byte 8 0))
379 (sb!disassem
:define-instruction-format
(simple 8)
380 (op :field
(byte 7 1))
381 (width :field
(byte 1 0) :type
'width
)
386 ;;; Same as simple, but with direction bit
387 (sb!disassem
:define-instruction-format
(simple-dir 8 :include
'simple
)
388 (op :field
(byte 6 2))
389 (dir :field
(byte 1 1)))
391 ;;; Same as simple, but with the immediate value occurring by default,
392 ;;; and with an appropiate printer.
393 (sb!disassem
:define-instruction-format
(accum-imm 8
395 :default-printer
'(:name
396 :tab accum
", " imm
))
397 (imm :type
'imm-data
))
399 (sb!disassem
:define-instruction-format
(reg-no-width 8
400 :default-printer
'(:name
:tab reg
))
401 (op :field
(byte 5 3))
402 (reg :field
(byte 3 0) :type
'word-reg
)
404 (accum :type
'word-accum
)
407 ;;; adds a width field to reg-no-width
408 (sb!disassem
:define-instruction-format
(reg 8
409 :default-printer
'(:name
:tab reg
))
410 (op :field
(byte 4 4))
411 (width :field
(byte 1 3) :type
'width
)
412 (reg :field
(byte 3 0) :type
'reg
)
418 ;;; Same as reg, but with direction bit
419 (sb!disassem
:define-instruction-format
(reg-dir 8 :include
'reg
)
420 (op :field
(byte 3 5))
421 (dir :field
(byte 1 4)))
423 (sb!disassem
:define-instruction-format
(two-bytes 16
424 :default-printer
'(:name
))
425 (op :fields
(list (byte 8 0) (byte 8 8))))
427 (sb!disassem
:define-instruction-format
(reg-reg/mem
16
429 `(:name
:tab reg
", " reg
/mem
))
430 (op :field
(byte 7 1))
431 (width :field
(byte 1 0) :type
'width
)
432 (reg/mem
:fields
(list (byte 2 14) (byte 3 8))
434 (reg :field
(byte 3 11) :type
'reg
)
438 ;;; same as reg-reg/mem, but with direction bit
439 (sb!disassem
:define-instruction-format
(reg-reg/mem-dir
16
440 :include
'reg-reg
/mem
444 ,(swap-if 'dir
'reg
/mem
", " 'reg
)))
445 (op :field
(byte 6 2))
446 (dir :field
(byte 1 1)))
448 ;;; Same as reg-rem/mem, but uses the reg field as a second op code.
449 (sb!disassem
:define-instruction-format
(reg/mem
16
450 :default-printer
'(:name
:tab reg
/mem
))
451 (op :fields
(list (byte 7 1) (byte 3 11)))
452 (width :field
(byte 1 0) :type
'width
)
453 (reg/mem
:fields
(list (byte 2 14) (byte 3 8))
454 :type
'sized-reg
/mem
)
458 ;;; Same as reg/mem, but with the immediate value occurring by default,
459 ;;; and with an appropiate printer.
460 (sb!disassem
:define-instruction-format
(reg/mem-imm
16
463 '(:name
:tab reg
/mem
", " imm
))
464 (reg/mem
:type
'sized-reg
/mem
)
465 (imm :type
'imm-data
))
467 ;;; Same as reg/mem, but with using the accumulator in the default printer
468 (sb!disassem
:define-instruction-format
470 :include
'reg
/mem
:default-printer
'(:name
:tab accum
", " reg
/mem
))
471 (reg/mem
:type
'reg
/mem
) ; don't need a size
472 (accum :type
'accum
))
474 ;;; Same as reg-reg/mem, but with a prefix of #b00001111
475 (sb!disassem
:define-instruction-format
(ext-reg-reg/mem
24
477 `(:name
:tab reg
", " reg
/mem
))
478 (prefix :field
(byte 8 0) :value
#b00001111
)
479 (op :field
(byte 7 9))
480 (width :field
(byte 1 8) :type
'width
)
481 (reg/mem
:fields
(list (byte 2 22) (byte 3 16))
483 (reg :field
(byte 3 19) :type
'reg
)
487 ;;; Same as reg/mem, but with a prefix of #b00001111
488 (sb!disassem
:define-instruction-format
(ext-reg/mem
24
489 :default-printer
'(:name
:tab reg
/mem
))
490 (prefix :field
(byte 8 0) :value
#b00001111
)
491 (op :fields
(list (byte 7 9) (byte 3 19)))
492 (width :field
(byte 1 8) :type
'width
)
493 (reg/mem
:fields
(list (byte 2 22) (byte 3 16))
494 :type
'sized-reg
/mem
)
498 (sb!disassem
:define-instruction-format
(ext-reg/mem-imm
24
499 :include
'ext-reg
/mem
501 '(:name
:tab reg
/mem
", " imm
))
502 (imm :type
'imm-data
))
504 ;;;; This section was added by jrd, for fp instructions.
506 ;;; regular fp inst to/from registers/memory
507 (sb!disassem
:define-instruction-format
(floating-point 16
509 `(:name
:tab reg
/mem
))
510 (prefix :field
(byte 5 3) :value
#b11011
)
511 (op :fields
(list (byte 3 0) (byte 3 11)))
512 (reg/mem
:fields
(list (byte 2 14) (byte 3 8)) :type
'reg
/mem
))
514 ;;; fp insn to/from fp reg
515 (sb!disassem
:define-instruction-format
(floating-point-fp 16
516 :default-printer
`(:name
:tab fp-reg
))
517 (prefix :field
(byte 5 3) :value
#b11011
)
518 (suffix :field
(byte 2 14) :value
#b11
)
519 (op :fields
(list (byte 3 0) (byte 3 11)))
520 (fp-reg :field
(byte 3 8) :type
'fp-reg
))
522 ;;; fp insn to/from fp reg, with the reversed source/destination flag.
523 (sb!disassem
:define-instruction-format
524 (floating-point-fp-d 16
525 :default-printer
`(:name
:tab
,(swap-if 'd
"ST0" ", " 'fp-reg
)))
526 (prefix :field
(byte 5 3) :value
#b11011
)
527 (suffix :field
(byte 2 14) :value
#b11
)
528 (op :fields
(list (byte 2 0) (byte 3 11)))
529 (d :field
(byte 1 2))
530 (fp-reg :field
(byte 3 8) :type
'fp-reg
))
533 ;;; (added by (?) pfw)
534 ;;; fp no operand isns
535 (sb!disassem
:define-instruction-format
(floating-point-no 16
536 :default-printer
'(:name
))
537 (prefix :field
(byte 8 0) :value
#b11011001
)
538 (suffix :field
(byte 3 13) :value
#b111
)
539 (op :field
(byte 5 8)))
541 (sb!disassem
:define-instruction-format
(floating-point-3 16
542 :default-printer
'(:name
))
543 (prefix :field
(byte 5 3) :value
#b11011
)
544 (suffix :field
(byte 2 14) :value
#b11
)
545 (op :fields
(list (byte 3 0) (byte 6 8))))
547 (sb!disassem
:define-instruction-format
(floating-point-5 16
548 :default-printer
'(:name
))
549 (prefix :field
(byte 8 0) :value
#b11011011
)
550 (suffix :field
(byte 3 13) :value
#b111
)
551 (op :field
(byte 5 8)))
553 (sb!disassem
:define-instruction-format
(floating-point-st 16
554 :default-printer
'(:name
))
555 (prefix :field
(byte 8 0) :value
#b11011111
)
556 (suffix :field
(byte 3 13) :value
#b111
)
557 (op :field
(byte 5 8)))
559 (sb!disassem
:define-instruction-format
(string-op 8
561 :default-printer
'(:name width
)))
563 (sb!disassem
:define-instruction-format
(short-cond-jump 16)
564 (op :field
(byte 4 4))
565 (cc :field
(byte 4 0) :type
'condition-code
)
566 (label :field
(byte 8 8) :type
'displacement
))
568 (sb!disassem
:define-instruction-format
(short-jump 16
569 :default-printer
'(:name
:tab label
))
570 (const :field
(byte 4 4) :value
#b1110
)
571 (op :field
(byte 4 0))
572 (label :field
(byte 8 8) :type
'displacement
))
574 (sb!disassem
:define-instruction-format
(near-cond-jump 16)
575 (op :fields
(list (byte 8 0) (byte 4 12)) :value
'(#b00001111
#b1000
))
576 (cc :field
(byte 4 8) :type
'condition-code
)
577 ;; The disassembler currently doesn't let you have an instruction > 32 bits
578 ;; long, so we fake it by using a prefilter to read the offset.
579 (label :type
'displacement
580 :prefilter
(lambda (value dstate
)
581 (declare (ignore value
)) ; always nil anyway
582 (sb!disassem
:read-signed-suffix
32 dstate
))))
584 (sb!disassem
:define-instruction-format
(near-jump 8
585 :default-printer
'(:name
:tab label
))
586 (op :field
(byte 8 0))
587 ;; The disassembler currently doesn't let you have an instruction > 32 bits
588 ;; long, so we fake it by using a prefilter to read the address.
589 (label :type
'displacement
590 :prefilter
(lambda (value dstate
)
591 (declare (ignore value
)) ; always nil anyway
592 (sb!disassem
:read-signed-suffix
32 dstate
))))
595 (sb!disassem
:define-instruction-format
(cond-set 24
596 :default-printer
'('set cc
:tab reg
/mem
))
597 (prefix :field
(byte 8 0) :value
#b00001111
)
598 (op :field
(byte 4 12) :value
#b1001
)
599 (cc :field
(byte 4 8) :type
'condition-code
)
600 (reg/mem
:fields
(list (byte 2 22) (byte 3 16))
602 (reg :field
(byte 3 19) :value
#b000
))
604 (sb!disassem
:define-instruction-format
(cond-move 24
606 '('cmov cc
:tab reg
", " reg
/mem
))
607 (prefix :field
(byte 8 0) :value
#b00001111
)
608 (op :field
(byte 4 12) :value
#b0100
)
609 (cc :field
(byte 4 8) :type
'condition-code
)
610 (reg/mem
:fields
(list (byte 2 22) (byte 3 16))
612 (reg :field
(byte 3 19) :type
'reg
))
614 (sb!disassem
:define-instruction-format
(enter-format 32
615 :default-printer
'(:name
617 (:unless
(:constant
0)
619 (op :field
(byte 8 0))
620 (disp :field
(byte 16 8))
621 (level :field
(byte 8 24)))
623 (sb!disassem
:define-instruction-format
(prefetch 24
625 '(:name
", " reg
/mem
))
626 (prefix :field
(byte 8 0) :value
#b00001111
)
627 (op :field
(byte 8 8) :value
#b00011000
)
628 (reg/mem
:fields
(list (byte 2 22) (byte 3 16)) :type
'byte-reg
/mem
)
629 (reg :field
(byte 3 19) :type
'reg
))
631 ;;; Single byte instruction with an immediate byte argument.
632 (sb!disassem
:define-instruction-format
(byte-imm 16
633 :default-printer
'(:name
:tab code
))
634 (op :field
(byte 8 0))
635 (code :field
(byte 8 8)))
637 ;;; Two byte instruction with an immediate byte argument.
639 (sb!disassem
:define-instruction-format
(word-imm 24
640 :default-printer
'(:name
:tab code
))
641 (op :field
(byte 16 0))
642 (code :field
(byte 8 16)))
645 ;;;; primitive emitters
647 (define-bitfield-emitter emit-word
16
650 (define-bitfield-emitter emit-dword
32
653 (define-bitfield-emitter emit-byte-with-reg
8
654 (byte 5 3) (byte 3 0))
656 (define-bitfield-emitter emit-mod-reg-r
/m-byte
8
657 (byte 2 6) (byte 3 3) (byte 3 0))
659 (define-bitfield-emitter emit-sib-byte
8
660 (byte 2 6) (byte 3 3) (byte 3 0))
664 (defun emit-absolute-fixup (segment fixup
)
665 (note-fixup segment
:absolute fixup
)
666 (let ((offset (fixup-offset fixup
)))
668 (emit-back-patch segment
669 4 ; FIXME: n-word-bytes
670 (lambda (segment posn
)
671 (declare (ignore posn
))
673 (- (+ (component-header-length)
674 (or (label-position offset
)
676 other-pointer-lowtag
))))
677 (emit-dword segment
(or offset
0)))))
679 (defun emit-relative-fixup (segment fixup
)
680 (note-fixup segment
:relative fixup
)
681 (emit-dword segment
(or (fixup-offset fixup
) 0)))
683 ;;;; the effective-address (ea) structure
685 (defun reg-tn-encoding (tn)
686 (declare (type tn tn
))
687 ; (aver (eq (sb-name (sc-sb (tn-sc tn))) 'registers))
688 (let ((offset (tn-offset tn
)))
689 (logior (ash (logand offset
1) 2)
692 (defstruct (ea (:constructor make-ea
(size &key base index scale disp
))
694 (size nil
:type
(member :byte
:word
:dword
:xmmword
))
695 (base nil
:type
(or tn null
))
696 (index nil
:type
(or tn null
))
697 (scale 1 :type
(member 1 2 4 8))
698 (disp 0 :type
(or (unsigned-byte 32) (signed-byte 32) fixup
)))
699 (def!method print-object
((ea ea
) stream
)
700 (cond ((or *print-escape
* *print-readably
*)
701 (print-unreadable-object (ea stream
:type t
)
703 "~S~@[ base=~S~]~@[ index=~S~]~@[ scale=~S~]~@[ disp=~S~]"
707 (let ((scale (ea-scale ea
)))
708 (if (= scale
1) nil scale
))
711 (format stream
"~A PTR [" (symbol-name (ea-size ea
)))
713 (write-string (sb!c
::location-print-name
(ea-base ea
)) stream
)
715 (write-string "+" stream
)))
717 (write-string (sb!c
::location-print-name
(ea-index ea
)) stream
))
718 (unless (= (ea-scale ea
) 1)
719 (format stream
"*~A" (ea-scale ea
)))
720 (typecase (ea-disp ea
)
723 (format stream
"~@D" (ea-disp ea
)))
725 (format stream
"+~A" (ea-disp ea
))))
726 (write-char #\
] stream
))))
728 (defun emit-ea (segment thing reg
&optional allow-constants
)
731 (ecase (sb-name (sc-sb (tn-sc thing
)))
733 (emit-mod-reg-r/m-byte segment
#b11 reg
(reg-tn-encoding thing
)))
735 (emit-mod-reg-r/m-byte segment
#b11 reg
(reg-tn-encoding thing
)))
737 ;; Convert stack tns into an index off of EBP.
738 (let ((disp (frame-byte-offset (tn-offset thing
))))
739 (cond ((<= -
128 disp
127)
740 (emit-mod-reg-r/m-byte segment
#b01 reg
#b101
)
741 (emit-byte segment disp
))
743 (emit-mod-reg-r/m-byte segment
#b10 reg
#b101
)
744 (emit-dword segment disp
)))))
746 (unless allow-constants
748 "Constant TNs can only be directly used in MOV, PUSH, and CMP."))
749 (emit-mod-reg-r/m-byte segment
#b00 reg
#b101
)
750 (emit-absolute-fixup segment
753 (- (* (tn-offset thing
) n-word-bytes
)
754 other-pointer-lowtag
))))))
756 (let* ((base (ea-base thing
))
757 (index (ea-index thing
))
758 (scale (ea-scale thing
))
759 (disp (ea-disp thing
))
760 (mod (cond ((or (null base
)
762 (not (= (reg-tn-encoding base
) #b101
))))
764 ((and (fixnump disp
) (<= -
128 disp
127))
768 (r/m
(cond (index #b100
)
770 (t (reg-tn-encoding base
)))))
771 (emit-mod-reg-r/m-byte segment mod reg r
/m
)
773 (let ((ss (1- (integer-length scale
)))
774 (index (if (null index
)
776 (let ((index (reg-tn-encoding index
)))
778 (error "can't index off of ESP")
780 (base (if (null base
)
782 (reg-tn-encoding base
))))
783 (emit-sib-byte segment ss index base
)))
785 (emit-byte segment disp
))
786 ((or (= mod
#b10
) (null base
))
788 (emit-absolute-fixup segment disp
)
789 (emit-dword segment disp
))))))
791 (emit-mod-reg-r/m-byte segment
#b00 reg
#b101
)
792 (emit-absolute-fixup segment thing
))))
794 (defun fp-reg-tn-p (thing)
796 (eq (sb-name (sc-sb (tn-sc thing
))) 'float-registers
)))
798 ;;; like the above, but for fp-instructions--jrd
799 (defun emit-fp-op (segment thing op
)
800 (if (fp-reg-tn-p thing
)
801 (emit-byte segment
(dpb op
(byte 3 3) (dpb (tn-offset thing
)
804 (emit-ea segment thing op
)))
806 (defun byte-reg-p (thing)
808 (eq (sb-name (sc-sb (tn-sc thing
))) 'registers
)
809 (member (sc-name (tn-sc thing
)) *byte-sc-names
*)
812 (defun byte-ea-p (thing)
814 (ea (eq (ea-size thing
) :byte
))
816 (and (member (sc-name (tn-sc thing
)) *byte-sc-names
*) t
))
819 (defun word-reg-p (thing)
821 (eq (sb-name (sc-sb (tn-sc thing
))) 'registers
)
822 (member (sc-name (tn-sc thing
)) *word-sc-names
*)
825 (defun word-ea-p (thing)
827 (ea (eq (ea-size thing
) :word
))
828 (tn (and (member (sc-name (tn-sc thing
)) *word-sc-names
*) t
))
831 (defun dword-reg-p (thing)
833 (eq (sb-name (sc-sb (tn-sc thing
))) 'registers
)
834 (member (sc-name (tn-sc thing
)) *dword-sc-names
*)
837 (defun dword-ea-p (thing)
839 (ea (eq (ea-size thing
) :dword
))
841 (and (member (sc-name (tn-sc thing
)) *dword-sc-names
*) t
))
844 (defun register-p (thing)
846 (eq (sb-name (sc-sb (tn-sc thing
))) 'registers
)))
848 (defun xmm-register-p (thing)
850 (eq (sb-name (sc-sb (tn-sc thing
))) 'xmm-registers
)
851 (member (sc-name (tn-sc thing
)) *xmmword-sc-names
*)
854 (defun xmm-ea-p (thing)
856 (ea (eq (ea-size thing
) :xmmword
))
858 (and (member (sc-name (tn-sc thing
)) *xmmword-sc-names
*) t
))
861 (defun accumulator-p (thing)
862 (and (register-p thing
)
863 (= (tn-offset thing
) 0)))
867 (def!constant
+operand-size-prefix-byte
+ #b01100110
)
869 (defun maybe-emit-operand-size-prefix (segment size
)
870 (unless (or (eq size
:byte
) (eq size
+default-operand-size
+))
871 (emit-byte segment
+operand-size-prefix-byte
+)))
873 (defun operand-size (thing)
876 ;; FIXME: might as well be COND instead of having to use #. readmacro
877 ;; to hack up the code
878 (case (sc-name (tn-sc thing
))
885 ;; added by jrd: float-registers is a separate size (?)
890 (#.
*xmmword-sc-names
*
893 (error "can't tell the size of ~S ~S" thing
(sc-name (tn-sc thing
))))))
899 (defun matching-operand-size (dst src
)
900 (let ((dst-size (operand-size dst
))
901 (src-size (operand-size src
)))
904 (if (eq dst-size src-size
)
906 (error "size mismatch: ~S is a ~S and ~S is a ~S."
907 dst dst-size src src-size
))
911 (error "can't tell the size of either ~S or ~S" dst src
)))))
913 (defun emit-sized-immediate (segment size value
)
916 (emit-byte segment value
))
918 (emit-word segment value
))
920 (emit-dword segment value
))))
922 (defun toggle-word-width (chunk inst stream dstate
)
923 (declare (ignore chunk inst stream
))
924 (let ((word-width (or (sb!disassem
:dstate-get-prop dstate
'word-width
)
925 +default-operand-size
+)))
926 (setf (sb!disassem
:dstate-get-prop dstate
'word-width
)
931 ;;; This is a "prefix" instruction, which means that it modifies the
932 ;;; following instruction in some way without having an actual
933 ;;; mnemonic of its own.
934 (define-instruction operand-size-prefix
(segment)
935 (:printer byte
((op +operand-size-prefix-byte
+))
936 nil
; don't actually print it
937 :control
#'toggle-word-width
))
939 ;;;; general data transfer
941 (define-instruction mov
(segment dst src
)
942 ;; immediate to register
943 (:printer reg
((op #b1011
) (imm nil
:type
'imm-data
))
944 '(:name
:tab reg
", " imm
))
945 ;; absolute mem to/from accumulator
946 (:printer simple-dir
((op #b101000
) (imm nil
:type
'imm-addr
))
947 `(:name
:tab
,(swap-if 'dir
'accum
", " '("[" imm
"]"))))
948 ;; register to/from register/memory
949 (:printer reg-reg
/mem-dir
((op #b100010
)))
950 ;; immediate to register/memory
951 (:printer reg
/mem-imm
((op '(#b1100011
#b000
))))
954 (let ((size (matching-operand-size dst src
)))
955 (maybe-emit-operand-size-prefix segment size
)
956 (cond ((register-p dst
)
957 (cond ((integerp src
)
958 (emit-byte-with-reg segment
962 (reg-tn-encoding dst
))
963 (emit-sized-immediate segment size src
))
964 ((and (fixup-p src
) (accumulator-p dst
))
969 (emit-absolute-fixup segment src
))
975 (emit-ea segment src
(reg-tn-encoding dst
) t
))))
976 ((and (fixup-p dst
) (accumulator-p src
))
977 (emit-byte segment
(if (eq size
:byte
) #b10100010
#b10100011
))
978 (emit-absolute-fixup segment dst
))
980 (emit-byte segment
(if (eq size
:byte
) #b11000110
#b11000111
))
981 (emit-ea segment dst
#b000
)
982 (emit-sized-immediate segment size src
))
984 (emit-byte segment
(if (eq size
:byte
) #b10001000
#b10001001
))
985 (emit-ea segment dst
(reg-tn-encoding src
)))
987 (aver (eq size
:dword
))
988 (emit-byte segment
#b11000111
)
989 (emit-ea segment dst
#b000
)
990 (emit-absolute-fixup segment src
))
992 (error "bogus arguments to MOV: ~S ~S" dst src
))))))
994 (defun emit-move-with-extension (segment dst src opcode
)
995 (aver (register-p dst
))
996 (let ((dst-size (operand-size dst
))
997 (src-size (operand-size src
)))
1000 (aver (eq src-size
:byte
))
1001 (maybe-emit-operand-size-prefix segment
:word
)
1002 (emit-byte segment
#b00001111
)
1003 (emit-byte segment opcode
)
1004 (emit-ea segment src
(reg-tn-encoding dst
)))
1008 (maybe-emit-operand-size-prefix segment
:dword
)
1009 (emit-byte segment
#b00001111
)
1010 (emit-byte segment opcode
)
1011 (emit-ea segment src
(reg-tn-encoding dst
)))
1013 (emit-byte segment
#b00001111
)
1014 (emit-byte segment
(logior opcode
1))
1015 (emit-ea segment src
(reg-tn-encoding dst
))))))))
1017 (define-instruction movsx
(segment dst src
)
1018 (:printer ext-reg-reg
/mem
((op #b1011111
) (reg nil
:type
'word-reg
)))
1019 (:emitter
(emit-move-with-extension segment dst src
#b10111110
)))
1021 (define-instruction movzx
(segment dst src
)
1022 (:printer ext-reg-reg
/mem
((op #b1011011
) (reg nil
:type
'word-reg
)))
1023 (:emitter
(emit-move-with-extension segment dst src
#b10110110
)))
1025 (define-instruction push
(segment src
)
1027 (:printer reg-no-width
((op #b01010
)))
1029 (:printer reg
/mem
((op '(#b1111111
#b110
)) (width 1)))
1031 (:printer byte
((op #b01101010
) (imm nil
:type
'signed-imm-byte
))
1033 (:printer byte
((op #b01101000
) (imm nil
:type
'imm-word
))
1035 ;; ### segment registers?
1038 (cond ((integerp src
)
1039 (cond ((<= -
128 src
127)
1040 (emit-byte segment
#b01101010
)
1041 (emit-byte segment src
))
1043 (emit-byte segment
#b01101000
)
1044 (emit-dword segment src
))))
1046 ;; Interpret the fixup as an immediate dword to push.
1047 (emit-byte segment
#b01101000
)
1048 (emit-absolute-fixup segment src
))
1050 (let ((size (operand-size src
)))
1051 (aver (not (eq size
:byte
)))
1052 (maybe-emit-operand-size-prefix segment size
)
1053 (cond ((register-p src
)
1054 (emit-byte-with-reg segment
#b01010
(reg-tn-encoding src
)))
1056 (emit-byte segment
#b11111111
)
1057 (emit-ea segment src
#b110 t
))))))))
1059 (define-instruction pusha
(segment)
1060 (:printer byte
((op #b01100000
)))
1062 (emit-byte segment
#b01100000
)))
1064 (define-instruction pop
(segment dst
)
1065 (:printer reg-no-width
((op #b01011
)))
1066 (:printer reg
/mem
((op '(#b1000111
#b000
)) (width 1)))
1068 (let ((size (operand-size dst
)))
1069 (aver (not (eq size
:byte
)))
1070 (maybe-emit-operand-size-prefix segment size
)
1071 (cond ((register-p dst
)
1072 (emit-byte-with-reg segment
#b01011
(reg-tn-encoding dst
)))
1074 (emit-byte segment
#b10001111
)
1075 (emit-ea segment dst
#b000
))))))
1077 (define-instruction popa
(segment)
1078 (:printer byte
((op #b01100001
)))
1080 (emit-byte segment
#b01100001
)))
1082 (define-instruction xchg
(segment operand1 operand2
)
1083 ;; Register with accumulator.
1084 (:printer reg-no-width
((op #b10010
)) '(:name
:tab accum
", " reg
))
1085 ;; Register/Memory with Register.
1086 (:printer reg-reg
/mem
((op #b1000011
)))
1088 (let ((size (matching-operand-size operand1 operand2
)))
1089 (maybe-emit-operand-size-prefix segment size
)
1090 (labels ((xchg-acc-with-something (acc something
)
1091 (if (and (not (eq size
:byte
)) (register-p something
))
1092 (emit-byte-with-reg segment
1094 (reg-tn-encoding something
))
1095 (xchg-reg-with-something acc something
)))
1096 (xchg-reg-with-something (reg something
)
1097 (emit-byte segment
(if (eq size
:byte
) #b10000110
#b10000111
))
1098 (emit-ea segment something
(reg-tn-encoding reg
))))
1099 (cond ((accumulator-p operand1
)
1100 (xchg-acc-with-something operand1 operand2
))
1101 ((accumulator-p operand2
)
1102 (xchg-acc-with-something operand2 operand1
))
1103 ((register-p operand1
)
1104 (xchg-reg-with-something operand1 operand2
))
1105 ((register-p operand2
)
1106 (xchg-reg-with-something operand2 operand1
))
1108 (error "bogus args to XCHG: ~S ~S" operand1 operand2
)))))))
1110 (define-instruction lea
(segment dst src
)
1111 (:printer reg-reg
/mem
((op #b1000110
) (width 1)))
1113 (aver (dword-reg-p dst
))
1114 (emit-byte segment
#b10001101
)
1115 (emit-ea segment src
(reg-tn-encoding dst
))))
1117 (define-instruction cmpxchg
(segment dst src
)
1118 ;; Register/Memory with Register.
1119 (:printer ext-reg-reg
/mem
((op #b1011000
)) '(:name
:tab reg
/mem
", " reg
))
1121 (aver (register-p src
))
1122 (let ((size (matching-operand-size src dst
)))
1123 (maybe-emit-operand-size-prefix segment size
)
1124 (emit-byte segment
#b00001111
)
1125 (emit-byte segment
(if (eq size
:byte
) #b10110000
#b10110001
))
1126 (emit-ea segment dst
(reg-tn-encoding src
)))))
1130 (define-instruction fs-segment-prefix
(segment)
1131 (:printer byte
((op #b01100100
)))
1133 (emit-byte segment
#x64
)))
1135 (define-instruction gs-segment-prefix
(segment)
1136 (:printer byte
((op #b01100101
)))
1138 (emit-byte segment
#x65
)))
1140 ;;;; flag control instructions
1142 ;;; CLC -- Clear Carry Flag.
1143 (define-instruction clc
(segment)
1144 (:printer byte
((op #b11111000
)))
1146 (emit-byte segment
#b11111000
)))
1148 ;;; CLD -- Clear Direction Flag.
1149 (define-instruction cld
(segment)
1150 (:printer byte
((op #b11111100
)))
1152 (emit-byte segment
#b11111100
)))
1154 ;;; CLI -- Clear Iterrupt Enable Flag.
1155 (define-instruction cli
(segment)
1156 (:printer byte
((op #b11111010
)))
1158 (emit-byte segment
#b11111010
)))
1160 ;;; CMC -- Complement Carry Flag.
1161 (define-instruction cmc
(segment)
1162 (:printer byte
((op #b11110101
)))
1164 (emit-byte segment
#b11110101
)))
1166 ;;; LAHF -- Load AH into flags.
1167 (define-instruction lahf
(segment)
1168 (:printer byte
((op #b10011111
)))
1170 (emit-byte segment
#b10011111
)))
1172 ;;; POPF -- Pop flags.
1173 (define-instruction popf
(segment)
1174 (:printer byte
((op #b10011101
)))
1176 (emit-byte segment
#b10011101
)))
1178 ;;; PUSHF -- push flags.
1179 (define-instruction pushf
(segment)
1180 (:printer byte
((op #b10011100
)))
1182 (emit-byte segment
#b10011100
)))
1184 ;;; SAHF -- Store AH into flags.
1185 (define-instruction sahf
(segment)
1186 (:printer byte
((op #b10011110
)))
1188 (emit-byte segment
#b10011110
)))
1190 ;;; STC -- Set Carry Flag.
1191 (define-instruction stc
(segment)
1192 (:printer byte
((op #b11111001
)))
1194 (emit-byte segment
#b11111001
)))
1196 ;;; STD -- Set Direction Flag.
1197 (define-instruction std
(segment)
1198 (:printer byte
((op #b11111101
)))
1200 (emit-byte segment
#b11111101
)))
1202 ;;; STI -- Set Interrupt Enable Flag.
1203 (define-instruction sti
(segment)
1204 (:printer byte
((op #b11111011
)))
1206 (emit-byte segment
#b11111011
)))
1210 (defun emit-random-arith-inst (name segment dst src opcode
1211 &optional allow-constants
)
1212 (let ((size (matching-operand-size dst src
)))
1213 (maybe-emit-operand-size-prefix segment size
)
1216 (cond ((and (not (eq size
:byte
)) (<= -
128 src
127))
1217 (emit-byte segment
#b10000011
)
1218 (emit-ea segment dst opcode allow-constants
)
1219 (emit-byte segment src
))
1220 ((accumulator-p dst
)
1227 (emit-sized-immediate segment size src
))
1229 (emit-byte segment
(if (eq size
:byte
) #b10000000
#b10000001
))
1230 (emit-ea segment dst opcode allow-constants
)
1231 (emit-sized-immediate segment size src
))))
1236 (if (eq size
:byte
) #b00000000
#b00000001
)))
1237 (emit-ea segment dst
(reg-tn-encoding src
) allow-constants
))
1242 (if (eq size
:byte
) #b00000010
#b00000011
)))
1243 (emit-ea segment src
(reg-tn-encoding dst
) allow-constants
))
1245 (error "bogus operands to ~A" name
)))))
1247 (eval-when (:compile-toplevel
:execute
)
1248 (defun arith-inst-printer-list (subop)
1249 `((accum-imm ((op ,(dpb subop
(byte 3 2) #b0000010
))))
1250 (reg/mem-imm
((op (#b1000000
,subop
))))
1251 (reg/mem-imm
((op (#b1000001
,subop
))
1252 (imm nil
:type signed-imm-byte
)))
1253 (reg-reg/mem-dir
((op ,(dpb subop
(byte 3 1) #b000000
))))))
1256 (define-instruction add
(segment dst src
)
1257 (:printer-list
(arith-inst-printer-list #b000
))
1258 (:emitter
(emit-random-arith-inst "ADD" segment dst src
#b000
)))
1260 (define-instruction adc
(segment dst src
)
1261 (:printer-list
(arith-inst-printer-list #b010
))
1262 (:emitter
(emit-random-arith-inst "ADC" segment dst src
#b010
)))
1264 (define-instruction sub
(segment dst src
)
1265 (:printer-list
(arith-inst-printer-list #b101
))
1266 (:emitter
(emit-random-arith-inst "SUB" segment dst src
#b101
)))
1268 (define-instruction sbb
(segment dst src
)
1269 (:printer-list
(arith-inst-printer-list #b011
))
1270 (:emitter
(emit-random-arith-inst "SBB" segment dst src
#b011
)))
1272 (define-instruction cmp
(segment dst src
)
1273 (:printer-list
(arith-inst-printer-list #b111
))
1274 (:emitter
(emit-random-arith-inst "CMP" segment dst src
#b111 t
)))
1276 (define-instruction inc
(segment dst
)
1278 (:printer reg-no-width
((op #b01000
)))
1280 (:printer reg
/mem
((op '(#b1111111
#b000
))))
1282 (let ((size (operand-size dst
)))
1283 (maybe-emit-operand-size-prefix segment size
)
1284 (cond ((and (not (eq size
:byte
)) (register-p dst
))
1285 (emit-byte-with-reg segment
#b01000
(reg-tn-encoding dst
)))
1287 (emit-byte segment
(if (eq size
:byte
) #b11111110
#b11111111
))
1288 (emit-ea segment dst
#b000
))))))
1290 (define-instruction dec
(segment dst
)
1292 (:printer reg-no-width
((op #b01001
)))
1294 (:printer reg
/mem
((op '(#b1111111
#b001
))))
1296 (let ((size (operand-size dst
)))
1297 (maybe-emit-operand-size-prefix segment size
)
1298 (cond ((and (not (eq size
:byte
)) (register-p dst
))
1299 (emit-byte-with-reg segment
#b01001
(reg-tn-encoding dst
)))
1301 (emit-byte segment
(if (eq size
:byte
) #b11111110
#b11111111
))
1302 (emit-ea segment dst
#b001
))))))
1304 (define-instruction neg
(segment dst
)
1305 (:printer reg
/mem
((op '(#b1111011
#b011
))))
1307 (let ((size (operand-size dst
)))
1308 (maybe-emit-operand-size-prefix segment size
)
1309 (emit-byte segment
(if (eq size
:byte
) #b11110110
#b11110111
))
1310 (emit-ea segment dst
#b011
))))
1312 (define-instruction aaa
(segment)
1313 (:printer byte
((op #b00110111
)))
1315 (emit-byte segment
#b00110111
)))
1317 (define-instruction aas
(segment)
1318 (:printer byte
((op #b00111111
)))
1320 (emit-byte segment
#b00111111
)))
1322 (define-instruction daa
(segment)
1323 (:printer byte
((op #b00100111
)))
1325 (emit-byte segment
#b00100111
)))
1327 (define-instruction das
(segment)
1328 (:printer byte
((op #b00101111
)))
1330 (emit-byte segment
#b00101111
)))
1332 (define-instruction mul
(segment dst src
)
1333 (:printer accum-reg
/mem
((op '(#b1111011
#b100
))))
1335 (let ((size (matching-operand-size dst src
)))
1336 (aver (accumulator-p dst
))
1337 (maybe-emit-operand-size-prefix segment size
)
1338 (emit-byte segment
(if (eq size
:byte
) #b11110110
#b11110111
))
1339 (emit-ea segment src
#b100
))))
1341 (define-instruction imul
(segment dst
&optional src1 src2
)
1342 (:printer accum-reg
/mem
((op '(#b1111011
#b101
))))
1343 (:printer ext-reg-reg
/mem
((op #b1010111
)))
1344 (:printer reg-reg
/mem
((op #b0110100
) (width 1)
1345 (imm nil
:type
'signed-imm-word
))
1346 '(:name
:tab reg
", " reg
/mem
", " imm
))
1347 (:printer reg-reg
/mem
((op #b0110101
) (width 1)
1348 (imm nil
:type
'signed-imm-byte
))
1349 '(:name
:tab reg
", " reg
/mem
", " imm
))
1351 (flet ((r/m-with-immed-to-reg
(reg r
/m immed
)
1352 (let* ((size (matching-operand-size reg r
/m
))
1353 (sx (and (not (eq size
:byte
)) (<= -
128 immed
127))))
1354 (maybe-emit-operand-size-prefix segment size
)
1355 (emit-byte segment
(if sx
#b01101011
#b01101001
))
1356 (emit-ea segment r
/m
(reg-tn-encoding reg
))
1358 (emit-byte segment immed
)
1359 (emit-sized-immediate segment size immed
)))))
1361 (r/m-with-immed-to-reg dst src1 src2
))
1364 (r/m-with-immed-to-reg dst dst src1
)
1365 (let ((size (matching-operand-size dst src1
)))
1366 (maybe-emit-operand-size-prefix segment size
)
1367 (emit-byte segment
#b00001111
)
1368 (emit-byte segment
#b10101111
)
1369 (emit-ea segment src1
(reg-tn-encoding dst
)))))
1371 (let ((size (operand-size dst
)))
1372 (maybe-emit-operand-size-prefix segment size
)
1373 (emit-byte segment
(if (eq size
:byte
) #b11110110
#b11110111
))
1374 (emit-ea segment dst
#b101
)))))))
1376 (define-instruction div
(segment dst src
)
1377 (:printer accum-reg
/mem
((op '(#b1111011
#b110
))))
1379 (let ((size (matching-operand-size dst src
)))
1380 (aver (accumulator-p dst
))
1381 (maybe-emit-operand-size-prefix segment size
)
1382 (emit-byte segment
(if (eq size
:byte
) #b11110110
#b11110111
))
1383 (emit-ea segment src
#b110
))))
1385 (define-instruction idiv
(segment dst src
)
1386 (:printer accum-reg
/mem
((op '(#b1111011
#b111
))))
1388 (let ((size (matching-operand-size dst src
)))
1389 (aver (accumulator-p dst
))
1390 (maybe-emit-operand-size-prefix segment size
)
1391 (emit-byte segment
(if (eq size
:byte
) #b11110110
#b11110111
))
1392 (emit-ea segment src
#b111
))))
1394 (define-instruction aad
(segment)
1395 (:printer two-bytes
((op '(#b11010101
#b00001010
))))
1397 (emit-byte segment
#b11010101
)
1398 (emit-byte segment
#b00001010
)))
1400 (define-instruction aam
(segment)
1401 (:printer two-bytes
((op '(#b11010100
#b00001010
))))
1403 (emit-byte segment
#b11010100
)
1404 (emit-byte segment
#b00001010
)))
1406 ;;; CBW -- Convert Byte to Word. AX <- sign_xtnd(AL)
1407 (define-instruction cbw
(segment)
1409 (maybe-emit-operand-size-prefix segment
:word
)
1410 (emit-byte segment
#b10011000
)))
1412 ;;; CWDE -- Convert Word To Double Word Extened. EAX <- sign_xtnd(AX)
1413 (define-instruction cwde
(segment)
1415 (maybe-emit-operand-size-prefix segment
:dword
)
1416 (emit-byte segment
#b10011000
)))
1418 ;;; CWD -- Convert Word to Double Word. DX:AX <- sign_xtnd(AX)
1419 (define-instruction cwd
(segment)
1421 (maybe-emit-operand-size-prefix segment
:word
)
1422 (emit-byte segment
#b10011001
)))
1424 ;;; CDQ -- Convert Double Word to Quad Word. EDX:EAX <- sign_xtnd(EAX)
1425 (define-instruction cdq
(segment)
1426 (:printer byte
((op #b10011001
)))
1428 (maybe-emit-operand-size-prefix segment
:dword
)
1429 (emit-byte segment
#b10011001
)))
1431 (define-instruction xadd
(segment dst src
)
1432 ;; Register/Memory with Register.
1433 (:printer ext-reg-reg
/mem
((op #b1100000
)) '(:name
:tab reg
/mem
", " reg
))
1435 (aver (register-p src
))
1436 (let ((size (matching-operand-size src dst
)))
1437 (maybe-emit-operand-size-prefix segment size
)
1438 (emit-byte segment
#b00001111
)
1439 (emit-byte segment
(if (eq size
:byte
) #b11000000
#b11000001
))
1440 (emit-ea segment dst
(reg-tn-encoding src
)))))
1445 (defun emit-shift-inst (segment dst amount opcode
)
1446 (let ((size (operand-size dst
)))
1447 (maybe-emit-operand-size-prefix segment size
)
1448 (multiple-value-bind (major-opcode immed
)
1450 (:cl
(values #b11010010 nil
))
1451 (1 (values #b11010000 nil
))
1452 (t (values #b11000000 t
)))
1454 (if (eq size
:byte
) major-opcode
(logior major-opcode
1)))
1455 (emit-ea segment dst opcode
)
1457 (emit-byte segment amount
)))))
1459 (eval-when (:compile-toplevel
:execute
)
1460 (defun shift-inst-printer-list (subop)
1461 `((reg/mem
((op (#b1101000
,subop
)))
1462 (:name
:tab reg
/mem
", 1"))
1463 (reg/mem
((op (#b1101001
,subop
)))
1464 (:name
:tab reg
/mem
", " 'cl
))
1465 (reg/mem-imm
((op (#b1100000
,subop
))
1466 (imm nil
:type signed-imm-byte
))))))
1468 (define-instruction rol
(segment dst amount
)
1470 (shift-inst-printer-list #b000
))
1472 (emit-shift-inst segment dst amount
#b000
)))
1474 (define-instruction ror
(segment dst amount
)
1476 (shift-inst-printer-list #b001
))
1478 (emit-shift-inst segment dst amount
#b001
)))
1480 (define-instruction rcl
(segment dst amount
)
1482 (shift-inst-printer-list #b010
))
1484 (emit-shift-inst segment dst amount
#b010
)))
1486 (define-instruction rcr
(segment dst amount
)
1488 (shift-inst-printer-list #b011
))
1490 (emit-shift-inst segment dst amount
#b011
)))
1492 (define-instruction shl
(segment dst amount
)
1494 (shift-inst-printer-list #b100
))
1496 (emit-shift-inst segment dst amount
#b100
)))
1498 (define-instruction shr
(segment dst amount
)
1500 (shift-inst-printer-list #b101
))
1502 (emit-shift-inst segment dst amount
#b101
)))
1504 (define-instruction sar
(segment dst amount
)
1506 (shift-inst-printer-list #b111
))
1508 (emit-shift-inst segment dst amount
#b111
)))
1510 (defun emit-double-shift (segment opcode dst src amt
)
1511 (let ((size (matching-operand-size dst src
)))
1512 (when (eq size
:byte
)
1513 (error "Double shifts can only be used with words."))
1514 (maybe-emit-operand-size-prefix segment size
)
1515 (emit-byte segment
#b00001111
)
1516 (emit-byte segment
(dpb opcode
(byte 1 3)
1517 (if (eq amt
:cl
) #b10100101
#b10100100
)))
1519 (emit-ea segment dst src
)
1520 (emit-ea segment dst
(reg-tn-encoding src
)) ; pw tries this
1521 (unless (eq amt
:cl
)
1522 (emit-byte segment amt
))))
1524 (eval-when (:compile-toplevel
:execute
)
1525 (defun double-shift-inst-printer-list (op)
1527 (ext-reg-reg/mem-imm
((op ,(logior op
#b10
))
1528 (imm nil
:type signed-imm-byte
)))
1529 (ext-reg-reg/mem
((op ,(logior op
#b10
)))
1530 (:name
:tab reg
/mem
", " reg
", " 'cl
)))))
1532 (define-instruction shld
(segment dst src amt
)
1533 (:declare
(type (or (member :cl
) (mod 32)) amt
))
1534 (:printer-list
(double-shift-inst-printer-list #b1010000
))
1536 (emit-double-shift segment
#b0 dst src amt
)))
1538 (define-instruction shrd
(segment dst src amt
)
1539 (:declare
(type (or (member :cl
) (mod 32)) amt
))
1540 (:printer-list
(double-shift-inst-printer-list #b1010100
))
1542 (emit-double-shift segment
#b1 dst src amt
)))
1544 (define-instruction and
(segment dst src
)
1546 (arith-inst-printer-list #b100
))
1548 (emit-random-arith-inst "AND" segment dst src
#b100
)))
1550 (define-instruction test
(segment this that
)
1551 (:printer accum-imm
((op #b1010100
)))
1552 (:printer reg
/mem-imm
((op '(#b1111011
#b000
))))
1553 (:printer reg-reg
/mem
((op #b1000010
)))
1555 (let ((size (matching-operand-size this that
)))
1556 (maybe-emit-operand-size-prefix segment size
)
1557 (flet ((test-immed-and-something (immed something
)
1558 (cond ((accumulator-p something
)
1560 (if (eq size
:byte
) #b10101000
#b10101001
))
1561 (emit-sized-immediate segment size immed
))
1564 (if (eq size
:byte
) #b11110110
#b11110111
))
1565 (emit-ea segment something
#b000
)
1566 (emit-sized-immediate segment size immed
))))
1567 (test-reg-and-something (reg something
)
1568 (emit-byte segment
(if (eq size
:byte
) #b10000100
#b10000101
))
1569 (emit-ea segment something
(reg-tn-encoding reg
))))
1570 (cond ((integerp that
)
1571 (test-immed-and-something that this
))
1573 (test-immed-and-something this that
))
1575 (test-reg-and-something this that
))
1577 (test-reg-and-something that this
))
1579 (error "bogus operands for TEST: ~S and ~S" this that
)))))))
1581 ;;; Emit the most compact form of the test immediate instruction,
1582 ;;; using an 8 bit test when the immediate is only 8 bits and the
1583 ;;; value is one of the four low registers (eax, ebx, ecx, edx) or the
1585 (defun emit-optimized-test-inst (x y
)
1588 (let ((offset (tn-offset x
)))
1589 (cond ((and (sc-is x any-reg descriptor-reg
)
1590 (or (= offset eax-offset
) (= offset ebx-offset
)
1591 (= offset ecx-offset
) (= offset edx-offset
)))
1592 (inst test
(make-random-tn :kind
:normal
1593 :sc
(sc-or-lose 'byte-reg
)
1596 ((sc-is x control-stack
)
1597 (inst test
(make-ea :byte
:base ebp-tn
1598 :disp
(- (* (1+ offset
) n-word-bytes
)))
1605 (define-instruction or
(segment dst src
)
1607 (arith-inst-printer-list #b001
))
1609 (emit-random-arith-inst "OR" segment dst src
#b001
)))
1611 (define-instruction xor
(segment dst src
)
1613 (arith-inst-printer-list #b110
))
1615 (emit-random-arith-inst "XOR" segment dst src
#b110
)))
1617 (define-instruction not
(segment dst
)
1618 (:printer reg
/mem
((op '(#b1111011
#b010
))))
1620 (let ((size (operand-size dst
)))
1621 (maybe-emit-operand-size-prefix segment size
)
1622 (emit-byte segment
(if (eq size
:byte
) #b11110110
#b11110111
))
1623 (emit-ea segment dst
#b010
))))
1625 ;;;; string manipulation
1627 (define-instruction cmps
(segment size
)
1628 (:printer string-op
((op #b1010011
)))
1630 (maybe-emit-operand-size-prefix segment size
)
1631 (emit-byte segment
(if (eq size
:byte
) #b10100110
#b10100111
))))
1633 (define-instruction ins
(segment acc
)
1634 (:printer string-op
((op #b0110110
)))
1636 (let ((size (operand-size acc
)))
1637 (aver (accumulator-p acc
))
1638 (maybe-emit-operand-size-prefix segment size
)
1639 (emit-byte segment
(if (eq size
:byte
) #b01101100
#b01101101
)))))
1641 (define-instruction lods
(segment acc
)
1642 (:printer string-op
((op #b1010110
)))
1644 (let ((size (operand-size acc
)))
1645 (aver (accumulator-p acc
))
1646 (maybe-emit-operand-size-prefix segment size
)
1647 (emit-byte segment
(if (eq size
:byte
) #b10101100
#b10101101
)))))
1649 (define-instruction movs
(segment size
)
1650 (:printer string-op
((op #b1010010
)))
1652 (maybe-emit-operand-size-prefix segment size
)
1653 (emit-byte segment
(if (eq size
:byte
) #b10100100
#b10100101
))))
1655 (define-instruction outs
(segment acc
)
1656 (:printer string-op
((op #b0110111
)))
1658 (let ((size (operand-size acc
)))
1659 (aver (accumulator-p acc
))
1660 (maybe-emit-operand-size-prefix segment size
)
1661 (emit-byte segment
(if (eq size
:byte
) #b01101110
#b01101111
)))))
1663 (define-instruction scas
(segment acc
)
1664 (:printer string-op
((op #b1010111
)))
1666 (let ((size (operand-size acc
)))
1667 (aver (accumulator-p acc
))
1668 (maybe-emit-operand-size-prefix segment size
)
1669 (emit-byte segment
(if (eq size
:byte
) #b10101110
#b10101111
)))))
1671 (define-instruction stos
(segment acc
)
1672 (:printer string-op
((op #b1010101
)))
1674 (let ((size (operand-size acc
)))
1675 (aver (accumulator-p acc
))
1676 (maybe-emit-operand-size-prefix segment size
)
1677 (emit-byte segment
(if (eq size
:byte
) #b10101010
#b10101011
)))))
1679 (define-instruction xlat
(segment)
1680 (:printer byte
((op #b11010111
)))
1682 (emit-byte segment
#b11010111
)))
1684 (define-instruction rep
(segment)
1686 (emit-byte segment
#b11110010
)))
1688 (define-instruction repe
(segment)
1689 (:printer byte
((op #b11110011
)))
1691 (emit-byte segment
#b11110011
)))
1693 (define-instruction repne
(segment)
1694 (:printer byte
((op #b11110010
)))
1696 (emit-byte segment
#b11110010
)))
1699 ;;;; bit manipulation
1701 (define-instruction bsf
(segment dst src
)
1702 (:printer ext-reg-reg
/mem
((op #b1011110
) (width 0)))
1704 (let ((size (matching-operand-size dst src
)))
1705 (when (eq size
:byte
)
1706 (error "can't scan bytes: ~S" src
))
1707 (maybe-emit-operand-size-prefix segment size
)
1708 (emit-byte segment
#b00001111
)
1709 (emit-byte segment
#b10111100
)
1710 (emit-ea segment src
(reg-tn-encoding dst
)))))
1712 (define-instruction bsr
(segment dst src
)
1713 (:printer ext-reg-reg
/mem
((op #b1011110
) (width 1)))
1715 (let ((size (matching-operand-size dst src
)))
1716 (when (eq size
:byte
)
1717 (error "can't scan bytes: ~S" src
))
1718 (maybe-emit-operand-size-prefix segment size
)
1719 (emit-byte segment
#b00001111
)
1720 (emit-byte segment
#b10111101
)
1721 (emit-ea segment src
(reg-tn-encoding dst
)))))
1723 (defun emit-bit-test-and-mumble (segment src index opcode
)
1724 (let ((size (operand-size src
)))
1725 (when (eq size
:byte
)
1726 (error "can't scan bytes: ~S" src
))
1727 (maybe-emit-operand-size-prefix segment size
)
1728 (emit-byte segment
#b00001111
)
1729 (cond ((integerp index
)
1730 (emit-byte segment
#b10111010
)
1731 (emit-ea segment src opcode
)
1732 (emit-byte segment index
))
1734 (emit-byte segment
(dpb opcode
(byte 3 3) #b10000011
))
1735 (emit-ea segment src
(reg-tn-encoding index
))))))
1737 (eval-when (:compile-toplevel
:execute
)
1738 (defun bit-test-inst-printer-list (subop)
1739 `((ext-reg/mem-imm
((op (#b1011101
,subop
))
1740 (reg/mem nil
:type word-reg
/mem
)
1741 (imm nil
:type imm-data
)
1743 (ext-reg-reg/mem
((op ,(dpb subop
(byte 3 2) #b1000001
))
1745 (:name
:tab reg
/mem
", " reg
)))))
1747 (define-instruction bt
(segment src index
)
1748 (:printer-list
(bit-test-inst-printer-list #b100
))
1750 (emit-bit-test-and-mumble segment src index
#b100
)))
1752 (define-instruction btc
(segment src index
)
1753 (:printer-list
(bit-test-inst-printer-list #b111
))
1755 (emit-bit-test-and-mumble segment src index
#b111
)))
1757 (define-instruction btr
(segment src index
)
1758 (:printer-list
(bit-test-inst-printer-list #b110
))
1760 (emit-bit-test-and-mumble segment src index
#b110
)))
1762 (define-instruction bts
(segment src index
)
1763 (:printer-list
(bit-test-inst-printer-list #b101
))
1765 (emit-bit-test-and-mumble segment src index
#b101
)))
1768 ;;;; control transfer
1770 (define-instruction call
(segment where
)
1771 (:printer near-jump
((op #b11101000
)))
1772 (:printer reg
/mem
((op '(#b1111111
#b010
)) (width 1)))
1776 (emit-byte segment
#b11101000
)
1777 (emit-back-patch segment
1779 (lambda (segment posn
)
1781 (- (label-position where
)
1784 (emit-byte segment
#b11101000
)
1785 (emit-relative-fixup segment where
))
1787 (emit-byte segment
#b11111111
)
1788 (emit-ea segment where
#b010
)))))
1790 (defun emit-byte-displacement-backpatch (segment target
)
1791 (emit-back-patch segment
1793 (lambda (segment posn
)
1794 (let ((disp (- (label-position target
) (1+ posn
))))
1795 (aver (<= -
128 disp
127))
1796 (emit-byte segment disp
)))))
1798 (define-instruction jmp
(segment cond
&optional where
)
1799 ;; conditional jumps
1800 (:printer short-cond-jump
((op #b0111
)) '('j cc
:tab label
))
1801 (:printer near-cond-jump
() '('j cc
:tab label
))
1802 ;; unconditional jumps
1803 (:printer short-jump
((op #b1011
)))
1804 (:printer near-jump
((op #b11101001
)) )
1805 (:printer reg
/mem
((op '(#b1111111
#b100
)) (width 1)))
1810 (lambda (segment posn delta-if-after
)
1811 (let ((disp (- (label-position where posn delta-if-after
)
1813 (when (<= -
128 disp
127)
1815 (dpb (conditional-opcode cond
)
1818 (emit-byte-displacement-backpatch segment where
)
1820 (lambda (segment posn
)
1821 (let ((disp (- (label-position where
) (+ posn
6))))
1822 (emit-byte segment
#b00001111
)
1824 (dpb (conditional-opcode cond
)
1827 (emit-dword segment disp
)))))
1828 ((label-p (setq where cond
))
1831 (lambda (segment posn delta-if-after
)
1832 (let ((disp (- (label-position where posn delta-if-after
)
1834 (when (<= -
128 disp
127)
1835 (emit-byte segment
#b11101011
)
1836 (emit-byte-displacement-backpatch segment where
)
1838 (lambda (segment posn
)
1839 (let ((disp (- (label-position where
) (+ posn
5))))
1840 (emit-byte segment
#b11101001
)
1841 (emit-dword segment disp
)))))
1843 (emit-byte segment
#b11101001
)
1844 (emit-relative-fixup segment where
))
1846 (unless (or (ea-p where
) (tn-p where
))
1847 (error "don't know what to do with ~A" where
))
1848 (emit-byte segment
#b11111111
)
1849 (emit-ea segment where
#b100
)))))
1851 (define-instruction jmp-short
(segment label
)
1853 (emit-byte segment
#b11101011
)
1854 (emit-byte-displacement-backpatch segment label
)))
1856 (define-instruction ret
(segment &optional stack-delta
)
1857 (:printer byte
((op #b11000011
)))
1858 (:printer byte
((op #b11000010
) (imm nil
:type
'imm-word-16
))
1862 (emit-byte segment
#b11000010
)
1863 (emit-word segment stack-delta
))
1865 (emit-byte segment
#b11000011
)))))
1867 (define-instruction jecxz
(segment target
)
1868 (:printer short-jump
((op #b0011
)))
1870 (emit-byte segment
#b11100011
)
1871 (emit-byte-displacement-backpatch segment target
)))
1873 (define-instruction loop
(segment target
)
1874 (:printer short-jump
((op #b0010
)))
1876 (emit-byte segment
#b11100010
) ; pfw this was 11100011, or jecxz!!!!
1877 (emit-byte-displacement-backpatch segment target
)))
1879 (define-instruction loopz
(segment target
)
1880 (:printer short-jump
((op #b0001
)))
1882 (emit-byte segment
#b11100001
)
1883 (emit-byte-displacement-backpatch segment target
)))
1885 (define-instruction loopnz
(segment target
)
1886 (:printer short-jump
((op #b0000
)))
1888 (emit-byte segment
#b11100000
)
1889 (emit-byte-displacement-backpatch segment target
)))
1891 ;;;; conditional move
1892 (define-instruction cmov
(segment cond dst src
)
1893 (:printer cond-move
())
1895 (aver (register-p dst
))
1896 (let ((size (matching-operand-size dst src
)))
1897 (aver (or (eq size
:word
) (eq size
:dword
)))
1898 (maybe-emit-operand-size-prefix segment size
))
1899 (emit-byte segment
#b00001111
)
1900 (emit-byte segment
(dpb (conditional-opcode cond
) (byte 4 0) #b01000000
))
1901 (emit-ea segment src
(reg-tn-encoding dst
))))
1903 ;;;; conditional byte set
1905 (define-instruction set
(segment dst cond
)
1906 (:printer cond-set
())
1908 (emit-byte segment
#b00001111
)
1909 (emit-byte segment
(dpb (conditional-opcode cond
) (byte 4 0) #b10010000
))
1910 (emit-ea segment dst
#b000
)))
1914 (define-instruction enter
(segment disp
&optional
(level 0))
1915 (:declare
(type (unsigned-byte 16) disp
)
1916 (type (unsigned-byte 8) level
))
1917 (:printer enter-format
((op #b11001000
)))
1919 (emit-byte segment
#b11001000
)
1920 (emit-word segment disp
)
1921 (emit-byte segment level
)))
1923 (define-instruction leave
(segment)
1924 (:printer byte
((op #b11001001
)))
1926 (emit-byte segment
#b11001001
)))
1929 (define-instruction prefetchnta
(segment ea
)
1930 (:printer prefetch
((op #b00011000
) (reg #b000
)))
1932 (aver (typep ea
'ea
))
1933 (aver (eq :byte
(ea-size ea
)))
1934 (emit-byte segment
#b00001111
)
1935 (emit-byte segment
#b00011000
)
1936 (emit-ea segment ea
#b000
)))
1938 (define-instruction prefetcht0
(segment ea
)
1939 (:printer prefetch
((op #b00011000
) (reg #b001
)))
1941 (aver (typep ea
'ea
))
1942 (aver (eq :byte
(ea-size ea
)))
1943 (emit-byte segment
#b00001111
)
1944 (emit-byte segment
#b00011000
)
1945 (emit-ea segment ea
#b001
)))
1947 (define-instruction prefetcht1
(segment ea
)
1948 (:printer prefetch
((op #b00011000
) (reg #b010
)))
1950 (aver (typep ea
'ea
))
1951 (aver (eq :byte
(ea-size ea
)))
1952 (emit-byte segment
#b00001111
)
1953 (emit-byte segment
#b00011000
)
1954 (emit-ea segment ea
#b010
)))
1956 (define-instruction prefetcht2
(segment ea
)
1957 (:printer prefetch
((op #b00011000
) (reg #b011
)))
1959 (aver (typep ea
'ea
))
1960 (aver (eq :byte
(ea-size ea
)))
1961 (emit-byte segment
#b00001111
)
1962 (emit-byte segment
#b00011000
)
1963 (emit-ea segment ea
#b011
)))
1965 ;;;; interrupt instructions
1967 (defun snarf-error-junk (sap offset
&optional length-only
)
1968 (let* ((length (sb!sys
:sap-ref-8 sap offset
))
1969 (vector (make-array length
:element-type
'(unsigned-byte 8))))
1970 (declare (type sb
!sys
:system-area-pointer sap
)
1971 (type (unsigned-byte 8) length
)
1972 (type (simple-array (unsigned-byte 8) (*)) vector
))
1974 (values 0 (1+ length
) nil nil
))
1976 (sb!kernel
:copy-ub8-from-system-area sap
(1+ offset
)
1978 (collect ((sc-offsets)
1980 (lengths 1) ; the length byte
1982 (error-number (sb!c
:read-var-integer vector index
)))
1985 (when (>= index length
)
1987 (let ((old-index index
))
1988 (sc-offsets (sb!c
:read-var-integer vector index
))
1989 (lengths (- index old-index
))))
1990 (values error-number
1996 (defmacro break-cases
(breaknum &body cases
)
1997 (let ((bn-temp (gensym)))
1998 (collect ((clauses))
1999 (dolist (case cases
)
2000 (clauses `((= ,bn-temp
,(car case
)) ,@(cdr case
))))
2001 `(let ((,bn-temp
,breaknum
))
2002 (cond ,@(clauses))))))
2005 (defun break-control (chunk inst stream dstate
)
2006 (declare (ignore inst
))
2007 (flet ((nt (x) (if stream
(sb!disassem
:note x dstate
))))
2008 ;; FIXME: Make sure that BYTE-IMM-CODE is defined. The genesis
2009 ;; map has it undefined; and it should be easier to look in the target
2010 ;; Lisp (with (DESCRIBE 'BYTE-IMM-CODE)) than to definitively deduce
2011 ;; from first principles whether it's defined in some way that genesis
2013 (case #!-darwin
(byte-imm-code chunk dstate
)
2014 #!+darwin
(word-imm-code chunk dstate
)
2017 (sb!disassem
:handle-break-args
#'snarf-error-junk stream dstate
))
2020 (sb!disassem
:handle-break-args
#'snarf-error-junk stream dstate
))
2022 (nt "breakpoint trap"))
2023 (#.pending-interrupt-trap
2024 (nt "pending interrupt trap"))
2027 (#.fun-end-breakpoint-trap
2028 (nt "function end breakpoint trap")))))
2030 (define-instruction break
(segment code
)
2031 (:declare
(type (unsigned-byte 8) code
))
2032 #!-darwin
(:printer byte-imm
((op #b11001100
)) '(:name
:tab code
)
2033 :control
#'break-control
)
2034 #!+darwin
(:printer word-imm
((op #b0000101100001111
)) '(:name
:tab code
)
2035 :control
#'break-control
)
2037 #!-darwin
(emit-byte segment
#b11001100
)
2038 ;; On darwin, trap handling via SIGTRAP is unreliable, therefore we
2039 ;; throw a sigill with 0x0b0f instead and check for this in the
2040 ;; SIGILL handler and pass it on to the sigtrap handler if
2042 #!+darwin
(emit-word segment
#b0000101100001111
)
2043 (emit-byte segment code
)))
2045 (define-instruction int
(segment number
)
2046 (:declare
(type (unsigned-byte 8) number
))
2047 (:printer byte-imm
((op #b11001101
)))
2051 (emit-byte segment
#b11001100
))
2053 (emit-byte segment
#b11001101
)
2054 (emit-byte segment number
)))))
2056 (define-instruction into
(segment)
2057 (:printer byte
((op #b11001110
)))
2059 (emit-byte segment
#b11001110
)))
2061 (define-instruction bound
(segment reg bounds
)
2063 (let ((size (matching-operand-size reg bounds
)))
2064 (when (eq size
:byte
)
2065 (error "can't bounds-test bytes: ~S" reg
))
2066 (maybe-emit-operand-size-prefix segment size
)
2067 (emit-byte segment
#b01100010
)
2068 (emit-ea segment bounds
(reg-tn-encoding reg
)))))
2070 (define-instruction iret
(segment)
2071 (:printer byte
((op #b11001111
)))
2073 (emit-byte segment
#b11001111
)))
2075 ;;;; processor control
2077 (define-instruction hlt
(segment)
2078 (:printer byte
((op #b11110100
)))
2080 (emit-byte segment
#b11110100
)))
2082 (define-instruction nop
(segment)
2083 (:printer byte
((op #b10010000
)))
2085 (emit-byte segment
#b10010000
)))
2087 (define-instruction wait
(segment)
2088 (:printer byte
((op #b10011011
)))
2090 (emit-byte segment
#b10011011
)))
2092 (define-instruction lock
(segment)
2093 (:printer byte
((op #b11110000
)))
2095 (emit-byte segment
#b11110000
)))
2097 ;;;; miscellaneous hackery
2099 (define-instruction byte
(segment byte
)
2101 (emit-byte segment byte
)))
2103 (define-instruction word
(segment word
)
2105 (emit-word segment word
)))
2107 (define-instruction dword
(segment dword
)
2109 (emit-dword segment dword
)))
2111 (defun emit-header-data (segment type
)
2112 (emit-back-patch segment
2114 (lambda (segment posn
)
2118 (component-header-length))
2122 (define-instruction simple-fun-header-word
(segment)
2124 (emit-header-data segment simple-fun-header-widetag
)))
2126 (define-instruction lra-header-word
(segment)
2128 (emit-header-data segment return-pc-header-widetag
)))
2131 ;;;; SSE instructions
2133 ;;;; Automatically generated
2136 (DEFINE-INSTRUCTION ADDPS
2138 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2139 (EMIT-BYTE SEGMENT
88)
2140 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2142 (DEFINE-INSTRUCTION ADDSUBPS
2144 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2145 (EMIT-BYTE SEGMENT
15)
2146 (EMIT-BYTE SEGMENT
208)
2147 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2149 (DEFINE-INSTRUCTION ANDNPS
2151 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2152 (EMIT-BYTE SEGMENT
85)
2153 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2155 (DEFINE-INSTRUCTION ANDPS
2157 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2158 (EMIT-BYTE SEGMENT
84)
2159 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2161 (DEFINE-INSTRUCTION DIVPS
2163 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2164 (EMIT-BYTE SEGMENT
94)
2165 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2167 (DEFINE-INSTRUCTION HADDPS
2169 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2170 (EMIT-BYTE SEGMENT
15)
2171 (EMIT-BYTE SEGMENT
124)
2172 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2174 (DEFINE-INSTRUCTION HSUBPS
2176 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2177 (EMIT-BYTE SEGMENT
15)
2178 (EMIT-BYTE SEGMENT
125)
2179 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2181 (DEFINE-INSTRUCTION MAXPS
2183 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2184 (EMIT-BYTE SEGMENT
95)
2185 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2187 (DEFINE-INSTRUCTION MINPS
2189 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2190 (EMIT-BYTE SEGMENT
93)
2191 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2193 (DEFINE-INSTRUCTION MULPS
2195 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2196 (EMIT-BYTE SEGMENT
89)
2197 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2199 (DEFINE-INSTRUCTION ORPS
2201 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2202 (EMIT-BYTE SEGMENT
86)
2203 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2205 (DEFINE-INSTRUCTION RCPPS
2207 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2208 (EMIT-BYTE SEGMENT
83)
2209 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2211 (DEFINE-INSTRUCTION RSQRTPS
2213 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2214 (EMIT-BYTE SEGMENT
82)
2215 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2217 (DEFINE-INSTRUCTION SQRTPS
2219 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2220 (EMIT-BYTE SEGMENT
81)
2221 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2223 (DEFINE-INSTRUCTION SUBPS
2225 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2226 (EMIT-BYTE SEGMENT
92)
2227 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2229 (DEFINE-INSTRUCTION UNPCKHPS
2231 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2232 (EMIT-BYTE SEGMENT
21)
2233 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2235 (DEFINE-INSTRUCTION UNPCKLPS
2237 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2238 (EMIT-BYTE SEGMENT
20)
2239 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2241 (DEFINE-INSTRUCTION XORPS
2243 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2244 (EMIT-BYTE SEGMENT
87)
2245 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2247 (DEFINE-INSTRUCTION ADDPD
2249 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2250 (EMIT-BYTE SEGMENT
15)
2251 (EMIT-BYTE SEGMENT
88)
2252 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2254 (DEFINE-INSTRUCTION ADDSUBPD
2256 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2257 (EMIT-BYTE SEGMENT
15)
2258 (EMIT-BYTE SEGMENT
208)
2259 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2261 (DEFINE-INSTRUCTION ANDNPD
2263 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2264 (EMIT-BYTE SEGMENT
15)
2265 (EMIT-BYTE SEGMENT
85)
2266 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2268 (DEFINE-INSTRUCTION ANDPD
2270 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2271 (EMIT-BYTE SEGMENT
15)
2272 (EMIT-BYTE SEGMENT
84)
2273 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2275 (DEFINE-INSTRUCTION DIVPD
2277 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2278 (EMIT-BYTE SEGMENT
15)
2279 (EMIT-BYTE SEGMENT
94)
2280 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2282 (DEFINE-INSTRUCTION HADDPD
2284 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2285 (EMIT-BYTE SEGMENT
15)
2286 (EMIT-BYTE SEGMENT
124)
2287 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2289 (DEFINE-INSTRUCTION HSUBPD
2291 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2292 (EMIT-BYTE SEGMENT
15)
2293 (EMIT-BYTE SEGMENT
125)
2294 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2296 (DEFINE-INSTRUCTION MAXPD
2298 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2299 (EMIT-BYTE SEGMENT
15)
2300 (EMIT-BYTE SEGMENT
95)
2301 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2303 (DEFINE-INSTRUCTION MINPD
2305 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2306 (EMIT-BYTE SEGMENT
15)
2307 (EMIT-BYTE SEGMENT
93)
2308 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2310 (DEFINE-INSTRUCTION MULPD
2312 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2313 (EMIT-BYTE SEGMENT
15)
2314 (EMIT-BYTE SEGMENT
89)
2315 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2317 (DEFINE-INSTRUCTION ORPD
2319 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2320 (EMIT-BYTE SEGMENT
15)
2321 (EMIT-BYTE SEGMENT
86)
2322 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2324 (DEFINE-INSTRUCTION SQRTPD
2326 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2327 (EMIT-BYTE SEGMENT
15)
2328 (EMIT-BYTE SEGMENT
81)
2329 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2331 (DEFINE-INSTRUCTION SUBPD
2333 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2334 (EMIT-BYTE SEGMENT
15)
2335 (EMIT-BYTE SEGMENT
92)
2336 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2338 (DEFINE-INSTRUCTION UNPCKHPD
2340 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2341 (EMIT-BYTE SEGMENT
15)
2342 (EMIT-BYTE SEGMENT
21)
2343 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2345 (DEFINE-INSTRUCTION UNPCKLPD
2347 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2348 (EMIT-BYTE SEGMENT
15)
2349 (EMIT-BYTE SEGMENT
20)
2350 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2352 (DEFINE-INSTRUCTION XORPD
2354 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2355 (EMIT-BYTE SEGMENT
15)
2356 (EMIT-BYTE SEGMENT
87)
2357 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2359 (DEFINE-INSTRUCTION ADDSD
2361 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2362 (EMIT-BYTE SEGMENT
15)
2363 (EMIT-BYTE SEGMENT
88)
2364 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2366 (DEFINE-INSTRUCTION COMISD
2368 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2369 (EMIT-BYTE SEGMENT
15)
2370 (EMIT-BYTE SEGMENT
47)
2371 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2373 (DEFINE-INSTRUCTION DIVSD
2375 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2376 (EMIT-BYTE SEGMENT
15)
2377 (EMIT-BYTE SEGMENT
94)
2378 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2380 (DEFINE-INSTRUCTION MAXSD
2382 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2383 (EMIT-BYTE SEGMENT
15)
2384 (EMIT-BYTE SEGMENT
95)
2385 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2387 (DEFINE-INSTRUCTION MINSD
2389 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2390 (EMIT-BYTE SEGMENT
15)
2391 (EMIT-BYTE SEGMENT
93)
2392 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2394 (DEFINE-INSTRUCTION MULSD
2396 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2397 (EMIT-BYTE SEGMENT
15)
2398 (EMIT-BYTE SEGMENT
89)
2399 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2401 (DEFINE-INSTRUCTION SQRTSD
2403 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2404 (EMIT-BYTE SEGMENT
15)
2405 (EMIT-BYTE SEGMENT
81)
2406 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2408 (DEFINE-INSTRUCTION SUBSD
2410 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2411 (EMIT-BYTE SEGMENT
15)
2412 (EMIT-BYTE SEGMENT
92)
2413 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2415 (DEFINE-INSTRUCTION UCOMISD
2417 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2418 (EMIT-BYTE SEGMENT
15)
2419 (EMIT-BYTE SEGMENT
46)
2420 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2422 (DEFINE-INSTRUCTION ADDSS
2424 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2425 (EMIT-BYTE SEGMENT
15)
2426 (EMIT-BYTE SEGMENT
88)
2427 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2429 (DEFINE-INSTRUCTION COMISS
2431 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2432 (EMIT-BYTE SEGMENT
47)
2433 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2435 (DEFINE-INSTRUCTION DIVSS
2437 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2438 (EMIT-BYTE SEGMENT
15)
2439 (EMIT-BYTE SEGMENT
94)
2440 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2442 (DEFINE-INSTRUCTION MAXSS
2444 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2445 (EMIT-BYTE SEGMENT
15)
2446 (EMIT-BYTE SEGMENT
95)
2447 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2449 (DEFINE-INSTRUCTION MINSS
2451 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2452 (EMIT-BYTE SEGMENT
15)
2453 (EMIT-BYTE SEGMENT
93)
2454 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2456 (DEFINE-INSTRUCTION MULSS
2458 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2459 (EMIT-BYTE SEGMENT
15)
2460 (EMIT-BYTE SEGMENT
89)
2461 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2463 (DEFINE-INSTRUCTION RCPSS
2465 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2466 (EMIT-BYTE SEGMENT
15)
2467 (EMIT-BYTE SEGMENT
83)
2468 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2470 (DEFINE-INSTRUCTION RSQRTSS
2472 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2473 (EMIT-BYTE SEGMENT
15)
2474 (EMIT-BYTE SEGMENT
82)
2475 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2477 (DEFINE-INSTRUCTION SQRTSS
2479 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2480 (EMIT-BYTE SEGMENT
15)
2481 (EMIT-BYTE SEGMENT
81)
2482 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2484 (DEFINE-INSTRUCTION SUBSS
2486 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2487 (EMIT-BYTE SEGMENT
15)
2488 (EMIT-BYTE SEGMENT
92)
2489 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2491 (DEFINE-INSTRUCTION UCOMISS
2493 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2494 (EMIT-BYTE SEGMENT
46)
2495 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2497 (DEFINE-INSTRUCTION PACKSSDW
2499 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2500 (EMIT-BYTE SEGMENT
15)
2501 (EMIT-BYTE SEGMENT
107)
2502 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2504 (DEFINE-INSTRUCTION PACKSSWB
2506 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2507 (EMIT-BYTE SEGMENT
15)
2508 (EMIT-BYTE SEGMENT
99)
2509 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2511 (DEFINE-INSTRUCTION PACKUSWB
2513 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2514 (EMIT-BYTE SEGMENT
15)
2515 (EMIT-BYTE SEGMENT
103)
2516 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2518 (DEFINE-INSTRUCTION PADDB
2520 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2521 (EMIT-BYTE SEGMENT
15)
2522 (EMIT-BYTE SEGMENT
252)
2523 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2525 (DEFINE-INSTRUCTION PADDD
2527 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2528 (EMIT-BYTE SEGMENT
15)
2529 (EMIT-BYTE SEGMENT
254)
2530 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2532 (DEFINE-INSTRUCTION PADDQ
2534 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2535 (EMIT-BYTE SEGMENT
15)
2536 (EMIT-BYTE SEGMENT
212)
2537 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2539 (DEFINE-INSTRUCTION PADDSB
2541 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2542 (EMIT-BYTE SEGMENT
15)
2543 (EMIT-BYTE SEGMENT
236)
2544 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2546 (DEFINE-INSTRUCTION PADDSW
2548 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2549 (EMIT-BYTE SEGMENT
15)
2550 (EMIT-BYTE SEGMENT
237)
2551 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2553 (DEFINE-INSTRUCTION PADDUSB
2555 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2556 (EMIT-BYTE SEGMENT
15)
2557 (EMIT-BYTE SEGMENT
220)
2558 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2560 (DEFINE-INSTRUCTION PADDUSW
2562 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2563 (EMIT-BYTE SEGMENT
15)
2564 (EMIT-BYTE SEGMENT
221)
2565 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2567 (DEFINE-INSTRUCTION PADDW
2569 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2570 (EMIT-BYTE SEGMENT
15)
2571 (EMIT-BYTE SEGMENT
253)
2572 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2574 (DEFINE-INSTRUCTION PAND
2576 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2577 (EMIT-BYTE SEGMENT
15)
2578 (EMIT-BYTE SEGMENT
219)
2579 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2581 (DEFINE-INSTRUCTION PANDN
2583 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2584 (EMIT-BYTE SEGMENT
15)
2585 (EMIT-BYTE SEGMENT
223)
2586 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2588 (DEFINE-INSTRUCTION PAVGB
2590 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2591 (EMIT-BYTE SEGMENT
15)
2592 (EMIT-BYTE SEGMENT
224)
2593 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2595 (DEFINE-INSTRUCTION PAVGW
2597 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2598 (EMIT-BYTE SEGMENT
15)
2599 (EMIT-BYTE SEGMENT
227)
2600 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2602 (DEFINE-INSTRUCTION PCMPEQB
2604 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2605 (EMIT-BYTE SEGMENT
15)
2606 (EMIT-BYTE SEGMENT
116)
2607 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2609 (DEFINE-INSTRUCTION PCMPEQD
2611 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2612 (EMIT-BYTE SEGMENT
15)
2613 (EMIT-BYTE SEGMENT
118)
2614 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2616 (DEFINE-INSTRUCTION PCMPEQW
2618 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2619 (EMIT-BYTE SEGMENT
15)
2620 (EMIT-BYTE SEGMENT
117)
2621 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2623 (DEFINE-INSTRUCTION PCMPGTB
2625 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2626 (EMIT-BYTE SEGMENT
15)
2627 (EMIT-BYTE SEGMENT
100)
2628 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2630 (DEFINE-INSTRUCTION PCMPGTD
2632 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2633 (EMIT-BYTE SEGMENT
15)
2634 (EMIT-BYTE SEGMENT
102)
2635 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2637 (DEFINE-INSTRUCTION PCMPGTW
2639 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2640 (EMIT-BYTE SEGMENT
15)
2641 (EMIT-BYTE SEGMENT
101)
2642 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2644 (DEFINE-INSTRUCTION PMADDWD
2646 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2647 (EMIT-BYTE SEGMENT
15)
2648 (EMIT-BYTE SEGMENT
245)
2649 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2651 (DEFINE-INSTRUCTION PMAXSW
2653 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2654 (EMIT-BYTE SEGMENT
15)
2655 (EMIT-BYTE SEGMENT
238)
2656 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2658 (DEFINE-INSTRUCTION PMAXUB
2660 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2661 (EMIT-BYTE SEGMENT
15)
2662 (EMIT-BYTE SEGMENT
222)
2663 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2665 (DEFINE-INSTRUCTION PMINSW
2667 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2668 (EMIT-BYTE SEGMENT
15)
2669 (EMIT-BYTE SEGMENT
234)
2670 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2672 (DEFINE-INSTRUCTION PMINUB
2674 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2675 (EMIT-BYTE SEGMENT
15)
2676 (EMIT-BYTE SEGMENT
218)
2677 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2679 (DEFINE-INSTRUCTION PMOVMSKB
2681 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2682 (EMIT-BYTE SEGMENT
15)
2683 (EMIT-BYTE SEGMENT
215)
2684 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2686 (DEFINE-INSTRUCTION PMULHUW
2688 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2689 (EMIT-BYTE SEGMENT
15)
2690 (EMIT-BYTE SEGMENT
228)
2691 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2693 (DEFINE-INSTRUCTION PMULHW
2695 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2696 (EMIT-BYTE SEGMENT
15)
2697 (EMIT-BYTE SEGMENT
229)
2698 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2700 (DEFINE-INSTRUCTION PMULLW
2702 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2703 (EMIT-BYTE SEGMENT
15)
2704 (EMIT-BYTE SEGMENT
213)
2705 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2707 (DEFINE-INSTRUCTION PMULUDQ
2709 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2710 (EMIT-BYTE SEGMENT
15)
2711 (EMIT-BYTE SEGMENT
244)
2712 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2714 (DEFINE-INSTRUCTION POR
2716 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2717 (EMIT-BYTE SEGMENT
15)
2718 (EMIT-BYTE SEGMENT
235)
2719 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2721 (DEFINE-INSTRUCTION PSADBW
2723 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2724 (EMIT-BYTE SEGMENT
15)
2725 (EMIT-BYTE SEGMENT
246)
2726 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2728 (DEFINE-INSTRUCTION PSSLD
2730 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2731 (EMIT-BYTE SEGMENT
15)
2732 (EMIT-BYTE SEGMENT
242)
2733 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2735 (DEFINE-INSTRUCTION PSLLQ
2737 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2738 (EMIT-BYTE SEGMENT
15)
2739 (EMIT-BYTE SEGMENT
243)
2740 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2742 (DEFINE-INSTRUCTION PSLLW
2744 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2745 (EMIT-BYTE SEGMENT
15)
2746 (EMIT-BYTE SEGMENT
241)
2747 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2749 (DEFINE-INSTRUCTION PSRAD
2751 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2752 (EMIT-BYTE SEGMENT
15)
2753 (EMIT-BYTE SEGMENT
226)
2754 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2756 (DEFINE-INSTRUCTION PSRAW
2758 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2759 (EMIT-BYTE SEGMENT
15)
2760 (EMIT-BYTE SEGMENT
226)
2761 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2763 (DEFINE-INSTRUCTION PSRLD
2765 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2766 (EMIT-BYTE SEGMENT
15)
2767 (EMIT-BYTE SEGMENT
210)
2768 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2770 (DEFINE-INSTRUCTION PSRLQ
2772 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2773 (EMIT-BYTE SEGMENT
15)
2774 (EMIT-BYTE SEGMENT
211)
2775 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2777 (DEFINE-INSTRUCTION PSRLW
2779 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2780 (EMIT-BYTE SEGMENT
15)
2781 (EMIT-BYTE SEGMENT
209)
2782 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2784 (DEFINE-INSTRUCTION PSUBB
2786 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2787 (EMIT-BYTE SEGMENT
15)
2788 (EMIT-BYTE SEGMENT
248)
2789 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2791 (DEFINE-INSTRUCTION PSUBD
2793 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2794 (EMIT-BYTE SEGMENT
15)
2795 (EMIT-BYTE SEGMENT
250)
2796 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2798 (DEFINE-INSTRUCTION PSUBQ
2800 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2801 (EMIT-BYTE SEGMENT
15)
2802 (EMIT-BYTE SEGMENT
251)
2803 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2805 (DEFINE-INSTRUCTION PSUBSB
2807 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2808 (EMIT-BYTE SEGMENT
15)
2809 (EMIT-BYTE SEGMENT
232)
2810 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2812 (DEFINE-INSTRUCTION PSUBSW
2814 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2815 (EMIT-BYTE SEGMENT
15)
2816 (EMIT-BYTE SEGMENT
233)
2817 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2819 (DEFINE-INSTRUCTION PSUBUSB
2821 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2822 (EMIT-BYTE SEGMENT
15)
2823 (EMIT-BYTE SEGMENT
216)
2824 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2826 (DEFINE-INSTRUCTION PSUBUSW
2828 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2829 (EMIT-BYTE SEGMENT
15)
2830 (EMIT-BYTE SEGMENT
217)
2831 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2833 (DEFINE-INSTRUCTION PSUBW
2835 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2836 (EMIT-BYTE SEGMENT
15)
2837 (EMIT-BYTE SEGMENT
249)
2838 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2840 (DEFINE-INSTRUCTION PUNPCKHBW
2842 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2843 (EMIT-BYTE SEGMENT
15)
2844 (EMIT-BYTE SEGMENT
104)
2845 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2847 (DEFINE-INSTRUCTION PUNPCKHDQ
2849 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2850 (EMIT-BYTE SEGMENT
15)
2851 (EMIT-BYTE SEGMENT
106)
2852 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2854 (DEFINE-INSTRUCTION PUNPCKHQDQ
2856 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2857 (EMIT-BYTE SEGMENT
15)
2858 (EMIT-BYTE SEGMENT
109)
2859 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2861 (DEFINE-INSTRUCTION PUNPCKHWD
2863 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2864 (EMIT-BYTE SEGMENT
15)
2865 (EMIT-BYTE SEGMENT
105)
2866 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2868 (DEFINE-INSTRUCTION PUNPCKLBW
2870 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2871 (EMIT-BYTE SEGMENT
15)
2872 (EMIT-BYTE SEGMENT
96)
2873 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2875 (DEFINE-INSTRUCTION PUNPCKLDQ
2877 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2878 (EMIT-BYTE SEGMENT
15)
2879 (EMIT-BYTE SEGMENT
98)
2880 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2882 (DEFINE-INSTRUCTION PUNPCKLQDQ
2884 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2885 (EMIT-BYTE SEGMENT
15)
2886 (EMIT-BYTE SEGMENT
108)
2887 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2889 (DEFINE-INSTRUCTION PUNPCKLWD
2891 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2892 (EMIT-BYTE SEGMENT
15)
2893 (EMIT-BYTE SEGMENT
97)
2894 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2896 (DEFINE-INSTRUCTION PXOR
2898 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2899 (EMIT-BYTE SEGMENT
15)
2900 (EMIT-BYTE SEGMENT
239)
2901 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2903 (DEFINE-INSTRUCTION CVTDQ2PD
2905 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2906 (EMIT-BYTE SEGMENT
15)
2907 (EMIT-BYTE SEGMENT
230)
2908 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2910 (DEFINE-INSTRUCTION CVTDQ2PS
2912 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2913 (EMIT-BYTE SEGMENT
91)
2914 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2916 (DEFINE-INSTRUCTION CVTPD2DQ
2918 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2919 (EMIT-BYTE SEGMENT
15)
2920 (EMIT-BYTE SEGMENT
230)
2921 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2923 (DEFINE-INSTRUCTION CVTPD2PI
2925 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2926 (EMIT-BYTE SEGMENT
15)
2927 (EMIT-BYTE SEGMENT
45)
2928 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2930 (DEFINE-INSTRUCTION CVTPD2PS
2932 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2933 (EMIT-BYTE SEGMENT
15)
2934 (EMIT-BYTE SEGMENT
90)
2935 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2937 (DEFINE-INSTRUCTION CVTPI2PD
2939 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2940 (EMIT-BYTE SEGMENT
15)
2941 (EMIT-BYTE SEGMENT
42)
2942 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2944 (DEFINE-INSTRUCTION CVTPI2PS
2946 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2947 (EMIT-BYTE SEGMENT
42)
2948 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2950 (DEFINE-INSTRUCTION CVTPS2DQ
2952 (:EMITTER
(EMIT-BYTE SEGMENT
102)
2953 (EMIT-BYTE SEGMENT
15)
2954 (EMIT-BYTE SEGMENT
91)
2955 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2957 (DEFINE-INSTRUCTION CVTPS2PD
2959 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2960 (EMIT-BYTE SEGMENT
90)
2961 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2963 (DEFINE-INSTRUCTION CVTPS2PI
2965 (:EMITTER
(EMIT-BYTE SEGMENT
15)
2966 (EMIT-BYTE SEGMENT
45)
2967 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2969 (DEFINE-INSTRUCTION CVTSD2SI
2971 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2972 (EMIT-BYTE SEGMENT
15)
2973 (EMIT-BYTE SEGMENT
45)
2974 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2976 (DEFINE-INSTRUCTION CVTSD2SS
2978 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2979 (EMIT-BYTE SEGMENT
15)
2980 (EMIT-BYTE SEGMENT
90)
2981 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2983 (DEFINE-INSTRUCTION CVTSI2SD
2985 (:EMITTER
(EMIT-BYTE SEGMENT
242)
2986 (EMIT-BYTE SEGMENT
15)
2987 (EMIT-BYTE SEGMENT
42)
2988 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2990 (DEFINE-INSTRUCTION CVTSI2SS
2992 (:EMITTER
(EMIT-BYTE SEGMENT
243)
2993 (EMIT-BYTE SEGMENT
15)
2994 (EMIT-BYTE SEGMENT
42)
2995 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
2997 (DEFINE-INSTRUCTION CVTSS2SD
2999 (:EMITTER
(EMIT-BYTE SEGMENT
243)
3000 (EMIT-BYTE SEGMENT
15)
3001 (EMIT-BYTE SEGMENT
90)
3002 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3004 (DEFINE-INSTRUCTION CVTSS2SI
3006 (:EMITTER
(EMIT-BYTE SEGMENT
243)
3007 (EMIT-BYTE SEGMENT
15)
3008 (EMIT-BYTE SEGMENT
45)
3009 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3011 (DEFINE-INSTRUCTION CVTTPD2DQ
3013 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3014 (EMIT-BYTE SEGMENT
15)
3015 (EMIT-BYTE SEGMENT
230)
3016 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3018 (DEFINE-INSTRUCTION CVTTPD2PI
3020 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3021 (EMIT-BYTE SEGMENT
15)
3022 (EMIT-BYTE SEGMENT
44)
3023 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3025 (DEFINE-INSTRUCTION CVTTPS2DQ
3027 (:EMITTER
(EMIT-BYTE SEGMENT
243)
3028 (EMIT-BYTE SEGMENT
15)
3029 (EMIT-BYTE SEGMENT
91)
3030 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3032 (DEFINE-INSTRUCTION CVTTPS2PI
3034 (:EMITTER
(EMIT-BYTE SEGMENT
15)
3035 (EMIT-BYTE SEGMENT
44)
3036 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3038 (DEFINE-INSTRUCTION CVTTSD2SI
3040 (:EMITTER
(EMIT-BYTE SEGMENT
242)
3041 (EMIT-BYTE SEGMENT
15)
3042 (EMIT-BYTE SEGMENT
44)
3043 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3045 (DEFINE-INSTRUCTION CVTTSS2SI
3047 (:EMITTER
(EMIT-BYTE SEGMENT
243)
3048 (EMIT-BYTE SEGMENT
15)
3049 (EMIT-BYTE SEGMENT
44)
3050 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3052 (DEFINE-INSTRUCTION LDDQU
3054 (:EMITTER
(EMIT-BYTE SEGMENT
242)
3055 (EMIT-BYTE SEGMENT
15)
3056 (EMIT-BYTE SEGMENT
240)
3057 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3059 (DEFINE-INSTRUCTION MASKMOVDQU
3061 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3062 (EMIT-BYTE SEGMENT
15)
3063 (EMIT-BYTE SEGMENT
247)
3064 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3066 (DEFINE-INSTRUCTION MOVDDUP
3068 (:EMITTER
(EMIT-BYTE SEGMENT
242)
3069 (EMIT-BYTE SEGMENT
15)
3070 (EMIT-BYTE SEGMENT
18)
3071 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3073 (DEFINE-INSTRUCTION MOVHLPS
3075 (:EMITTER
(EMIT-BYTE SEGMENT
15)
3076 (EMIT-BYTE SEGMENT
18)
3077 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3079 (DEFINE-INSTRUCTION MOVLHPS
3081 (:EMITTER
(EMIT-BYTE SEGMENT
15)
3082 (EMIT-BYTE SEGMENT
22)
3083 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3085 (DEFINE-INSTRUCTION MOVMSKPD
3087 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3088 (EMIT-BYTE SEGMENT
15)
3089 (EMIT-BYTE SEGMENT
80)
3090 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3092 (DEFINE-INSTRUCTION MOVMSKPS
3094 (:EMITTER
(EMIT-BYTE SEGMENT
15)
3095 (EMIT-BYTE SEGMENT
80)
3096 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3098 (DEFINE-INSTRUCTION MOVNTDQ
3100 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3101 (EMIT-BYTE SEGMENT
15)
3102 (EMIT-BYTE SEGMENT
231)
3103 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3105 (DEFINE-INSTRUCTION MOVNTPD
3107 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3108 (EMIT-BYTE SEGMENT
15)
3109 (EMIT-BYTE SEGMENT
43)
3110 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3112 (DEFINE-INSTRUCTION MOVNTPS
3114 (:EMITTER
(EMIT-BYTE SEGMENT
15)
3115 (EMIT-BYTE SEGMENT
43)
3116 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3118 (DEFINE-INSTRUCTION MOVSHDUP
3120 (:EMITTER
(EMIT-BYTE SEGMENT
243)
3121 (EMIT-BYTE SEGMENT
15)
3122 (EMIT-BYTE SEGMENT
22)
3123 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3125 (DEFINE-INSTRUCTION MOVSLDUP
3127 (:EMITTER
(EMIT-BYTE SEGMENT
243)
3128 (EMIT-BYTE SEGMENT
15)
3129 (EMIT-BYTE SEGMENT
18)
3130 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))))
3132 (DEFINE-INSTRUCTION PEXTRW
3133 (SEGMENT DST SRC BYTE
)
3134 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3135 (EMIT-BYTE SEGMENT
15)
3136 (EMIT-BYTE SEGMENT
197)
3137 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3138 (EMIT-SIZED-IMMEDIATE SEGMENT
:BYTE BYTE
)))
3140 (DEFINE-INSTRUCTION PINSRW
3141 (SEGMENT DST SRC BYTE
)
3142 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3143 (EMIT-BYTE SEGMENT
15)
3144 (EMIT-BYTE SEGMENT
196)
3145 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3146 (EMIT-SIZED-IMMEDIATE SEGMENT
:BYTE BYTE
)))
3148 (DEFINE-INSTRUCTION PSHUFD
3149 (SEGMENT DST SRC BYTE
)
3150 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3151 (EMIT-BYTE SEGMENT
15)
3152 (EMIT-BYTE SEGMENT
112)
3153 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3154 (EMIT-SIZED-IMMEDIATE SEGMENT
:BYTE BYTE
)))
3156 (DEFINE-INSTRUCTION PSHUFHW
3157 (SEGMENT DST SRC BYTE
)
3158 (:EMITTER
(EMIT-BYTE SEGMENT
243)
3159 (EMIT-BYTE SEGMENT
15)
3160 (EMIT-BYTE SEGMENT
112)
3161 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3162 (EMIT-SIZED-IMMEDIATE SEGMENT
:BYTE BYTE
)))
3164 (DEFINE-INSTRUCTION PSHUFLW
3165 (SEGMENT DST SRC BYTE
)
3166 (:EMITTER
(EMIT-BYTE SEGMENT
242)
3167 (EMIT-BYTE SEGMENT
15)
3168 (EMIT-BYTE SEGMENT
112)
3169 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3170 (EMIT-SIZED-IMMEDIATE SEGMENT
:BYTE BYTE
)))
3172 (DEFINE-INSTRUCTION SHUFPD
3173 (SEGMENT DST SRC BYTE
)
3174 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3175 (EMIT-BYTE SEGMENT
15)
3176 (EMIT-BYTE SEGMENT
198)
3177 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3178 (EMIT-SIZED-IMMEDIATE SEGMENT
:BYTE BYTE
)))
3180 (DEFINE-INSTRUCTION SHUFPS
3181 (SEGMENT DST SRC BYTE
)
3182 (:EMITTER
(EMIT-BYTE SEGMENT
15)
3183 (EMIT-BYTE SEGMENT
198)
3184 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3185 (EMIT-SIZED-IMMEDIATE SEGMENT
:BYTE BYTE
)))
3187 (DEFINE-INSTRUCTION CMPPD
3188 (SEGMENT DST SRC COND
)
3189 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3190 (EMIT-BYTE SEGMENT
15)
3191 (EMIT-BYTE SEGMENT
194)
3192 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3193 (EMIT-SIZED-IMMEDIATE SEGMENT
3212 (DEFINE-INSTRUCTION CMPPS
3213 (SEGMENT DST SRC COND
)
3214 (:EMITTER
(EMIT-BYTE SEGMENT
15)
3215 (EMIT-BYTE SEGMENT
194)
3216 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3217 (EMIT-SIZED-IMMEDIATE SEGMENT
3236 (DEFINE-INSTRUCTION CMPSD
3237 (SEGMENT DST SRC COND
)
3238 (:EMITTER
(EMIT-BYTE SEGMENT
242)
3239 (EMIT-BYTE SEGMENT
15)
3240 (EMIT-BYTE SEGMENT
194)
3241 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3242 (EMIT-SIZED-IMMEDIATE SEGMENT
3261 (DEFINE-INSTRUCTION CMPSS
3262 (SEGMENT DST SRC COND
)
3263 (:EMITTER
(EMIT-BYTE SEGMENT
243)
3264 (EMIT-BYTE SEGMENT
15)
3265 (EMIT-BYTE SEGMENT
194)
3266 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
))
3267 (EMIT-SIZED-IMMEDIATE SEGMENT
3286 (DEFINE-INSTRUCTION MOVAPD
3290 ((XMM-REGISTER-P DST
) (EMIT-BYTE SEGMENT
102)
3291 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
40)
3292 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3293 (T (EMIT-BYTE SEGMENT
102)
3294 (EMIT-BYTE SEGMENT
15)
3295 (EMIT-BYTE SEGMENT
41)
3296 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3298 (DEFINE-INSTRUCTION MOVAPS
3302 ((XMM-REGISTER-P DST
) (EMIT-BYTE SEGMENT
15)
3303 (EMIT-BYTE SEGMENT
40)
3304 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3305 (T (EMIT-BYTE SEGMENT
15)
3306 (EMIT-BYTE SEGMENT
41)
3307 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3309 (DEFINE-INSTRUCTION MOVD
3313 ((XMM-REGISTER-P DST
) (EMIT-BYTE SEGMENT
102)
3314 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
110)
3315 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3316 (T (EMIT-BYTE SEGMENT
102)
3317 (EMIT-BYTE SEGMENT
15)
3318 (EMIT-BYTE SEGMENT
126)
3319 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3321 (DEFINE-INSTRUCTION MOVDQA
3325 ((XMM-REGISTER-P DST
) (EMIT-BYTE SEGMENT
102)
3326 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
111)
3327 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3328 (T (EMIT-BYTE SEGMENT
102)
3329 (EMIT-BYTE SEGMENT
15)
3330 (EMIT-BYTE SEGMENT
127)
3331 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3333 (DEFINE-INSTRUCTION MOVDQU
3337 ((XMM-REGISTER-P DST
) (EMIT-BYTE SEGMENT
243)
3338 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
111)
3339 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3340 (T (EMIT-BYTE SEGMENT
243)
3341 (EMIT-BYTE SEGMENT
15)
3342 (EMIT-BYTE SEGMENT
127)
3343 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3345 (DEFINE-INSTRUCTION MOVHPD
3349 ((XMM-REGISTER-P DST
) (EMIT-BYTE SEGMENT
102)
3350 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
22)
3351 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3352 (T (EMIT-BYTE SEGMENT
102)
3353 (EMIT-BYTE SEGMENT
15)
3354 (EMIT-BYTE SEGMENT
23)
3355 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3357 (DEFINE-INSTRUCTION MOVHPS
3361 ((XMM-REGISTER-P DST
) (EMIT-BYTE SEGMENT
15)
3362 (EMIT-BYTE SEGMENT
22)
3363 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3364 (T (EMIT-BYTE SEGMENT
15)
3365 (EMIT-BYTE SEGMENT
23)
3366 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3368 (DEFINE-INSTRUCTION MOVLPD
3372 ((XMM-REGISTER-P DST
) (EMIT-BYTE SEGMENT
102)
3373 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
18)
3374 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3375 (T (EMIT-BYTE SEGMENT
102)
3376 (EMIT-BYTE SEGMENT
15)
3377 (EMIT-BYTE SEGMENT
19)
3378 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3380 (DEFINE-INSTRUCTION MOVLPS
3384 ((XMM-REGISTER-P DST
) (EMIT-BYTE SEGMENT
15)
3385 (EMIT-BYTE SEGMENT
18)
3386 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3387 (T (EMIT-BYTE SEGMENT
15)
3388 (EMIT-BYTE SEGMENT
19)
3389 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3391 (DEFINE-INSTRUCTION MOVQ
3395 ((XMM-REGISTER-P DST
) (EMIT-BYTE SEGMENT
243)
3396 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
126)
3397 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3398 (T (EMIT-BYTE SEGMENT
102)
3399 (EMIT-BYTE SEGMENT
15)
3400 (EMIT-BYTE SEGMENT
214)
3401 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3403 (DEFINE-INSTRUCTION MOVSD
3407 ((XMM-REGISTER-P DST
) (EMIT-BYTE SEGMENT
242)
3408 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
16)
3409 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3410 (T (EMIT-BYTE SEGMENT
242)
3411 (EMIT-BYTE SEGMENT
15)
3412 (EMIT-BYTE SEGMENT
17)
3413 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3415 (DEFINE-INSTRUCTION MOVSS
3419 ((XMM-REGISTER-P DST
) (EMIT-BYTE SEGMENT
243)
3420 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
16)
3421 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3422 (T (EMIT-BYTE SEGMENT
243)
3423 (EMIT-BYTE SEGMENT
15)
3424 (EMIT-BYTE SEGMENT
17)
3425 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3427 (DEFINE-INSTRUCTION MOVUPD
3431 ((XMM-REGISTER-P DST
) (EMIT-BYTE SEGMENT
102)
3432 (EMIT-BYTE SEGMENT
15) (EMIT-BYTE SEGMENT
16)
3433 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3434 (T (EMIT-BYTE SEGMENT
102)
3435 (EMIT-BYTE SEGMENT
15)
3436 (EMIT-BYTE SEGMENT
17)
3437 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3439 (DEFINE-INSTRUCTION MOVUPS
3443 ((XMM-REGISTER-P DST
) (EMIT-BYTE SEGMENT
15)
3444 (EMIT-BYTE SEGMENT
16)
3445 (EMIT-EA SEGMENT SRC
(REG-TN-ENCODING DST
)))
3446 (T (EMIT-BYTE SEGMENT
15)
3447 (EMIT-BYTE SEGMENT
17)
3448 (EMIT-EA SEGMENT DST
(REG-TN-ENCODING SRC
))))))
3450 (DEFINE-INSTRUCTION PSLLD-IB
3451 (SEGMENT DST AMOUNT
)
3452 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3453 (EMIT-BYTE SEGMENT
15)
3454 (EMIT-BYTE SEGMENT
114)
3455 (EMIT-EA SEGMENT DST
6)
3456 (EMIT-BYTE SEGMENT AMOUNT
)))
3458 (DEFINE-INSTRUCTION PSLLDQ-IB
3459 (SEGMENT DST AMOUNT
)
3460 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3461 (EMIT-BYTE SEGMENT
15)
3462 (EMIT-BYTE SEGMENT
115)
3463 (EMIT-EA SEGMENT DST
7)
3464 (EMIT-BYTE SEGMENT AMOUNT
)))
3466 (DEFINE-INSTRUCTION PSLLQ-IB
3467 (SEGMENT DST AMOUNT
)
3468 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3469 (EMIT-BYTE SEGMENT
15)
3470 (EMIT-BYTE SEGMENT
115)
3471 (EMIT-EA SEGMENT DST
6)
3472 (EMIT-BYTE SEGMENT AMOUNT
)))
3474 (DEFINE-INSTRUCTION PSLLW-IB
3475 (SEGMENT DST AMOUNT
)
3476 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3477 (EMIT-BYTE SEGMENT
15)
3478 (EMIT-BYTE SEGMENT
113)
3479 (EMIT-EA SEGMENT DST
6)
3480 (EMIT-BYTE SEGMENT AMOUNT
)))
3482 (DEFINE-INSTRUCTION PSRAD-IB
3483 (SEGMENT DST AMOUNT
)
3484 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3485 (EMIT-BYTE SEGMENT
15)
3486 (EMIT-BYTE SEGMENT
114)
3487 (EMIT-EA SEGMENT DST
4)
3488 (EMIT-BYTE SEGMENT AMOUNT
)))
3490 (DEFINE-INSTRUCTION PSRAW-IB
3491 (SEGMENT DST AMOUNT
)
3492 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3493 (EMIT-BYTE SEGMENT
15)
3494 (EMIT-BYTE SEGMENT
113)
3495 (EMIT-EA SEGMENT DST
4)
3496 (EMIT-BYTE SEGMENT AMOUNT
)))
3498 (DEFINE-INSTRUCTION PSRLD-IB
3499 (SEGMENT DST AMOUNT
)
3500 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3501 (EMIT-BYTE SEGMENT
15)
3502 (EMIT-BYTE SEGMENT
114)
3503 (EMIT-EA SEGMENT DST
2)
3504 (EMIT-BYTE SEGMENT AMOUNT
)))
3506 (DEFINE-INSTRUCTION PSRLDQ-IB
3507 (SEGMENT DST AMOUNT
)
3508 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3509 (EMIT-BYTE SEGMENT
15)
3510 (EMIT-BYTE SEGMENT
115)
3511 (EMIT-EA SEGMENT DST
3)
3512 (EMIT-BYTE SEGMENT AMOUNT
)))
3514 (DEFINE-INSTRUCTION PSRLQ-IB
3515 (SEGMENT DST AMOUNT
)
3516 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3517 (EMIT-BYTE SEGMENT
15)
3518 (EMIT-BYTE SEGMENT
115)
3519 (EMIT-EA SEGMENT DST
2)
3520 (EMIT-BYTE SEGMENT AMOUNT
)))
3522 (DEFINE-INSTRUCTION PSRLW-IB
3523 (SEGMENT DST AMOUNT
)
3524 (:EMITTER
(EMIT-BYTE SEGMENT
102)
3525 (EMIT-BYTE SEGMENT
15)
3526 (EMIT-BYTE SEGMENT
113)
3527 (EMIT-EA SEGMENT DST
2)
3528 (EMIT-BYTE SEGMENT AMOUNT
)))
3535 (define-instruction cpuid
(segment)
3537 (emit-byte segment
#x0F
)
3538 (emit-byte segment
#xA2
)))
3543 ;;;; fp instructions
3545 ;;;; FIXME: This section said "added by jrd", which should end up in CREDITS.
3547 ;;;; Note: We treat the single-precision and double-precision variants
3548 ;;;; as separate instructions.
3550 ;;; Load single to st(0).
3551 (define-instruction fld
(segment source
)
3552 (:printer floating-point
((op '(#b001
#b000
))))
3554 (emit-byte segment
#b11011001
)
3555 (emit-fp-op segment source
#b000
)))
3557 ;;; Load double to st(0).
3558 (define-instruction fldd
(segment source
)
3559 (:printer floating-point
((op '(#b101
#b000
))))
3560 (:printer floating-point-fp
((op '(#b001
#b000
))))
3562 (if (fp-reg-tn-p source
)
3563 (emit-byte segment
#b11011001
)
3564 (emit-byte segment
#b11011101
))
3565 (emit-fp-op segment source
#b000
)))
3567 ;;; Load long to st(0).
3568 (define-instruction fldl
(segment source
)
3569 (:printer floating-point
((op '(#b011
#b101
))))
3571 (emit-byte segment
#b11011011
)
3572 (emit-fp-op segment source
#b101
)))
3574 ;;; Store single from st(0).
3575 (define-instruction fst
(segment dest
)
3576 (:printer floating-point
((op '(#b001
#b010
))))
3578 (cond ((fp-reg-tn-p dest
)
3579 (emit-byte segment
#b11011101
)
3580 (emit-fp-op segment dest
#b010
))
3582 (emit-byte segment
#b11011001
)
3583 (emit-fp-op segment dest
#b010
)))))
3585 ;;; Store double from st(0).
3586 (define-instruction fstd
(segment dest
)
3587 (:printer floating-point
((op '(#b101
#b010
))))
3588 (:printer floating-point-fp
((op '(#b101
#b010
))))
3590 (cond ((fp-reg-tn-p dest
)
3591 (emit-byte segment
#b11011101
)
3592 (emit-fp-op segment dest
#b010
))
3594 (emit-byte segment
#b11011101
)
3595 (emit-fp-op segment dest
#b010
)))))
3597 ;;; Arithmetic ops are all done with at least one operand at top of
3598 ;;; stack. The other operand is is another register or a 32/64 bit
3601 ;;; dtc: I've tried to follow the Intel ASM386 conventions, but note
3602 ;;; that these conflict with the Gdb conventions for binops. To reduce
3603 ;;; the confusion I've added comments showing the mathamatical
3604 ;;; operation and the two syntaxes. By the ASM386 convention the
3605 ;;; instruction syntax is:
3608 ;;; or Fop Destination, Source
3610 ;;; If only one operand is given then it is the source and the
3611 ;;; destination is ST(0). There are reversed forms of the fsub and
3612 ;;; fdiv instructions inducated by an 'R' suffix.
3614 ;;; The mathematical operation for the non-reverse form is always:
3615 ;;; destination = destination op source
3617 ;;; For the reversed form it is:
3618 ;;; destination = source op destination
3620 ;;; The instructions below only accept one operand at present which is
3621 ;;; usually the source. I've hack in extra instructions to implement
3622 ;;; the fops with a ST(i) destination, these have a -sti suffix and
3623 ;;; the operand is the destination with the source being ST(0).
3626 ;;; st(0) = st(0) + memory or st(i).
3627 (define-instruction fadd
(segment source
)
3628 (:printer floating-point
((op '(#b000
#b000
))))
3630 (emit-byte segment
#b11011000
)
3631 (emit-fp-op segment source
#b000
)))
3634 ;;; st(0) = st(0) + memory or st(i).
3635 (define-instruction faddd
(segment source
)
3636 (:printer floating-point
((op '(#b100
#b000
))))
3637 (:printer floating-point-fp
((op '(#b000
#b000
))))
3639 (if (fp-reg-tn-p source
)
3640 (emit-byte segment
#b11011000
)
3641 (emit-byte segment
#b11011100
))
3642 (emit-fp-op segment source
#b000
)))
3644 ;;; Add double destination st(i):
3645 ;;; st(i) = st(0) + st(i).
3646 (define-instruction fadd-sti
(segment destination
)
3647 (:printer floating-point-fp
((op '(#b100
#b000
))))
3649 (aver (fp-reg-tn-p destination
))
3650 (emit-byte segment
#b11011100
)
3651 (emit-fp-op segment destination
#b000
)))
3653 (define-instruction faddp-sti
(segment destination
)
3654 (:printer floating-point-fp
((op '(#b110
#b000
))))
3656 (aver (fp-reg-tn-p destination
))
3657 (emit-byte segment
#b11011110
)
3658 (emit-fp-op segment destination
#b000
)))
3660 ;;; Subtract single:
3661 ;;; st(0) = st(0) - memory or st(i).
3662 (define-instruction fsub
(segment source
)
3663 (:printer floating-point
((op '(#b000
#b100
))))
3665 (emit-byte segment
#b11011000
)
3666 (emit-fp-op segment source
#b100
)))
3668 ;;; Subtract single, reverse:
3669 ;;; st(0) = memory or st(i) - st(0).
3670 (define-instruction fsubr
(segment source
)
3671 (:printer floating-point
((op '(#b000
#b101
))))
3673 (emit-byte segment
#b11011000
)
3674 (emit-fp-op segment source
#b101
)))
3676 ;;; Subtract double:
3677 ;;; st(0) = st(0) - memory or st(i).
3678 (define-instruction fsubd
(segment source
)
3679 (:printer floating-point
((op '(#b100
#b100
))))
3680 (:printer floating-point-fp
((op '(#b000
#b100
))))
3682 (if (fp-reg-tn-p source
)
3683 (emit-byte segment
#b11011000
)
3684 (emit-byte segment
#b11011100
))
3685 (emit-fp-op segment source
#b100
)))
3687 ;;; Subtract double, reverse:
3688 ;;; st(0) = memory or st(i) - st(0).
3689 (define-instruction fsubrd
(segment source
)
3690 (:printer floating-point
((op '(#b100
#b101
))))
3691 (:printer floating-point-fp
((op '(#b000
#b101
))))
3693 (if (fp-reg-tn-p source
)
3694 (emit-byte segment
#b11011000
)
3695 (emit-byte segment
#b11011100
))
3696 (emit-fp-op segment source
#b101
)))
3698 ;;; Subtract double, destination st(i):
3699 ;;; st(i) = st(i) - st(0).
3701 ;;; ASM386 syntax: FSUB ST(i), ST
3702 ;;; Gdb syntax: fsubr %st,%st(i)
3703 (define-instruction fsub-sti
(segment destination
)
3704 (:printer floating-point-fp
((op '(#b100
#b101
))))
3706 (aver (fp-reg-tn-p destination
))
3707 (emit-byte segment
#b11011100
)
3708 (emit-fp-op segment destination
#b101
)))
3710 (define-instruction fsubp-sti
(segment destination
)
3711 (:printer floating-point-fp
((op '(#b110
#b101
))))
3713 (aver (fp-reg-tn-p destination
))
3714 (emit-byte segment
#b11011110
)
3715 (emit-fp-op segment destination
#b101
)))
3717 ;;; Subtract double, reverse, destination st(i):
3718 ;;; st(i) = st(0) - st(i).
3720 ;;; ASM386 syntax: FSUBR ST(i), ST
3721 ;;; Gdb syntax: fsub %st,%st(i)
3722 (define-instruction fsubr-sti
(segment destination
)
3723 (:printer floating-point-fp
((op '(#b100
#b100
))))
3725 (aver (fp-reg-tn-p destination
))
3726 (emit-byte segment
#b11011100
)
3727 (emit-fp-op segment destination
#b100
)))
3729 (define-instruction fsubrp-sti
(segment destination
)
3730 (:printer floating-point-fp
((op '(#b110
#b100
))))
3732 (aver (fp-reg-tn-p destination
))
3733 (emit-byte segment
#b11011110
)
3734 (emit-fp-op segment destination
#b100
)))
3736 ;;; Multiply single:
3737 ;;; st(0) = st(0) * memory or st(i).
3738 (define-instruction fmul
(segment source
)
3739 (:printer floating-point
((op '(#b000
#b001
))))
3741 (emit-byte segment
#b11011000
)
3742 (emit-fp-op segment source
#b001
)))
3744 ;;; Multiply double:
3745 ;;; st(0) = st(0) * memory or st(i).
3746 (define-instruction fmuld
(segment source
)
3747 (:printer floating-point
((op '(#b100
#b001
))))
3748 (:printer floating-point-fp
((op '(#b000
#b001
))))
3750 (if (fp-reg-tn-p source
)
3751 (emit-byte segment
#b11011000
)
3752 (emit-byte segment
#b11011100
))
3753 (emit-fp-op segment source
#b001
)))
3755 ;;; Multiply double, destination st(i):
3756 ;;; st(i) = st(i) * st(0).
3757 (define-instruction fmul-sti
(segment destination
)
3758 (:printer floating-point-fp
((op '(#b100
#b001
))))
3760 (aver (fp-reg-tn-p destination
))
3761 (emit-byte segment
#b11011100
)
3762 (emit-fp-op segment destination
#b001
)))
3765 ;;; st(0) = st(0) / memory or st(i).
3766 (define-instruction fdiv
(segment source
)
3767 (:printer floating-point
((op '(#b000
#b110
))))
3769 (emit-byte segment
#b11011000
)
3770 (emit-fp-op segment source
#b110
)))
3772 ;;; Divide single, reverse:
3773 ;;; st(0) = memory or st(i) / st(0).
3774 (define-instruction fdivr
(segment source
)
3775 (:printer floating-point
((op '(#b000
#b111
))))
3777 (emit-byte segment
#b11011000
)
3778 (emit-fp-op segment source
#b111
)))
3781 ;;; st(0) = st(0) / memory or st(i).
3782 (define-instruction fdivd
(segment source
)
3783 (:printer floating-point
((op '(#b100
#b110
))))
3784 (:printer floating-point-fp
((op '(#b000
#b110
))))
3786 (if (fp-reg-tn-p source
)
3787 (emit-byte segment
#b11011000
)
3788 (emit-byte segment
#b11011100
))
3789 (emit-fp-op segment source
#b110
)))
3791 ;;; Divide double, reverse:
3792 ;;; st(0) = memory or st(i) / st(0).
3793 (define-instruction fdivrd
(segment source
)
3794 (:printer floating-point
((op '(#b100
#b111
))))
3795 (:printer floating-point-fp
((op '(#b000
#b111
))))
3797 (if (fp-reg-tn-p source
)
3798 (emit-byte segment
#b11011000
)
3799 (emit-byte segment
#b11011100
))
3800 (emit-fp-op segment source
#b111
)))
3802 ;;; Divide double, destination st(i):
3803 ;;; st(i) = st(i) / st(0).
3805 ;;; ASM386 syntax: FDIV ST(i), ST
3806 ;;; Gdb syntax: fdivr %st,%st(i)
3807 (define-instruction fdiv-sti
(segment destination
)
3808 (:printer floating-point-fp
((op '(#b100
#b111
))))
3810 (aver (fp-reg-tn-p destination
))
3811 (emit-byte segment
#b11011100
)
3812 (emit-fp-op segment destination
#b111
)))
3814 ;;; Divide double, reverse, destination st(i):
3815 ;;; st(i) = st(0) / st(i).
3817 ;;; ASM386 syntax: FDIVR ST(i), ST
3818 ;;; Gdb syntax: fdiv %st,%st(i)
3819 (define-instruction fdivr-sti
(segment destination
)
3820 (:printer floating-point-fp
((op '(#b100
#b110
))))
3822 (aver (fp-reg-tn-p destination
))
3823 (emit-byte segment
#b11011100
)
3824 (emit-fp-op segment destination
#b110
)))
3826 ;;; Exchange fr0 with fr(n). (There is no double precision variant.)
3827 (define-instruction fxch
(segment source
)
3828 (:printer floating-point-fp
((op '(#b001
#b001
))))
3830 (unless (and (tn-p source
)
3831 (eq (sb-name (sc-sb (tn-sc source
))) 'float-registers
))
3833 (emit-byte segment
#b11011001
)
3834 (emit-fp-op segment source
#b001
)))
3836 ;;; Push 32-bit integer to st0.
3837 (define-instruction fild
(segment source
)
3838 (:printer floating-point
((op '(#b011
#b000
))))
3840 (emit-byte segment
#b11011011
)
3841 (emit-fp-op segment source
#b000
)))
3843 ;;; Push 64-bit integer to st0.
3844 (define-instruction fildl
(segment source
)
3845 (:printer floating-point
((op '(#b111
#b101
))))
3847 (emit-byte segment
#b11011111
)
3848 (emit-fp-op segment source
#b101
)))
3850 ;;; Store 32-bit integer.
3851 (define-instruction fist
(segment dest
)
3852 (:printer floating-point
((op '(#b011
#b010
))))
3854 (emit-byte segment
#b11011011
)
3855 (emit-fp-op segment dest
#b010
)))
3857 ;;; Store and pop 32-bit integer.
3858 (define-instruction fistp
(segment dest
)
3859 (:printer floating-point
((op '(#b011
#b011
))))
3861 (emit-byte segment
#b11011011
)
3862 (emit-fp-op segment dest
#b011
)))
3864 ;;; Store and pop 64-bit integer.
3865 (define-instruction fistpl
(segment dest
)
3866 (:printer floating-point
((op '(#b111
#b111
))))
3868 (emit-byte segment
#b11011111
)
3869 (emit-fp-op segment dest
#b111
)))
3871 ;;; Store single from st(0) and pop.
3872 (define-instruction fstp
(segment dest
)
3873 (:printer floating-point
((op '(#b001
#b011
))))
3875 (cond ((fp-reg-tn-p dest
)
3876 (emit-byte segment
#b11011101
)
3877 (emit-fp-op segment dest
#b011
))
3879 (emit-byte segment
#b11011001
)
3880 (emit-fp-op segment dest
#b011
)))))
3882 ;;; Store double from st(0) and pop.
3883 (define-instruction fstpd
(segment dest
)
3884 (:printer floating-point
((op '(#b101
#b011
))))
3885 (:printer floating-point-fp
((op '(#b101
#b011
))))
3887 (cond ((fp-reg-tn-p dest
)
3888 (emit-byte segment
#b11011101
)
3889 (emit-fp-op segment dest
#b011
))
3891 (emit-byte segment
#b11011101
)
3892 (emit-fp-op segment dest
#b011
)))))
3894 ;;; Store long from st(0) and pop.
3895 (define-instruction fstpl
(segment dest
)
3896 (:printer floating-point
((op '(#b011
#b111
))))
3898 (emit-byte segment
#b11011011
)
3899 (emit-fp-op segment dest
#b111
)))
3901 ;;; Decrement stack-top pointer.
3902 (define-instruction fdecstp
(segment)
3903 (:printer floating-point-no
((op #b10110
)))
3905 (emit-byte segment
#b11011001
)
3906 (emit-byte segment
#b11110110
)))
3908 ;;; Increment stack-top pointer.
3909 (define-instruction fincstp
(segment)
3910 (:printer floating-point-no
((op #b10111
)))
3912 (emit-byte segment
#b11011001
)
3913 (emit-byte segment
#b11110111
)))
3915 ;;; Free fp register.
3916 (define-instruction ffree
(segment dest
)
3917 (:printer floating-point-fp
((op '(#b101
#b000
))))
3919 (emit-byte segment
#b11011101
)
3920 (emit-fp-op segment dest
#b000
)))
3922 (define-instruction fabs
(segment)
3923 (:printer floating-point-no
((op #b00001
)))
3925 (emit-byte segment
#b11011001
)
3926 (emit-byte segment
#b11100001
)))
3928 (define-instruction fchs
(segment)
3929 (:printer floating-point-no
((op #b00000
)))
3931 (emit-byte segment
#b11011001
)
3932 (emit-byte segment
#b11100000
)))
3934 (define-instruction frndint
(segment)
3935 (:printer floating-point-no
((op #b11100
)))
3937 (emit-byte segment
#b11011001
)
3938 (emit-byte segment
#b11111100
)))
3941 (define-instruction fninit
(segment)
3942 (:printer floating-point-5
((op #b00011
)))
3944 (emit-byte segment
#b11011011
)
3945 (emit-byte segment
#b11100011
)))
3947 ;;; Store Status Word to AX.
3948 (define-instruction fnstsw
(segment)
3949 (:printer floating-point-st
((op #b00000
)))
3951 (emit-byte segment
#b11011111
)
3952 (emit-byte segment
#b11100000
)))
3954 ;;; Load Control Word.
3956 ;;; src must be a memory location
3957 (define-instruction fldcw
(segment src
)
3958 (:printer floating-point
((op '(#b001
#b101
))))
3960 (emit-byte segment
#b11011001
)
3961 (emit-fp-op segment src
#b101
)))
3963 ;;; Store Control Word.
3964 (define-instruction fnstcw
(segment dst
)
3965 (:printer floating-point
((op '(#b001
#b111
))))
3967 (emit-byte segment
#b11011001
)
3968 (emit-fp-op segment dst
#b111
)))
3970 ;;; Store FP Environment.
3971 (define-instruction fstenv
(segment dst
)
3972 (:printer floating-point
((op '(#b001
#b110
))))
3974 (emit-byte segment
#b11011001
)
3975 (emit-fp-op segment dst
#b110
)))
3977 ;;; Restore FP Environment.
3978 (define-instruction fldenv
(segment src
)
3979 (:printer floating-point
((op '(#b001
#b100
))))
3981 (emit-byte segment
#b11011001
)
3982 (emit-fp-op segment src
#b100
)))
3985 (define-instruction fsave
(segment dst
)
3986 (:printer floating-point
((op '(#b101
#b110
))))
3988 (emit-byte segment
#b11011101
)
3989 (emit-fp-op segment dst
#b110
)))
3991 ;;; Restore FP State.
3992 (define-instruction frstor
(segment src
)
3993 (:printer floating-point
((op '(#b101
#b100
))))
3995 (emit-byte segment
#b11011101
)
3996 (emit-fp-op segment src
#b100
)))
3998 ;;; Clear exceptions.
3999 (define-instruction fnclex
(segment)
4000 (:printer floating-point-5
((op #b00010
)))
4002 (emit-byte segment
#b11011011
)
4003 (emit-byte segment
#b11100010
)))
4006 (define-instruction fcom
(segment src
)
4007 (:printer floating-point
((op '(#b000
#b010
))))
4009 (emit-byte segment
#b11011000
)
4010 (emit-fp-op segment src
#b010
)))
4012 (define-instruction fcomd
(segment src
)
4013 (:printer floating-point
((op '(#b100
#b010
))))
4014 (:printer floating-point-fp
((op '(#b000
#b010
))))
4016 (if (fp-reg-tn-p src
)
4017 (emit-byte segment
#b11011000
)
4018 (emit-byte segment
#b11011100
))
4019 (emit-fp-op segment src
#b010
)))
4021 ;;; Compare ST1 to ST0, popping the stack twice.
4022 (define-instruction fcompp
(segment)
4023 (:printer floating-point-3
((op '(#b110
#b011001
))))
4025 (emit-byte segment
#b11011110
)
4026 (emit-byte segment
#b11011001
)))
4028 ;;; unordered comparison
4029 (define-instruction fucom
(segment src
)
4030 (:printer floating-point-fp
((op '(#b101
#b100
))))
4032 (aver (fp-reg-tn-p src
))
4033 (emit-byte segment
#b11011101
)
4034 (emit-fp-op segment src
#b100
)))
4036 (define-instruction ftst
(segment)
4037 (:printer floating-point-no
((op #b00100
)))
4039 (emit-byte segment
#b11011001
)
4040 (emit-byte segment
#b11100100
)))
4044 (define-instruction fsqrt
(segment)
4045 (:printer floating-point-no
((op #b11010
)))
4047 (emit-byte segment
#b11011001
)
4048 (emit-byte segment
#b11111010
)))
4050 (define-instruction fscale
(segment)
4051 (:printer floating-point-no
((op #b11101
)))
4053 (emit-byte segment
#b11011001
)
4054 (emit-byte segment
#b11111101
)))
4056 (define-instruction fxtract
(segment)
4057 (:printer floating-point-no
((op #b10100
)))
4059 (emit-byte segment
#b11011001
)
4060 (emit-byte segment
#b11110100
)))
4062 (define-instruction fsin
(segment)
4063 (:printer floating-point-no
((op #b11110
)))
4065 (emit-byte segment
#b11011001
)
4066 (emit-byte segment
#b11111110
)))
4068 (define-instruction fcos
(segment)
4069 (:printer floating-point-no
((op #b11111
)))
4071 (emit-byte segment
#b11011001
)
4072 (emit-byte segment
#b11111111
)))
4074 (define-instruction fprem1
(segment)
4075 (:printer floating-point-no
((op #b10101
)))
4077 (emit-byte segment
#b11011001
)
4078 (emit-byte segment
#b11110101
)))
4080 (define-instruction fprem
(segment)
4081 (:printer floating-point-no
((op #b11000
)))
4083 (emit-byte segment
#b11011001
)
4084 (emit-byte segment
#b11111000
)))
4086 (define-instruction fxam
(segment)
4087 (:printer floating-point-no
((op #b00101
)))
4089 (emit-byte segment
#b11011001
)
4090 (emit-byte segment
#b11100101
)))
4092 ;;; These do push/pop to stack and need special handling
4093 ;;; in any VOPs that use them. See the book.
4095 ;;; st0 <- st1*log2(st0)
4096 (define-instruction fyl2x
(segment) ; pops stack
4097 (:printer floating-point-no
((op #b10001
)))
4099 (emit-byte segment
#b11011001
)
4100 (emit-byte segment
#b11110001
)))
4102 (define-instruction fyl2xp1
(segment)
4103 (:printer floating-point-no
((op #b11001
)))
4105 (emit-byte segment
#b11011001
)
4106 (emit-byte segment
#b11111001
)))
4108 (define-instruction f2xm1
(segment)
4109 (:printer floating-point-no
((op #b10000
)))
4111 (emit-byte segment
#b11011001
)
4112 (emit-byte segment
#b11110000
)))
4114 (define-instruction fptan
(segment) ; st(0) <- 1; st(1) <- tan
4115 (:printer floating-point-no
((op #b10010
)))
4117 (emit-byte segment
#b11011001
)
4118 (emit-byte segment
#b11110010
)))
4120 (define-instruction fpatan
(segment) ; POPS STACK
4121 (:printer floating-point-no
((op #b10011
)))
4123 (emit-byte segment
#b11011001
)
4124 (emit-byte segment
#b11110011
)))
4126 ;;;; loading constants
4128 (define-instruction fldz
(segment)
4129 (:printer floating-point-no
((op #b01110
)))
4131 (emit-byte segment
#b11011001
)
4132 (emit-byte segment
#b11101110
)))
4134 (define-instruction fld1
(segment)
4135 (:printer floating-point-no
((op #b01000
)))
4137 (emit-byte segment
#b11011001
)
4138 (emit-byte segment
#b11101000
)))
4140 (define-instruction fldpi
(segment)
4141 (:printer floating-point-no
((op #b01011
)))
4143 (emit-byte segment
#b11011001
)
4144 (emit-byte segment
#b11101011
)))
4146 (define-instruction fldl2t
(segment)
4147 (:printer floating-point-no
((op #b01001
)))
4149 (emit-byte segment
#b11011001
)
4150 (emit-byte segment
#b11101001
)))
4152 (define-instruction fldl2e
(segment)
4153 (:printer floating-point-no
((op #b01010
)))
4155 (emit-byte segment
#b11011001
)
4156 (emit-byte segment
#b11101010
)))
4158 (define-instruction fldlg2
(segment)
4159 (:printer floating-point-no
((op #b01100
)))
4161 (emit-byte segment
#b11011001
)
4162 (emit-byte segment
#b11101100
)))
4164 (define-instruction fldln2
(segment)
4165 (:printer floating-point-no
((op #b01101
)))
4167 (emit-byte segment
#b11011001
)
4168 (emit-byte segment
#b11101101
)))