1 /****************************************************************************
3 * Realmode X86 Emulator Library
5 * Copyright (C) 1996-1999 SciTech Software, Inc.
6 * Copyright (C) David Mosberger-Tang
7 * Copyright (C) 1999 Egbert Eich
9 * ========================================================================
11 * Permission to use, copy, modify, distribute, and sell this software and
12 * its documentation for any purpose is hereby granted without fee,
13 * provided that the above copyright notice appear in all copies and that
14 * both that copyright notice and this permission notice appear in
15 * supporting documentation, and that the name of the authors not be used
16 * in advertising or publicity pertaining to distribution of the software
17 * without specific, written prior permission. The authors makes no
18 * representations about the suitability of this software for any purpose.
19 * It is provided "as is" without express or implied warranty.
21 * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
22 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
23 * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
24 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
25 * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
26 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
27 * PERFORMANCE OF THIS SOFTWARE.
29 * ========================================================================
33 * Developer: Kendall Bennett
35 * Description: This file includes subroutines to implement the decoding
36 * and emulation of all the x86 processor instructions.
38 * There are approximately 250 subroutines in here, which correspond
39 * to the 256 byte-"opcodes" found on the 8086. The table which
40 * dispatches this is found in the files optab.[ch].
42 * Each opcode proc has a comment preceeding it which gives it's table
43 * address. Several opcodes are missing (undefined) in the table.
45 * Each proc includes information for decoding (DECODE_PRINTF and
46 * DECODE_PRINTF2), debugging (TRACE_REGS, SINGLE_STEP), and misc
47 * functions (START_OF_INSTR, END_OF_INSTR).
49 * Many of the procedures are *VERY* similar in coding. This has
50 * allowed for a very large amount of code to be generated in a fairly
51 * short amount of time (i.e. cut, paste, and modify). The result is
52 * that much of the code below could have been folded into subroutines
53 * for a large reduction in size of this file. The downside would be
54 * that there would be a penalty in execution speed. The file could
55 * also have been *MUCH* larger by inlining certain functions which
56 * were called. This could have resulted even faster execution. The
57 * prime directive I used to decide whether to inline the code or to
58 * modularize it, was basically: 1) no unnecessary subroutine calls,
59 * 2) no routines more than about 200 lines in size, and 3) modularize
60 * any code that I might not get right the first time. The fetch_*
61 * subroutines fall into the latter category. The The decode_* fall
62 * into the second category. The coding of the "switch(mod){ .... }"
63 * in many of the subroutines below falls into the first category.
64 * Especially, the coding of {add,and,or,sub,...}_{byte,word}
65 * subroutines are an especially glaring case of the third guideline.
66 * Since so much of the code is cloned from other modules (compare
67 * opcode #00 to opcode #01), making the basic operations subroutine
68 * calls is especially important; otherwise mistakes in coding an
69 * "add" would represent a nightmare in maintenance.
71 ****************************************************************************/
73 /* $XFree86: xc/extras/x86emu/src/x86emu/ops.c,v 1.8tsi Exp $ */
75 #include "x86emu/x86emui.h"
77 /*----------------------------- Implementation ----------------------------*/
79 /****************************************************************************
81 op1 - Instruction op code
84 Handles illegal opcodes.
85 ****************************************************************************/
86 static void x86emuOp_illegal_op(
90 if (M
.x86
.R_SP
!= 0) {
91 DECODE_PRINTF("ILLEGAL X86 OPCODE\n");
93 printk("%04x:%04x: %02X ILLEGAL X86 OPCODE!\n",
94 M
.x86
.R_CS
, M
.x86
.R_IP
-1,op1
);
98 /* If we get here, it means the stack pointer is back to zero
99 * so we are just returning from an emulator service call
100 * so therte is no need to display an error message. We trap
101 * the emulator with an 0xF1 opcode to finish the service
109 /****************************************************************************
112 ****************************************************************************/
113 static void x86emuOp_add_byte_RM_R(u8
X86EMU_UNUSED(op1
))
117 u8
*destreg
, *srcreg
;
121 DECODE_PRINTF("ADD\t");
122 FETCH_DECODE_MODRM(mod
, rh
, rl
);
125 destoffset
= decode_rm00_address(rl
);
127 destval
= fetch_data_byte(destoffset
);
128 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
131 destval
= add_byte(destval
, *srcreg
);
132 store_data_byte(destoffset
, destval
);
135 destoffset
= decode_rm01_address(rl
);
137 destval
= fetch_data_byte(destoffset
);
138 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
141 destval
= add_byte(destval
, *srcreg
);
142 store_data_byte(destoffset
, destval
);
145 destoffset
= decode_rm10_address(rl
);
147 destval
= fetch_data_byte(destoffset
);
148 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
151 destval
= add_byte(destval
, *srcreg
);
152 store_data_byte(destoffset
, destval
);
154 case 3: /* register to register */
155 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
157 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
160 *destreg
= add_byte(*destreg
, *srcreg
);
163 DECODE_CLEAR_SEGOVR();
167 /****************************************************************************
170 ****************************************************************************/
171 static void x86emuOp_add_word_RM_R(u8
X86EMU_UNUSED(op1
))
177 DECODE_PRINTF("ADD\t");
178 FETCH_DECODE_MODRM(mod
, rh
, rl
);
181 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
185 destoffset
= decode_rm00_address(rl
);
187 destval
= fetch_data_long(destoffset
);
188 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
191 destval
= add_long(destval
, *srcreg
);
192 store_data_long(destoffset
, destval
);
197 destoffset
= decode_rm00_address(rl
);
199 destval
= fetch_data_word(destoffset
);
200 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
203 destval
= add_word(destval
, *srcreg
);
204 store_data_word(destoffset
, destval
);
208 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
212 destoffset
= decode_rm01_address(rl
);
214 destval
= fetch_data_long(destoffset
);
215 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
218 destval
= add_long(destval
, *srcreg
);
219 store_data_long(destoffset
, destval
);
224 destoffset
= decode_rm01_address(rl
);
226 destval
= fetch_data_word(destoffset
);
227 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
230 destval
= add_word(destval
, *srcreg
);
231 store_data_word(destoffset
, destval
);
235 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
239 destoffset
= decode_rm10_address(rl
);
241 destval
= fetch_data_long(destoffset
);
242 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
245 destval
= add_long(destval
, *srcreg
);
246 store_data_long(destoffset
, destval
);
251 destoffset
= decode_rm10_address(rl
);
253 destval
= fetch_data_word(destoffset
);
254 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
257 destval
= add_word(destval
, *srcreg
);
258 store_data_word(destoffset
, destval
);
261 case 3: /* register to register */
262 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
263 u32
*destreg
,*srcreg
;
265 destreg
= DECODE_RM_LONG_REGISTER(rl
);
267 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
270 *destreg
= add_long(*destreg
, *srcreg
);
272 u16
*destreg
,*srcreg
;
274 destreg
= DECODE_RM_WORD_REGISTER(rl
);
276 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
279 *destreg
= add_word(*destreg
, *srcreg
);
283 DECODE_CLEAR_SEGOVR();
287 /****************************************************************************
290 ****************************************************************************/
291 static void x86emuOp_add_byte_R_RM(u8
X86EMU_UNUSED(op1
))
294 u8
*destreg
, *srcreg
;
299 DECODE_PRINTF("ADD\t");
300 FETCH_DECODE_MODRM(mod
, rh
, rl
);
303 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
305 srcoffset
= decode_rm00_address(rl
);
306 srcval
= fetch_data_byte(srcoffset
);
309 *destreg
= add_byte(*destreg
, srcval
);
312 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
314 srcoffset
= decode_rm01_address(rl
);
315 srcval
= fetch_data_byte(srcoffset
);
318 *destreg
= add_byte(*destreg
, srcval
);
321 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
323 srcoffset
= decode_rm10_address(rl
);
324 srcval
= fetch_data_byte(srcoffset
);
327 *destreg
= add_byte(*destreg
, srcval
);
329 case 3: /* register to register */
330 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
332 srcreg
= DECODE_RM_BYTE_REGISTER(rl
);
335 *destreg
= add_byte(*destreg
, *srcreg
);
338 DECODE_CLEAR_SEGOVR();
342 /****************************************************************************
345 ****************************************************************************/
346 static void x86emuOp_add_word_R_RM(u8
X86EMU_UNUSED(op1
))
352 DECODE_PRINTF("ADD\t");
353 FETCH_DECODE_MODRM(mod
, rh
, rl
);
356 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
360 destreg
= DECODE_RM_LONG_REGISTER(rh
);
362 srcoffset
= decode_rm00_address(rl
);
363 srcval
= fetch_data_long(srcoffset
);
366 *destreg
= add_long(*destreg
, srcval
);
371 destreg
= DECODE_RM_WORD_REGISTER(rh
);
373 srcoffset
= decode_rm00_address(rl
);
374 srcval
= fetch_data_word(srcoffset
);
377 *destreg
= add_word(*destreg
, srcval
);
381 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
385 destreg
= DECODE_RM_LONG_REGISTER(rh
);
387 srcoffset
= decode_rm01_address(rl
);
388 srcval
= fetch_data_long(srcoffset
);
391 *destreg
= add_long(*destreg
, srcval
);
396 destreg
= DECODE_RM_WORD_REGISTER(rh
);
398 srcoffset
= decode_rm01_address(rl
);
399 srcval
= fetch_data_word(srcoffset
);
402 *destreg
= add_word(*destreg
, srcval
);
406 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
410 destreg
= DECODE_RM_LONG_REGISTER(rh
);
412 srcoffset
= decode_rm10_address(rl
);
413 srcval
= fetch_data_long(srcoffset
);
416 *destreg
= add_long(*destreg
, srcval
);
421 destreg
= DECODE_RM_WORD_REGISTER(rh
);
423 srcoffset
= decode_rm10_address(rl
);
424 srcval
= fetch_data_word(srcoffset
);
427 *destreg
= add_word(*destreg
, srcval
);
430 case 3: /* register to register */
431 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
432 u32
*destreg
,*srcreg
;
434 destreg
= DECODE_RM_LONG_REGISTER(rh
);
436 srcreg
= DECODE_RM_LONG_REGISTER(rl
);
439 *destreg
= add_long(*destreg
, *srcreg
);
441 u16
*destreg
,*srcreg
;
443 destreg
= DECODE_RM_WORD_REGISTER(rh
);
445 srcreg
= DECODE_RM_WORD_REGISTER(rl
);
448 *destreg
= add_word(*destreg
, *srcreg
);
452 DECODE_CLEAR_SEGOVR();
456 /****************************************************************************
459 ****************************************************************************/
460 static void x86emuOp_add_byte_AL_IMM(u8
X86EMU_UNUSED(op1
))
465 DECODE_PRINTF("ADD\tAL,");
466 srcval
= fetch_byte_imm();
467 DECODE_PRINTF2("%x\n", srcval
);
469 M
.x86
.R_AL
= add_byte(M
.x86
.R_AL
, srcval
);
470 DECODE_CLEAR_SEGOVR();
474 /****************************************************************************
477 ****************************************************************************/
478 static void x86emuOp_add_word_AX_IMM(u8
X86EMU_UNUSED(op1
))
483 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
484 DECODE_PRINTF("ADD\tEAX,");
485 srcval
= fetch_long_imm();
487 DECODE_PRINTF("ADD\tAX,");
488 srcval
= fetch_word_imm();
490 DECODE_PRINTF2("%x\n", srcval
);
492 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
493 M
.x86
.R_EAX
= add_long(M
.x86
.R_EAX
, srcval
);
495 M
.x86
.R_AX
= add_word(M
.x86
.R_AX
, (u16
)srcval
);
497 DECODE_CLEAR_SEGOVR();
501 /****************************************************************************
504 ****************************************************************************/
505 static void x86emuOp_push_ES(u8
X86EMU_UNUSED(op1
))
508 DECODE_PRINTF("PUSH\tES\n");
510 push_word(M
.x86
.R_ES
);
511 DECODE_CLEAR_SEGOVR();
515 /****************************************************************************
518 ****************************************************************************/
519 static void x86emuOp_pop_ES(u8
X86EMU_UNUSED(op1
))
522 DECODE_PRINTF("POP\tES\n");
524 M
.x86
.R_ES
= pop_word();
525 DECODE_CLEAR_SEGOVR();
529 /****************************************************************************
532 ****************************************************************************/
533 static void x86emuOp_or_byte_RM_R(u8
X86EMU_UNUSED(op1
))
536 u8
*destreg
, *srcreg
;
541 DECODE_PRINTF("OR\t");
542 FETCH_DECODE_MODRM(mod
, rh
, rl
);
545 destoffset
= decode_rm00_address(rl
);
547 destval
= fetch_data_byte(destoffset
);
548 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
551 destval
= or_byte(destval
, *srcreg
);
552 store_data_byte(destoffset
, destval
);
555 destoffset
= decode_rm01_address(rl
);
557 destval
= fetch_data_byte(destoffset
);
558 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
561 destval
= or_byte(destval
, *srcreg
);
562 store_data_byte(destoffset
, destval
);
565 destoffset
= decode_rm10_address(rl
);
567 destval
= fetch_data_byte(destoffset
);
568 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
571 destval
= or_byte(destval
, *srcreg
);
572 store_data_byte(destoffset
, destval
);
574 case 3: /* register to register */
575 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
577 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
580 *destreg
= or_byte(*destreg
, *srcreg
);
583 DECODE_CLEAR_SEGOVR();
587 /****************************************************************************
590 ****************************************************************************/
591 static void x86emuOp_or_word_RM_R(u8
X86EMU_UNUSED(op1
))
597 DECODE_PRINTF("OR\t");
598 FETCH_DECODE_MODRM(mod
, rh
, rl
);
601 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
605 destoffset
= decode_rm00_address(rl
);
607 destval
= fetch_data_long(destoffset
);
608 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
611 destval
= or_long(destval
, *srcreg
);
612 store_data_long(destoffset
, destval
);
617 destoffset
= decode_rm00_address(rl
);
619 destval
= fetch_data_word(destoffset
);
620 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
623 destval
= or_word(destval
, *srcreg
);
624 store_data_word(destoffset
, destval
);
628 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
632 destoffset
= decode_rm01_address(rl
);
634 destval
= fetch_data_long(destoffset
);
635 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
638 destval
= or_long(destval
, *srcreg
);
639 store_data_long(destoffset
, destval
);
644 destoffset
= decode_rm01_address(rl
);
646 destval
= fetch_data_word(destoffset
);
647 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
650 destval
= or_word(destval
, *srcreg
);
651 store_data_word(destoffset
, destval
);
655 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
659 destoffset
= decode_rm10_address(rl
);
661 destval
= fetch_data_long(destoffset
);
662 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
665 destval
= or_long(destval
, *srcreg
);
666 store_data_long(destoffset
, destval
);
671 destoffset
= decode_rm10_address(rl
);
673 destval
= fetch_data_word(destoffset
);
674 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
677 destval
= or_word(destval
, *srcreg
);
678 store_data_word(destoffset
, destval
);
681 case 3: /* register to register */
682 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
683 u32
*destreg
,*srcreg
;
685 destreg
= DECODE_RM_LONG_REGISTER(rl
);
687 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
690 *destreg
= or_long(*destreg
, *srcreg
);
692 u16
*destreg
,*srcreg
;
694 destreg
= DECODE_RM_WORD_REGISTER(rl
);
696 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
699 *destreg
= or_word(*destreg
, *srcreg
);
703 DECODE_CLEAR_SEGOVR();
707 /****************************************************************************
710 ****************************************************************************/
711 static void x86emuOp_or_byte_R_RM(u8
X86EMU_UNUSED(op1
))
714 u8
*destreg
, *srcreg
;
719 DECODE_PRINTF("OR\t");
720 FETCH_DECODE_MODRM(mod
, rh
, rl
);
723 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
725 srcoffset
= decode_rm00_address(rl
);
726 srcval
= fetch_data_byte(srcoffset
);
729 *destreg
= or_byte(*destreg
, srcval
);
732 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
734 srcoffset
= decode_rm01_address(rl
);
735 srcval
= fetch_data_byte(srcoffset
);
738 *destreg
= or_byte(*destreg
, srcval
);
741 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
743 srcoffset
= decode_rm10_address(rl
);
744 srcval
= fetch_data_byte(srcoffset
);
747 *destreg
= or_byte(*destreg
, srcval
);
749 case 3: /* register to register */
750 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
752 srcreg
= DECODE_RM_BYTE_REGISTER(rl
);
755 *destreg
= or_byte(*destreg
, *srcreg
);
758 DECODE_CLEAR_SEGOVR();
762 /****************************************************************************
765 ****************************************************************************/
766 static void x86emuOp_or_word_R_RM(u8
X86EMU_UNUSED(op1
))
772 DECODE_PRINTF("OR\t");
773 FETCH_DECODE_MODRM(mod
, rh
, rl
);
776 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
780 destreg
= DECODE_RM_LONG_REGISTER(rh
);
782 srcoffset
= decode_rm00_address(rl
);
783 srcval
= fetch_data_long(srcoffset
);
786 *destreg
= or_long(*destreg
, srcval
);
791 destreg
= DECODE_RM_WORD_REGISTER(rh
);
793 srcoffset
= decode_rm00_address(rl
);
794 srcval
= fetch_data_word(srcoffset
);
797 *destreg
= or_word(*destreg
, srcval
);
801 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
805 destreg
= DECODE_RM_LONG_REGISTER(rh
);
807 srcoffset
= decode_rm01_address(rl
);
808 srcval
= fetch_data_long(srcoffset
);
811 *destreg
= or_long(*destreg
, srcval
);
816 destreg
= DECODE_RM_WORD_REGISTER(rh
);
818 srcoffset
= decode_rm01_address(rl
);
819 srcval
= fetch_data_word(srcoffset
);
822 *destreg
= or_word(*destreg
, srcval
);
826 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
830 destreg
= DECODE_RM_LONG_REGISTER(rh
);
832 srcoffset
= decode_rm10_address(rl
);
833 srcval
= fetch_data_long(srcoffset
);
836 *destreg
= or_long(*destreg
, srcval
);
841 destreg
= DECODE_RM_WORD_REGISTER(rh
);
843 srcoffset
= decode_rm10_address(rl
);
844 srcval
= fetch_data_word(srcoffset
);
847 *destreg
= or_word(*destreg
, srcval
);
850 case 3: /* register to register */
851 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
852 u32
*destreg
,*srcreg
;
854 destreg
= DECODE_RM_LONG_REGISTER(rh
);
856 srcreg
= DECODE_RM_LONG_REGISTER(rl
);
859 *destreg
= or_long(*destreg
, *srcreg
);
861 u16
*destreg
,*srcreg
;
863 destreg
= DECODE_RM_WORD_REGISTER(rh
);
865 srcreg
= DECODE_RM_WORD_REGISTER(rl
);
868 *destreg
= or_word(*destreg
, *srcreg
);
872 DECODE_CLEAR_SEGOVR();
876 /****************************************************************************
879 ****************************************************************************/
880 static void x86emuOp_or_byte_AL_IMM(u8
X86EMU_UNUSED(op1
))
885 DECODE_PRINTF("OR\tAL,");
886 srcval
= fetch_byte_imm();
887 DECODE_PRINTF2("%x\n", srcval
);
889 M
.x86
.R_AL
= or_byte(M
.x86
.R_AL
, srcval
);
890 DECODE_CLEAR_SEGOVR();
894 /****************************************************************************
897 ****************************************************************************/
898 static void x86emuOp_or_word_AX_IMM(u8
X86EMU_UNUSED(op1
))
903 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
904 DECODE_PRINTF("OR\tEAX,");
905 srcval
= fetch_long_imm();
907 DECODE_PRINTF("OR\tAX,");
908 srcval
= fetch_word_imm();
910 DECODE_PRINTF2("%x\n", srcval
);
912 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
913 M
.x86
.R_EAX
= or_long(M
.x86
.R_EAX
, srcval
);
915 M
.x86
.R_AX
= or_word(M
.x86
.R_AX
, (u16
)srcval
);
917 DECODE_CLEAR_SEGOVR();
921 /****************************************************************************
924 ****************************************************************************/
925 static void x86emuOp_push_CS(u8
X86EMU_UNUSED(op1
))
928 DECODE_PRINTF("PUSH\tCS\n");
930 push_word(M
.x86
.R_CS
);
931 DECODE_CLEAR_SEGOVR();
935 /****************************************************************************
937 Handles opcode 0x0f. Escape for two-byte opcode (286 or better)
938 ****************************************************************************/
939 static void x86emuOp_two_byte(u8
X86EMU_UNUSED(op1
))
941 u8 op2
= (*sys_rdb
)(((u32
)M
.x86
.R_CS
<< 4) + (M
.x86
.R_IP
++));
942 INC_DECODED_INST_LEN(1);
943 (*x86emu_optab2
[op2
])(op2
);
946 /****************************************************************************
949 ****************************************************************************/
950 static void x86emuOp_adc_byte_RM_R(u8
X86EMU_UNUSED(op1
))
953 u8
*destreg
, *srcreg
;
958 DECODE_PRINTF("ADC\t");
959 FETCH_DECODE_MODRM(mod
, rh
, rl
);
962 destoffset
= decode_rm00_address(rl
);
964 destval
= fetch_data_byte(destoffset
);
965 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
968 destval
= adc_byte(destval
, *srcreg
);
969 store_data_byte(destoffset
, destval
);
972 destoffset
= decode_rm01_address(rl
);
974 destval
= fetch_data_byte(destoffset
);
975 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
978 destval
= adc_byte(destval
, *srcreg
);
979 store_data_byte(destoffset
, destval
);
982 destoffset
= decode_rm10_address(rl
);
984 destval
= fetch_data_byte(destoffset
);
985 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
988 destval
= adc_byte(destval
, *srcreg
);
989 store_data_byte(destoffset
, destval
);
991 case 3: /* register to register */
992 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
994 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
997 *destreg
= adc_byte(*destreg
, *srcreg
);
1000 DECODE_CLEAR_SEGOVR();
1004 /****************************************************************************
1007 ****************************************************************************/
1008 static void x86emuOp_adc_word_RM_R(u8
X86EMU_UNUSED(op1
))
1014 DECODE_PRINTF("ADC\t");
1015 FETCH_DECODE_MODRM(mod
, rh
, rl
);
1018 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1022 destoffset
= decode_rm00_address(rl
);
1024 destval
= fetch_data_long(destoffset
);
1025 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
1026 DECODE_PRINTF("\n");
1028 destval
= adc_long(destval
, *srcreg
);
1029 store_data_long(destoffset
, destval
);
1034 destoffset
= decode_rm00_address(rl
);
1036 destval
= fetch_data_word(destoffset
);
1037 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
1038 DECODE_PRINTF("\n");
1040 destval
= adc_word(destval
, *srcreg
);
1041 store_data_word(destoffset
, destval
);
1045 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1049 destoffset
= decode_rm01_address(rl
);
1051 destval
= fetch_data_long(destoffset
);
1052 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
1053 DECODE_PRINTF("\n");
1055 destval
= adc_long(destval
, *srcreg
);
1056 store_data_long(destoffset
, destval
);
1061 destoffset
= decode_rm01_address(rl
);
1063 destval
= fetch_data_word(destoffset
);
1064 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
1065 DECODE_PRINTF("\n");
1067 destval
= adc_word(destval
, *srcreg
);
1068 store_data_word(destoffset
, destval
);
1072 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1076 destoffset
= decode_rm10_address(rl
);
1078 destval
= fetch_data_long(destoffset
);
1079 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
1080 DECODE_PRINTF("\n");
1082 destval
= adc_long(destval
, *srcreg
);
1083 store_data_long(destoffset
, destval
);
1088 destoffset
= decode_rm10_address(rl
);
1090 destval
= fetch_data_word(destoffset
);
1091 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
1092 DECODE_PRINTF("\n");
1094 destval
= adc_word(destval
, *srcreg
);
1095 store_data_word(destoffset
, destval
);
1098 case 3: /* register to register */
1099 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1100 u32
*destreg
,*srcreg
;
1102 destreg
= DECODE_RM_LONG_REGISTER(rl
);
1104 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
1105 DECODE_PRINTF("\n");
1107 *destreg
= adc_long(*destreg
, *srcreg
);
1109 u16
*destreg
,*srcreg
;
1111 destreg
= DECODE_RM_WORD_REGISTER(rl
);
1113 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
1114 DECODE_PRINTF("\n");
1116 *destreg
= adc_word(*destreg
, *srcreg
);
1120 DECODE_CLEAR_SEGOVR();
1124 /****************************************************************************
1127 ****************************************************************************/
1128 static void x86emuOp_adc_byte_R_RM(u8
X86EMU_UNUSED(op1
))
1131 u8
*destreg
, *srcreg
;
1136 DECODE_PRINTF("ADC\t");
1137 FETCH_DECODE_MODRM(mod
, rh
, rl
);
1140 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
1142 srcoffset
= decode_rm00_address(rl
);
1143 srcval
= fetch_data_byte(srcoffset
);
1144 DECODE_PRINTF("\n");
1146 *destreg
= adc_byte(*destreg
, srcval
);
1149 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
1151 srcoffset
= decode_rm01_address(rl
);
1152 srcval
= fetch_data_byte(srcoffset
);
1153 DECODE_PRINTF("\n");
1155 *destreg
= adc_byte(*destreg
, srcval
);
1158 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
1160 srcoffset
= decode_rm10_address(rl
);
1161 srcval
= fetch_data_byte(srcoffset
);
1162 DECODE_PRINTF("\n");
1164 *destreg
= adc_byte(*destreg
, srcval
);
1166 case 3: /* register to register */
1167 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
1169 srcreg
= DECODE_RM_BYTE_REGISTER(rl
);
1170 DECODE_PRINTF("\n");
1172 *destreg
= adc_byte(*destreg
, *srcreg
);
1175 DECODE_CLEAR_SEGOVR();
1179 /****************************************************************************
1182 ****************************************************************************/
1183 static void x86emuOp_adc_word_R_RM(u8
X86EMU_UNUSED(op1
))
1189 DECODE_PRINTF("ADC\t");
1190 FETCH_DECODE_MODRM(mod
, rh
, rl
);
1193 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1197 destreg
= DECODE_RM_LONG_REGISTER(rh
);
1199 srcoffset
= decode_rm00_address(rl
);
1200 srcval
= fetch_data_long(srcoffset
);
1201 DECODE_PRINTF("\n");
1203 *destreg
= adc_long(*destreg
, srcval
);
1208 destreg
= DECODE_RM_WORD_REGISTER(rh
);
1210 srcoffset
= decode_rm00_address(rl
);
1211 srcval
= fetch_data_word(srcoffset
);
1212 DECODE_PRINTF("\n");
1214 *destreg
= adc_word(*destreg
, srcval
);
1218 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1222 destreg
= DECODE_RM_LONG_REGISTER(rh
);
1224 srcoffset
= decode_rm01_address(rl
);
1225 srcval
= fetch_data_long(srcoffset
);
1226 DECODE_PRINTF("\n");
1228 *destreg
= adc_long(*destreg
, srcval
);
1233 destreg
= DECODE_RM_WORD_REGISTER(rh
);
1235 srcoffset
= decode_rm01_address(rl
);
1236 srcval
= fetch_data_word(srcoffset
);
1237 DECODE_PRINTF("\n");
1239 *destreg
= adc_word(*destreg
, srcval
);
1243 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1247 destreg
= DECODE_RM_LONG_REGISTER(rh
);
1249 srcoffset
= decode_rm10_address(rl
);
1250 srcval
= fetch_data_long(srcoffset
);
1251 DECODE_PRINTF("\n");
1253 *destreg
= adc_long(*destreg
, srcval
);
1258 destreg
= DECODE_RM_WORD_REGISTER(rh
);
1260 srcoffset
= decode_rm10_address(rl
);
1261 srcval
= fetch_data_word(srcoffset
);
1262 DECODE_PRINTF("\n");
1264 *destreg
= adc_word(*destreg
, srcval
);
1267 case 3: /* register to register */
1268 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1269 u32
*destreg
,*srcreg
;
1271 destreg
= DECODE_RM_LONG_REGISTER(rh
);
1273 srcreg
= DECODE_RM_LONG_REGISTER(rl
);
1274 DECODE_PRINTF("\n");
1276 *destreg
= adc_long(*destreg
, *srcreg
);
1278 u16
*destreg
,*srcreg
;
1280 destreg
= DECODE_RM_WORD_REGISTER(rh
);
1282 srcreg
= DECODE_RM_WORD_REGISTER(rl
);
1283 DECODE_PRINTF("\n");
1285 *destreg
= adc_word(*destreg
, *srcreg
);
1289 DECODE_CLEAR_SEGOVR();
1293 /****************************************************************************
1296 ****************************************************************************/
1297 static void x86emuOp_adc_byte_AL_IMM(u8
X86EMU_UNUSED(op1
))
1302 DECODE_PRINTF("ADC\tAL,");
1303 srcval
= fetch_byte_imm();
1304 DECODE_PRINTF2("%x\n", srcval
);
1306 M
.x86
.R_AL
= adc_byte(M
.x86
.R_AL
, srcval
);
1307 DECODE_CLEAR_SEGOVR();
1311 /****************************************************************************
1314 ****************************************************************************/
1315 static void x86emuOp_adc_word_AX_IMM(u8
X86EMU_UNUSED(op1
))
1320 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1321 DECODE_PRINTF("ADC\tEAX,");
1322 srcval
= fetch_long_imm();
1324 DECODE_PRINTF("ADC\tAX,");
1325 srcval
= fetch_word_imm();
1327 DECODE_PRINTF2("%x\n", srcval
);
1329 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1330 M
.x86
.R_EAX
= adc_long(M
.x86
.R_EAX
, srcval
);
1332 M
.x86
.R_AX
= adc_word(M
.x86
.R_AX
, (u16
)srcval
);
1334 DECODE_CLEAR_SEGOVR();
1338 /****************************************************************************
1341 ****************************************************************************/
1342 static void x86emuOp_push_SS(u8
X86EMU_UNUSED(op1
))
1345 DECODE_PRINTF("PUSH\tSS\n");
1347 push_word(M
.x86
.R_SS
);
1348 DECODE_CLEAR_SEGOVR();
1352 /****************************************************************************
1355 ****************************************************************************/
1356 static void x86emuOp_pop_SS(u8
X86EMU_UNUSED(op1
))
1359 DECODE_PRINTF("POP\tSS\n");
1361 M
.x86
.R_SS
= pop_word();
1362 DECODE_CLEAR_SEGOVR();
1366 /****************************************************************************
1369 ****************************************************************************/
1370 static void x86emuOp_sbb_byte_RM_R(u8
X86EMU_UNUSED(op1
))
1373 u8
*destreg
, *srcreg
;
1378 DECODE_PRINTF("SBB\t");
1379 FETCH_DECODE_MODRM(mod
, rh
, rl
);
1382 destoffset
= decode_rm00_address(rl
);
1384 destval
= fetch_data_byte(destoffset
);
1385 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
1386 DECODE_PRINTF("\n");
1388 destval
= sbb_byte(destval
, *srcreg
);
1389 store_data_byte(destoffset
, destval
);
1392 destoffset
= decode_rm01_address(rl
);
1394 destval
= fetch_data_byte(destoffset
);
1395 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
1396 DECODE_PRINTF("\n");
1398 destval
= sbb_byte(destval
, *srcreg
);
1399 store_data_byte(destoffset
, destval
);
1402 destoffset
= decode_rm10_address(rl
);
1404 destval
= fetch_data_byte(destoffset
);
1405 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
1406 DECODE_PRINTF("\n");
1408 destval
= sbb_byte(destval
, *srcreg
);
1409 store_data_byte(destoffset
, destval
);
1411 case 3: /* register to register */
1412 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
1414 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
1415 DECODE_PRINTF("\n");
1417 *destreg
= sbb_byte(*destreg
, *srcreg
);
1420 DECODE_CLEAR_SEGOVR();
1424 /****************************************************************************
1427 ****************************************************************************/
1428 static void x86emuOp_sbb_word_RM_R(u8
X86EMU_UNUSED(op1
))
1434 DECODE_PRINTF("SBB\t");
1435 FETCH_DECODE_MODRM(mod
, rh
, rl
);
1438 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1442 destoffset
= decode_rm00_address(rl
);
1444 destval
= fetch_data_long(destoffset
);
1445 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
1446 DECODE_PRINTF("\n");
1448 destval
= sbb_long(destval
, *srcreg
);
1449 store_data_long(destoffset
, destval
);
1454 destoffset
= decode_rm00_address(rl
);
1456 destval
= fetch_data_word(destoffset
);
1457 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
1458 DECODE_PRINTF("\n");
1460 destval
= sbb_word(destval
, *srcreg
);
1461 store_data_word(destoffset
, destval
);
1465 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1469 destoffset
= decode_rm01_address(rl
);
1471 destval
= fetch_data_long(destoffset
);
1472 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
1473 DECODE_PRINTF("\n");
1475 destval
= sbb_long(destval
, *srcreg
);
1476 store_data_long(destoffset
, destval
);
1481 destoffset
= decode_rm01_address(rl
);
1483 destval
= fetch_data_word(destoffset
);
1484 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
1485 DECODE_PRINTF("\n");
1487 destval
= sbb_word(destval
, *srcreg
);
1488 store_data_word(destoffset
, destval
);
1492 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1496 destoffset
= decode_rm10_address(rl
);
1498 destval
= fetch_data_long(destoffset
);
1499 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
1500 DECODE_PRINTF("\n");
1502 destval
= sbb_long(destval
, *srcreg
);
1503 store_data_long(destoffset
, destval
);
1508 destoffset
= decode_rm10_address(rl
);
1510 destval
= fetch_data_word(destoffset
);
1511 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
1512 DECODE_PRINTF("\n");
1514 destval
= sbb_word(destval
, *srcreg
);
1515 store_data_word(destoffset
, destval
);
1518 case 3: /* register to register */
1519 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1520 u32
*destreg
,*srcreg
;
1522 destreg
= DECODE_RM_LONG_REGISTER(rl
);
1524 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
1525 DECODE_PRINTF("\n");
1527 *destreg
= sbb_long(*destreg
, *srcreg
);
1529 u16
*destreg
,*srcreg
;
1531 destreg
= DECODE_RM_WORD_REGISTER(rl
);
1533 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
1534 DECODE_PRINTF("\n");
1536 *destreg
= sbb_word(*destreg
, *srcreg
);
1540 DECODE_CLEAR_SEGOVR();
1544 /****************************************************************************
1547 ****************************************************************************/
1548 static void x86emuOp_sbb_byte_R_RM(u8
X86EMU_UNUSED(op1
))
1551 u8
*destreg
, *srcreg
;
1556 DECODE_PRINTF("SBB\t");
1557 FETCH_DECODE_MODRM(mod
, rh
, rl
);
1560 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
1562 srcoffset
= decode_rm00_address(rl
);
1563 srcval
= fetch_data_byte(srcoffset
);
1564 DECODE_PRINTF("\n");
1566 *destreg
= sbb_byte(*destreg
, srcval
);
1569 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
1571 srcoffset
= decode_rm01_address(rl
);
1572 srcval
= fetch_data_byte(srcoffset
);
1573 DECODE_PRINTF("\n");
1575 *destreg
= sbb_byte(*destreg
, srcval
);
1578 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
1580 srcoffset
= decode_rm10_address(rl
);
1581 srcval
= fetch_data_byte(srcoffset
);
1582 DECODE_PRINTF("\n");
1584 *destreg
= sbb_byte(*destreg
, srcval
);
1586 case 3: /* register to register */
1587 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
1589 srcreg
= DECODE_RM_BYTE_REGISTER(rl
);
1590 DECODE_PRINTF("\n");
1592 *destreg
= sbb_byte(*destreg
, *srcreg
);
1595 DECODE_CLEAR_SEGOVR();
1599 /****************************************************************************
1602 ****************************************************************************/
1603 static void x86emuOp_sbb_word_R_RM(u8
X86EMU_UNUSED(op1
))
1609 DECODE_PRINTF("SBB\t");
1610 FETCH_DECODE_MODRM(mod
, rh
, rl
);
1613 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1617 destreg
= DECODE_RM_LONG_REGISTER(rh
);
1619 srcoffset
= decode_rm00_address(rl
);
1620 srcval
= fetch_data_long(srcoffset
);
1621 DECODE_PRINTF("\n");
1623 *destreg
= sbb_long(*destreg
, srcval
);
1628 destreg
= DECODE_RM_WORD_REGISTER(rh
);
1630 srcoffset
= decode_rm00_address(rl
);
1631 srcval
= fetch_data_word(srcoffset
);
1632 DECODE_PRINTF("\n");
1634 *destreg
= sbb_word(*destreg
, srcval
);
1638 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1642 destreg
= DECODE_RM_LONG_REGISTER(rh
);
1644 srcoffset
= decode_rm01_address(rl
);
1645 srcval
= fetch_data_long(srcoffset
);
1646 DECODE_PRINTF("\n");
1648 *destreg
= sbb_long(*destreg
, srcval
);
1653 destreg
= DECODE_RM_WORD_REGISTER(rh
);
1655 srcoffset
= decode_rm01_address(rl
);
1656 srcval
= fetch_data_word(srcoffset
);
1657 DECODE_PRINTF("\n");
1659 *destreg
= sbb_word(*destreg
, srcval
);
1663 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1667 destreg
= DECODE_RM_LONG_REGISTER(rh
);
1669 srcoffset
= decode_rm10_address(rl
);
1670 srcval
= fetch_data_long(srcoffset
);
1671 DECODE_PRINTF("\n");
1673 *destreg
= sbb_long(*destreg
, srcval
);
1678 destreg
= DECODE_RM_WORD_REGISTER(rh
);
1680 srcoffset
= decode_rm10_address(rl
);
1681 srcval
= fetch_data_word(srcoffset
);
1682 DECODE_PRINTF("\n");
1684 *destreg
= sbb_word(*destreg
, srcval
);
1687 case 3: /* register to register */
1688 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1689 u32
*destreg
,*srcreg
;
1691 destreg
= DECODE_RM_LONG_REGISTER(rh
);
1693 srcreg
= DECODE_RM_LONG_REGISTER(rl
);
1694 DECODE_PRINTF("\n");
1696 *destreg
= sbb_long(*destreg
, *srcreg
);
1698 u16
*destreg
,*srcreg
;
1700 destreg
= DECODE_RM_WORD_REGISTER(rh
);
1702 srcreg
= DECODE_RM_WORD_REGISTER(rl
);
1703 DECODE_PRINTF("\n");
1705 *destreg
= sbb_word(*destreg
, *srcreg
);
1709 DECODE_CLEAR_SEGOVR();
1713 /****************************************************************************
1716 ****************************************************************************/
1717 static void x86emuOp_sbb_byte_AL_IMM(u8
X86EMU_UNUSED(op1
))
1722 DECODE_PRINTF("SBB\tAL,");
1723 srcval
= fetch_byte_imm();
1724 DECODE_PRINTF2("%x\n", srcval
);
1726 M
.x86
.R_AL
= sbb_byte(M
.x86
.R_AL
, srcval
);
1727 DECODE_CLEAR_SEGOVR();
1731 /****************************************************************************
1734 ****************************************************************************/
1735 static void x86emuOp_sbb_word_AX_IMM(u8
X86EMU_UNUSED(op1
))
1740 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1741 DECODE_PRINTF("SBB\tEAX,");
1742 srcval
= fetch_long_imm();
1744 DECODE_PRINTF("SBB\tAX,");
1745 srcval
= fetch_word_imm();
1747 DECODE_PRINTF2("%x\n", srcval
);
1749 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1750 M
.x86
.R_EAX
= sbb_long(M
.x86
.R_EAX
, srcval
);
1752 M
.x86
.R_AX
= sbb_word(M
.x86
.R_AX
, (u16
)srcval
);
1754 DECODE_CLEAR_SEGOVR();
1758 /****************************************************************************
1761 ****************************************************************************/
1762 static void x86emuOp_push_DS(u8
X86EMU_UNUSED(op1
))
1765 DECODE_PRINTF("PUSH\tDS\n");
1767 push_word(M
.x86
.R_DS
);
1768 DECODE_CLEAR_SEGOVR();
1772 /****************************************************************************
1775 ****************************************************************************/
1776 static void x86emuOp_pop_DS(u8
X86EMU_UNUSED(op1
))
1779 DECODE_PRINTF("POP\tDS\n");
1781 M
.x86
.R_DS
= pop_word();
1782 DECODE_CLEAR_SEGOVR();
1786 /****************************************************************************
1789 ****************************************************************************/
1790 static void x86emuOp_and_byte_RM_R(u8
X86EMU_UNUSED(op1
))
1793 u8
*destreg
, *srcreg
;
1798 DECODE_PRINTF("AND\t");
1799 FETCH_DECODE_MODRM(mod
, rh
, rl
);
1803 destoffset
= decode_rm00_address(rl
);
1805 destval
= fetch_data_byte(destoffset
);
1806 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
1807 DECODE_PRINTF("\n");
1809 destval
= and_byte(destval
, *srcreg
);
1810 store_data_byte(destoffset
, destval
);
1814 destoffset
= decode_rm01_address(rl
);
1816 destval
= fetch_data_byte(destoffset
);
1817 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
1818 DECODE_PRINTF("\n");
1820 destval
= and_byte(destval
, *srcreg
);
1821 store_data_byte(destoffset
, destval
);
1825 destoffset
= decode_rm10_address(rl
);
1827 destval
= fetch_data_byte(destoffset
);
1828 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
1829 DECODE_PRINTF("\n");
1831 destval
= and_byte(destval
, *srcreg
);
1832 store_data_byte(destoffset
, destval
);
1835 case 3: /* register to register */
1836 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
1838 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
1839 DECODE_PRINTF("\n");
1841 *destreg
= and_byte(*destreg
, *srcreg
);
1844 DECODE_CLEAR_SEGOVR();
1848 /****************************************************************************
1851 ****************************************************************************/
1852 static void x86emuOp_and_word_RM_R(u8
X86EMU_UNUSED(op1
))
1858 DECODE_PRINTF("AND\t");
1859 FETCH_DECODE_MODRM(mod
, rh
, rl
);
1862 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1866 destoffset
= decode_rm00_address(rl
);
1868 destval
= fetch_data_long(destoffset
);
1869 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
1870 DECODE_PRINTF("\n");
1872 destval
= and_long(destval
, *srcreg
);
1873 store_data_long(destoffset
, destval
);
1878 destoffset
= decode_rm00_address(rl
);
1880 destval
= fetch_data_word(destoffset
);
1881 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
1882 DECODE_PRINTF("\n");
1884 destval
= and_word(destval
, *srcreg
);
1885 store_data_word(destoffset
, destval
);
1889 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1893 destoffset
= decode_rm01_address(rl
);
1895 destval
= fetch_data_long(destoffset
);
1896 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
1897 DECODE_PRINTF("\n");
1899 destval
= and_long(destval
, *srcreg
);
1900 store_data_long(destoffset
, destval
);
1905 destoffset
= decode_rm01_address(rl
);
1907 destval
= fetch_data_word(destoffset
);
1908 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
1909 DECODE_PRINTF("\n");
1911 destval
= and_word(destval
, *srcreg
);
1912 store_data_word(destoffset
, destval
);
1916 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1920 destoffset
= decode_rm10_address(rl
);
1922 destval
= fetch_data_long(destoffset
);
1923 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
1924 DECODE_PRINTF("\n");
1926 destval
= and_long(destval
, *srcreg
);
1927 store_data_long(destoffset
, destval
);
1932 destoffset
= decode_rm10_address(rl
);
1934 destval
= fetch_data_word(destoffset
);
1935 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
1936 DECODE_PRINTF("\n");
1938 destval
= and_word(destval
, *srcreg
);
1939 store_data_word(destoffset
, destval
);
1942 case 3: /* register to register */
1943 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
1944 u32
*destreg
,*srcreg
;
1946 destreg
= DECODE_RM_LONG_REGISTER(rl
);
1948 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
1949 DECODE_PRINTF("\n");
1951 *destreg
= and_long(*destreg
, *srcreg
);
1953 u16
*destreg
,*srcreg
;
1955 destreg
= DECODE_RM_WORD_REGISTER(rl
);
1957 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
1958 DECODE_PRINTF("\n");
1960 *destreg
= and_word(*destreg
, *srcreg
);
1964 DECODE_CLEAR_SEGOVR();
1968 /****************************************************************************
1971 ****************************************************************************/
1972 static void x86emuOp_and_byte_R_RM(u8
X86EMU_UNUSED(op1
))
1975 u8
*destreg
, *srcreg
;
1980 DECODE_PRINTF("AND\t");
1981 FETCH_DECODE_MODRM(mod
, rh
, rl
);
1984 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
1986 srcoffset
= decode_rm00_address(rl
);
1987 srcval
= fetch_data_byte(srcoffset
);
1988 DECODE_PRINTF("\n");
1990 *destreg
= and_byte(*destreg
, srcval
);
1993 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
1995 srcoffset
= decode_rm01_address(rl
);
1996 srcval
= fetch_data_byte(srcoffset
);
1997 DECODE_PRINTF("\n");
1999 *destreg
= and_byte(*destreg
, srcval
);
2002 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
2004 srcoffset
= decode_rm10_address(rl
);
2005 srcval
= fetch_data_byte(srcoffset
);
2006 DECODE_PRINTF("\n");
2008 *destreg
= and_byte(*destreg
, srcval
);
2010 case 3: /* register to register */
2011 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
2013 srcreg
= DECODE_RM_BYTE_REGISTER(rl
);
2014 DECODE_PRINTF("\n");
2016 *destreg
= and_byte(*destreg
, *srcreg
);
2019 DECODE_CLEAR_SEGOVR();
2023 /****************************************************************************
2026 ****************************************************************************/
2027 static void x86emuOp_and_word_R_RM(u8
X86EMU_UNUSED(op1
))
2033 DECODE_PRINTF("AND\t");
2034 FETCH_DECODE_MODRM(mod
, rh
, rl
);
2037 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2041 destreg
= DECODE_RM_LONG_REGISTER(rh
);
2043 srcoffset
= decode_rm00_address(rl
);
2044 srcval
= fetch_data_long(srcoffset
);
2045 DECODE_PRINTF("\n");
2047 *destreg
= and_long(*destreg
, srcval
);
2052 destreg
= DECODE_RM_WORD_REGISTER(rh
);
2054 srcoffset
= decode_rm00_address(rl
);
2055 srcval
= fetch_data_word(srcoffset
);
2056 DECODE_PRINTF("\n");
2058 *destreg
= and_word(*destreg
, srcval
);
2062 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2066 destreg
= DECODE_RM_LONG_REGISTER(rh
);
2068 srcoffset
= decode_rm01_address(rl
);
2069 srcval
= fetch_data_long(srcoffset
);
2070 DECODE_PRINTF("\n");
2072 *destreg
= and_long(*destreg
, srcval
);
2078 destreg
= DECODE_RM_WORD_REGISTER(rh
);
2080 srcoffset
= decode_rm01_address(rl
);
2081 srcval
= fetch_data_word(srcoffset
);
2082 DECODE_PRINTF("\n");
2084 *destreg
= and_word(*destreg
, srcval
);
2088 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2092 destreg
= DECODE_RM_LONG_REGISTER(rh
);
2094 srcoffset
= decode_rm10_address(rl
);
2095 srcval
= fetch_data_long(srcoffset
);
2096 DECODE_PRINTF("\n");
2098 *destreg
= and_long(*destreg
, srcval
);
2103 destreg
= DECODE_RM_WORD_REGISTER(rh
);
2105 srcoffset
= decode_rm10_address(rl
);
2106 srcval
= fetch_data_word(srcoffset
);
2107 DECODE_PRINTF("\n");
2109 *destreg
= and_word(*destreg
, srcval
);
2112 case 3: /* register to register */
2113 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2114 u32
*destreg
,*srcreg
;
2116 destreg
= DECODE_RM_LONG_REGISTER(rh
);
2118 srcreg
= DECODE_RM_LONG_REGISTER(rl
);
2119 DECODE_PRINTF("\n");
2121 *destreg
= and_long(*destreg
, *srcreg
);
2123 u16
*destreg
,*srcreg
;
2125 destreg
= DECODE_RM_WORD_REGISTER(rh
);
2127 srcreg
= DECODE_RM_WORD_REGISTER(rl
);
2128 DECODE_PRINTF("\n");
2130 *destreg
= and_word(*destreg
, *srcreg
);
2134 DECODE_CLEAR_SEGOVR();
2138 /****************************************************************************
2141 ****************************************************************************/
2142 static void x86emuOp_and_byte_AL_IMM(u8
X86EMU_UNUSED(op1
))
2147 DECODE_PRINTF("AND\tAL,");
2148 srcval
= fetch_byte_imm();
2149 DECODE_PRINTF2("%x\n", srcval
);
2151 M
.x86
.R_AL
= and_byte(M
.x86
.R_AL
, srcval
);
2152 DECODE_CLEAR_SEGOVR();
2156 /****************************************************************************
2159 ****************************************************************************/
2160 static void x86emuOp_and_word_AX_IMM(u8
X86EMU_UNUSED(op1
))
2165 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2166 DECODE_PRINTF("AND\tEAX,");
2167 srcval
= fetch_long_imm();
2169 DECODE_PRINTF("AND\tAX,");
2170 srcval
= fetch_word_imm();
2172 DECODE_PRINTF2("%x\n", srcval
);
2174 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2175 M
.x86
.R_EAX
= and_long(M
.x86
.R_EAX
, srcval
);
2177 M
.x86
.R_AX
= and_word(M
.x86
.R_AX
, (u16
)srcval
);
2179 DECODE_CLEAR_SEGOVR();
2183 /****************************************************************************
2186 ****************************************************************************/
2187 static void x86emuOp_segovr_ES(u8
X86EMU_UNUSED(op1
))
2190 DECODE_PRINTF("ES:\n");
2192 M
.x86
.mode
|= SYSMODE_SEGOVR_ES
;
2194 * note the lack of DECODE_CLEAR_SEGOVR(r) since, here is one of 4
2195 * opcode subroutines we do not want to do this.
2200 /****************************************************************************
2203 ****************************************************************************/
2204 static void x86emuOp_daa(u8
X86EMU_UNUSED(op1
))
2207 DECODE_PRINTF("DAA\n");
2209 M
.x86
.R_AL
= daa_byte(M
.x86
.R_AL
);
2210 DECODE_CLEAR_SEGOVR();
2214 /****************************************************************************
2217 ****************************************************************************/
2218 static void x86emuOp_sub_byte_RM_R(u8
X86EMU_UNUSED(op1
))
2221 u8
*destreg
, *srcreg
;
2226 DECODE_PRINTF("SUB\t");
2227 FETCH_DECODE_MODRM(mod
, rh
, rl
);
2230 destoffset
= decode_rm00_address(rl
);
2232 destval
= fetch_data_byte(destoffset
);
2233 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
2234 DECODE_PRINTF("\n");
2236 destval
= sub_byte(destval
, *srcreg
);
2237 store_data_byte(destoffset
, destval
);
2240 destoffset
= decode_rm01_address(rl
);
2242 destval
= fetch_data_byte(destoffset
);
2243 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
2244 DECODE_PRINTF("\n");
2246 destval
= sub_byte(destval
, *srcreg
);
2247 store_data_byte(destoffset
, destval
);
2250 destoffset
= decode_rm10_address(rl
);
2252 destval
= fetch_data_byte(destoffset
);
2253 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
2254 DECODE_PRINTF("\n");
2256 destval
= sub_byte(destval
, *srcreg
);
2257 store_data_byte(destoffset
, destval
);
2259 case 3: /* register to register */
2260 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
2262 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
2263 DECODE_PRINTF("\n");
2265 *destreg
= sub_byte(*destreg
, *srcreg
);
2268 DECODE_CLEAR_SEGOVR();
2272 /****************************************************************************
2275 ****************************************************************************/
2276 static void x86emuOp_sub_word_RM_R(u8
X86EMU_UNUSED(op1
))
2282 DECODE_PRINTF("SUB\t");
2283 FETCH_DECODE_MODRM(mod
, rh
, rl
);
2286 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2290 destoffset
= decode_rm00_address(rl
);
2292 destval
= fetch_data_long(destoffset
);
2293 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
2294 DECODE_PRINTF("\n");
2296 destval
= sub_long(destval
, *srcreg
);
2297 store_data_long(destoffset
, destval
);
2302 destoffset
= decode_rm00_address(rl
);
2304 destval
= fetch_data_word(destoffset
);
2305 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
2306 DECODE_PRINTF("\n");
2308 destval
= sub_word(destval
, *srcreg
);
2309 store_data_word(destoffset
, destval
);
2313 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2317 destoffset
= decode_rm01_address(rl
);
2319 destval
= fetch_data_long(destoffset
);
2320 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
2321 DECODE_PRINTF("\n");
2323 destval
= sub_long(destval
, *srcreg
);
2324 store_data_long(destoffset
, destval
);
2329 destoffset
= decode_rm01_address(rl
);
2331 destval
= fetch_data_word(destoffset
);
2332 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
2333 DECODE_PRINTF("\n");
2335 destval
= sub_word(destval
, *srcreg
);
2336 store_data_word(destoffset
, destval
);
2340 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2344 destoffset
= decode_rm10_address(rl
);
2346 destval
= fetch_data_long(destoffset
);
2347 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
2348 DECODE_PRINTF("\n");
2350 destval
= sub_long(destval
, *srcreg
);
2351 store_data_long(destoffset
, destval
);
2356 destoffset
= decode_rm10_address(rl
);
2358 destval
= fetch_data_word(destoffset
);
2359 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
2360 DECODE_PRINTF("\n");
2362 destval
= sub_word(destval
, *srcreg
);
2363 store_data_word(destoffset
, destval
);
2366 case 3: /* register to register */
2367 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2368 u32
*destreg
,*srcreg
;
2370 destreg
= DECODE_RM_LONG_REGISTER(rl
);
2372 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
2373 DECODE_PRINTF("\n");
2375 *destreg
= sub_long(*destreg
, *srcreg
);
2377 u16
*destreg
,*srcreg
;
2379 destreg
= DECODE_RM_WORD_REGISTER(rl
);
2381 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
2382 DECODE_PRINTF("\n");
2384 *destreg
= sub_word(*destreg
, *srcreg
);
2388 DECODE_CLEAR_SEGOVR();
2392 /****************************************************************************
2395 ****************************************************************************/
2396 static void x86emuOp_sub_byte_R_RM(u8
X86EMU_UNUSED(op1
))
2399 u8
*destreg
, *srcreg
;
2404 DECODE_PRINTF("SUB\t");
2405 FETCH_DECODE_MODRM(mod
, rh
, rl
);
2408 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
2410 srcoffset
= decode_rm00_address(rl
);
2411 srcval
= fetch_data_byte(srcoffset
);
2412 DECODE_PRINTF("\n");
2414 *destreg
= sub_byte(*destreg
, srcval
);
2417 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
2419 srcoffset
= decode_rm01_address(rl
);
2420 srcval
= fetch_data_byte(srcoffset
);
2421 DECODE_PRINTF("\n");
2423 *destreg
= sub_byte(*destreg
, srcval
);
2426 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
2428 srcoffset
= decode_rm10_address(rl
);
2429 srcval
= fetch_data_byte(srcoffset
);
2430 DECODE_PRINTF("\n");
2432 *destreg
= sub_byte(*destreg
, srcval
);
2434 case 3: /* register to register */
2435 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
2437 srcreg
= DECODE_RM_BYTE_REGISTER(rl
);
2438 DECODE_PRINTF("\n");
2440 *destreg
= sub_byte(*destreg
, *srcreg
);
2443 DECODE_CLEAR_SEGOVR();
2447 /****************************************************************************
2450 ****************************************************************************/
2451 static void x86emuOp_sub_word_R_RM(u8
X86EMU_UNUSED(op1
))
2457 DECODE_PRINTF("SUB\t");
2458 FETCH_DECODE_MODRM(mod
, rh
, rl
);
2461 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2465 destreg
= DECODE_RM_LONG_REGISTER(rh
);
2467 srcoffset
= decode_rm00_address(rl
);
2468 srcval
= fetch_data_long(srcoffset
);
2469 DECODE_PRINTF("\n");
2471 *destreg
= sub_long(*destreg
, srcval
);
2476 destreg
= DECODE_RM_WORD_REGISTER(rh
);
2478 srcoffset
= decode_rm00_address(rl
);
2479 srcval
= fetch_data_word(srcoffset
);
2480 DECODE_PRINTF("\n");
2482 *destreg
= sub_word(*destreg
, srcval
);
2486 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2490 destreg
= DECODE_RM_LONG_REGISTER(rh
);
2492 srcoffset
= decode_rm01_address(rl
);
2493 srcval
= fetch_data_long(srcoffset
);
2494 DECODE_PRINTF("\n");
2496 *destreg
= sub_long(*destreg
, srcval
);
2501 destreg
= DECODE_RM_WORD_REGISTER(rh
);
2503 srcoffset
= decode_rm01_address(rl
);
2504 srcval
= fetch_data_word(srcoffset
);
2505 DECODE_PRINTF("\n");
2507 *destreg
= sub_word(*destreg
, srcval
);
2511 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2515 destreg
= DECODE_RM_LONG_REGISTER(rh
);
2517 srcoffset
= decode_rm10_address(rl
);
2518 srcval
= fetch_data_long(srcoffset
);
2519 DECODE_PRINTF("\n");
2521 *destreg
= sub_long(*destreg
, srcval
);
2526 destreg
= DECODE_RM_WORD_REGISTER(rh
);
2528 srcoffset
= decode_rm10_address(rl
);
2529 srcval
= fetch_data_word(srcoffset
);
2530 DECODE_PRINTF("\n");
2532 *destreg
= sub_word(*destreg
, srcval
);
2535 case 3: /* register to register */
2536 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2537 u32
*destreg
,*srcreg
;
2539 destreg
= DECODE_RM_LONG_REGISTER(rh
);
2541 srcreg
= DECODE_RM_LONG_REGISTER(rl
);
2542 DECODE_PRINTF("\n");
2544 *destreg
= sub_long(*destreg
, *srcreg
);
2546 u16
*destreg
,*srcreg
;
2548 destreg
= DECODE_RM_WORD_REGISTER(rh
);
2550 srcreg
= DECODE_RM_WORD_REGISTER(rl
);
2551 DECODE_PRINTF("\n");
2553 *destreg
= sub_word(*destreg
, *srcreg
);
2557 DECODE_CLEAR_SEGOVR();
2561 /****************************************************************************
2564 ****************************************************************************/
2565 static void x86emuOp_sub_byte_AL_IMM(u8
X86EMU_UNUSED(op1
))
2570 DECODE_PRINTF("SUB\tAL,");
2571 srcval
= fetch_byte_imm();
2572 DECODE_PRINTF2("%x\n", srcval
);
2574 M
.x86
.R_AL
= sub_byte(M
.x86
.R_AL
, srcval
);
2575 DECODE_CLEAR_SEGOVR();
2579 /****************************************************************************
2582 ****************************************************************************/
2583 static void x86emuOp_sub_word_AX_IMM(u8
X86EMU_UNUSED(op1
))
2588 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2589 DECODE_PRINTF("SUB\tEAX,");
2590 srcval
= fetch_long_imm();
2592 DECODE_PRINTF("SUB\tAX,");
2593 srcval
= fetch_word_imm();
2595 DECODE_PRINTF2("%x\n", srcval
);
2597 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2598 M
.x86
.R_EAX
= sub_long(M
.x86
.R_EAX
, srcval
);
2600 M
.x86
.R_AX
= sub_word(M
.x86
.R_AX
, (u16
)srcval
);
2602 DECODE_CLEAR_SEGOVR();
2606 /****************************************************************************
2609 ****************************************************************************/
2610 static void x86emuOp_segovr_CS(u8
X86EMU_UNUSED(op1
))
2613 DECODE_PRINTF("CS:\n");
2615 M
.x86
.mode
|= SYSMODE_SEGOVR_CS
;
2616 /* note no DECODE_CLEAR_SEGOVR here. */
2620 /****************************************************************************
2623 ****************************************************************************/
2624 static void x86emuOp_das(u8
X86EMU_UNUSED(op1
))
2627 DECODE_PRINTF("DAS\n");
2629 M
.x86
.R_AL
= das_byte(M
.x86
.R_AL
);
2630 DECODE_CLEAR_SEGOVR();
2634 /****************************************************************************
2637 ****************************************************************************/
2638 static void x86emuOp_xor_byte_RM_R(u8
X86EMU_UNUSED(op1
))
2641 u8
*destreg
, *srcreg
;
2646 DECODE_PRINTF("XOR\t");
2647 FETCH_DECODE_MODRM(mod
, rh
, rl
);
2650 destoffset
= decode_rm00_address(rl
);
2652 destval
= fetch_data_byte(destoffset
);
2653 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
2654 DECODE_PRINTF("\n");
2656 destval
= xor_byte(destval
, *srcreg
);
2657 store_data_byte(destoffset
, destval
);
2660 destoffset
= decode_rm01_address(rl
);
2662 destval
= fetch_data_byte(destoffset
);
2663 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
2664 DECODE_PRINTF("\n");
2666 destval
= xor_byte(destval
, *srcreg
);
2667 store_data_byte(destoffset
, destval
);
2670 destoffset
= decode_rm10_address(rl
);
2672 destval
= fetch_data_byte(destoffset
);
2673 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
2674 DECODE_PRINTF("\n");
2676 destval
= xor_byte(destval
, *srcreg
);
2677 store_data_byte(destoffset
, destval
);
2679 case 3: /* register to register */
2680 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
2682 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
2683 DECODE_PRINTF("\n");
2685 *destreg
= xor_byte(*destreg
, *srcreg
);
2688 DECODE_CLEAR_SEGOVR();
2692 /****************************************************************************
2695 ****************************************************************************/
2696 static void x86emuOp_xor_word_RM_R(u8
X86EMU_UNUSED(op1
))
2702 DECODE_PRINTF("XOR\t");
2703 FETCH_DECODE_MODRM(mod
, rh
, rl
);
2706 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2710 destoffset
= decode_rm00_address(rl
);
2712 destval
= fetch_data_long(destoffset
);
2713 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
2714 DECODE_PRINTF("\n");
2716 destval
= xor_long(destval
, *srcreg
);
2717 store_data_long(destoffset
, destval
);
2722 destoffset
= decode_rm00_address(rl
);
2724 destval
= fetch_data_word(destoffset
);
2725 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
2726 DECODE_PRINTF("\n");
2728 destval
= xor_word(destval
, *srcreg
);
2729 store_data_word(destoffset
, destval
);
2733 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2737 destoffset
= decode_rm01_address(rl
);
2739 destval
= fetch_data_long(destoffset
);
2740 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
2741 DECODE_PRINTF("\n");
2743 destval
= xor_long(destval
, *srcreg
);
2744 store_data_long(destoffset
, destval
);
2749 destoffset
= decode_rm01_address(rl
);
2751 destval
= fetch_data_word(destoffset
);
2752 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
2753 DECODE_PRINTF("\n");
2755 destval
= xor_word(destval
, *srcreg
);
2756 store_data_word(destoffset
, destval
);
2760 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2764 destoffset
= decode_rm10_address(rl
);
2766 destval
= fetch_data_long(destoffset
);
2767 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
2768 DECODE_PRINTF("\n");
2770 destval
= xor_long(destval
, *srcreg
);
2771 store_data_long(destoffset
, destval
);
2776 destoffset
= decode_rm10_address(rl
);
2778 destval
= fetch_data_word(destoffset
);
2779 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
2780 DECODE_PRINTF("\n");
2782 destval
= xor_word(destval
, *srcreg
);
2783 store_data_word(destoffset
, destval
);
2786 case 3: /* register to register */
2787 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2788 u32
*destreg
,*srcreg
;
2790 destreg
= DECODE_RM_LONG_REGISTER(rl
);
2792 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
2793 DECODE_PRINTF("\n");
2795 *destreg
= xor_long(*destreg
, *srcreg
);
2797 u16
*destreg
,*srcreg
;
2799 destreg
= DECODE_RM_WORD_REGISTER(rl
);
2801 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
2802 DECODE_PRINTF("\n");
2804 *destreg
= xor_word(*destreg
, *srcreg
);
2808 DECODE_CLEAR_SEGOVR();
2812 /****************************************************************************
2815 ****************************************************************************/
2816 static void x86emuOp_xor_byte_R_RM(u8
X86EMU_UNUSED(op1
))
2819 u8
*destreg
, *srcreg
;
2824 DECODE_PRINTF("XOR\t");
2825 FETCH_DECODE_MODRM(mod
, rh
, rl
);
2828 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
2830 srcoffset
= decode_rm00_address(rl
);
2831 srcval
= fetch_data_byte(srcoffset
);
2832 DECODE_PRINTF("\n");
2834 *destreg
= xor_byte(*destreg
, srcval
);
2837 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
2839 srcoffset
= decode_rm01_address(rl
);
2840 srcval
= fetch_data_byte(srcoffset
);
2841 DECODE_PRINTF("\n");
2843 *destreg
= xor_byte(*destreg
, srcval
);
2846 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
2848 srcoffset
= decode_rm10_address(rl
);
2849 srcval
= fetch_data_byte(srcoffset
);
2850 DECODE_PRINTF("\n");
2852 *destreg
= xor_byte(*destreg
, srcval
);
2854 case 3: /* register to register */
2855 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
2857 srcreg
= DECODE_RM_BYTE_REGISTER(rl
);
2858 DECODE_PRINTF("\n");
2860 *destreg
= xor_byte(*destreg
, *srcreg
);
2863 DECODE_CLEAR_SEGOVR();
2867 /****************************************************************************
2870 ****************************************************************************/
2871 static void x86emuOp_xor_word_R_RM(u8
X86EMU_UNUSED(op1
))
2877 DECODE_PRINTF("XOR\t");
2878 FETCH_DECODE_MODRM(mod
, rh
, rl
);
2881 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2885 destreg
= DECODE_RM_LONG_REGISTER(rh
);
2887 srcoffset
= decode_rm00_address(rl
);
2888 srcval
= fetch_data_long(srcoffset
);
2889 DECODE_PRINTF("\n");
2891 *destreg
= xor_long(*destreg
, srcval
);
2896 destreg
= DECODE_RM_WORD_REGISTER(rh
);
2898 srcoffset
= decode_rm00_address(rl
);
2899 srcval
= fetch_data_word(srcoffset
);
2900 DECODE_PRINTF("\n");
2902 *destreg
= xor_word(*destreg
, srcval
);
2906 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2910 destreg
= DECODE_RM_LONG_REGISTER(rh
);
2912 srcoffset
= decode_rm01_address(rl
);
2913 srcval
= fetch_data_long(srcoffset
);
2914 DECODE_PRINTF("\n");
2916 *destreg
= xor_long(*destreg
, srcval
);
2921 destreg
= DECODE_RM_WORD_REGISTER(rh
);
2923 srcoffset
= decode_rm01_address(rl
);
2924 srcval
= fetch_data_word(srcoffset
);
2925 DECODE_PRINTF("\n");
2927 *destreg
= xor_word(*destreg
, srcval
);
2931 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2935 destreg
= DECODE_RM_LONG_REGISTER(rh
);
2937 srcoffset
= decode_rm10_address(rl
);
2938 srcval
= fetch_data_long(srcoffset
);
2939 DECODE_PRINTF("\n");
2941 *destreg
= xor_long(*destreg
, srcval
);
2946 destreg
= DECODE_RM_WORD_REGISTER(rh
);
2948 srcoffset
= decode_rm10_address(rl
);
2949 srcval
= fetch_data_word(srcoffset
);
2950 DECODE_PRINTF("\n");
2952 *destreg
= xor_word(*destreg
, srcval
);
2955 case 3: /* register to register */
2956 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
2957 u32
*destreg
,*srcreg
;
2959 destreg
= DECODE_RM_LONG_REGISTER(rh
);
2961 srcreg
= DECODE_RM_LONG_REGISTER(rl
);
2962 DECODE_PRINTF("\n");
2964 *destreg
= xor_long(*destreg
, *srcreg
);
2966 u16
*destreg
,*srcreg
;
2968 destreg
= DECODE_RM_WORD_REGISTER(rh
);
2970 srcreg
= DECODE_RM_WORD_REGISTER(rl
);
2971 DECODE_PRINTF("\n");
2973 *destreg
= xor_word(*destreg
, *srcreg
);
2977 DECODE_CLEAR_SEGOVR();
2981 /****************************************************************************
2984 ****************************************************************************/
2985 static void x86emuOp_xor_byte_AL_IMM(u8
X86EMU_UNUSED(op1
))
2990 DECODE_PRINTF("XOR\tAL,");
2991 srcval
= fetch_byte_imm();
2992 DECODE_PRINTF2("%x\n", srcval
);
2994 M
.x86
.R_AL
= xor_byte(M
.x86
.R_AL
, srcval
);
2995 DECODE_CLEAR_SEGOVR();
2999 /****************************************************************************
3002 ****************************************************************************/
3003 static void x86emuOp_xor_word_AX_IMM(u8
X86EMU_UNUSED(op1
))
3008 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3009 DECODE_PRINTF("XOR\tEAX,");
3010 srcval
= fetch_long_imm();
3012 DECODE_PRINTF("XOR\tAX,");
3013 srcval
= fetch_word_imm();
3015 DECODE_PRINTF2("%x\n", srcval
);
3017 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3018 M
.x86
.R_EAX
= xor_long(M
.x86
.R_EAX
, srcval
);
3020 M
.x86
.R_AX
= xor_word(M
.x86
.R_AX
, (u16
)srcval
);
3022 DECODE_CLEAR_SEGOVR();
3026 /****************************************************************************
3029 ****************************************************************************/
3030 static void x86emuOp_segovr_SS(u8
X86EMU_UNUSED(op1
))
3033 DECODE_PRINTF("SS:\n");
3035 M
.x86
.mode
|= SYSMODE_SEGOVR_SS
;
3036 /* no DECODE_CLEAR_SEGOVR ! */
3040 /****************************************************************************
3043 ****************************************************************************/
3044 static void x86emuOp_aaa(u8
X86EMU_UNUSED(op1
))
3047 DECODE_PRINTF("AAA\n");
3049 M
.x86
.R_AX
= aaa_word(M
.x86
.R_AX
);
3050 DECODE_CLEAR_SEGOVR();
3054 /****************************************************************************
3057 ****************************************************************************/
3058 static void x86emuOp_cmp_byte_RM_R(u8
X86EMU_UNUSED(op1
))
3062 u8
*destreg
, *srcreg
;
3066 DECODE_PRINTF("CMP\t");
3067 FETCH_DECODE_MODRM(mod
, rh
, rl
);
3070 destoffset
= decode_rm00_address(rl
);
3072 destval
= fetch_data_byte(destoffset
);
3073 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
3074 DECODE_PRINTF("\n");
3076 cmp_byte(destval
, *srcreg
);
3079 destoffset
= decode_rm01_address(rl
);
3081 destval
= fetch_data_byte(destoffset
);
3082 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
3083 DECODE_PRINTF("\n");
3085 cmp_byte(destval
, *srcreg
);
3088 destoffset
= decode_rm10_address(rl
);
3090 destval
= fetch_data_byte(destoffset
);
3091 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
3092 DECODE_PRINTF("\n");
3094 cmp_byte(destval
, *srcreg
);
3096 case 3: /* register to register */
3097 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
3099 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
3100 DECODE_PRINTF("\n");
3102 cmp_byte(*destreg
, *srcreg
);
3105 DECODE_CLEAR_SEGOVR();
3109 /****************************************************************************
3112 ****************************************************************************/
3113 static void x86emuOp_cmp_word_RM_R(u8
X86EMU_UNUSED(op1
))
3119 DECODE_PRINTF("CMP\t");
3120 FETCH_DECODE_MODRM(mod
, rh
, rl
);
3123 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3127 destoffset
= decode_rm00_address(rl
);
3129 destval
= fetch_data_long(destoffset
);
3130 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
3131 DECODE_PRINTF("\n");
3133 cmp_long(destval
, *srcreg
);
3138 destoffset
= decode_rm00_address(rl
);
3140 destval
= fetch_data_word(destoffset
);
3141 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
3142 DECODE_PRINTF("\n");
3144 cmp_word(destval
, *srcreg
);
3148 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3152 destoffset
= decode_rm01_address(rl
);
3154 destval
= fetch_data_long(destoffset
);
3155 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
3156 DECODE_PRINTF("\n");
3158 cmp_long(destval
, *srcreg
);
3163 destoffset
= decode_rm01_address(rl
);
3165 destval
= fetch_data_word(destoffset
);
3166 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
3167 DECODE_PRINTF("\n");
3169 cmp_word(destval
, *srcreg
);
3173 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3177 destoffset
= decode_rm10_address(rl
);
3179 destval
= fetch_data_long(destoffset
);
3180 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
3181 DECODE_PRINTF("\n");
3183 cmp_long(destval
, *srcreg
);
3188 destoffset
= decode_rm10_address(rl
);
3190 destval
= fetch_data_word(destoffset
);
3191 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
3192 DECODE_PRINTF("\n");
3194 cmp_word(destval
, *srcreg
);
3197 case 3: /* register to register */
3198 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3199 u32
*destreg
,*srcreg
;
3201 destreg
= DECODE_RM_LONG_REGISTER(rl
);
3203 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
3204 DECODE_PRINTF("\n");
3206 cmp_long(*destreg
, *srcreg
);
3208 u16
*destreg
,*srcreg
;
3210 destreg
= DECODE_RM_WORD_REGISTER(rl
);
3212 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
3213 DECODE_PRINTF("\n");
3215 cmp_word(*destreg
, *srcreg
);
3219 DECODE_CLEAR_SEGOVR();
3223 /****************************************************************************
3226 ****************************************************************************/
3227 static void x86emuOp_cmp_byte_R_RM(u8
X86EMU_UNUSED(op1
))
3230 u8
*destreg
, *srcreg
;
3235 DECODE_PRINTF("CMP\t");
3236 FETCH_DECODE_MODRM(mod
, rh
, rl
);
3239 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
3241 srcoffset
= decode_rm00_address(rl
);
3242 srcval
= fetch_data_byte(srcoffset
);
3243 DECODE_PRINTF("\n");
3245 cmp_byte(*destreg
, srcval
);
3248 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
3250 srcoffset
= decode_rm01_address(rl
);
3251 srcval
= fetch_data_byte(srcoffset
);
3252 DECODE_PRINTF("\n");
3254 cmp_byte(*destreg
, srcval
);
3257 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
3259 srcoffset
= decode_rm10_address(rl
);
3260 srcval
= fetch_data_byte(srcoffset
);
3261 DECODE_PRINTF("\n");
3263 cmp_byte(*destreg
, srcval
);
3265 case 3: /* register to register */
3266 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
3268 srcreg
= DECODE_RM_BYTE_REGISTER(rl
);
3269 DECODE_PRINTF("\n");
3271 cmp_byte(*destreg
, *srcreg
);
3274 DECODE_CLEAR_SEGOVR();
3278 /****************************************************************************
3281 ****************************************************************************/
3282 static void x86emuOp_cmp_word_R_RM(u8
X86EMU_UNUSED(op1
))
3288 DECODE_PRINTF("CMP\t");
3289 FETCH_DECODE_MODRM(mod
, rh
, rl
);
3292 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3296 destreg
= DECODE_RM_LONG_REGISTER(rh
);
3298 srcoffset
= decode_rm00_address(rl
);
3299 srcval
= fetch_data_long(srcoffset
);
3300 DECODE_PRINTF("\n");
3302 cmp_long(*destreg
, srcval
);
3307 destreg
= DECODE_RM_WORD_REGISTER(rh
);
3309 srcoffset
= decode_rm00_address(rl
);
3310 srcval
= fetch_data_word(srcoffset
);
3311 DECODE_PRINTF("\n");
3313 cmp_word(*destreg
, srcval
);
3317 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3321 destreg
= DECODE_RM_LONG_REGISTER(rh
);
3323 srcoffset
= decode_rm01_address(rl
);
3324 srcval
= fetch_data_long(srcoffset
);
3325 DECODE_PRINTF("\n");
3327 cmp_long(*destreg
, srcval
);
3332 destreg
= DECODE_RM_WORD_REGISTER(rh
);
3334 srcoffset
= decode_rm01_address(rl
);
3335 srcval
= fetch_data_word(srcoffset
);
3336 DECODE_PRINTF("\n");
3338 cmp_word(*destreg
, srcval
);
3342 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3346 destreg
= DECODE_RM_LONG_REGISTER(rh
);
3348 srcoffset
= decode_rm10_address(rl
);
3349 srcval
= fetch_data_long(srcoffset
);
3350 DECODE_PRINTF("\n");
3352 cmp_long(*destreg
, srcval
);
3357 destreg
= DECODE_RM_WORD_REGISTER(rh
);
3359 srcoffset
= decode_rm10_address(rl
);
3360 srcval
= fetch_data_word(srcoffset
);
3361 DECODE_PRINTF("\n");
3363 cmp_word(*destreg
, srcval
);
3366 case 3: /* register to register */
3367 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3368 u32
*destreg
,*srcreg
;
3370 destreg
= DECODE_RM_LONG_REGISTER(rh
);
3372 srcreg
= DECODE_RM_LONG_REGISTER(rl
);
3373 DECODE_PRINTF("\n");
3375 cmp_long(*destreg
, *srcreg
);
3377 u16
*destreg
,*srcreg
;
3379 destreg
= DECODE_RM_WORD_REGISTER(rh
);
3381 srcreg
= DECODE_RM_WORD_REGISTER(rl
);
3382 DECODE_PRINTF("\n");
3384 cmp_word(*destreg
, *srcreg
);
3388 DECODE_CLEAR_SEGOVR();
3392 /****************************************************************************
3395 ****************************************************************************/
3396 static void x86emuOp_cmp_byte_AL_IMM(u8
X86EMU_UNUSED(op1
))
3401 DECODE_PRINTF("CMP\tAL,");
3402 srcval
= fetch_byte_imm();
3403 DECODE_PRINTF2("%x\n", srcval
);
3405 cmp_byte(M
.x86
.R_AL
, srcval
);
3406 DECODE_CLEAR_SEGOVR();
3410 /****************************************************************************
3413 ****************************************************************************/
3414 static void x86emuOp_cmp_word_AX_IMM(u8
X86EMU_UNUSED(op1
))
3419 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3420 DECODE_PRINTF("CMP\tEAX,");
3421 srcval
= fetch_long_imm();
3423 DECODE_PRINTF("CMP\tAX,");
3424 srcval
= fetch_word_imm();
3426 DECODE_PRINTF2("%x\n", srcval
);
3428 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3429 cmp_long(M
.x86
.R_EAX
, srcval
);
3431 cmp_word(M
.x86
.R_AX
, (u16
)srcval
);
3433 DECODE_CLEAR_SEGOVR();
3437 /****************************************************************************
3440 ****************************************************************************/
3441 static void x86emuOp_segovr_DS(u8
X86EMU_UNUSED(op1
))
3444 DECODE_PRINTF("DS:\n");
3446 M
.x86
.mode
|= SYSMODE_SEGOVR_DS
;
3447 /* NO DECODE_CLEAR_SEGOVR! */
3451 /****************************************************************************
3454 ****************************************************************************/
3455 static void x86emuOp_aas(u8
X86EMU_UNUSED(op1
))
3458 DECODE_PRINTF("AAS\n");
3460 M
.x86
.R_AX
= aas_word(M
.x86
.R_AX
);
3461 DECODE_CLEAR_SEGOVR();
3465 /****************************************************************************
3468 ****************************************************************************/
3469 static void x86emuOp_inc_AX(u8
X86EMU_UNUSED(op1
))
3472 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3473 DECODE_PRINTF("INC\tEAX\n");
3475 DECODE_PRINTF("INC\tAX\n");
3478 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3479 M
.x86
.R_EAX
= inc_long(M
.x86
.R_EAX
);
3481 M
.x86
.R_AX
= inc_word(M
.x86
.R_AX
);
3483 DECODE_CLEAR_SEGOVR();
3487 /****************************************************************************
3490 ****************************************************************************/
3491 static void x86emuOp_inc_CX(u8
X86EMU_UNUSED(op1
))
3494 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3495 DECODE_PRINTF("INC\tECX\n");
3497 DECODE_PRINTF("INC\tCX\n");
3500 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3501 M
.x86
.R_ECX
= inc_long(M
.x86
.R_ECX
);
3503 M
.x86
.R_CX
= inc_word(M
.x86
.R_CX
);
3505 DECODE_CLEAR_SEGOVR();
3509 /****************************************************************************
3512 ****************************************************************************/
3513 static void x86emuOp_inc_DX(u8
X86EMU_UNUSED(op1
))
3516 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3517 DECODE_PRINTF("INC\tEDX\n");
3519 DECODE_PRINTF("INC\tDX\n");
3522 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3523 M
.x86
.R_EDX
= inc_long(M
.x86
.R_EDX
);
3525 M
.x86
.R_DX
= inc_word(M
.x86
.R_DX
);
3527 DECODE_CLEAR_SEGOVR();
3531 /****************************************************************************
3534 ****************************************************************************/
3535 static void x86emuOp_inc_BX(u8
X86EMU_UNUSED(op1
))
3538 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3539 DECODE_PRINTF("INC\tEBX\n");
3541 DECODE_PRINTF("INC\tBX\n");
3544 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3545 M
.x86
.R_EBX
= inc_long(M
.x86
.R_EBX
);
3547 M
.x86
.R_BX
= inc_word(M
.x86
.R_BX
);
3549 DECODE_CLEAR_SEGOVR();
3553 /****************************************************************************
3556 ****************************************************************************/
3557 static void x86emuOp_inc_SP(u8
X86EMU_UNUSED(op1
))
3560 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3561 DECODE_PRINTF("INC\tESP\n");
3563 DECODE_PRINTF("INC\tSP\n");
3566 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3567 M
.x86
.R_ESP
= inc_long(M
.x86
.R_ESP
);
3569 M
.x86
.R_SP
= inc_word(M
.x86
.R_SP
);
3571 DECODE_CLEAR_SEGOVR();
3575 /****************************************************************************
3578 ****************************************************************************/
3579 static void x86emuOp_inc_BP(u8
X86EMU_UNUSED(op1
))
3582 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3583 DECODE_PRINTF("INC\tEBP\n");
3585 DECODE_PRINTF("INC\tBP\n");
3588 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3589 M
.x86
.R_EBP
= inc_long(M
.x86
.R_EBP
);
3591 M
.x86
.R_BP
= inc_word(M
.x86
.R_BP
);
3593 DECODE_CLEAR_SEGOVR();
3597 /****************************************************************************
3600 ****************************************************************************/
3601 static void x86emuOp_inc_SI(u8
X86EMU_UNUSED(op1
))
3604 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3605 DECODE_PRINTF("INC\tESI\n");
3607 DECODE_PRINTF("INC\tSI\n");
3610 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3611 M
.x86
.R_ESI
= inc_long(M
.x86
.R_ESI
);
3613 M
.x86
.R_SI
= inc_word(M
.x86
.R_SI
);
3615 DECODE_CLEAR_SEGOVR();
3619 /****************************************************************************
3622 ****************************************************************************/
3623 static void x86emuOp_inc_DI(u8
X86EMU_UNUSED(op1
))
3626 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3627 DECODE_PRINTF("INC\tEDI\n");
3629 DECODE_PRINTF("INC\tDI\n");
3632 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3633 M
.x86
.R_EDI
= inc_long(M
.x86
.R_EDI
);
3635 M
.x86
.R_DI
= inc_word(M
.x86
.R_DI
);
3637 DECODE_CLEAR_SEGOVR();
3641 /****************************************************************************
3644 ****************************************************************************/
3645 static void x86emuOp_dec_AX(u8
X86EMU_UNUSED(op1
))
3648 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3649 DECODE_PRINTF("DEC\tEAX\n");
3651 DECODE_PRINTF("DEC\tAX\n");
3654 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3655 M
.x86
.R_EAX
= dec_long(M
.x86
.R_EAX
);
3657 M
.x86
.R_AX
= dec_word(M
.x86
.R_AX
);
3659 DECODE_CLEAR_SEGOVR();
3663 /****************************************************************************
3666 ****************************************************************************/
3667 static void x86emuOp_dec_CX(u8
X86EMU_UNUSED(op1
))
3670 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3671 DECODE_PRINTF("DEC\tECX\n");
3673 DECODE_PRINTF("DEC\tCX\n");
3676 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3677 M
.x86
.R_ECX
= dec_long(M
.x86
.R_ECX
);
3679 M
.x86
.R_CX
= dec_word(M
.x86
.R_CX
);
3681 DECODE_CLEAR_SEGOVR();
3685 /****************************************************************************
3688 ****************************************************************************/
3689 static void x86emuOp_dec_DX(u8
X86EMU_UNUSED(op1
))
3692 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3693 DECODE_PRINTF("DEC\tEDX\n");
3695 DECODE_PRINTF("DEC\tDX\n");
3698 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3699 M
.x86
.R_EDX
= dec_long(M
.x86
.R_EDX
);
3701 M
.x86
.R_DX
= dec_word(M
.x86
.R_DX
);
3703 DECODE_CLEAR_SEGOVR();
3707 /****************************************************************************
3710 ****************************************************************************/
3711 static void x86emuOp_dec_BX(u8
X86EMU_UNUSED(op1
))
3714 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3715 DECODE_PRINTF("DEC\tEBX\n");
3717 DECODE_PRINTF("DEC\tBX\n");
3720 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3721 M
.x86
.R_EBX
= dec_long(M
.x86
.R_EBX
);
3723 M
.x86
.R_BX
= dec_word(M
.x86
.R_BX
);
3725 DECODE_CLEAR_SEGOVR();
3729 /****************************************************************************
3732 ****************************************************************************/
3733 static void x86emuOp_dec_SP(u8
X86EMU_UNUSED(op1
))
3736 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3737 DECODE_PRINTF("DEC\tESP\n");
3739 DECODE_PRINTF("DEC\tSP\n");
3742 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3743 M
.x86
.R_ESP
= dec_long(M
.x86
.R_ESP
);
3745 M
.x86
.R_SP
= dec_word(M
.x86
.R_SP
);
3747 DECODE_CLEAR_SEGOVR();
3751 /****************************************************************************
3754 ****************************************************************************/
3755 static void x86emuOp_dec_BP(u8
X86EMU_UNUSED(op1
))
3758 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3759 DECODE_PRINTF("DEC\tEBP\n");
3761 DECODE_PRINTF("DEC\tBP\n");
3764 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3765 M
.x86
.R_EBP
= dec_long(M
.x86
.R_EBP
);
3767 M
.x86
.R_BP
= dec_word(M
.x86
.R_BP
);
3769 DECODE_CLEAR_SEGOVR();
3773 /****************************************************************************
3776 ****************************************************************************/
3777 static void x86emuOp_dec_SI(u8
X86EMU_UNUSED(op1
))
3780 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3781 DECODE_PRINTF("DEC\tESI\n");
3783 DECODE_PRINTF("DEC\tSI\n");
3786 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3787 M
.x86
.R_ESI
= dec_long(M
.x86
.R_ESI
);
3789 M
.x86
.R_SI
= dec_word(M
.x86
.R_SI
);
3791 DECODE_CLEAR_SEGOVR();
3795 /****************************************************************************
3798 ****************************************************************************/
3799 static void x86emuOp_dec_DI(u8
X86EMU_UNUSED(op1
))
3802 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3803 DECODE_PRINTF("DEC\tEDI\n");
3805 DECODE_PRINTF("DEC\tDI\n");
3808 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3809 M
.x86
.R_EDI
= dec_long(M
.x86
.R_EDI
);
3811 M
.x86
.R_DI
= dec_word(M
.x86
.R_DI
);
3813 DECODE_CLEAR_SEGOVR();
3817 /****************************************************************************
3820 ****************************************************************************/
3821 static void x86emuOp_push_AX(u8
X86EMU_UNUSED(op1
))
3824 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3825 DECODE_PRINTF("PUSH\tEAX\n");
3827 DECODE_PRINTF("PUSH\tAX\n");
3830 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3831 push_long(M
.x86
.R_EAX
);
3833 push_word(M
.x86
.R_AX
);
3835 DECODE_CLEAR_SEGOVR();
3839 /****************************************************************************
3842 ****************************************************************************/
3843 static void x86emuOp_push_CX(u8
X86EMU_UNUSED(op1
))
3846 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3847 DECODE_PRINTF("PUSH\tECX\n");
3849 DECODE_PRINTF("PUSH\tCX\n");
3852 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3853 push_long(M
.x86
.R_ECX
);
3855 push_word(M
.x86
.R_CX
);
3857 DECODE_CLEAR_SEGOVR();
3861 /****************************************************************************
3864 ****************************************************************************/
3865 static void x86emuOp_push_DX(u8
X86EMU_UNUSED(op1
))
3868 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3869 DECODE_PRINTF("PUSH\tEDX\n");
3871 DECODE_PRINTF("PUSH\tDX\n");
3874 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3875 push_long(M
.x86
.R_EDX
);
3877 push_word(M
.x86
.R_DX
);
3879 DECODE_CLEAR_SEGOVR();
3883 /****************************************************************************
3886 ****************************************************************************/
3887 static void x86emuOp_push_BX(u8
X86EMU_UNUSED(op1
))
3890 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3891 DECODE_PRINTF("PUSH\tEBX\n");
3893 DECODE_PRINTF("PUSH\tBX\n");
3896 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3897 push_long(M
.x86
.R_EBX
);
3899 push_word(M
.x86
.R_BX
);
3901 DECODE_CLEAR_SEGOVR();
3905 /****************************************************************************
3908 ****************************************************************************/
3909 static void x86emuOp_push_SP(u8
X86EMU_UNUSED(op1
))
3912 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3913 DECODE_PRINTF("PUSH\tESP\n");
3915 DECODE_PRINTF("PUSH\tSP\n");
3918 /* Always push (E)SP, since we are emulating an i386 and above
3919 * processor. This is necessary as some BIOS'es use this to check
3920 * what type of processor is in the system.
3922 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3923 push_long(M
.x86
.R_ESP
);
3925 push_word((u16
)(M
.x86
.R_SP
));
3927 DECODE_CLEAR_SEGOVR();
3931 /****************************************************************************
3934 ****************************************************************************/
3935 static void x86emuOp_push_BP(u8
X86EMU_UNUSED(op1
))
3938 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3939 DECODE_PRINTF("PUSH\tEBP\n");
3941 DECODE_PRINTF("PUSH\tBP\n");
3944 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3945 push_long(M
.x86
.R_EBP
);
3947 push_word(M
.x86
.R_BP
);
3949 DECODE_CLEAR_SEGOVR();
3953 /****************************************************************************
3956 ****************************************************************************/
3957 static void x86emuOp_push_SI(u8
X86EMU_UNUSED(op1
))
3960 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3961 DECODE_PRINTF("PUSH\tESI\n");
3963 DECODE_PRINTF("PUSH\tSI\n");
3966 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3967 push_long(M
.x86
.R_ESI
);
3969 push_word(M
.x86
.R_SI
);
3971 DECODE_CLEAR_SEGOVR();
3975 /****************************************************************************
3978 ****************************************************************************/
3979 static void x86emuOp_push_DI(u8
X86EMU_UNUSED(op1
))
3982 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3983 DECODE_PRINTF("PUSH\tEDI\n");
3985 DECODE_PRINTF("PUSH\tDI\n");
3988 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
3989 push_long(M
.x86
.R_EDI
);
3991 push_word(M
.x86
.R_DI
);
3993 DECODE_CLEAR_SEGOVR();
3997 /****************************************************************************
4000 ****************************************************************************/
4001 static void x86emuOp_pop_AX(u8
X86EMU_UNUSED(op1
))
4004 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4005 DECODE_PRINTF("POP\tEAX\n");
4007 DECODE_PRINTF("POP\tAX\n");
4010 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4011 M
.x86
.R_EAX
= pop_long();
4013 M
.x86
.R_AX
= pop_word();
4015 DECODE_CLEAR_SEGOVR();
4019 /****************************************************************************
4022 ****************************************************************************/
4023 static void x86emuOp_pop_CX(u8
X86EMU_UNUSED(op1
))
4026 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4027 DECODE_PRINTF("POP\tECX\n");
4029 DECODE_PRINTF("POP\tCX\n");
4032 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4033 M
.x86
.R_ECX
= pop_long();
4035 M
.x86
.R_CX
= pop_word();
4037 DECODE_CLEAR_SEGOVR();
4041 /****************************************************************************
4044 ****************************************************************************/
4045 static void x86emuOp_pop_DX(u8
X86EMU_UNUSED(op1
))
4048 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4049 DECODE_PRINTF("POP\tEDX\n");
4051 DECODE_PRINTF("POP\tDX\n");
4054 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4055 M
.x86
.R_EDX
= pop_long();
4057 M
.x86
.R_DX
= pop_word();
4059 DECODE_CLEAR_SEGOVR();
4063 /****************************************************************************
4066 ****************************************************************************/
4067 static void x86emuOp_pop_BX(u8
X86EMU_UNUSED(op1
))
4070 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4071 DECODE_PRINTF("POP\tEBX\n");
4073 DECODE_PRINTF("POP\tBX\n");
4076 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4077 M
.x86
.R_EBX
= pop_long();
4079 M
.x86
.R_BX
= pop_word();
4081 DECODE_CLEAR_SEGOVR();
4085 /****************************************************************************
4088 ****************************************************************************/
4089 static void x86emuOp_pop_SP(u8
X86EMU_UNUSED(op1
))
4092 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4093 DECODE_PRINTF("POP\tESP\n");
4095 DECODE_PRINTF("POP\tSP\n");
4098 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4099 M
.x86
.R_ESP
= pop_long();
4101 M
.x86
.R_SP
= pop_word();
4103 DECODE_CLEAR_SEGOVR();
4107 /****************************************************************************
4110 ****************************************************************************/
4111 static void x86emuOp_pop_BP(u8
X86EMU_UNUSED(op1
))
4114 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4115 DECODE_PRINTF("POP\tEBP\n");
4117 DECODE_PRINTF("POP\tBP\n");
4120 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4121 M
.x86
.R_EBP
= pop_long();
4123 M
.x86
.R_BP
= pop_word();
4125 DECODE_CLEAR_SEGOVR();
4129 /****************************************************************************
4132 ****************************************************************************/
4133 static void x86emuOp_pop_SI(u8
X86EMU_UNUSED(op1
))
4136 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4137 DECODE_PRINTF("POP\tESI\n");
4139 DECODE_PRINTF("POP\tSI\n");
4142 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4143 M
.x86
.R_ESI
= pop_long();
4145 M
.x86
.R_SI
= pop_word();
4147 DECODE_CLEAR_SEGOVR();
4151 /****************************************************************************
4154 ****************************************************************************/
4155 static void x86emuOp_pop_DI(u8
X86EMU_UNUSED(op1
))
4158 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4159 DECODE_PRINTF("POP\tEDI\n");
4161 DECODE_PRINTF("POP\tDI\n");
4164 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4165 M
.x86
.R_EDI
= pop_long();
4167 M
.x86
.R_DI
= pop_word();
4169 DECODE_CLEAR_SEGOVR();
4173 /****************************************************************************
4176 ****************************************************************************/
4177 static void x86emuOp_push_all(u8
X86EMU_UNUSED(op1
))
4180 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4181 DECODE_PRINTF("PUSHAD\n");
4183 DECODE_PRINTF("PUSHA\n");
4186 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4187 u32 old_sp
= M
.x86
.R_ESP
;
4189 push_long(M
.x86
.R_EAX
);
4190 push_long(M
.x86
.R_ECX
);
4191 push_long(M
.x86
.R_EDX
);
4192 push_long(M
.x86
.R_EBX
);
4194 push_long(M
.x86
.R_EBP
);
4195 push_long(M
.x86
.R_ESI
);
4196 push_long(M
.x86
.R_EDI
);
4198 u16 old_sp
= M
.x86
.R_SP
;
4200 push_word(M
.x86
.R_AX
);
4201 push_word(M
.x86
.R_CX
);
4202 push_word(M
.x86
.R_DX
);
4203 push_word(M
.x86
.R_BX
);
4205 push_word(M
.x86
.R_BP
);
4206 push_word(M
.x86
.R_SI
);
4207 push_word(M
.x86
.R_DI
);
4209 DECODE_CLEAR_SEGOVR();
4213 /****************************************************************************
4216 ****************************************************************************/
4217 static void x86emuOp_pop_all(u8
X86EMU_UNUSED(op1
))
4220 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4221 DECODE_PRINTF("POPAD\n");
4223 DECODE_PRINTF("POPA\n");
4226 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4227 M
.x86
.R_EDI
= pop_long();
4228 M
.x86
.R_ESI
= pop_long();
4229 M
.x86
.R_EBP
= pop_long();
4230 M
.x86
.R_ESP
+= 4; /* skip ESP */
4231 M
.x86
.R_EBX
= pop_long();
4232 M
.x86
.R_EDX
= pop_long();
4233 M
.x86
.R_ECX
= pop_long();
4234 M
.x86
.R_EAX
= pop_long();
4236 M
.x86
.R_DI
= pop_word();
4237 M
.x86
.R_SI
= pop_word();
4238 M
.x86
.R_BP
= pop_word();
4239 M
.x86
.R_SP
+= 2; /* skip SP */
4240 M
.x86
.R_BX
= pop_word();
4241 M
.x86
.R_DX
= pop_word();
4242 M
.x86
.R_CX
= pop_word();
4243 M
.x86
.R_AX
= pop_word();
4245 DECODE_CLEAR_SEGOVR();
4249 /*opcode 0x62 ILLEGAL OP, calls x86emuOp_illegal_op() */
4250 /*opcode 0x63 ILLEGAL OP, calls x86emuOp_illegal_op() */
4252 /****************************************************************************
4255 ****************************************************************************/
4256 static void x86emuOp_segovr_FS(u8
X86EMU_UNUSED(op1
))
4259 DECODE_PRINTF("FS:\n");
4261 M
.x86
.mode
|= SYSMODE_SEGOVR_FS
;
4263 * note the lack of DECODE_CLEAR_SEGOVR(r) since, here is one of 4
4264 * opcode subroutines we do not want to do this.
4269 /****************************************************************************
4272 ****************************************************************************/
4273 static void x86emuOp_segovr_GS(u8
X86EMU_UNUSED(op1
))
4276 DECODE_PRINTF("GS:\n");
4278 M
.x86
.mode
|= SYSMODE_SEGOVR_GS
;
4280 * note the lack of DECODE_CLEAR_SEGOVR(r) since, here is one of 4
4281 * opcode subroutines we do not want to do this.
4286 /****************************************************************************
4288 Handles opcode 0x66 - prefix for 32-bit register
4289 ****************************************************************************/
4290 static void x86emuOp_prefix_data(u8
X86EMU_UNUSED(op1
))
4293 DECODE_PRINTF("DATA:\n");
4295 M
.x86
.mode
|= SYSMODE_PREFIX_DATA
;
4296 /* note no DECODE_CLEAR_SEGOVR here. */
4300 /****************************************************************************
4302 Handles opcode 0x67 - prefix for 32-bit address
4303 ****************************************************************************/
4304 static void x86emuOp_prefix_addr(u8
X86EMU_UNUSED(op1
))
4307 DECODE_PRINTF("ADDR:\n");
4309 M
.x86
.mode
|= SYSMODE_PREFIX_ADDR
;
4310 /* note no DECODE_CLEAR_SEGOVR here. */
4314 /****************************************************************************
4317 ****************************************************************************/
4318 static void x86emuOp_push_word_IMM(u8
X86EMU_UNUSED(op1
))
4323 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4324 imm
= fetch_long_imm();
4326 imm
= fetch_word_imm();
4328 DECODE_PRINTF2("PUSH\t%x\n", imm
);
4330 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4333 push_word((u16
)imm
);
4335 DECODE_CLEAR_SEGOVR();
4339 /****************************************************************************
4342 ****************************************************************************/
4343 static void x86emuOp_imul_word_IMM(u8
X86EMU_UNUSED(op1
))
4349 DECODE_PRINTF("IMUL\t");
4350 FETCH_DECODE_MODRM(mod
, rh
, rl
);
4353 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4359 destreg
= DECODE_RM_LONG_REGISTER(rh
);
4361 srcoffset
= decode_rm00_address(rl
);
4362 srcval
= fetch_data_long(srcoffset
);
4363 imm
= fetch_long_imm();
4364 DECODE_PRINTF2(",%d\n", (s32
)imm
);
4366 imul_long_direct(&res_lo
,&res_hi
,(s32
)srcval
,(s32
)imm
);
4374 *destreg
= (u32
)res_lo
;
4381 destreg
= DECODE_RM_WORD_REGISTER(rh
);
4383 srcoffset
= decode_rm00_address(rl
);
4384 srcval
= fetch_data_word(srcoffset
);
4385 imm
= fetch_word_imm();
4386 DECODE_PRINTF2(",%d\n", (s32
)imm
);
4388 res
= (s16
)srcval
* (s16
)imm
;
4396 *destreg
= (u16
)res
;
4400 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4406 destreg
= DECODE_RM_LONG_REGISTER(rh
);
4408 srcoffset
= decode_rm01_address(rl
);
4409 srcval
= fetch_data_long(srcoffset
);
4410 imm
= fetch_long_imm();
4411 DECODE_PRINTF2(",%d\n", (s32
)imm
);
4413 imul_long_direct(&res_lo
,&res_hi
,(s32
)srcval
,(s32
)imm
);
4421 *destreg
= (u32
)res_lo
;
4428 destreg
= DECODE_RM_WORD_REGISTER(rh
);
4430 srcoffset
= decode_rm01_address(rl
);
4431 srcval
= fetch_data_word(srcoffset
);
4432 imm
= fetch_word_imm();
4433 DECODE_PRINTF2(",%d\n", (s32
)imm
);
4435 res
= (s16
)srcval
* (s16
)imm
;
4443 *destreg
= (u16
)res
;
4447 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4453 destreg
= DECODE_RM_LONG_REGISTER(rh
);
4455 srcoffset
= decode_rm10_address(rl
);
4456 srcval
= fetch_data_long(srcoffset
);
4457 imm
= fetch_long_imm();
4458 DECODE_PRINTF2(",%d\n", (s32
)imm
);
4460 imul_long_direct(&res_lo
,&res_hi
,(s32
)srcval
,(s32
)imm
);
4468 *destreg
= (u32
)res_lo
;
4475 destreg
= DECODE_RM_WORD_REGISTER(rh
);
4477 srcoffset
= decode_rm10_address(rl
);
4478 srcval
= fetch_data_word(srcoffset
);
4479 imm
= fetch_word_imm();
4480 DECODE_PRINTF2(",%d\n", (s32
)imm
);
4482 res
= (s16
)srcval
* (s16
)imm
;
4490 *destreg
= (u16
)res
;
4493 case 3: /* register to register */
4494 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4495 u32
*destreg
,*srcreg
;
4499 destreg
= DECODE_RM_LONG_REGISTER(rh
);
4501 srcreg
= DECODE_RM_LONG_REGISTER(rl
);
4502 imm
= fetch_long_imm();
4503 DECODE_PRINTF2(",%d\n", (s32
)imm
);
4505 imul_long_direct(&res_lo
,&res_hi
,(s32
)*srcreg
,(s32
)imm
);
4513 *destreg
= (u32
)res_lo
;
4515 u16
*destreg
,*srcreg
;
4519 destreg
= DECODE_RM_WORD_REGISTER(rh
);
4521 srcreg
= DECODE_RM_WORD_REGISTER(rl
);
4522 imm
= fetch_word_imm();
4523 DECODE_PRINTF2(",%d\n", (s32
)imm
);
4524 res
= (s16
)*srcreg
* (s16
)imm
;
4532 *destreg
= (u16
)res
;
4536 DECODE_CLEAR_SEGOVR();
4540 /****************************************************************************
4543 ****************************************************************************/
4544 static void x86emuOp_push_byte_IMM(u8
X86EMU_UNUSED(op1
))
4549 imm
= (s8
)fetch_byte_imm();
4550 DECODE_PRINTF2("PUSH\t%d\n", imm
);
4552 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4553 push_long((s32
)imm
);
4557 DECODE_CLEAR_SEGOVR();
4561 /****************************************************************************
4564 ****************************************************************************/
4565 static void x86emuOp_imul_byte_IMM(u8
X86EMU_UNUSED(op1
))
4572 DECODE_PRINTF("IMUL\t");
4573 FETCH_DECODE_MODRM(mod
, rh
, rl
);
4576 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4581 destreg
= DECODE_RM_LONG_REGISTER(rh
);
4583 srcoffset
= decode_rm00_address(rl
);
4584 srcval
= fetch_data_long(srcoffset
);
4585 imm
= fetch_byte_imm();
4586 DECODE_PRINTF2(",%d\n", (s32
)imm
);
4588 imul_long_direct(&res_lo
,&res_hi
,(s32
)srcval
,(s32
)imm
);
4596 *destreg
= (u32
)res_lo
;
4602 destreg
= DECODE_RM_WORD_REGISTER(rh
);
4604 srcoffset
= decode_rm00_address(rl
);
4605 srcval
= fetch_data_word(srcoffset
);
4606 imm
= fetch_byte_imm();
4607 DECODE_PRINTF2(",%d\n", (s32
)imm
);
4609 res
= (s16
)srcval
* (s16
)imm
;
4617 *destreg
= (u16
)res
;
4621 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4626 destreg
= DECODE_RM_LONG_REGISTER(rh
);
4628 srcoffset
= decode_rm01_address(rl
);
4629 srcval
= fetch_data_long(srcoffset
);
4630 imm
= fetch_byte_imm();
4631 DECODE_PRINTF2(",%d\n", (s32
)imm
);
4633 imul_long_direct(&res_lo
,&res_hi
,(s32
)srcval
,(s32
)imm
);
4641 *destreg
= (u32
)res_lo
;
4647 destreg
= DECODE_RM_WORD_REGISTER(rh
);
4649 srcoffset
= decode_rm01_address(rl
);
4650 srcval
= fetch_data_word(srcoffset
);
4651 imm
= fetch_byte_imm();
4652 DECODE_PRINTF2(",%d\n", (s32
)imm
);
4654 res
= (s16
)srcval
* (s16
)imm
;
4662 *destreg
= (u16
)res
;
4666 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4671 destreg
= DECODE_RM_LONG_REGISTER(rh
);
4673 srcoffset
= decode_rm10_address(rl
);
4674 srcval
= fetch_data_long(srcoffset
);
4675 imm
= fetch_byte_imm();
4676 DECODE_PRINTF2(",%d\n", (s32
)imm
);
4678 imul_long_direct(&res_lo
,&res_hi
,(s32
)srcval
,(s32
)imm
);
4686 *destreg
= (u32
)res_lo
;
4692 destreg
= DECODE_RM_WORD_REGISTER(rh
);
4694 srcoffset
= decode_rm10_address(rl
);
4695 srcval
= fetch_data_word(srcoffset
);
4696 imm
= fetch_byte_imm();
4697 DECODE_PRINTF2(",%d\n", (s32
)imm
);
4699 res
= (s16
)srcval
* (s16
)imm
;
4707 *destreg
= (u16
)res
;
4710 case 3: /* register to register */
4711 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4712 u32
*destreg
,*srcreg
;
4715 destreg
= DECODE_RM_LONG_REGISTER(rh
);
4717 srcreg
= DECODE_RM_LONG_REGISTER(rl
);
4718 imm
= fetch_byte_imm();
4719 DECODE_PRINTF2(",%d\n", (s32
)imm
);
4721 imul_long_direct(&res_lo
,&res_hi
,(s32
)*srcreg
,(s32
)imm
);
4729 *destreg
= (u32
)res_lo
;
4731 u16
*destreg
,*srcreg
;
4734 destreg
= DECODE_RM_WORD_REGISTER(rh
);
4736 srcreg
= DECODE_RM_WORD_REGISTER(rl
);
4737 imm
= fetch_byte_imm();
4738 DECODE_PRINTF2(",%d\n", (s32
)imm
);
4739 res
= (s16
)*srcreg
* (s16
)imm
;
4747 *destreg
= (u16
)res
;
4751 DECODE_CLEAR_SEGOVR();
4755 /****************************************************************************
4758 ****************************************************************************/
4759 static void x86emuOp_ins_byte(u8
X86EMU_UNUSED(op1
))
4762 DECODE_PRINTF("INSB\n");
4765 DECODE_CLEAR_SEGOVR();
4769 /****************************************************************************
4772 ****************************************************************************/
4773 static void x86emuOp_ins_word(u8
X86EMU_UNUSED(op1
))
4776 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4777 DECODE_PRINTF("INSD\n");
4780 DECODE_PRINTF("INSW\n");
4784 DECODE_CLEAR_SEGOVR();
4788 /****************************************************************************
4791 ****************************************************************************/
4792 static void x86emuOp_outs_byte(u8
X86EMU_UNUSED(op1
))
4795 DECODE_PRINTF("OUTSB\n");
4798 DECODE_CLEAR_SEGOVR();
4802 /****************************************************************************
4805 ****************************************************************************/
4806 static void x86emuOp_outs_word(u8
X86EMU_UNUSED(op1
))
4809 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
4810 DECODE_PRINTF("OUTSD\n");
4813 DECODE_PRINTF("OUTSW\n");
4817 DECODE_CLEAR_SEGOVR();
4821 /****************************************************************************
4824 ****************************************************************************/
4825 static void x86emuOp_jump_near_O(u8
X86EMU_UNUSED(op1
))
4830 /* jump to byte offset if overflow flag is set */
4832 DECODE_PRINTF("JO\t");
4833 offset
= (s8
)fetch_byte_imm();
4834 target
= (u16
)(M
.x86
.R_IP
+ (s16
)offset
);
4835 DECODE_PRINTF2("%x\n", target
);
4837 if (ACCESS_FLAG(F_OF
))
4838 M
.x86
.R_IP
= target
;
4839 DECODE_CLEAR_SEGOVR();
4843 /****************************************************************************
4846 ****************************************************************************/
4847 static void x86emuOp_jump_near_NO(u8
X86EMU_UNUSED(op1
))
4852 /* jump to byte offset if overflow is not set */
4854 DECODE_PRINTF("JNO\t");
4855 offset
= (s8
)fetch_byte_imm();
4856 target
= (u16
)(M
.x86
.R_IP
+ (s16
)offset
);
4857 DECODE_PRINTF2("%x\n", target
);
4859 if (!ACCESS_FLAG(F_OF
))
4860 M
.x86
.R_IP
= target
;
4861 DECODE_CLEAR_SEGOVR();
4865 /****************************************************************************
4868 ****************************************************************************/
4869 static void x86emuOp_jump_near_B(u8
X86EMU_UNUSED(op1
))
4874 /* jump to byte offset if carry flag is set. */
4876 DECODE_PRINTF("JB\t");
4877 offset
= (s8
)fetch_byte_imm();
4878 target
= (u16
)(M
.x86
.R_IP
+ (s16
)offset
);
4879 DECODE_PRINTF2("%x\n", target
);
4881 if (ACCESS_FLAG(F_CF
))
4882 M
.x86
.R_IP
= target
;
4883 DECODE_CLEAR_SEGOVR();
4887 /****************************************************************************
4890 ****************************************************************************/
4891 static void x86emuOp_jump_near_NB(u8
X86EMU_UNUSED(op1
))
4896 /* jump to byte offset if carry flag is clear. */
4898 DECODE_PRINTF("JNB\t");
4899 offset
= (s8
)fetch_byte_imm();
4900 target
= (u16
)(M
.x86
.R_IP
+ (s16
)offset
);
4901 DECODE_PRINTF2("%x\n", target
);
4903 if (!ACCESS_FLAG(F_CF
))
4904 M
.x86
.R_IP
= target
;
4905 DECODE_CLEAR_SEGOVR();
4909 /****************************************************************************
4912 ****************************************************************************/
4913 static void x86emuOp_jump_near_Z(u8
X86EMU_UNUSED(op1
))
4918 /* jump to byte offset if zero flag is set. */
4920 DECODE_PRINTF("JZ\t");
4921 offset
= (s8
)fetch_byte_imm();
4922 target
= (u16
)(M
.x86
.R_IP
+ (s16
)offset
);
4923 DECODE_PRINTF2("%x\n", target
);
4925 if (ACCESS_FLAG(F_ZF
))
4926 M
.x86
.R_IP
= target
;
4927 DECODE_CLEAR_SEGOVR();
4931 /****************************************************************************
4934 ****************************************************************************/
4935 static void x86emuOp_jump_near_NZ(u8
X86EMU_UNUSED(op1
))
4940 /* jump to byte offset if zero flag is clear. */
4942 DECODE_PRINTF("JNZ\t");
4943 offset
= (s8
)fetch_byte_imm();
4944 target
= (u16
)(M
.x86
.R_IP
+ (s16
)offset
);
4945 DECODE_PRINTF2("%x\n", target
);
4947 if (!ACCESS_FLAG(F_ZF
))
4948 M
.x86
.R_IP
= target
;
4949 DECODE_CLEAR_SEGOVR();
4953 /****************************************************************************
4956 ****************************************************************************/
4957 static void x86emuOp_jump_near_BE(u8
X86EMU_UNUSED(op1
))
4962 /* jump to byte offset if carry flag is set or if the zero
4965 DECODE_PRINTF("JBE\t");
4966 offset
= (s8
)fetch_byte_imm();
4967 target
= (u16
)(M
.x86
.R_IP
+ (s16
)offset
);
4968 DECODE_PRINTF2("%x\n", target
);
4970 if (ACCESS_FLAG(F_CF
) || ACCESS_FLAG(F_ZF
))
4971 M
.x86
.R_IP
= target
;
4972 DECODE_CLEAR_SEGOVR();
4976 /****************************************************************************
4979 ****************************************************************************/
4980 static void x86emuOp_jump_near_NBE(u8
X86EMU_UNUSED(op1
))
4985 /* jump to byte offset if carry flag is clear and if the zero
4988 DECODE_PRINTF("JNBE\t");
4989 offset
= (s8
)fetch_byte_imm();
4990 target
= (u16
)(M
.x86
.R_IP
+ (s16
)offset
);
4991 DECODE_PRINTF2("%x\n", target
);
4993 if (!(ACCESS_FLAG(F_CF
) || ACCESS_FLAG(F_ZF
)))
4994 M
.x86
.R_IP
= target
;
4995 DECODE_CLEAR_SEGOVR();
4999 /****************************************************************************
5002 ****************************************************************************/
5003 static void x86emuOp_jump_near_S(u8
X86EMU_UNUSED(op1
))
5008 /* jump to byte offset if sign flag is set */
5010 DECODE_PRINTF("JS\t");
5011 offset
= (s8
)fetch_byte_imm();
5012 target
= (u16
)(M
.x86
.R_IP
+ (s16
)offset
);
5013 DECODE_PRINTF2("%x\n", target
);
5015 if (ACCESS_FLAG(F_SF
))
5016 M
.x86
.R_IP
= target
;
5017 DECODE_CLEAR_SEGOVR();
5021 /****************************************************************************
5024 ****************************************************************************/
5025 static void x86emuOp_jump_near_NS(u8
X86EMU_UNUSED(op1
))
5030 /* jump to byte offset if sign flag is clear */
5032 DECODE_PRINTF("JNS\t");
5033 offset
= (s8
)fetch_byte_imm();
5034 target
= (u16
)(M
.x86
.R_IP
+ (s16
)offset
);
5035 DECODE_PRINTF2("%x\n", target
);
5037 if (!ACCESS_FLAG(F_SF
))
5038 M
.x86
.R_IP
= target
;
5039 DECODE_CLEAR_SEGOVR();
5043 /****************************************************************************
5046 ****************************************************************************/
5047 static void x86emuOp_jump_near_P(u8
X86EMU_UNUSED(op1
))
5052 /* jump to byte offset if parity flag is set (even parity) */
5054 DECODE_PRINTF("JP\t");
5055 offset
= (s8
)fetch_byte_imm();
5056 target
= (u16
)(M
.x86
.R_IP
+ (s16
)offset
);
5057 DECODE_PRINTF2("%x\n", target
);
5059 if (ACCESS_FLAG(F_PF
))
5060 M
.x86
.R_IP
= target
;
5061 DECODE_CLEAR_SEGOVR();
5065 /****************************************************************************
5068 ****************************************************************************/
5069 static void x86emuOp_jump_near_NP(u8
X86EMU_UNUSED(op1
))
5074 /* jump to byte offset if parity flag is clear (odd parity) */
5076 DECODE_PRINTF("JNP\t");
5077 offset
= (s8
)fetch_byte_imm();
5078 target
= (u16
)(M
.x86
.R_IP
+ (s16
)offset
);
5079 DECODE_PRINTF2("%x\n", target
);
5081 if (!ACCESS_FLAG(F_PF
))
5082 M
.x86
.R_IP
= target
;
5083 DECODE_CLEAR_SEGOVR();
5087 /****************************************************************************
5090 ****************************************************************************/
5091 static void x86emuOp_jump_near_L(u8
X86EMU_UNUSED(op1
))
5097 /* jump to byte offset if sign flag not equal to overflow flag. */
5099 DECODE_PRINTF("JL\t");
5100 offset
= (s8
)fetch_byte_imm();
5101 target
= (u16
)(M
.x86
.R_IP
+ (s16
)offset
);
5102 DECODE_PRINTF2("%x\n", target
);
5104 sf
= ACCESS_FLAG(F_SF
) != 0;
5105 of
= ACCESS_FLAG(F_OF
) != 0;
5107 M
.x86
.R_IP
= target
;
5108 DECODE_CLEAR_SEGOVR();
5112 /****************************************************************************
5115 ****************************************************************************/
5116 static void x86emuOp_jump_near_NL(u8
X86EMU_UNUSED(op1
))
5122 /* jump to byte offset if sign flag not equal to overflow flag. */
5124 DECODE_PRINTF("JNL\t");
5125 offset
= (s8
)fetch_byte_imm();
5126 target
= (u16
)(M
.x86
.R_IP
+ (s16
)offset
);
5127 DECODE_PRINTF2("%x\n", target
);
5129 sf
= ACCESS_FLAG(F_SF
) != 0;
5130 of
= ACCESS_FLAG(F_OF
) != 0;
5131 /* note: inverse of above, but using == instead of xor. */
5133 M
.x86
.R_IP
= target
;
5134 DECODE_CLEAR_SEGOVR();
5138 /****************************************************************************
5141 ****************************************************************************/
5142 static void x86emuOp_jump_near_LE(u8
X86EMU_UNUSED(op1
))
5148 /* jump to byte offset if sign flag not equal to overflow flag
5149 or the zero flag is set */
5151 DECODE_PRINTF("JLE\t");
5152 offset
= (s8
)fetch_byte_imm();
5153 target
= (u16
)(M
.x86
.R_IP
+ (s16
)offset
);
5154 DECODE_PRINTF2("%x\n", target
);
5156 sf
= ACCESS_FLAG(F_SF
) != 0;
5157 of
= ACCESS_FLAG(F_OF
) != 0;
5158 if ((sf
^ of
) || ACCESS_FLAG(F_ZF
))
5159 M
.x86
.R_IP
= target
;
5160 DECODE_CLEAR_SEGOVR();
5164 /****************************************************************************
5167 ****************************************************************************/
5168 static void x86emuOp_jump_near_NLE(u8
X86EMU_UNUSED(op1
))
5174 /* jump to byte offset if sign flag equal to overflow flag.
5175 and the zero flag is clear */
5177 DECODE_PRINTF("JNLE\t");
5178 offset
= (s8
)fetch_byte_imm();
5179 target
= (u16
)(M
.x86
.R_IP
+ (s16
)offset
);
5180 DECODE_PRINTF2("%x\n", target
);
5182 sf
= ACCESS_FLAG(F_SF
) != 0;
5183 of
= ACCESS_FLAG(F_OF
) != 0;
5184 if ((sf
== of
) && !ACCESS_FLAG(F_ZF
))
5185 M
.x86
.R_IP
= target
;
5186 DECODE_CLEAR_SEGOVR();
5190 static u8 (*opc80_byte_operation
[])(u8 d
, u8 s
) =
5202 /****************************************************************************
5205 ****************************************************************************/
5206 static void x86emuOp_opc80_byte_RM_IMM(u8
X86EMU_UNUSED(op1
))
5215 * Weirdo special case instruction format. Part of the opcode
5216 * held below in "RH". Doubly nested case would result, except
5217 * that the decoded instruction
5220 FETCH_DECODE_MODRM(mod
, rh
, rl
);
5222 if (DEBUG_DECODE()) {
5223 /* XXX DECODE_PRINTF may be changed to something more
5224 general, so that it is important to leave the strings
5225 in the same format, even though the result is that the
5226 above test is done twice. */
5230 DECODE_PRINTF("ADD\t");
5233 DECODE_PRINTF("OR\t");
5236 DECODE_PRINTF("ADC\t");
5239 DECODE_PRINTF("SBB\t");
5242 DECODE_PRINTF("AND\t");
5245 DECODE_PRINTF("SUB\t");
5248 DECODE_PRINTF("XOR\t");
5251 DECODE_PRINTF("CMP\t");
5256 /* know operation, decode the mod byte to find the addressing
5260 DECODE_PRINTF("BYTE PTR ");
5261 destoffset
= decode_rm00_address(rl
);
5263 destval
= fetch_data_byte(destoffset
);
5264 imm
= fetch_byte_imm();
5265 DECODE_PRINTF2("%x\n", imm
);
5267 destval
= (*opc80_byte_operation
[rh
]) (destval
, imm
);
5269 store_data_byte(destoffset
, destval
);
5272 DECODE_PRINTF("BYTE PTR ");
5273 destoffset
= decode_rm01_address(rl
);
5275 destval
= fetch_data_byte(destoffset
);
5276 imm
= fetch_byte_imm();
5277 DECODE_PRINTF2("%x\n", imm
);
5279 destval
= (*opc80_byte_operation
[rh
]) (destval
, imm
);
5281 store_data_byte(destoffset
, destval
);
5284 DECODE_PRINTF("BYTE PTR ");
5285 destoffset
= decode_rm10_address(rl
);
5287 destval
= fetch_data_byte(destoffset
);
5288 imm
= fetch_byte_imm();
5289 DECODE_PRINTF2("%x\n", imm
);
5291 destval
= (*opc80_byte_operation
[rh
]) (destval
, imm
);
5293 store_data_byte(destoffset
, destval
);
5295 case 3: /* register to register */
5296 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
5298 imm
= fetch_byte_imm();
5299 DECODE_PRINTF2("%x\n", imm
);
5301 destval
= (*opc80_byte_operation
[rh
]) (*destreg
, imm
);
5306 DECODE_CLEAR_SEGOVR();
5310 static u16 (*opc81_word_operation
[])(u16 d
, u16 s
) =
5322 static u32 (*opc81_long_operation
[])(u32 d
, u32 s
) =
5334 /****************************************************************************
5337 ****************************************************************************/
5338 static void x86emuOp_opc81_word_RM_IMM(u8
X86EMU_UNUSED(op1
))
5344 * Weirdo special case instruction format. Part of the opcode
5345 * held below in "RH". Doubly nested case would result, except
5346 * that the decoded instruction
5349 FETCH_DECODE_MODRM(mod
, rh
, rl
);
5351 if (DEBUG_DECODE()) {
5352 /* XXX DECODE_PRINTF may be changed to something more
5353 general, so that it is important to leave the strings
5354 in the same format, even though the result is that the
5355 above test is done twice. */
5359 DECODE_PRINTF("ADD\t");
5362 DECODE_PRINTF("OR\t");
5365 DECODE_PRINTF("ADC\t");
5368 DECODE_PRINTF("SBB\t");
5371 DECODE_PRINTF("AND\t");
5374 DECODE_PRINTF("SUB\t");
5377 DECODE_PRINTF("XOR\t");
5380 DECODE_PRINTF("CMP\t");
5386 * Know operation, decode the mod byte to find the addressing
5391 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
5394 DECODE_PRINTF("DWORD PTR ");
5395 destoffset
= decode_rm00_address(rl
);
5397 destval
= fetch_data_long(destoffset
);
5398 imm
= fetch_long_imm();
5399 DECODE_PRINTF2("%x\n", imm
);
5401 destval
= (*opc81_long_operation
[rh
]) (destval
, imm
);
5403 store_data_long(destoffset
, destval
);
5407 DECODE_PRINTF("WORD PTR ");
5408 destoffset
= decode_rm00_address(rl
);
5410 destval
= fetch_data_word(destoffset
);
5411 imm
= fetch_word_imm();
5412 DECODE_PRINTF2("%x\n", imm
);
5414 destval
= (*opc81_word_operation
[rh
]) (destval
, imm
);
5416 store_data_word(destoffset
, destval
);
5420 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
5423 DECODE_PRINTF("DWORD PTR ");
5424 destoffset
= decode_rm01_address(rl
);
5426 destval
= fetch_data_long(destoffset
);
5427 imm
= fetch_long_imm();
5428 DECODE_PRINTF2("%x\n", imm
);
5430 destval
= (*opc81_long_operation
[rh
]) (destval
, imm
);
5432 store_data_long(destoffset
, destval
);
5436 DECODE_PRINTF("WORD PTR ");
5437 destoffset
= decode_rm01_address(rl
);
5439 destval
= fetch_data_word(destoffset
);
5440 imm
= fetch_word_imm();
5441 DECODE_PRINTF2("%x\n", imm
);
5443 destval
= (*opc81_word_operation
[rh
]) (destval
, imm
);
5445 store_data_word(destoffset
, destval
);
5449 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
5452 DECODE_PRINTF("DWORD PTR ");
5453 destoffset
= decode_rm10_address(rl
);
5455 destval
= fetch_data_long(destoffset
);
5456 imm
= fetch_long_imm();
5457 DECODE_PRINTF2("%x\n", imm
);
5459 destval
= (*opc81_long_operation
[rh
]) (destval
, imm
);
5461 store_data_long(destoffset
, destval
);
5465 DECODE_PRINTF("WORD PTR ");
5466 destoffset
= decode_rm10_address(rl
);
5468 destval
= fetch_data_word(destoffset
);
5469 imm
= fetch_word_imm();
5470 DECODE_PRINTF2("%x\n", imm
);
5472 destval
= (*opc81_word_operation
[rh
]) (destval
, imm
);
5474 store_data_word(destoffset
, destval
);
5477 case 3: /* register to register */
5478 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
5482 destreg
= DECODE_RM_LONG_REGISTER(rl
);
5484 imm
= fetch_long_imm();
5485 DECODE_PRINTF2("%x\n", imm
);
5487 destval
= (*opc81_long_operation
[rh
]) (*destreg
, imm
);
5494 destreg
= DECODE_RM_WORD_REGISTER(rl
);
5496 imm
= fetch_word_imm();
5497 DECODE_PRINTF2("%x\n", imm
);
5499 destval
= (*opc81_word_operation
[rh
]) (*destreg
, imm
);
5505 DECODE_CLEAR_SEGOVR();
5509 static u8 (*opc82_byte_operation
[])(u8 s
, u8 d
) =
5512 or_byte
, /*01 *//*YYY UNUSED ???? */
5515 and_byte
, /*04 *//*YYY UNUSED ???? */
5517 xor_byte
, /*06 *//*YYY UNUSED ???? */
5521 /****************************************************************************
5524 ****************************************************************************/
5525 static void x86emuOp_opc82_byte_RM_IMM(u8
X86EMU_UNUSED(op1
))
5534 * Weirdo special case instruction format. Part of the opcode
5535 * held below in "RH". Doubly nested case would result, except
5536 * that the decoded instruction Similar to opcode 81, except that
5537 * the immediate byte is sign extended to a word length.
5540 FETCH_DECODE_MODRM(mod
, rh
, rl
);
5542 if (DEBUG_DECODE()) {
5543 /* XXX DECODE_PRINTF may be changed to something more
5544 general, so that it is important to leave the strings
5545 in the same format, even though the result is that the
5546 above test is done twice. */
5549 DECODE_PRINTF("ADD\t");
5552 DECODE_PRINTF("OR\t");
5555 DECODE_PRINTF("ADC\t");
5558 DECODE_PRINTF("SBB\t");
5561 DECODE_PRINTF("AND\t");
5564 DECODE_PRINTF("SUB\t");
5567 DECODE_PRINTF("XOR\t");
5570 DECODE_PRINTF("CMP\t");
5575 /* know operation, decode the mod byte to find the addressing
5579 DECODE_PRINTF("BYTE PTR ");
5580 destoffset
= decode_rm00_address(rl
);
5581 destval
= fetch_data_byte(destoffset
);
5582 imm
= fetch_byte_imm();
5583 DECODE_PRINTF2(",%x\n", imm
);
5585 destval
= (*opc82_byte_operation
[rh
]) (destval
, imm
);
5587 store_data_byte(destoffset
, destval
);
5590 DECODE_PRINTF("BYTE PTR ");
5591 destoffset
= decode_rm01_address(rl
);
5592 destval
= fetch_data_byte(destoffset
);
5593 imm
= fetch_byte_imm();
5594 DECODE_PRINTF2(",%x\n", imm
);
5596 destval
= (*opc82_byte_operation
[rh
]) (destval
, imm
);
5598 store_data_byte(destoffset
, destval
);
5601 DECODE_PRINTF("BYTE PTR ");
5602 destoffset
= decode_rm10_address(rl
);
5603 destval
= fetch_data_byte(destoffset
);
5604 imm
= fetch_byte_imm();
5605 DECODE_PRINTF2(",%x\n", imm
);
5607 destval
= (*opc82_byte_operation
[rh
]) (destval
, imm
);
5609 store_data_byte(destoffset
, destval
);
5611 case 3: /* register to register */
5612 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
5613 imm
= fetch_byte_imm();
5614 DECODE_PRINTF2(",%x\n", imm
);
5616 destval
= (*opc82_byte_operation
[rh
]) (*destreg
, imm
);
5621 DECODE_CLEAR_SEGOVR();
5625 static u16 (*opc83_word_operation
[])(u16 s
, u16 d
) =
5628 or_word
, /*01 *//*YYY UNUSED ???? */
5631 and_word
, /*04 *//*YYY UNUSED ???? */
5633 xor_word
, /*06 *//*YYY UNUSED ???? */
5637 static u32 (*opc83_long_operation
[])(u32 s
, u32 d
) =
5640 or_long
, /*01 *//*YYY UNUSED ???? */
5643 and_long
, /*04 *//*YYY UNUSED ???? */
5645 xor_long
, /*06 *//*YYY UNUSED ???? */
5649 /****************************************************************************
5652 ****************************************************************************/
5653 static void x86emuOp_opc83_word_RM_IMM(u8
X86EMU_UNUSED(op1
))
5659 * Weirdo special case instruction format. Part of the opcode
5660 * held below in "RH". Doubly nested case would result, except
5661 * that the decoded instruction Similar to opcode 81, except that
5662 * the immediate byte is sign extended to a word length.
5665 FETCH_DECODE_MODRM(mod
, rh
, rl
);
5667 if (DEBUG_DECODE()) {
5668 /* XXX DECODE_PRINTF may be changed to something more
5669 general, so that it is important to leave the strings
5670 in the same format, even though the result is that the
5671 above test is done twice. */
5674 DECODE_PRINTF("ADD\t");
5677 DECODE_PRINTF("OR\t");
5680 DECODE_PRINTF("ADC\t");
5683 DECODE_PRINTF("SBB\t");
5686 DECODE_PRINTF("AND\t");
5689 DECODE_PRINTF("SUB\t");
5692 DECODE_PRINTF("XOR\t");
5695 DECODE_PRINTF("CMP\t");
5700 /* know operation, decode the mod byte to find the addressing
5704 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
5707 DECODE_PRINTF("DWORD PTR ");
5708 destoffset
= decode_rm00_address(rl
);
5709 destval
= fetch_data_long(destoffset
);
5710 imm
= (s8
) fetch_byte_imm();
5711 DECODE_PRINTF2(",%x\n", imm
);
5713 destval
= (*opc83_long_operation
[rh
]) (destval
, imm
);
5715 store_data_long(destoffset
, destval
);
5719 DECODE_PRINTF("WORD PTR ");
5720 destoffset
= decode_rm00_address(rl
);
5721 destval
= fetch_data_word(destoffset
);
5722 imm
= (s8
) fetch_byte_imm();
5723 DECODE_PRINTF2(",%x\n", imm
);
5725 destval
= (*opc83_word_operation
[rh
]) (destval
, imm
);
5727 store_data_word(destoffset
, destval
);
5731 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
5734 DECODE_PRINTF("DWORD PTR ");
5735 destoffset
= decode_rm01_address(rl
);
5736 destval
= fetch_data_long(destoffset
);
5737 imm
= (s8
) fetch_byte_imm();
5738 DECODE_PRINTF2(",%x\n", imm
);
5740 destval
= (*opc83_long_operation
[rh
]) (destval
, imm
);
5742 store_data_long(destoffset
, destval
);
5746 DECODE_PRINTF("WORD PTR ");
5747 destoffset
= decode_rm01_address(rl
);
5748 destval
= fetch_data_word(destoffset
);
5749 imm
= (s8
) fetch_byte_imm();
5750 DECODE_PRINTF2(",%x\n", imm
);
5752 destval
= (*opc83_word_operation
[rh
]) (destval
, imm
);
5754 store_data_word(destoffset
, destval
);
5758 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
5761 DECODE_PRINTF("DWORD PTR ");
5762 destoffset
= decode_rm10_address(rl
);
5763 destval
= fetch_data_long(destoffset
);
5764 imm
= (s8
) fetch_byte_imm();
5765 DECODE_PRINTF2(",%x\n", imm
);
5767 destval
= (*opc83_long_operation
[rh
]) (destval
, imm
);
5769 store_data_long(destoffset
, destval
);
5773 DECODE_PRINTF("WORD PTR ");
5774 destoffset
= decode_rm10_address(rl
);
5775 destval
= fetch_data_word(destoffset
);
5776 imm
= (s8
) fetch_byte_imm();
5777 DECODE_PRINTF2(",%x\n", imm
);
5779 destval
= (*opc83_word_operation
[rh
]) (destval
, imm
);
5781 store_data_word(destoffset
, destval
);
5784 case 3: /* register to register */
5785 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
5789 destreg
= DECODE_RM_LONG_REGISTER(rl
);
5790 imm
= (s8
) fetch_byte_imm();
5791 DECODE_PRINTF2(",%x\n", imm
);
5793 destval
= (*opc83_long_operation
[rh
]) (*destreg
, imm
);
5800 destreg
= DECODE_RM_WORD_REGISTER(rl
);
5801 imm
= (s8
) fetch_byte_imm();
5802 DECODE_PRINTF2(",%x\n", imm
);
5804 destval
= (*opc83_word_operation
[rh
]) (*destreg
, imm
);
5810 DECODE_CLEAR_SEGOVR();
5814 /****************************************************************************
5817 ****************************************************************************/
5818 static void x86emuOp_test_byte_RM_R(u8
X86EMU_UNUSED(op1
))
5821 u8
*destreg
, *srcreg
;
5826 DECODE_PRINTF("TEST\t");
5827 FETCH_DECODE_MODRM(mod
, rh
, rl
);
5830 destoffset
= decode_rm00_address(rl
);
5832 destval
= fetch_data_byte(destoffset
);
5833 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
5834 DECODE_PRINTF("\n");
5836 test_byte(destval
, *srcreg
);
5839 destoffset
= decode_rm01_address(rl
);
5841 destval
= fetch_data_byte(destoffset
);
5842 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
5843 DECODE_PRINTF("\n");
5845 test_byte(destval
, *srcreg
);
5848 destoffset
= decode_rm10_address(rl
);
5850 destval
= fetch_data_byte(destoffset
);
5851 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
5852 DECODE_PRINTF("\n");
5854 test_byte(destval
, *srcreg
);
5856 case 3: /* register to register */
5857 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
5859 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
5860 DECODE_PRINTF("\n");
5862 test_byte(*destreg
, *srcreg
);
5865 DECODE_CLEAR_SEGOVR();
5869 /****************************************************************************
5872 ****************************************************************************/
5873 static void x86emuOp_test_word_RM_R(u8
X86EMU_UNUSED(op1
))
5879 DECODE_PRINTF("TEST\t");
5880 FETCH_DECODE_MODRM(mod
, rh
, rl
);
5883 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
5887 destoffset
= decode_rm00_address(rl
);
5889 destval
= fetch_data_long(destoffset
);
5890 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
5891 DECODE_PRINTF("\n");
5893 test_long(destval
, *srcreg
);
5898 destoffset
= decode_rm00_address(rl
);
5900 destval
= fetch_data_word(destoffset
);
5901 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
5902 DECODE_PRINTF("\n");
5904 test_word(destval
, *srcreg
);
5908 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
5912 destoffset
= decode_rm01_address(rl
);
5914 destval
= fetch_data_long(destoffset
);
5915 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
5916 DECODE_PRINTF("\n");
5918 test_long(destval
, *srcreg
);
5923 destoffset
= decode_rm01_address(rl
);
5925 destval
= fetch_data_word(destoffset
);
5926 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
5927 DECODE_PRINTF("\n");
5929 test_word(destval
, *srcreg
);
5933 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
5937 destoffset
= decode_rm10_address(rl
);
5939 destval
= fetch_data_long(destoffset
);
5940 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
5941 DECODE_PRINTF("\n");
5943 test_long(destval
, *srcreg
);
5948 destoffset
= decode_rm10_address(rl
);
5950 destval
= fetch_data_word(destoffset
);
5951 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
5952 DECODE_PRINTF("\n");
5954 test_word(destval
, *srcreg
);
5957 case 3: /* register to register */
5958 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
5959 u32
*destreg
,*srcreg
;
5961 destreg
= DECODE_RM_LONG_REGISTER(rl
);
5963 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
5964 DECODE_PRINTF("\n");
5966 test_long(*destreg
, *srcreg
);
5968 u16
*destreg
,*srcreg
;
5970 destreg
= DECODE_RM_WORD_REGISTER(rl
);
5972 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
5973 DECODE_PRINTF("\n");
5975 test_word(*destreg
, *srcreg
);
5979 DECODE_CLEAR_SEGOVR();
5983 /****************************************************************************
5986 ****************************************************************************/
5987 static void x86emuOp_xchg_byte_RM_R(u8
X86EMU_UNUSED(op1
))
5990 u8
*destreg
, *srcreg
;
5996 DECODE_PRINTF("XCHG\t");
5997 FETCH_DECODE_MODRM(mod
, rh
, rl
);
6000 destoffset
= decode_rm00_address(rl
);
6002 destval
= fetch_data_byte(destoffset
);
6003 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
6004 DECODE_PRINTF("\n");
6009 store_data_byte(destoffset
, destval
);
6012 destoffset
= decode_rm01_address(rl
);
6014 destval
= fetch_data_byte(destoffset
);
6015 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
6016 DECODE_PRINTF("\n");
6021 store_data_byte(destoffset
, destval
);
6024 destoffset
= decode_rm10_address(rl
);
6026 destval
= fetch_data_byte(destoffset
);
6027 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
6028 DECODE_PRINTF("\n");
6033 store_data_byte(destoffset
, destval
);
6035 case 3: /* register to register */
6036 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
6038 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
6039 DECODE_PRINTF("\n");
6046 DECODE_CLEAR_SEGOVR();
6050 /****************************************************************************
6053 ****************************************************************************/
6054 static void x86emuOp_xchg_word_RM_R(u8
X86EMU_UNUSED(op1
))
6060 DECODE_PRINTF("XCHG\t");
6061 FETCH_DECODE_MODRM(mod
, rh
, rl
);
6064 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6068 destoffset
= decode_rm00_address(rl
);
6070 destval
= fetch_data_long(destoffset
);
6071 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
6072 DECODE_PRINTF("\n");
6077 store_data_long(destoffset
, destval
);
6082 destoffset
= decode_rm00_address(rl
);
6084 destval
= fetch_data_word(destoffset
);
6085 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
6086 DECODE_PRINTF("\n");
6091 store_data_word(destoffset
, destval
);
6095 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6099 destoffset
= decode_rm01_address(rl
);
6101 destval
= fetch_data_long(destoffset
);
6102 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
6103 DECODE_PRINTF("\n");
6108 store_data_long(destoffset
, destval
);
6113 destoffset
= decode_rm01_address(rl
);
6115 destval
= fetch_data_word(destoffset
);
6116 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
6117 DECODE_PRINTF("\n");
6122 store_data_word(destoffset
, destval
);
6126 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6130 destoffset
= decode_rm10_address(rl
);
6132 destval
= fetch_data_long(destoffset
);
6133 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
6134 DECODE_PRINTF("\n");
6139 store_data_long(destoffset
, destval
);
6144 destoffset
= decode_rm10_address(rl
);
6146 destval
= fetch_data_word(destoffset
);
6147 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
6148 DECODE_PRINTF("\n");
6153 store_data_word(destoffset
, destval
);
6156 case 3: /* register to register */
6157 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6158 u32
*destreg
,*srcreg
;
6161 destreg
= DECODE_RM_LONG_REGISTER(rl
);
6163 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
6164 DECODE_PRINTF("\n");
6170 u16
*destreg
,*srcreg
;
6173 destreg
= DECODE_RM_WORD_REGISTER(rl
);
6175 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
6176 DECODE_PRINTF("\n");
6184 DECODE_CLEAR_SEGOVR();
6188 /****************************************************************************
6191 ****************************************************************************/
6192 static void x86emuOp_mov_byte_RM_R(u8
X86EMU_UNUSED(op1
))
6195 u8
*destreg
, *srcreg
;
6199 DECODE_PRINTF("MOV\t");
6200 FETCH_DECODE_MODRM(mod
, rh
, rl
);
6203 destoffset
= decode_rm00_address(rl
);
6205 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
6206 DECODE_PRINTF("\n");
6208 store_data_byte(destoffset
, *srcreg
);
6211 destoffset
= decode_rm01_address(rl
);
6213 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
6214 DECODE_PRINTF("\n");
6216 store_data_byte(destoffset
, *srcreg
);
6219 destoffset
= decode_rm10_address(rl
);
6221 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
6222 DECODE_PRINTF("\n");
6224 store_data_byte(destoffset
, *srcreg
);
6226 case 3: /* register to register */
6227 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
6229 srcreg
= DECODE_RM_BYTE_REGISTER(rh
);
6230 DECODE_PRINTF("\n");
6235 DECODE_CLEAR_SEGOVR();
6239 /****************************************************************************
6242 ****************************************************************************/
6243 static void x86emuOp_mov_word_RM_R(u8
X86EMU_UNUSED(op1
))
6249 DECODE_PRINTF("MOV\t");
6250 FETCH_DECODE_MODRM(mod
, rh
, rl
);
6253 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6256 destoffset
= decode_rm00_address(rl
);
6258 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
6259 DECODE_PRINTF("\n");
6261 store_data_long(destoffset
, *srcreg
);
6265 destoffset
= decode_rm00_address(rl
);
6267 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
6268 DECODE_PRINTF("\n");
6270 store_data_word(destoffset
, *srcreg
);
6274 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6277 destoffset
= decode_rm01_address(rl
);
6279 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
6280 DECODE_PRINTF("\n");
6282 store_data_long(destoffset
, *srcreg
);
6286 destoffset
= decode_rm01_address(rl
);
6288 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
6289 DECODE_PRINTF("\n");
6291 store_data_word(destoffset
, *srcreg
);
6295 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6298 destoffset
= decode_rm10_address(rl
);
6300 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
6301 DECODE_PRINTF("\n");
6303 store_data_long(destoffset
, *srcreg
);
6307 destoffset
= decode_rm10_address(rl
);
6309 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
6310 DECODE_PRINTF("\n");
6312 store_data_word(destoffset
, *srcreg
);
6315 case 3: /* register to register */
6316 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6317 u32
*destreg
,*srcreg
;
6319 destreg
= DECODE_RM_LONG_REGISTER(rl
);
6321 srcreg
= DECODE_RM_LONG_REGISTER(rh
);
6322 DECODE_PRINTF("\n");
6326 u16
*destreg
,*srcreg
;
6328 destreg
= DECODE_RM_WORD_REGISTER(rl
);
6330 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
6331 DECODE_PRINTF("\n");
6337 DECODE_CLEAR_SEGOVR();
6341 /****************************************************************************
6344 ****************************************************************************/
6345 static void x86emuOp_mov_byte_R_RM(u8
X86EMU_UNUSED(op1
))
6348 u8
*destreg
, *srcreg
;
6353 DECODE_PRINTF("MOV\t");
6354 FETCH_DECODE_MODRM(mod
, rh
, rl
);
6357 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
6359 srcoffset
= decode_rm00_address(rl
);
6360 srcval
= fetch_data_byte(srcoffset
);
6361 DECODE_PRINTF("\n");
6366 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
6368 srcoffset
= decode_rm01_address(rl
);
6369 srcval
= fetch_data_byte(srcoffset
);
6370 DECODE_PRINTF("\n");
6375 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
6377 srcoffset
= decode_rm10_address(rl
);
6378 srcval
= fetch_data_byte(srcoffset
);
6379 DECODE_PRINTF("\n");
6383 case 3: /* register to register */
6384 destreg
= DECODE_RM_BYTE_REGISTER(rh
);
6386 srcreg
= DECODE_RM_BYTE_REGISTER(rl
);
6387 DECODE_PRINTF("\n");
6392 DECODE_CLEAR_SEGOVR();
6396 /****************************************************************************
6399 ****************************************************************************/
6400 static void x86emuOp_mov_word_R_RM(u8
X86EMU_UNUSED(op1
))
6406 DECODE_PRINTF("MOV\t");
6407 FETCH_DECODE_MODRM(mod
, rh
, rl
);
6410 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6414 destreg
= DECODE_RM_LONG_REGISTER(rh
);
6416 srcoffset
= decode_rm00_address(rl
);
6417 srcval
= fetch_data_long(srcoffset
);
6418 DECODE_PRINTF("\n");
6425 destreg
= DECODE_RM_WORD_REGISTER(rh
);
6427 srcoffset
= decode_rm00_address(rl
);
6428 srcval
= fetch_data_word(srcoffset
);
6429 DECODE_PRINTF("\n");
6435 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6439 destreg
= DECODE_RM_LONG_REGISTER(rh
);
6441 srcoffset
= decode_rm01_address(rl
);
6442 srcval
= fetch_data_long(srcoffset
);
6443 DECODE_PRINTF("\n");
6450 destreg
= DECODE_RM_WORD_REGISTER(rh
);
6452 srcoffset
= decode_rm01_address(rl
);
6453 srcval
= fetch_data_word(srcoffset
);
6454 DECODE_PRINTF("\n");
6460 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6464 destreg
= DECODE_RM_LONG_REGISTER(rh
);
6466 srcoffset
= decode_rm10_address(rl
);
6467 srcval
= fetch_data_long(srcoffset
);
6468 DECODE_PRINTF("\n");
6475 destreg
= DECODE_RM_WORD_REGISTER(rh
);
6477 srcoffset
= decode_rm10_address(rl
);
6478 srcval
= fetch_data_word(srcoffset
);
6479 DECODE_PRINTF("\n");
6484 case 3: /* register to register */
6485 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6486 u32
*destreg
, *srcreg
;
6488 destreg
= DECODE_RM_LONG_REGISTER(rh
);
6490 srcreg
= DECODE_RM_LONG_REGISTER(rl
);
6491 DECODE_PRINTF("\n");
6495 u16
*destreg
, *srcreg
;
6497 destreg
= DECODE_RM_WORD_REGISTER(rh
);
6499 srcreg
= DECODE_RM_WORD_REGISTER(rl
);
6500 DECODE_PRINTF("\n");
6506 DECODE_CLEAR_SEGOVR();
6510 /****************************************************************************
6513 ****************************************************************************/
6514 static void x86emuOp_mov_word_RM_SR(u8
X86EMU_UNUSED(op1
))
6517 u16
*destreg
, *srcreg
;
6522 DECODE_PRINTF("MOV\t");
6523 FETCH_DECODE_MODRM(mod
, rh
, rl
);
6526 destoffset
= decode_rm00_address(rl
);
6528 srcreg
= decode_rm_seg_register(rh
);
6529 DECODE_PRINTF("\n");
6532 store_data_word(destoffset
, destval
);
6535 destoffset
= decode_rm01_address(rl
);
6537 srcreg
= decode_rm_seg_register(rh
);
6538 DECODE_PRINTF("\n");
6541 store_data_word(destoffset
, destval
);
6544 destoffset
= decode_rm10_address(rl
);
6546 srcreg
= decode_rm_seg_register(rh
);
6547 DECODE_PRINTF("\n");
6550 store_data_word(destoffset
, destval
);
6552 case 3: /* register to register */
6553 destreg
= DECODE_RM_WORD_REGISTER(rl
);
6555 srcreg
= decode_rm_seg_register(rh
);
6556 DECODE_PRINTF("\n");
6561 DECODE_CLEAR_SEGOVR();
6565 /****************************************************************************
6568 ****************************************************************************/
6569 static void x86emuOp_lea_word_R_M(u8
X86EMU_UNUSED(op1
))
6576 * TODO: Need to handle address size prefix!
6578 * lea eax,[eax+ebx*2] ??
6582 DECODE_PRINTF("LEA\t");
6583 FETCH_DECODE_MODRM(mod
, rh
, rl
);
6586 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
6588 destoffset
= decode_rm00_address(rl
);
6589 DECODE_PRINTF("\n");
6591 *srcreg
= (u16
)destoffset
;
6594 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
6596 destoffset
= decode_rm01_address(rl
);
6597 DECODE_PRINTF("\n");
6599 *srcreg
= (u16
)destoffset
;
6602 srcreg
= DECODE_RM_WORD_REGISTER(rh
);
6604 destoffset
= decode_rm10_address(rl
);
6605 DECODE_PRINTF("\n");
6607 *srcreg
= (u16
)destoffset
;
6609 case 3: /* register to register */
6610 /* undefined. Do nothing. */
6613 DECODE_CLEAR_SEGOVR();
6617 /****************************************************************************
6620 ****************************************************************************/
6621 static void x86emuOp_mov_word_SR_RM(u8
X86EMU_UNUSED(op1
))
6624 u16
*destreg
, *srcreg
;
6629 DECODE_PRINTF("MOV\t");
6630 FETCH_DECODE_MODRM(mod
, rh
, rl
);
6633 destreg
= decode_rm_seg_register(rh
);
6635 srcoffset
= decode_rm00_address(rl
);
6636 srcval
= fetch_data_word(srcoffset
);
6637 DECODE_PRINTF("\n");
6642 destreg
= decode_rm_seg_register(rh
);
6644 srcoffset
= decode_rm01_address(rl
);
6645 srcval
= fetch_data_word(srcoffset
);
6646 DECODE_PRINTF("\n");
6651 destreg
= decode_rm_seg_register(rh
);
6653 srcoffset
= decode_rm10_address(rl
);
6654 srcval
= fetch_data_word(srcoffset
);
6655 DECODE_PRINTF("\n");
6659 case 3: /* register to register */
6660 destreg
= decode_rm_seg_register(rh
);
6662 srcreg
= DECODE_RM_WORD_REGISTER(rl
);
6663 DECODE_PRINTF("\n");
6669 * Clean up, and reset all the R_xSP pointers to the correct
6670 * locations. This is about 3x too much overhead (doing all the
6671 * segreg ptrs when only one is needed, but this instruction
6672 * *cannot* be that common, and this isn't too much work anyway.
6674 DECODE_CLEAR_SEGOVR();
6678 /****************************************************************************
6681 ****************************************************************************/
6682 static void x86emuOp_pop_RM(u8
X86EMU_UNUSED(op1
))
6688 DECODE_PRINTF("POP\t");
6689 FETCH_DECODE_MODRM(mod
, rh
, rl
);
6691 DECODE_PRINTF("ILLEGAL DECODE OF OPCODE 8F\n");
6696 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6699 destoffset
= decode_rm00_address(rl
);
6700 DECODE_PRINTF("\n");
6702 destval
= pop_long();
6703 store_data_long(destoffset
, destval
);
6707 destoffset
= decode_rm00_address(rl
);
6708 DECODE_PRINTF("\n");
6710 destval
= pop_word();
6711 store_data_word(destoffset
, destval
);
6715 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6718 destoffset
= decode_rm01_address(rl
);
6719 DECODE_PRINTF("\n");
6721 destval
= pop_long();
6722 store_data_long(destoffset
, destval
);
6726 destoffset
= decode_rm01_address(rl
);
6727 DECODE_PRINTF("\n");
6729 destval
= pop_word();
6730 store_data_word(destoffset
, destval
);
6734 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6737 destoffset
= decode_rm10_address(rl
);
6738 DECODE_PRINTF("\n");
6740 destval
= pop_long();
6741 store_data_long(destoffset
, destval
);
6745 destoffset
= decode_rm10_address(rl
);
6746 DECODE_PRINTF("\n");
6748 destval
= pop_word();
6749 store_data_word(destoffset
, destval
);
6752 case 3: /* register to register */
6753 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6756 destreg
= DECODE_RM_LONG_REGISTER(rl
);
6757 DECODE_PRINTF("\n");
6759 *destreg
= pop_long();
6763 destreg
= DECODE_RM_WORD_REGISTER(rl
);
6764 DECODE_PRINTF("\n");
6766 *destreg
= pop_word();
6770 DECODE_CLEAR_SEGOVR();
6774 /****************************************************************************
6777 ****************************************************************************/
6778 static void x86emuOp_nop(u8
X86EMU_UNUSED(op1
))
6781 DECODE_PRINTF("NOP\n");
6783 DECODE_CLEAR_SEGOVR();
6787 /****************************************************************************
6790 ****************************************************************************/
6791 static void x86emuOp_xchg_word_AX_CX(u8
X86EMU_UNUSED(op1
))
6796 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6797 DECODE_PRINTF("XCHG\tEAX,ECX\n");
6799 DECODE_PRINTF("XCHG\tAX,CX\n");
6802 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6804 M
.x86
.R_EAX
= M
.x86
.R_ECX
;
6808 M
.x86
.R_AX
= M
.x86
.R_CX
;
6809 M
.x86
.R_CX
= (u16
)tmp
;
6811 DECODE_CLEAR_SEGOVR();
6815 /****************************************************************************
6818 ****************************************************************************/
6819 static void x86emuOp_xchg_word_AX_DX(u8
X86EMU_UNUSED(op1
))
6824 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6825 DECODE_PRINTF("XCHG\tEAX,EDX\n");
6827 DECODE_PRINTF("XCHG\tAX,DX\n");
6830 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6832 M
.x86
.R_EAX
= M
.x86
.R_EDX
;
6836 M
.x86
.R_AX
= M
.x86
.R_DX
;
6837 M
.x86
.R_DX
= (u16
)tmp
;
6839 DECODE_CLEAR_SEGOVR();
6843 /****************************************************************************
6846 ****************************************************************************/
6847 static void x86emuOp_xchg_word_AX_BX(u8
X86EMU_UNUSED(op1
))
6852 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6853 DECODE_PRINTF("XCHG\tEAX,EBX\n");
6855 DECODE_PRINTF("XCHG\tAX,BX\n");
6858 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6860 M
.x86
.R_EAX
= M
.x86
.R_EBX
;
6864 M
.x86
.R_AX
= M
.x86
.R_BX
;
6865 M
.x86
.R_BX
= (u16
)tmp
;
6867 DECODE_CLEAR_SEGOVR();
6871 /****************************************************************************
6874 ****************************************************************************/
6875 static void x86emuOp_xchg_word_AX_SP(u8
X86EMU_UNUSED(op1
))
6880 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6881 DECODE_PRINTF("XCHG\tEAX,ESP\n");
6883 DECODE_PRINTF("XCHG\tAX,SP\n");
6886 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6888 M
.x86
.R_EAX
= M
.x86
.R_ESP
;
6892 M
.x86
.R_AX
= M
.x86
.R_SP
;
6893 M
.x86
.R_SP
= (u16
)tmp
;
6895 DECODE_CLEAR_SEGOVR();
6899 /****************************************************************************
6902 ****************************************************************************/
6903 static void x86emuOp_xchg_word_AX_BP(u8
X86EMU_UNUSED(op1
))
6908 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6909 DECODE_PRINTF("XCHG\tEAX,EBP\n");
6911 DECODE_PRINTF("XCHG\tAX,BP\n");
6914 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6916 M
.x86
.R_EAX
= M
.x86
.R_EBP
;
6920 M
.x86
.R_AX
= M
.x86
.R_BP
;
6921 M
.x86
.R_BP
= (u16
)tmp
;
6923 DECODE_CLEAR_SEGOVR();
6927 /****************************************************************************
6930 ****************************************************************************/
6931 static void x86emuOp_xchg_word_AX_SI(u8
X86EMU_UNUSED(op1
))
6936 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6937 DECODE_PRINTF("XCHG\tEAX,ESI\n");
6939 DECODE_PRINTF("XCHG\tAX,SI\n");
6942 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6944 M
.x86
.R_EAX
= M
.x86
.R_ESI
;
6948 M
.x86
.R_AX
= M
.x86
.R_SI
;
6949 M
.x86
.R_SI
= (u16
)tmp
;
6951 DECODE_CLEAR_SEGOVR();
6955 /****************************************************************************
6958 ****************************************************************************/
6959 static void x86emuOp_xchg_word_AX_DI(u8
X86EMU_UNUSED(op1
))
6964 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6965 DECODE_PRINTF("XCHG\tEAX,EDI\n");
6967 DECODE_PRINTF("XCHG\tAX,DI\n");
6970 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6972 M
.x86
.R_EAX
= M
.x86
.R_EDI
;
6976 M
.x86
.R_AX
= M
.x86
.R_DI
;
6977 M
.x86
.R_DI
= (u16
)tmp
;
6979 DECODE_CLEAR_SEGOVR();
6983 /****************************************************************************
6986 ****************************************************************************/
6987 static void x86emuOp_cbw(u8
X86EMU_UNUSED(op1
))
6990 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6991 DECODE_PRINTF("CWDE\n");
6993 DECODE_PRINTF("CBW\n");
6996 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
6997 if (M
.x86
.R_AX
& 0x8000) {
6998 M
.x86
.R_EAX
|= 0xffff0000;
7000 M
.x86
.R_EAX
&= 0x0000ffff;
7003 if (M
.x86
.R_AL
& 0x80) {
7009 DECODE_CLEAR_SEGOVR();
7013 /****************************************************************************
7016 ****************************************************************************/
7017 static void x86emuOp_cwd(u8
X86EMU_UNUSED(op1
))
7020 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7021 DECODE_PRINTF("CDQ\n");
7023 DECODE_PRINTF("CWD\n");
7025 DECODE_PRINTF("CWD\n");
7027 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7028 if (M
.x86
.R_EAX
& 0x80000000) {
7029 M
.x86
.R_EDX
= 0xffffffff;
7034 if (M
.x86
.R_AX
& 0x8000) {
7035 M
.x86
.R_DX
= 0xffff;
7040 DECODE_CLEAR_SEGOVR();
7044 /****************************************************************************
7047 ****************************************************************************/
7048 static void x86emuOp_call_far_IMM(u8
X86EMU_UNUSED(op1
))
7053 DECODE_PRINTF("CALL\t");
7054 faroff
= fetch_word_imm();
7055 farseg
= fetch_word_imm();
7056 DECODE_PRINTF2("%04x:", farseg
);
7057 DECODE_PRINTF2("%04x\n", faroff
);
7058 CALL_TRACE(M
.x86
.saved_cs
, M
.x86
.saved_ip
, farseg
, faroff
, "FAR ");
7062 * Hooked interrupt vectors calling into our "BIOS" will cause
7063 * problems unless all intersegment stuff is checked for BIOS
7064 * access. Check needed here. For moment, let it alone.
7067 push_word(M
.x86
.R_CS
);
7068 M
.x86
.R_CS
= farseg
;
7069 push_word(M
.x86
.R_IP
);
7070 M
.x86
.R_IP
= faroff
;
7071 DECODE_CLEAR_SEGOVR();
7075 /****************************************************************************
7078 ****************************************************************************/
7079 static void x86emuOp_wait(u8
X86EMU_UNUSED(op1
))
7082 DECODE_PRINTF("WAIT");
7085 DECODE_CLEAR_SEGOVR();
7089 /****************************************************************************
7092 ****************************************************************************/
7093 static void x86emuOp_pushf_word(u8
X86EMU_UNUSED(op1
))
7098 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7099 DECODE_PRINTF("PUSHFD\n");
7101 DECODE_PRINTF("PUSHF\n");
7105 /* clear out *all* bits not representing flags, and turn on real bits */
7106 flags
= (M
.x86
.R_EFLG
& F_MSK
) | F_ALWAYS_ON
;
7107 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7110 push_word((u16
)flags
);
7112 DECODE_CLEAR_SEGOVR();
7116 /****************************************************************************
7119 ****************************************************************************/
7120 static void x86emuOp_popf_word(u8
X86EMU_UNUSED(op1
))
7123 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7124 DECODE_PRINTF("POPFD\n");
7126 DECODE_PRINTF("POPF\n");
7129 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7130 M
.x86
.R_EFLG
= pop_long();
7132 M
.x86
.R_FLG
= pop_word();
7134 DECODE_CLEAR_SEGOVR();
7138 /****************************************************************************
7141 ****************************************************************************/
7142 static void x86emuOp_sahf(u8
X86EMU_UNUSED(op1
))
7145 DECODE_PRINTF("SAHF\n");
7147 /* clear the lower bits of the flag register */
7148 M
.x86
.R_FLG
&= 0xffffff00;
7149 /* or in the AH register into the flags register */
7150 M
.x86
.R_FLG
|= M
.x86
.R_AH
;
7151 DECODE_CLEAR_SEGOVR();
7155 /****************************************************************************
7158 ****************************************************************************/
7159 static void x86emuOp_lahf(u8
X86EMU_UNUSED(op1
))
7162 DECODE_PRINTF("LAHF\n");
7164 M
.x86
.R_AH
= (u8
)(M
.x86
.R_FLG
& 0xff);
7165 /*undocumented TC++ behavior??? Nope. It's documented, but
7166 you have too look real hard to notice it. */
7168 DECODE_CLEAR_SEGOVR();
7172 /****************************************************************************
7175 ****************************************************************************/
7176 static void x86emuOp_mov_AL_M_IMM(u8
X86EMU_UNUSED(op1
))
7181 DECODE_PRINTF("MOV\tAL,");
7182 offset
= fetch_word_imm();
7183 DECODE_PRINTF2("[%04x]\n", offset
);
7185 M
.x86
.R_AL
= fetch_data_byte(offset
);
7186 DECODE_CLEAR_SEGOVR();
7190 /****************************************************************************
7193 ****************************************************************************/
7194 static void x86emuOp_mov_AX_M_IMM(u8
X86EMU_UNUSED(op1
))
7199 offset
= fetch_word_imm();
7200 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7201 DECODE_PRINTF2("MOV\tEAX,[%04x]\n", offset
);
7203 DECODE_PRINTF2("MOV\tAX,[%04x]\n", offset
);
7206 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7207 M
.x86
.R_EAX
= fetch_data_long(offset
);
7209 M
.x86
.R_AX
= fetch_data_word(offset
);
7211 DECODE_CLEAR_SEGOVR();
7215 /****************************************************************************
7218 ****************************************************************************/
7219 static void x86emuOp_mov_M_AL_IMM(u8
X86EMU_UNUSED(op1
))
7224 DECODE_PRINTF("MOV\t");
7225 offset
= fetch_word_imm();
7226 DECODE_PRINTF2("[%04x],AL\n", offset
);
7228 store_data_byte(offset
, M
.x86
.R_AL
);
7229 DECODE_CLEAR_SEGOVR();
7233 /****************************************************************************
7236 ****************************************************************************/
7237 static void x86emuOp_mov_M_AX_IMM(u8
X86EMU_UNUSED(op1
))
7242 offset
= fetch_word_imm();
7243 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7244 DECODE_PRINTF2("MOV\t[%04x],EAX\n", offset
);
7246 DECODE_PRINTF2("MOV\t[%04x],AX\n", offset
);
7249 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7250 store_data_long(offset
, M
.x86
.R_EAX
);
7252 store_data_word(offset
, M
.x86
.R_AX
);
7254 DECODE_CLEAR_SEGOVR();
7258 /****************************************************************************
7261 ****************************************************************************/
7262 static void x86emuOp_movs_byte(u8
X86EMU_UNUSED(op1
))
7269 DECODE_PRINTF("MOVS\tBYTE\n");
7270 if (ACCESS_FLAG(F_DF
)) /* down */
7276 if (M
.x86
.mode
& (SYSMODE_PREFIX_REPE
| SYSMODE_PREFIX_REPNE
)) {
7277 /* dont care whether REPE or REPNE */
7278 /* move them until CX is ZERO. */
7281 M
.x86
.mode
&= ~(SYSMODE_PREFIX_REPE
| SYSMODE_PREFIX_REPNE
);
7284 val
= fetch_data_byte(M
.x86
.R_SI
);
7285 store_data_byte_abs(M
.x86
.R_ES
, M
.x86
.R_DI
, val
);
7289 DECODE_CLEAR_SEGOVR();
7293 /****************************************************************************
7296 ****************************************************************************/
7297 static void x86emuOp_movs_word(u8
X86EMU_UNUSED(op1
))
7304 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7305 DECODE_PRINTF("MOVS\tDWORD\n");
7306 if (ACCESS_FLAG(F_DF
)) /* down */
7311 DECODE_PRINTF("MOVS\tWORD\n");
7312 if (ACCESS_FLAG(F_DF
)) /* down */
7319 if (M
.x86
.mode
& (SYSMODE_PREFIX_REPE
| SYSMODE_PREFIX_REPNE
)) {
7320 /* dont care whether REPE or REPNE */
7321 /* move them until CX is ZERO. */
7324 M
.x86
.mode
&= ~(SYSMODE_PREFIX_REPE
| SYSMODE_PREFIX_REPNE
);
7327 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7328 val
= fetch_data_long(M
.x86
.R_SI
);
7329 store_data_long_abs(M
.x86
.R_ES
, M
.x86
.R_DI
, val
);
7331 val
= fetch_data_word(M
.x86
.R_SI
);
7332 store_data_word_abs(M
.x86
.R_ES
, M
.x86
.R_DI
, (u16
)val
);
7337 DECODE_CLEAR_SEGOVR();
7341 /****************************************************************************
7344 ****************************************************************************/
7345 static void x86emuOp_cmps_byte(u8
X86EMU_UNUSED(op1
))
7351 DECODE_PRINTF("CMPS\tBYTE\n");
7353 if (ACCESS_FLAG(F_DF
)) /* down */
7358 if (M
.x86
.mode
& SYSMODE_PREFIX_REPE
) {
7360 /* move them until CX is ZERO. */
7361 while (M
.x86
.R_CX
!= 0) {
7362 val1
= fetch_data_byte(M
.x86
.R_SI
);
7363 val2
= fetch_data_byte_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7364 cmp_byte(val1
, val2
);
7368 if (ACCESS_FLAG(F_ZF
) == 0)
7371 M
.x86
.mode
&= ~SYSMODE_PREFIX_REPE
;
7372 } else if (M
.x86
.mode
& SYSMODE_PREFIX_REPNE
) {
7374 /* move them until CX is ZERO. */
7375 while (M
.x86
.R_CX
!= 0) {
7376 val1
= fetch_data_byte(M
.x86
.R_SI
);
7377 val2
= fetch_data_byte_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7378 cmp_byte(val1
, val2
);
7382 if (ACCESS_FLAG(F_ZF
))
7383 break; /* zero flag set means equal */
7385 M
.x86
.mode
&= ~SYSMODE_PREFIX_REPNE
;
7387 val1
= fetch_data_byte(M
.x86
.R_SI
);
7388 val2
= fetch_data_byte_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7389 cmp_byte(val1
, val2
);
7393 DECODE_CLEAR_SEGOVR();
7397 /****************************************************************************
7400 ****************************************************************************/
7401 static void x86emuOp_cmps_word(u8
X86EMU_UNUSED(op1
))
7407 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7408 DECODE_PRINTF("CMPS\tDWORD\n");
7409 if (ACCESS_FLAG(F_DF
)) /* down */
7414 DECODE_PRINTF("CMPS\tWORD\n");
7415 if (ACCESS_FLAG(F_DF
)) /* down */
7421 if (M
.x86
.mode
& SYSMODE_PREFIX_REPE
) {
7423 /* move them until CX is ZERO. */
7424 while (M
.x86
.R_CX
!= 0) {
7425 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7426 val1
= fetch_data_long(M
.x86
.R_SI
);
7427 val2
= fetch_data_long_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7428 cmp_long(val1
, val2
);
7430 val1
= fetch_data_word(M
.x86
.R_SI
);
7431 val2
= fetch_data_word_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7432 cmp_word((u16
)val1
, (u16
)val2
);
7437 if (ACCESS_FLAG(F_ZF
) == 0)
7440 M
.x86
.mode
&= ~SYSMODE_PREFIX_REPE
;
7441 } else if (M
.x86
.mode
& SYSMODE_PREFIX_REPNE
) {
7443 /* move them until CX is ZERO. */
7444 while (M
.x86
.R_CX
!= 0) {
7445 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7446 val1
= fetch_data_long(M
.x86
.R_SI
);
7447 val2
= fetch_data_long_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7448 cmp_long(val1
, val2
);
7450 val1
= fetch_data_word(M
.x86
.R_SI
);
7451 val2
= fetch_data_word_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7452 cmp_word((u16
)val1
, (u16
)val2
);
7457 if (ACCESS_FLAG(F_ZF
))
7458 break; /* zero flag set means equal */
7460 M
.x86
.mode
&= ~SYSMODE_PREFIX_REPNE
;
7462 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7463 val1
= fetch_data_long(M
.x86
.R_SI
);
7464 val2
= fetch_data_long_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7465 cmp_long(val1
, val2
);
7467 val1
= fetch_data_word(M
.x86
.R_SI
);
7468 val2
= fetch_data_word_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7469 cmp_word((u16
)val1
, (u16
)val2
);
7474 DECODE_CLEAR_SEGOVR();
7478 /****************************************************************************
7481 ****************************************************************************/
7482 static void x86emuOp_test_AL_IMM(u8
X86EMU_UNUSED(op1
))
7487 DECODE_PRINTF("TEST\tAL,");
7488 imm
= fetch_byte_imm();
7489 DECODE_PRINTF2("%04x\n", imm
);
7491 test_byte(M
.x86
.R_AL
, (u8
)imm
);
7492 DECODE_CLEAR_SEGOVR();
7496 /****************************************************************************
7499 ****************************************************************************/
7500 static void x86emuOp_test_AX_IMM(u8
X86EMU_UNUSED(op1
))
7505 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7506 DECODE_PRINTF("TEST\tEAX,");
7507 srcval
= fetch_long_imm();
7509 DECODE_PRINTF("TEST\tAX,");
7510 srcval
= fetch_word_imm();
7512 DECODE_PRINTF2("%x\n", srcval
);
7514 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7515 test_long(M
.x86
.R_EAX
, srcval
);
7517 test_word(M
.x86
.R_AX
, (u16
)srcval
);
7519 DECODE_CLEAR_SEGOVR();
7523 /****************************************************************************
7526 ****************************************************************************/
7527 static void x86emuOp_stos_byte(u8
X86EMU_UNUSED(op1
))
7532 DECODE_PRINTF("STOS\tBYTE\n");
7533 if (ACCESS_FLAG(F_DF
)) /* down */
7538 if (M
.x86
.mode
& (SYSMODE_PREFIX_REPE
| SYSMODE_PREFIX_REPNE
)) {
7539 /* dont care whether REPE or REPNE */
7540 /* move them until CX is ZERO. */
7541 while (M
.x86
.R_CX
!= 0) {
7542 store_data_byte_abs(M
.x86
.R_ES
, M
.x86
.R_DI
, M
.x86
.R_AL
);
7546 M
.x86
.mode
&= ~(SYSMODE_PREFIX_REPE
| SYSMODE_PREFIX_REPNE
);
7548 store_data_byte_abs(M
.x86
.R_ES
, M
.x86
.R_DI
, M
.x86
.R_AL
);
7551 DECODE_CLEAR_SEGOVR();
7555 /****************************************************************************
7558 ****************************************************************************/
7559 static void x86emuOp_stos_word(u8
X86EMU_UNUSED(op1
))
7565 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7566 DECODE_PRINTF("STOS\tDWORD\n");
7567 if (ACCESS_FLAG(F_DF
)) /* down */
7572 DECODE_PRINTF("STOS\tWORD\n");
7573 if (ACCESS_FLAG(F_DF
)) /* down */
7580 if (M
.x86
.mode
& (SYSMODE_PREFIX_REPE
| SYSMODE_PREFIX_REPNE
)) {
7581 /* dont care whether REPE or REPNE */
7582 /* move them until CX is ZERO. */
7585 M
.x86
.mode
&= ~(SYSMODE_PREFIX_REPE
| SYSMODE_PREFIX_REPNE
);
7588 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7589 store_data_long_abs(M
.x86
.R_ES
, M
.x86
.R_DI
, M
.x86
.R_EAX
);
7591 store_data_word_abs(M
.x86
.R_ES
, M
.x86
.R_DI
, M
.x86
.R_AX
);
7595 DECODE_CLEAR_SEGOVR();
7599 /****************************************************************************
7602 ****************************************************************************/
7603 static void x86emuOp_lods_byte(u8
X86EMU_UNUSED(op1
))
7608 DECODE_PRINTF("LODS\tBYTE\n");
7610 if (ACCESS_FLAG(F_DF
)) /* down */
7614 if (M
.x86
.mode
& (SYSMODE_PREFIX_REPE
| SYSMODE_PREFIX_REPNE
)) {
7615 /* dont care whether REPE or REPNE */
7616 /* move them until CX is ZERO. */
7617 while (M
.x86
.R_CX
!= 0) {
7618 M
.x86
.R_AL
= fetch_data_byte(M
.x86
.R_SI
);
7622 M
.x86
.mode
&= ~(SYSMODE_PREFIX_REPE
| SYSMODE_PREFIX_REPNE
);
7624 M
.x86
.R_AL
= fetch_data_byte(M
.x86
.R_SI
);
7627 DECODE_CLEAR_SEGOVR();
7631 /****************************************************************************
7634 ****************************************************************************/
7635 static void x86emuOp_lods_word(u8
X86EMU_UNUSED(op1
))
7641 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7642 DECODE_PRINTF("LODS\tDWORD\n");
7643 if (ACCESS_FLAG(F_DF
)) /* down */
7648 DECODE_PRINTF("LODS\tWORD\n");
7649 if (ACCESS_FLAG(F_DF
)) /* down */
7656 if (M
.x86
.mode
& (SYSMODE_PREFIX_REPE
| SYSMODE_PREFIX_REPNE
)) {
7657 /* dont care whether REPE or REPNE */
7658 /* move them until CX is ZERO. */
7661 M
.x86
.mode
&= ~(SYSMODE_PREFIX_REPE
| SYSMODE_PREFIX_REPNE
);
7664 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7665 M
.x86
.R_EAX
= fetch_data_long(M
.x86
.R_SI
);
7667 M
.x86
.R_AX
= fetch_data_word(M
.x86
.R_SI
);
7671 DECODE_CLEAR_SEGOVR();
7675 /****************************************************************************
7678 ****************************************************************************/
7679 static void x86emuOp_scas_byte(u8
X86EMU_UNUSED(op1
))
7685 DECODE_PRINTF("SCAS\tBYTE\n");
7687 if (ACCESS_FLAG(F_DF
)) /* down */
7691 if (M
.x86
.mode
& SYSMODE_PREFIX_REPE
) {
7693 /* move them until CX is ZERO. */
7694 while (M
.x86
.R_CX
!= 0) {
7695 val2
= fetch_data_byte_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7696 cmp_byte(M
.x86
.R_AL
, val2
);
7699 if (ACCESS_FLAG(F_ZF
) == 0)
7702 M
.x86
.mode
&= ~SYSMODE_PREFIX_REPE
;
7703 } else if (M
.x86
.mode
& SYSMODE_PREFIX_REPNE
) {
7705 /* move them until CX is ZERO. */
7706 while (M
.x86
.R_CX
!= 0) {
7707 val2
= fetch_data_byte_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7708 cmp_byte(M
.x86
.R_AL
, val2
);
7711 if (ACCESS_FLAG(F_ZF
))
7712 break; /* zero flag set means equal */
7714 M
.x86
.mode
&= ~SYSMODE_PREFIX_REPNE
;
7716 val2
= fetch_data_byte_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7717 cmp_byte(M
.x86
.R_AL
, val2
);
7720 DECODE_CLEAR_SEGOVR();
7724 /****************************************************************************
7727 ****************************************************************************/
7728 static void x86emuOp_scas_word(u8
X86EMU_UNUSED(op1
))
7734 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7735 DECODE_PRINTF("SCAS\tDWORD\n");
7736 if (ACCESS_FLAG(F_DF
)) /* down */
7741 DECODE_PRINTF("SCAS\tWORD\n");
7742 if (ACCESS_FLAG(F_DF
)) /* down */
7748 if (M
.x86
.mode
& SYSMODE_PREFIX_REPE
) {
7750 /* move them until CX is ZERO. */
7751 while (M
.x86
.R_CX
!= 0) {
7752 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7753 val
= fetch_data_long_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7754 cmp_long(M
.x86
.R_EAX
, val
);
7756 val
= fetch_data_word_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7757 cmp_word(M
.x86
.R_AX
, (u16
)val
);
7761 if (ACCESS_FLAG(F_ZF
) == 0)
7764 M
.x86
.mode
&= ~SYSMODE_PREFIX_REPE
;
7765 } else if (M
.x86
.mode
& SYSMODE_PREFIX_REPNE
) {
7767 /* move them until CX is ZERO. */
7768 while (M
.x86
.R_CX
!= 0) {
7769 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7770 val
= fetch_data_long_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7771 cmp_long(M
.x86
.R_EAX
, val
);
7773 val
= fetch_data_word_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7774 cmp_word(M
.x86
.R_AX
, (u16
)val
);
7778 if (ACCESS_FLAG(F_ZF
))
7779 break; /* zero flag set means equal */
7781 M
.x86
.mode
&= ~SYSMODE_PREFIX_REPNE
;
7783 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7784 val
= fetch_data_long_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7785 cmp_long(M
.x86
.R_EAX
, val
);
7787 val
= fetch_data_word_abs(M
.x86
.R_ES
, M
.x86
.R_DI
);
7788 cmp_word(M
.x86
.R_AX
, (u16
)val
);
7792 DECODE_CLEAR_SEGOVR();
7796 /****************************************************************************
7799 ****************************************************************************/
7800 static void x86emuOp_mov_byte_AL_IMM(u8
X86EMU_UNUSED(op1
))
7805 DECODE_PRINTF("MOV\tAL,");
7806 imm
= fetch_byte_imm();
7807 DECODE_PRINTF2("%x\n", imm
);
7810 DECODE_CLEAR_SEGOVR();
7814 /****************************************************************************
7817 ****************************************************************************/
7818 static void x86emuOp_mov_byte_CL_IMM(u8
X86EMU_UNUSED(op1
))
7823 DECODE_PRINTF("MOV\tCL,");
7824 imm
= fetch_byte_imm();
7825 DECODE_PRINTF2("%x\n", imm
);
7828 DECODE_CLEAR_SEGOVR();
7832 /****************************************************************************
7835 ****************************************************************************/
7836 static void x86emuOp_mov_byte_DL_IMM(u8
X86EMU_UNUSED(op1
))
7841 DECODE_PRINTF("MOV\tDL,");
7842 imm
= fetch_byte_imm();
7843 DECODE_PRINTF2("%x\n", imm
);
7846 DECODE_CLEAR_SEGOVR();
7850 /****************************************************************************
7853 ****************************************************************************/
7854 static void x86emuOp_mov_byte_BL_IMM(u8
X86EMU_UNUSED(op1
))
7859 DECODE_PRINTF("MOV\tBL,");
7860 imm
= fetch_byte_imm();
7861 DECODE_PRINTF2("%x\n", imm
);
7864 DECODE_CLEAR_SEGOVR();
7868 /****************************************************************************
7871 ****************************************************************************/
7872 static void x86emuOp_mov_byte_AH_IMM(u8
X86EMU_UNUSED(op1
))
7877 DECODE_PRINTF("MOV\tAH,");
7878 imm
= fetch_byte_imm();
7879 DECODE_PRINTF2("%x\n", imm
);
7882 DECODE_CLEAR_SEGOVR();
7886 /****************************************************************************
7889 ****************************************************************************/
7890 static void x86emuOp_mov_byte_CH_IMM(u8
X86EMU_UNUSED(op1
))
7895 DECODE_PRINTF("MOV\tCH,");
7896 imm
= fetch_byte_imm();
7897 DECODE_PRINTF2("%x\n", imm
);
7900 DECODE_CLEAR_SEGOVR();
7904 /****************************************************************************
7907 ****************************************************************************/
7908 static void x86emuOp_mov_byte_DH_IMM(u8
X86EMU_UNUSED(op1
))
7913 DECODE_PRINTF("MOV\tDH,");
7914 imm
= fetch_byte_imm();
7915 DECODE_PRINTF2("%x\n", imm
);
7918 DECODE_CLEAR_SEGOVR();
7922 /****************************************************************************
7925 ****************************************************************************/
7926 static void x86emuOp_mov_byte_BH_IMM(u8
X86EMU_UNUSED(op1
))
7931 DECODE_PRINTF("MOV\tBH,");
7932 imm
= fetch_byte_imm();
7933 DECODE_PRINTF2("%x\n", imm
);
7936 DECODE_CLEAR_SEGOVR();
7940 /****************************************************************************
7943 ****************************************************************************/
7944 static void x86emuOp_mov_word_AX_IMM(u8
X86EMU_UNUSED(op1
))
7949 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7950 DECODE_PRINTF("MOV\tEAX,");
7951 srcval
= fetch_long_imm();
7953 DECODE_PRINTF("MOV\tAX,");
7954 srcval
= fetch_word_imm();
7956 DECODE_PRINTF2("%x\n", srcval
);
7958 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7959 M
.x86
.R_EAX
= srcval
;
7961 M
.x86
.R_AX
= (u16
)srcval
;
7963 DECODE_CLEAR_SEGOVR();
7967 /****************************************************************************
7970 ****************************************************************************/
7971 static void x86emuOp_mov_word_CX_IMM(u8
X86EMU_UNUSED(op1
))
7976 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7977 DECODE_PRINTF("MOV\tECX,");
7978 srcval
= fetch_long_imm();
7980 DECODE_PRINTF("MOV\tCX,");
7981 srcval
= fetch_word_imm();
7983 DECODE_PRINTF2("%x\n", srcval
);
7985 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
7986 M
.x86
.R_ECX
= srcval
;
7988 M
.x86
.R_CX
= (u16
)srcval
;
7990 DECODE_CLEAR_SEGOVR();
7994 /****************************************************************************
7997 ****************************************************************************/
7998 static void x86emuOp_mov_word_DX_IMM(u8
X86EMU_UNUSED(op1
))
8003 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8004 DECODE_PRINTF("MOV\tEDX,");
8005 srcval
= fetch_long_imm();
8007 DECODE_PRINTF("MOV\tDX,");
8008 srcval
= fetch_word_imm();
8010 DECODE_PRINTF2("%x\n", srcval
);
8012 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8013 M
.x86
.R_EDX
= srcval
;
8015 M
.x86
.R_DX
= (u16
)srcval
;
8017 DECODE_CLEAR_SEGOVR();
8021 /****************************************************************************
8024 ****************************************************************************/
8025 static void x86emuOp_mov_word_BX_IMM(u8
X86EMU_UNUSED(op1
))
8030 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8031 DECODE_PRINTF("MOV\tEBX,");
8032 srcval
= fetch_long_imm();
8034 DECODE_PRINTF("MOV\tBX,");
8035 srcval
= fetch_word_imm();
8037 DECODE_PRINTF2("%x\n", srcval
);
8039 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8040 M
.x86
.R_EBX
= srcval
;
8042 M
.x86
.R_BX
= (u16
)srcval
;
8044 DECODE_CLEAR_SEGOVR();
8048 /****************************************************************************
8051 ****************************************************************************/
8052 static void x86emuOp_mov_word_SP_IMM(u8
X86EMU_UNUSED(op1
))
8057 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8058 DECODE_PRINTF("MOV\tESP,");
8059 srcval
= fetch_long_imm();
8061 DECODE_PRINTF("MOV\tSP,");
8062 srcval
= fetch_word_imm();
8064 DECODE_PRINTF2("%x\n", srcval
);
8066 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8067 M
.x86
.R_ESP
= srcval
;
8069 M
.x86
.R_SP
= (u16
)srcval
;
8071 DECODE_CLEAR_SEGOVR();
8075 /****************************************************************************
8078 ****************************************************************************/
8079 static void x86emuOp_mov_word_BP_IMM(u8
X86EMU_UNUSED(op1
))
8084 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8085 DECODE_PRINTF("MOV\tEBP,");
8086 srcval
= fetch_long_imm();
8088 DECODE_PRINTF("MOV\tBP,");
8089 srcval
= fetch_word_imm();
8091 DECODE_PRINTF2("%x\n", srcval
);
8093 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8094 M
.x86
.R_EBP
= srcval
;
8096 M
.x86
.R_BP
= (u16
)srcval
;
8098 DECODE_CLEAR_SEGOVR();
8102 /****************************************************************************
8105 ****************************************************************************/
8106 static void x86emuOp_mov_word_SI_IMM(u8
X86EMU_UNUSED(op1
))
8111 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8112 DECODE_PRINTF("MOV\tESI,");
8113 srcval
= fetch_long_imm();
8115 DECODE_PRINTF("MOV\tSI,");
8116 srcval
= fetch_word_imm();
8118 DECODE_PRINTF2("%x\n", srcval
);
8120 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8121 M
.x86
.R_ESI
= srcval
;
8123 M
.x86
.R_SI
= (u16
)srcval
;
8125 DECODE_CLEAR_SEGOVR();
8129 /****************************************************************************
8132 ****************************************************************************/
8133 static void x86emuOp_mov_word_DI_IMM(u8
X86EMU_UNUSED(op1
))
8138 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8139 DECODE_PRINTF("MOV\tEDI,");
8140 srcval
= fetch_long_imm();
8142 DECODE_PRINTF("MOV\tDI,");
8143 srcval
= fetch_word_imm();
8145 DECODE_PRINTF2("%x\n", srcval
);
8147 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8148 M
.x86
.R_EDI
= srcval
;
8150 M
.x86
.R_DI
= (u16
)srcval
;
8152 DECODE_CLEAR_SEGOVR();
8156 /* used by opcodes c0, d0, and d2. */
8157 static u8(*opcD0_byte_operation
[])(u8 d
, u8 s
) =
8165 shl_byte
, /* sal_byte === shl_byte by definition */
8169 /****************************************************************************
8172 ****************************************************************************/
8173 static void x86emuOp_opcC0_byte_RM_MEM(u8
X86EMU_UNUSED(op1
))
8182 * Yet another weirdo special case instruction format. Part of
8183 * the opcode held below in "RH". Doubly nested case would
8184 * result, except that the decoded instruction
8187 FETCH_DECODE_MODRM(mod
, rh
, rl
);
8189 if (DEBUG_DECODE()) {
8190 /* XXX DECODE_PRINTF may be changed to something more
8191 general, so that it is important to leave the strings
8192 in the same format, even though the result is that the
8193 above test is done twice. */
8197 DECODE_PRINTF("ROL\t");
8200 DECODE_PRINTF("ROR\t");
8203 DECODE_PRINTF("RCL\t");
8206 DECODE_PRINTF("RCR\t");
8209 DECODE_PRINTF("SHL\t");
8212 DECODE_PRINTF("SHR\t");
8215 DECODE_PRINTF("SAL\t");
8218 DECODE_PRINTF("SAR\t");
8223 /* know operation, decode the mod byte to find the addressing
8227 DECODE_PRINTF("BYTE PTR ");
8228 destoffset
= decode_rm00_address(rl
);
8229 amt
= fetch_byte_imm();
8230 DECODE_PRINTF2(",%x\n", amt
);
8231 destval
= fetch_data_byte(destoffset
);
8233 destval
= (*opcD0_byte_operation
[rh
]) (destval
, amt
);
8234 store_data_byte(destoffset
, destval
);
8237 DECODE_PRINTF("BYTE PTR ");
8238 destoffset
= decode_rm01_address(rl
);
8239 amt
= fetch_byte_imm();
8240 DECODE_PRINTF2(",%x\n", amt
);
8241 destval
= fetch_data_byte(destoffset
);
8243 destval
= (*opcD0_byte_operation
[rh
]) (destval
, amt
);
8244 store_data_byte(destoffset
, destval
);
8247 DECODE_PRINTF("BYTE PTR ");
8248 destoffset
= decode_rm10_address(rl
);
8249 amt
= fetch_byte_imm();
8250 DECODE_PRINTF2(",%x\n", amt
);
8251 destval
= fetch_data_byte(destoffset
);
8253 destval
= (*opcD0_byte_operation
[rh
]) (destval
, amt
);
8254 store_data_byte(destoffset
, destval
);
8256 case 3: /* register to register */
8257 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
8258 amt
= fetch_byte_imm();
8259 DECODE_PRINTF2(",%x\n", amt
);
8261 destval
= (*opcD0_byte_operation
[rh
]) (*destreg
, amt
);
8265 DECODE_CLEAR_SEGOVR();
8269 /* used by opcodes c1, d1, and d3. */
8270 static u16(*opcD1_word_operation
[])(u16 s
, u8 d
) =
8278 shl_word
, /* sal_byte === shl_byte by definition */
8282 /* used by opcodes c1, d1, and d3. */
8283 static u32 (*opcD1_long_operation
[])(u32 s
, u8 d
) =
8291 shl_long
, /* sal_byte === shl_byte by definition */
8295 /****************************************************************************
8298 ****************************************************************************/
8299 static void x86emuOp_opcC1_word_RM_MEM(u8
X86EMU_UNUSED(op1
))
8306 * Yet another weirdo special case instruction format. Part of
8307 * the opcode held below in "RH". Doubly nested case would
8308 * result, except that the decoded instruction
8311 FETCH_DECODE_MODRM(mod
, rh
, rl
);
8313 if (DEBUG_DECODE()) {
8314 /* XXX DECODE_PRINTF may be changed to something more
8315 general, so that it is important to leave the strings
8316 in the same format, even though the result is that the
8317 above test is done twice. */
8321 DECODE_PRINTF("ROL\t");
8324 DECODE_PRINTF("ROR\t");
8327 DECODE_PRINTF("RCL\t");
8330 DECODE_PRINTF("RCR\t");
8333 DECODE_PRINTF("SHL\t");
8336 DECODE_PRINTF("SHR\t");
8339 DECODE_PRINTF("SAL\t");
8342 DECODE_PRINTF("SAR\t");
8347 /* know operation, decode the mod byte to find the addressing
8351 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8354 DECODE_PRINTF("DWORD PTR ");
8355 destoffset
= decode_rm00_address(rl
);
8356 amt
= fetch_byte_imm();
8357 DECODE_PRINTF2(",%x\n", amt
);
8358 destval
= fetch_data_long(destoffset
);
8360 destval
= (*opcD1_long_operation
[rh
]) (destval
, amt
);
8361 store_data_long(destoffset
, destval
);
8365 DECODE_PRINTF("WORD PTR ");
8366 destoffset
= decode_rm00_address(rl
);
8367 amt
= fetch_byte_imm();
8368 DECODE_PRINTF2(",%x\n", amt
);
8369 destval
= fetch_data_word(destoffset
);
8371 destval
= (*opcD1_word_operation
[rh
]) (destval
, amt
);
8372 store_data_word(destoffset
, destval
);
8376 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8379 DECODE_PRINTF("DWORD PTR ");
8380 destoffset
= decode_rm01_address(rl
);
8381 amt
= fetch_byte_imm();
8382 DECODE_PRINTF2(",%x\n", amt
);
8383 destval
= fetch_data_long(destoffset
);
8385 destval
= (*opcD1_long_operation
[rh
]) (destval
, amt
);
8386 store_data_long(destoffset
, destval
);
8390 DECODE_PRINTF("WORD PTR ");
8391 destoffset
= decode_rm01_address(rl
);
8392 amt
= fetch_byte_imm();
8393 DECODE_PRINTF2(",%x\n", amt
);
8394 destval
= fetch_data_word(destoffset
);
8396 destval
= (*opcD1_word_operation
[rh
]) (destval
, amt
);
8397 store_data_word(destoffset
, destval
);
8401 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8404 DECODE_PRINTF("DWORD PTR ");
8405 destoffset
= decode_rm10_address(rl
);
8406 amt
= fetch_byte_imm();
8407 DECODE_PRINTF2(",%x\n", amt
);
8408 destval
= fetch_data_long(destoffset
);
8410 destval
= (*opcD1_long_operation
[rh
]) (destval
, amt
);
8411 store_data_long(destoffset
, destval
);
8415 DECODE_PRINTF("WORD PTR ");
8416 destoffset
= decode_rm10_address(rl
);
8417 amt
= fetch_byte_imm();
8418 DECODE_PRINTF2(",%x\n", amt
);
8419 destval
= fetch_data_word(destoffset
);
8421 destval
= (*opcD1_word_operation
[rh
]) (destval
, amt
);
8422 store_data_word(destoffset
, destval
);
8425 case 3: /* register to register */
8426 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8429 destreg
= DECODE_RM_LONG_REGISTER(rl
);
8430 amt
= fetch_byte_imm();
8431 DECODE_PRINTF2(",%x\n", amt
);
8433 *destreg
= (*opcD1_long_operation
[rh
]) (*destreg
, amt
);
8437 destreg
= DECODE_RM_WORD_REGISTER(rl
);
8438 amt
= fetch_byte_imm();
8439 DECODE_PRINTF2(",%x\n", amt
);
8441 *destreg
= (*opcD1_word_operation
[rh
]) (*destreg
, amt
);
8445 DECODE_CLEAR_SEGOVR();
8449 /****************************************************************************
8452 ****************************************************************************/
8453 static void x86emuOp_ret_near_IMM(u8
X86EMU_UNUSED(op1
))
8458 DECODE_PRINTF("RET\t");
8459 imm
= fetch_word_imm();
8460 DECODE_PRINTF2("%x\n", imm
);
8461 RETURN_TRACE("RET",M
.x86
.saved_cs
,M
.x86
.saved_ip
);
8463 M
.x86
.R_IP
= pop_word();
8465 DECODE_CLEAR_SEGOVR();
8469 /****************************************************************************
8472 ****************************************************************************/
8473 static void x86emuOp_ret_near(u8
X86EMU_UNUSED(op1
))
8476 DECODE_PRINTF("RET\n");
8477 RETURN_TRACE("RET",M
.x86
.saved_cs
,M
.x86
.saved_ip
);
8479 M
.x86
.R_IP
= pop_word();
8480 DECODE_CLEAR_SEGOVR();
8484 /****************************************************************************
8487 ****************************************************************************/
8488 static void x86emuOp_les_R_IMM(u8
X86EMU_UNUSED(op1
))
8495 DECODE_PRINTF("LES\t");
8496 FETCH_DECODE_MODRM(mod
, rh
, rl
);
8499 dstreg
= DECODE_RM_WORD_REGISTER(rh
);
8501 srcoffset
= decode_rm00_address(rl
);
8502 DECODE_PRINTF("\n");
8504 *dstreg
= fetch_data_word(srcoffset
);
8505 M
.x86
.R_ES
= fetch_data_word(srcoffset
+ 2);
8508 dstreg
= DECODE_RM_WORD_REGISTER(rh
);
8510 srcoffset
= decode_rm01_address(rl
);
8511 DECODE_PRINTF("\n");
8513 *dstreg
= fetch_data_word(srcoffset
);
8514 M
.x86
.R_ES
= fetch_data_word(srcoffset
+ 2);
8517 dstreg
= DECODE_RM_WORD_REGISTER(rh
);
8519 srcoffset
= decode_rm10_address(rl
);
8520 DECODE_PRINTF("\n");
8522 *dstreg
= fetch_data_word(srcoffset
);
8523 M
.x86
.R_ES
= fetch_data_word(srcoffset
+ 2);
8525 case 3: /* register to register */
8529 DECODE_CLEAR_SEGOVR();
8533 /****************************************************************************
8536 ****************************************************************************/
8537 static void x86emuOp_lds_R_IMM(u8
X86EMU_UNUSED(op1
))
8544 DECODE_PRINTF("LDS\t");
8545 FETCH_DECODE_MODRM(mod
, rh
, rl
);
8548 dstreg
= DECODE_RM_WORD_REGISTER(rh
);
8550 srcoffset
= decode_rm00_address(rl
);
8551 DECODE_PRINTF("\n");
8553 *dstreg
= fetch_data_word(srcoffset
);
8554 M
.x86
.R_DS
= fetch_data_word(srcoffset
+ 2);
8557 dstreg
= DECODE_RM_WORD_REGISTER(rh
);
8559 srcoffset
= decode_rm01_address(rl
);
8560 DECODE_PRINTF("\n");
8562 *dstreg
= fetch_data_word(srcoffset
);
8563 M
.x86
.R_DS
= fetch_data_word(srcoffset
+ 2);
8566 dstreg
= DECODE_RM_WORD_REGISTER(rh
);
8568 srcoffset
= decode_rm10_address(rl
);
8569 DECODE_PRINTF("\n");
8571 *dstreg
= fetch_data_word(srcoffset
);
8572 M
.x86
.R_DS
= fetch_data_word(srcoffset
+ 2);
8574 case 3: /* register to register */
8578 DECODE_CLEAR_SEGOVR();
8582 /****************************************************************************
8585 ****************************************************************************/
8586 static void x86emuOp_mov_byte_RM_IMM(u8
X86EMU_UNUSED(op1
))
8594 DECODE_PRINTF("MOV\t");
8595 FETCH_DECODE_MODRM(mod
, rh
, rl
);
8597 DECODE_PRINTF("ILLEGAL DECODE OF OPCODE c6\n");
8602 DECODE_PRINTF("BYTE PTR ");
8603 destoffset
= decode_rm00_address(rl
);
8604 imm
= fetch_byte_imm();
8605 DECODE_PRINTF2(",%2x\n", imm
);
8607 store_data_byte(destoffset
, imm
);
8610 DECODE_PRINTF("BYTE PTR ");
8611 destoffset
= decode_rm01_address(rl
);
8612 imm
= fetch_byte_imm();
8613 DECODE_PRINTF2(",%2x\n", imm
);
8615 store_data_byte(destoffset
, imm
);
8618 DECODE_PRINTF("BYTE PTR ");
8619 destoffset
= decode_rm10_address(rl
);
8620 imm
= fetch_byte_imm();
8621 DECODE_PRINTF2(",%2x\n", imm
);
8623 store_data_byte(destoffset
, imm
);
8625 case 3: /* register to register */
8626 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
8627 imm
= fetch_byte_imm();
8628 DECODE_PRINTF2(",%2x\n", imm
);
8633 DECODE_CLEAR_SEGOVR();
8637 /****************************************************************************
8640 ****************************************************************************/
8641 static void x86emuOp_mov_word_RM_IMM(u8
X86EMU_UNUSED(op1
))
8647 DECODE_PRINTF("MOV\t");
8648 FETCH_DECODE_MODRM(mod
, rh
, rl
);
8650 DECODE_PRINTF("ILLEGAL DECODE OF OPCODE 8F\n");
8655 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8658 DECODE_PRINTF("DWORD PTR ");
8659 destoffset
= decode_rm00_address(rl
);
8660 imm
= fetch_long_imm();
8661 DECODE_PRINTF2(",%x\n", imm
);
8663 store_data_long(destoffset
, imm
);
8667 DECODE_PRINTF("WORD PTR ");
8668 destoffset
= decode_rm00_address(rl
);
8669 imm
= fetch_word_imm();
8670 DECODE_PRINTF2(",%x\n", imm
);
8672 store_data_word(destoffset
, imm
);
8676 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8679 DECODE_PRINTF("DWORD PTR ");
8680 destoffset
= decode_rm01_address(rl
);
8681 imm
= fetch_long_imm();
8682 DECODE_PRINTF2(",%x\n", imm
);
8684 store_data_long(destoffset
, imm
);
8688 DECODE_PRINTF("WORD PTR ");
8689 destoffset
= decode_rm01_address(rl
);
8690 imm
= fetch_word_imm();
8691 DECODE_PRINTF2(",%x\n", imm
);
8693 store_data_word(destoffset
, imm
);
8697 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8700 DECODE_PRINTF("DWORD PTR ");
8701 destoffset
= decode_rm10_address(rl
);
8702 imm
= fetch_long_imm();
8703 DECODE_PRINTF2(",%x\n", imm
);
8705 store_data_long(destoffset
, imm
);
8709 DECODE_PRINTF("WORD PTR ");
8710 destoffset
= decode_rm10_address(rl
);
8711 imm
= fetch_word_imm();
8712 DECODE_PRINTF2(",%x\n", imm
);
8714 store_data_word(destoffset
, imm
);
8717 case 3: /* register to register */
8718 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
8722 destreg
= DECODE_RM_LONG_REGISTER(rl
);
8723 imm
= fetch_long_imm();
8724 DECODE_PRINTF2(",%x\n", imm
);
8731 destreg
= DECODE_RM_WORD_REGISTER(rl
);
8732 imm
= fetch_word_imm();
8733 DECODE_PRINTF2(",%x\n", imm
);
8739 DECODE_CLEAR_SEGOVR();
8743 /****************************************************************************
8746 ****************************************************************************/
8747 static void x86emuOp_enter(u8
X86EMU_UNUSED(op1
))
8749 u16 local
,frame_pointer
;
8754 local
= fetch_word_imm();
8755 nesting
= fetch_byte_imm();
8756 DECODE_PRINTF2("ENTER %x\n", local
);
8757 DECODE_PRINTF2(",%x\n", nesting
);
8759 push_word(M
.x86
.R_BP
);
8760 frame_pointer
= M
.x86
.R_SP
;
8762 for (i
= 1; i
< nesting
; i
++) {
8764 push_word(fetch_data_word_abs(M
.x86
.R_SS
, M
.x86
.R_BP
));
8766 push_word(frame_pointer
);
8768 M
.x86
.R_BP
= frame_pointer
;
8769 M
.x86
.R_SP
= (u16
)(M
.x86
.R_SP
- local
);
8770 DECODE_CLEAR_SEGOVR();
8774 /****************************************************************************
8777 ****************************************************************************/
8778 static void x86emuOp_leave(u8
X86EMU_UNUSED(op1
))
8781 DECODE_PRINTF("LEAVE\n");
8783 M
.x86
.R_SP
= M
.x86
.R_BP
;
8784 M
.x86
.R_BP
= pop_word();
8785 DECODE_CLEAR_SEGOVR();
8789 /****************************************************************************
8792 ****************************************************************************/
8793 static void x86emuOp_ret_far_IMM(u8
X86EMU_UNUSED(op1
))
8798 DECODE_PRINTF("RETF\t");
8799 imm
= fetch_word_imm();
8800 DECODE_PRINTF2("%x\n", imm
);
8801 RETURN_TRACE("RETF",M
.x86
.saved_cs
,M
.x86
.saved_ip
);
8803 M
.x86
.R_IP
= pop_word();
8804 M
.x86
.R_CS
= pop_word();
8806 DECODE_CLEAR_SEGOVR();
8810 /****************************************************************************
8813 ****************************************************************************/
8814 static void x86emuOp_ret_far(u8
X86EMU_UNUSED(op1
))
8817 DECODE_PRINTF("RETF\n");
8818 RETURN_TRACE("RETF",M
.x86
.saved_cs
,M
.x86
.saved_ip
);
8820 M
.x86
.R_IP
= pop_word();
8821 M
.x86
.R_CS
= pop_word();
8822 DECODE_CLEAR_SEGOVR();
8826 /****************************************************************************
8829 ****************************************************************************/
8830 static void x86emuOp_int3(u8
X86EMU_UNUSED(op1
))
8833 DECODE_PRINTF("INT 3\n");
8835 if (_X86EMU_intrTab
[3]) {
8836 (*_X86EMU_intrTab
[3])(3);
8838 push_word((u16
)M
.x86
.R_FLG
);
8841 push_word(M
.x86
.R_CS
);
8842 M
.x86
.R_CS
= mem_access_word(3 * 4 + 2);
8843 push_word(M
.x86
.R_IP
);
8844 M
.x86
.R_IP
= mem_access_word(3 * 4);
8846 DECODE_CLEAR_SEGOVR();
8850 /****************************************************************************
8853 ****************************************************************************/
8854 static void x86emuOp_int_IMM(u8
X86EMU_UNUSED(op1
))
8859 DECODE_PRINTF("INT\t");
8860 intnum
= fetch_byte_imm();
8861 DECODE_PRINTF2("%x\n", intnum
);
8863 if (_X86EMU_intrTab
[intnum
]) {
8864 (*_X86EMU_intrTab
[intnum
])(intnum
);
8866 push_word((u16
)M
.x86
.R_FLG
);
8869 push_word(M
.x86
.R_CS
);
8870 M
.x86
.R_CS
= mem_access_word(intnum
* 4 + 2);
8871 push_word(M
.x86
.R_IP
);
8872 M
.x86
.R_IP
= mem_access_word(intnum
* 4);
8874 DECODE_CLEAR_SEGOVR();
8878 /****************************************************************************
8881 ****************************************************************************/
8882 static void x86emuOp_into(u8
X86EMU_UNUSED(op1
))
8885 DECODE_PRINTF("INTO\n");
8887 if (ACCESS_FLAG(F_OF
)) {
8888 if (_X86EMU_intrTab
[4]) {
8889 (*_X86EMU_intrTab
[4])(4);
8891 push_word((u16
)M
.x86
.R_FLG
);
8894 push_word(M
.x86
.R_CS
);
8895 M
.x86
.R_CS
= mem_access_word(4 * 4 + 2);
8896 push_word(M
.x86
.R_IP
);
8897 M
.x86
.R_IP
= mem_access_word(4 * 4);
8900 DECODE_CLEAR_SEGOVR();
8904 /****************************************************************************
8907 ****************************************************************************/
8908 static void x86emuOp_iret(u8
X86EMU_UNUSED(op1
))
8911 DECODE_PRINTF("IRET\n");
8915 M
.x86
.R_IP
= pop_word();
8916 M
.x86
.R_CS
= pop_word();
8917 M
.x86
.R_FLG
= pop_word();
8918 DECODE_CLEAR_SEGOVR();
8922 /****************************************************************************
8925 ****************************************************************************/
8926 static void x86emuOp_opcD0_byte_RM_1(u8
X86EMU_UNUSED(op1
))
8934 * Yet another weirdo special case instruction format. Part of
8935 * the opcode held below in "RH". Doubly nested case would
8936 * result, except that the decoded instruction
8939 FETCH_DECODE_MODRM(mod
, rh
, rl
);
8941 if (DEBUG_DECODE()) {
8942 /* XXX DECODE_PRINTF may be changed to something more
8943 general, so that it is important to leave the strings
8944 in the same format, even though the result is that the
8945 above test is done twice. */
8948 DECODE_PRINTF("ROL\t");
8951 DECODE_PRINTF("ROR\t");
8954 DECODE_PRINTF("RCL\t");
8957 DECODE_PRINTF("RCR\t");
8960 DECODE_PRINTF("SHL\t");
8963 DECODE_PRINTF("SHR\t");
8966 DECODE_PRINTF("SAL\t");
8969 DECODE_PRINTF("SAR\t");
8974 /* know operation, decode the mod byte to find the addressing
8978 DECODE_PRINTF("BYTE PTR ");
8979 destoffset
= decode_rm00_address(rl
);
8980 DECODE_PRINTF(",1\n");
8981 destval
= fetch_data_byte(destoffset
);
8983 destval
= (*opcD0_byte_operation
[rh
]) (destval
, 1);
8984 store_data_byte(destoffset
, destval
);
8987 DECODE_PRINTF("BYTE PTR ");
8988 destoffset
= decode_rm01_address(rl
);
8989 DECODE_PRINTF(",1\n");
8990 destval
= fetch_data_byte(destoffset
);
8992 destval
= (*opcD0_byte_operation
[rh
]) (destval
, 1);
8993 store_data_byte(destoffset
, destval
);
8996 DECODE_PRINTF("BYTE PTR ");
8997 destoffset
= decode_rm10_address(rl
);
8998 DECODE_PRINTF(",1\n");
8999 destval
= fetch_data_byte(destoffset
);
9001 destval
= (*opcD0_byte_operation
[rh
]) (destval
, 1);
9002 store_data_byte(destoffset
, destval
);
9004 case 3: /* register to register */
9005 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
9006 DECODE_PRINTF(",1\n");
9008 destval
= (*opcD0_byte_operation
[rh
]) (*destreg
, 1);
9012 DECODE_CLEAR_SEGOVR();
9016 /****************************************************************************
9019 ****************************************************************************/
9020 static void x86emuOp_opcD1_word_RM_1(u8
X86EMU_UNUSED(op1
))
9026 * Yet another weirdo special case instruction format. Part of
9027 * the opcode held below in "RH". Doubly nested case would
9028 * result, except that the decoded instruction
9031 FETCH_DECODE_MODRM(mod
, rh
, rl
);
9033 if (DEBUG_DECODE()) {
9034 /* XXX DECODE_PRINTF may be changed to something more
9035 general, so that it is important to leave the strings
9036 in the same format, even though the result is that the
9037 above test is done twice. */
9040 DECODE_PRINTF("ROL\t");
9043 DECODE_PRINTF("ROR\t");
9046 DECODE_PRINTF("RCL\t");
9049 DECODE_PRINTF("RCR\t");
9052 DECODE_PRINTF("SHL\t");
9055 DECODE_PRINTF("SHR\t");
9058 DECODE_PRINTF("SAL\t");
9061 DECODE_PRINTF("SAR\t");
9066 /* know operation, decode the mod byte to find the addressing
9070 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
9073 DECODE_PRINTF("DWORD PTR ");
9074 destoffset
= decode_rm00_address(rl
);
9075 DECODE_PRINTF(",1\n");
9076 destval
= fetch_data_long(destoffset
);
9078 destval
= (*opcD1_long_operation
[rh
]) (destval
, 1);
9079 store_data_long(destoffset
, destval
);
9083 DECODE_PRINTF("WORD PTR ");
9084 destoffset
= decode_rm00_address(rl
);
9085 DECODE_PRINTF(",1\n");
9086 destval
= fetch_data_word(destoffset
);
9088 destval
= (*opcD1_word_operation
[rh
]) (destval
, 1);
9089 store_data_word(destoffset
, destval
);
9093 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
9096 DECODE_PRINTF("DWORD PTR ");
9097 destoffset
= decode_rm01_address(rl
);
9098 DECODE_PRINTF(",1\n");
9099 destval
= fetch_data_long(destoffset
);
9101 destval
= (*opcD1_long_operation
[rh
]) (destval
, 1);
9102 store_data_long(destoffset
, destval
);
9106 DECODE_PRINTF("WORD PTR ");
9107 destoffset
= decode_rm01_address(rl
);
9108 DECODE_PRINTF(",1\n");
9109 destval
= fetch_data_word(destoffset
);
9111 destval
= (*opcD1_word_operation
[rh
]) (destval
, 1);
9112 store_data_word(destoffset
, destval
);
9116 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
9119 DECODE_PRINTF("DWORD PTR ");
9120 destoffset
= decode_rm10_address(rl
);
9121 DECODE_PRINTF(",1\n");
9122 destval
= fetch_data_long(destoffset
);
9124 destval
= (*opcD1_long_operation
[rh
]) (destval
, 1);
9125 store_data_long(destoffset
, destval
);
9129 DECODE_PRINTF("BYTE PTR ");
9130 destoffset
= decode_rm10_address(rl
);
9131 DECODE_PRINTF(",1\n");
9132 destval
= fetch_data_word(destoffset
);
9134 destval
= (*opcD1_word_operation
[rh
]) (destval
, 1);
9135 store_data_word(destoffset
, destval
);
9138 case 3: /* register to register */
9139 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
9143 destreg
= DECODE_RM_LONG_REGISTER(rl
);
9144 DECODE_PRINTF(",1\n");
9146 destval
= (*opcD1_long_operation
[rh
]) (*destreg
, 1);
9152 destreg
= DECODE_RM_WORD_REGISTER(rl
);
9153 DECODE_PRINTF(",1\n");
9155 destval
= (*opcD1_word_operation
[rh
]) (*destreg
, 1);
9160 DECODE_CLEAR_SEGOVR();
9164 /****************************************************************************
9167 ****************************************************************************/
9168 static void x86emuOp_opcD2_byte_RM_CL(u8
X86EMU_UNUSED(op1
))
9177 * Yet another weirdo special case instruction format. Part of
9178 * the opcode held below in "RH". Doubly nested case would
9179 * result, except that the decoded instruction
9182 FETCH_DECODE_MODRM(mod
, rh
, rl
);
9184 if (DEBUG_DECODE()) {
9185 /* XXX DECODE_PRINTF may be changed to something more
9186 general, so that it is important to leave the strings
9187 in the same format, even though the result is that the
9188 above test is done twice. */
9191 DECODE_PRINTF("ROL\t");
9194 DECODE_PRINTF("ROR\t");
9197 DECODE_PRINTF("RCL\t");
9200 DECODE_PRINTF("RCR\t");
9203 DECODE_PRINTF("SHL\t");
9206 DECODE_PRINTF("SHR\t");
9209 DECODE_PRINTF("SAL\t");
9212 DECODE_PRINTF("SAR\t");
9217 /* know operation, decode the mod byte to find the addressing
9222 DECODE_PRINTF("BYTE PTR ");
9223 destoffset
= decode_rm00_address(rl
);
9224 DECODE_PRINTF(",CL\n");
9225 destval
= fetch_data_byte(destoffset
);
9227 destval
= (*opcD0_byte_operation
[rh
]) (destval
, amt
);
9228 store_data_byte(destoffset
, destval
);
9231 DECODE_PRINTF("BYTE PTR ");
9232 destoffset
= decode_rm01_address(rl
);
9233 DECODE_PRINTF(",CL\n");
9234 destval
= fetch_data_byte(destoffset
);
9236 destval
= (*opcD0_byte_operation
[rh
]) (destval
, amt
);
9237 store_data_byte(destoffset
, destval
);
9240 DECODE_PRINTF("BYTE PTR ");
9241 destoffset
= decode_rm10_address(rl
);
9242 DECODE_PRINTF(",CL\n");
9243 destval
= fetch_data_byte(destoffset
);
9245 destval
= (*opcD0_byte_operation
[rh
]) (destval
, amt
);
9246 store_data_byte(destoffset
, destval
);
9248 case 3: /* register to register */
9249 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
9250 DECODE_PRINTF(",CL\n");
9252 destval
= (*opcD0_byte_operation
[rh
]) (*destreg
, amt
);
9256 DECODE_CLEAR_SEGOVR();
9260 /****************************************************************************
9263 ****************************************************************************/
9264 static void x86emuOp_opcD3_word_RM_CL(u8
X86EMU_UNUSED(op1
))
9271 * Yet another weirdo special case instruction format. Part of
9272 * the opcode held below in "RH". Doubly nested case would
9273 * result, except that the decoded instruction
9276 FETCH_DECODE_MODRM(mod
, rh
, rl
);
9278 if (DEBUG_DECODE()) {
9279 /* XXX DECODE_PRINTF may be changed to something more
9280 general, so that it is important to leave the strings
9281 in the same format, even though the result is that the
9282 above test is done twice. */
9285 DECODE_PRINTF("ROL\t");
9288 DECODE_PRINTF("ROR\t");
9291 DECODE_PRINTF("RCL\t");
9294 DECODE_PRINTF("RCR\t");
9297 DECODE_PRINTF("SHL\t");
9300 DECODE_PRINTF("SHR\t");
9303 DECODE_PRINTF("SAL\t");
9306 DECODE_PRINTF("SAR\t");
9311 /* know operation, decode the mod byte to find the addressing
9316 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
9319 DECODE_PRINTF("DWORD PTR ");
9320 destoffset
= decode_rm00_address(rl
);
9321 DECODE_PRINTF(",CL\n");
9322 destval
= fetch_data_long(destoffset
);
9324 destval
= (*opcD1_long_operation
[rh
]) (destval
, amt
);
9325 store_data_long(destoffset
, destval
);
9329 DECODE_PRINTF("WORD PTR ");
9330 destoffset
= decode_rm00_address(rl
);
9331 DECODE_PRINTF(",CL\n");
9332 destval
= fetch_data_word(destoffset
);
9334 destval
= (*opcD1_word_operation
[rh
]) (destval
, amt
);
9335 store_data_word(destoffset
, destval
);
9339 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
9342 DECODE_PRINTF("DWORD PTR ");
9343 destoffset
= decode_rm01_address(rl
);
9344 DECODE_PRINTF(",CL\n");
9345 destval
= fetch_data_long(destoffset
);
9347 destval
= (*opcD1_long_operation
[rh
]) (destval
, amt
);
9348 store_data_long(destoffset
, destval
);
9352 DECODE_PRINTF("WORD PTR ");
9353 destoffset
= decode_rm01_address(rl
);
9354 DECODE_PRINTF(",CL\n");
9355 destval
= fetch_data_word(destoffset
);
9357 destval
= (*opcD1_word_operation
[rh
]) (destval
, amt
);
9358 store_data_word(destoffset
, destval
);
9362 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
9365 DECODE_PRINTF("DWORD PTR ");
9366 destoffset
= decode_rm10_address(rl
);
9367 DECODE_PRINTF(",CL\n");
9368 destval
= fetch_data_long(destoffset
);
9370 destval
= (*opcD1_long_operation
[rh
]) (destval
, amt
);
9371 store_data_long(destoffset
, destval
);
9375 DECODE_PRINTF("WORD PTR ");
9376 destoffset
= decode_rm10_address(rl
);
9377 DECODE_PRINTF(",CL\n");
9378 destval
= fetch_data_word(destoffset
);
9380 destval
= (*opcD1_word_operation
[rh
]) (destval
, amt
);
9381 store_data_word(destoffset
, destval
);
9384 case 3: /* register to register */
9385 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
9388 destreg
= DECODE_RM_LONG_REGISTER(rl
);
9389 DECODE_PRINTF(",CL\n");
9391 *destreg
= (*opcD1_long_operation
[rh
]) (*destreg
, amt
);
9395 destreg
= DECODE_RM_WORD_REGISTER(rl
);
9396 DECODE_PRINTF(",CL\n");
9398 *destreg
= (*opcD1_word_operation
[rh
]) (*destreg
, amt
);
9402 DECODE_CLEAR_SEGOVR();
9406 /****************************************************************************
9409 ****************************************************************************/
9410 static void x86emuOp_aam(u8
X86EMU_UNUSED(op1
))
9415 DECODE_PRINTF("AAM\n");
9416 a
= fetch_byte_imm(); /* this is a stupid encoding. */
9418 /* fix: add base decoding
9419 aam_word(u8 val, int base a) */
9420 DECODE_PRINTF("ERROR DECODING AAM\n");
9425 /* note the type change here --- returning AL and AH in AX. */
9426 M
.x86
.R_AX
= aam_word(M
.x86
.R_AL
);
9427 DECODE_CLEAR_SEGOVR();
9431 /****************************************************************************
9434 ****************************************************************************/
9435 static void x86emuOp_aad(u8
X86EMU_UNUSED(op1
))
9440 DECODE_PRINTF("AAD\n");
9441 a
= fetch_byte_imm();
9443 /* fix: add base decoding
9444 aad_word(u16 val, int base a) */
9445 DECODE_PRINTF("ERROR DECODING AAM\n");
9450 M
.x86
.R_AX
= aad_word(M
.x86
.R_AX
);
9451 DECODE_CLEAR_SEGOVR();
9455 /* opcode 0xd6 ILLEGAL OPCODE */
9457 /****************************************************************************
9460 ****************************************************************************/
9461 static void x86emuOp_xlat(u8
X86EMU_UNUSED(op1
))
9466 DECODE_PRINTF("XLAT\n");
9468 addr
= (u16
)(M
.x86
.R_BX
+ (u8
)M
.x86
.R_AL
);
9469 M
.x86
.R_AL
= fetch_data_byte(addr
);
9470 DECODE_CLEAR_SEGOVR();
9474 /* instuctions D8 .. DF are in i87_ops.c */
9476 /****************************************************************************
9479 ****************************************************************************/
9480 static void x86emuOp_loopne(u8
X86EMU_UNUSED(op1
))
9485 DECODE_PRINTF("LOOPNE\t");
9486 ip
= (s8
) fetch_byte_imm();
9487 ip
+= (s16
) M
.x86
.R_IP
;
9488 DECODE_PRINTF2("%04x\n", ip
);
9491 if (M
.x86
.R_CX
!= 0 && !ACCESS_FLAG(F_ZF
)) /* CX != 0 and !ZF */
9493 DECODE_CLEAR_SEGOVR();
9497 /****************************************************************************
9500 ****************************************************************************/
9501 static void x86emuOp_loope(u8
X86EMU_UNUSED(op1
))
9506 DECODE_PRINTF("LOOPE\t");
9507 ip
= (s8
) fetch_byte_imm();
9508 ip
+= (s16
) M
.x86
.R_IP
;
9509 DECODE_PRINTF2("%04x\n", ip
);
9512 if (M
.x86
.R_CX
!= 0 && ACCESS_FLAG(F_ZF
)) /* CX != 0 and ZF */
9514 DECODE_CLEAR_SEGOVR();
9518 /****************************************************************************
9521 ****************************************************************************/
9522 static void x86emuOp_loop(u8
X86EMU_UNUSED(op1
))
9527 DECODE_PRINTF("LOOP\t");
9528 ip
= (s8
) fetch_byte_imm();
9529 ip
+= (s16
) M
.x86
.R_IP
;
9530 DECODE_PRINTF2("%04x\n", ip
);
9533 if (M
.x86
.R_CX
!= 0)
9535 DECODE_CLEAR_SEGOVR();
9539 /****************************************************************************
9542 ****************************************************************************/
9543 static void x86emuOp_jcxz(u8
X86EMU_UNUSED(op1
))
9548 /* jump to byte offset if overflow flag is set */
9550 DECODE_PRINTF("JCXZ\t");
9551 offset
= (s8
)fetch_byte_imm();
9552 target
= (u16
)(M
.x86
.R_IP
+ offset
);
9553 DECODE_PRINTF2("%x\n", target
);
9555 if (M
.x86
.R_CX
== 0)
9556 M
.x86
.R_IP
= target
;
9557 DECODE_CLEAR_SEGOVR();
9561 /****************************************************************************
9564 ****************************************************************************/
9565 static void x86emuOp_in_byte_AL_IMM(u8
X86EMU_UNUSED(op1
))
9570 DECODE_PRINTF("IN\t");
9571 port
= (u8
) fetch_byte_imm();
9572 DECODE_PRINTF2("%x,AL\n", port
);
9574 M
.x86
.R_AL
= (*sys_inb
)(port
);
9575 DECODE_CLEAR_SEGOVR();
9579 /****************************************************************************
9582 ****************************************************************************/
9583 static void x86emuOp_in_word_AX_IMM(u8
X86EMU_UNUSED(op1
))
9588 DECODE_PRINTF("IN\t");
9589 port
= (u8
) fetch_byte_imm();
9590 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
9591 DECODE_PRINTF2("EAX,%x\n", port
);
9593 DECODE_PRINTF2("AX,%x\n", port
);
9596 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
9597 M
.x86
.R_EAX
= (*sys_inl
)(port
);
9599 M
.x86
.R_AX
= (*sys_inw
)(port
);
9601 DECODE_CLEAR_SEGOVR();
9605 /****************************************************************************
9608 ****************************************************************************/
9609 static void x86emuOp_out_byte_IMM_AL(u8
X86EMU_UNUSED(op1
))
9614 DECODE_PRINTF("OUT\t");
9615 port
= (u8
) fetch_byte_imm();
9616 DECODE_PRINTF2("%x,AL\n", port
);
9618 (*sys_outb
)(port
, M
.x86
.R_AL
);
9619 DECODE_CLEAR_SEGOVR();
9623 /****************************************************************************
9626 ****************************************************************************/
9627 static void x86emuOp_out_word_IMM_AX(u8
X86EMU_UNUSED(op1
))
9632 DECODE_PRINTF("OUT\t");
9633 port
= (u8
) fetch_byte_imm();
9634 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
9635 DECODE_PRINTF2("%x,EAX\n", port
);
9637 DECODE_PRINTF2("%x,AX\n", port
);
9640 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
9641 (*sys_outl
)(port
, M
.x86
.R_EAX
);
9643 (*sys_outw
)(port
, M
.x86
.R_AX
);
9645 DECODE_CLEAR_SEGOVR();
9649 /****************************************************************************
9652 ****************************************************************************/
9653 static void x86emuOp_call_near_IMM(u8
X86EMU_UNUSED(op1
))
9658 DECODE_PRINTF("CALL\t");
9659 ip
= (s16
) fetch_word_imm();
9660 ip
+= (s16
) M
.x86
.R_IP
; /* CHECK SIGN */
9661 DECODE_PRINTF2("%04x\n", (u16
)ip
);
9662 CALL_TRACE(M
.x86
.saved_cs
, M
.x86
.saved_ip
, M
.x86
.R_CS
, ip
, "");
9664 push_word(M
.x86
.R_IP
);
9666 DECODE_CLEAR_SEGOVR();
9670 /****************************************************************************
9673 ****************************************************************************/
9674 static void x86emuOp_jump_near_IMM(u8
X86EMU_UNUSED(op1
))
9679 DECODE_PRINTF("JMP\t");
9680 ip
= (s16
)fetch_word_imm();
9681 ip
+= (s16
)M
.x86
.R_IP
;
9682 DECODE_PRINTF2("%04x\n", (u16
)ip
);
9684 M
.x86
.R_IP
= (u16
)ip
;
9685 DECODE_CLEAR_SEGOVR();
9689 /****************************************************************************
9692 ****************************************************************************/
9693 static void x86emuOp_jump_far_IMM(u8
X86EMU_UNUSED(op1
))
9698 DECODE_PRINTF("JMP\tFAR ");
9699 ip
= fetch_word_imm();
9700 cs
= fetch_word_imm();
9701 DECODE_PRINTF2("%04x:", cs
);
9702 DECODE_PRINTF2("%04x\n", ip
);
9706 DECODE_CLEAR_SEGOVR();
9710 /****************************************************************************
9713 ****************************************************************************/
9714 static void x86emuOp_jump_byte_IMM(u8
X86EMU_UNUSED(op1
))
9720 DECODE_PRINTF("JMP\t");
9721 offset
= (s8
)fetch_byte_imm();
9722 target
= (u16
)(M
.x86
.R_IP
+ offset
);
9723 DECODE_PRINTF2("%x\n", target
);
9725 M
.x86
.R_IP
= target
;
9726 DECODE_CLEAR_SEGOVR();
9730 /****************************************************************************
9733 ****************************************************************************/
9734 static void x86emuOp_in_byte_AL_DX(u8
X86EMU_UNUSED(op1
))
9737 DECODE_PRINTF("IN\tAL,DX\n");
9739 M
.x86
.R_AL
= (*sys_inb
)(M
.x86
.R_DX
);
9740 DECODE_CLEAR_SEGOVR();
9744 /****************************************************************************
9747 ****************************************************************************/
9748 static void x86emuOp_in_word_AX_DX(u8
X86EMU_UNUSED(op1
))
9751 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
9752 DECODE_PRINTF("IN\tEAX,DX\n");
9754 DECODE_PRINTF("IN\tAX,DX\n");
9757 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
9758 M
.x86
.R_EAX
= (*sys_inl
)(M
.x86
.R_DX
);
9760 M
.x86
.R_AX
= (*sys_inw
)(M
.x86
.R_DX
);
9762 DECODE_CLEAR_SEGOVR();
9766 /****************************************************************************
9769 ****************************************************************************/
9770 static void x86emuOp_out_byte_DX_AL(u8
X86EMU_UNUSED(op1
))
9773 DECODE_PRINTF("OUT\tDX,AL\n");
9775 (*sys_outb
)(M
.x86
.R_DX
, M
.x86
.R_AL
);
9776 DECODE_CLEAR_SEGOVR();
9780 /****************************************************************************
9783 ****************************************************************************/
9784 static void x86emuOp_out_word_DX_AX(u8
X86EMU_UNUSED(op1
))
9787 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
9788 DECODE_PRINTF("OUT\tDX,EAX\n");
9790 DECODE_PRINTF("OUT\tDX,AX\n");
9793 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
9794 (*sys_outl
)(M
.x86
.R_DX
, M
.x86
.R_EAX
);
9796 (*sys_outw
)(M
.x86
.R_DX
, M
.x86
.R_AX
);
9798 DECODE_CLEAR_SEGOVR();
9802 /****************************************************************************
9805 ****************************************************************************/
9806 static void x86emuOp_lock(u8
X86EMU_UNUSED(op1
))
9809 DECODE_PRINTF("LOCK:\n");
9811 DECODE_CLEAR_SEGOVR();
9815 /*opcode 0xf1 ILLEGAL OPERATION */
9817 /****************************************************************************
9820 ****************************************************************************/
9821 static void x86emuOp_repne(u8
X86EMU_UNUSED(op1
))
9824 DECODE_PRINTF("REPNE\n");
9826 M
.x86
.mode
|= SYSMODE_PREFIX_REPNE
;
9827 DECODE_CLEAR_SEGOVR();
9831 /****************************************************************************
9834 ****************************************************************************/
9835 static void x86emuOp_repe(u8
X86EMU_UNUSED(op1
))
9838 DECODE_PRINTF("REPE\n");
9840 M
.x86
.mode
|= SYSMODE_PREFIX_REPE
;
9841 DECODE_CLEAR_SEGOVR();
9845 /****************************************************************************
9848 ****************************************************************************/
9849 static void x86emuOp_halt(u8
X86EMU_UNUSED(op1
))
9852 DECODE_PRINTF("HALT\n");
9855 DECODE_CLEAR_SEGOVR();
9859 /****************************************************************************
9862 ****************************************************************************/
9863 static void x86emuOp_cmc(u8
X86EMU_UNUSED(op1
))
9865 /* complement the carry flag. */
9867 DECODE_PRINTF("CMC\n");
9870 DECODE_CLEAR_SEGOVR();
9874 /****************************************************************************
9877 ****************************************************************************/
9878 static void x86emuOp_opcF6_byte_RM(u8
X86EMU_UNUSED(op1
))
9885 /* long, drawn out code follows. Double switch for a total
9888 FETCH_DECODE_MODRM(mod
, rh
, rl
);
9890 case 0: /* mod=00 */
9892 case 0: /* test byte imm */
9893 DECODE_PRINTF("TEST\tBYTE PTR ");
9894 destoffset
= decode_rm00_address(rl
);
9896 srcval
= fetch_byte_imm();
9897 DECODE_PRINTF2("%02x\n", srcval
);
9898 destval
= fetch_data_byte(destoffset
);
9900 test_byte(destval
, srcval
);
9903 DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F6\n");
9907 DECODE_PRINTF("NOT\tBYTE PTR ");
9908 destoffset
= decode_rm00_address(rl
);
9909 DECODE_PRINTF("\n");
9910 destval
= fetch_data_byte(destoffset
);
9912 destval
= not_byte(destval
);
9913 store_data_byte(destoffset
, destval
);
9916 DECODE_PRINTF("NEG\tBYTE PTR ");
9917 destoffset
= decode_rm00_address(rl
);
9918 DECODE_PRINTF("\n");
9919 destval
= fetch_data_byte(destoffset
);
9921 destval
= neg_byte(destval
);
9922 store_data_byte(destoffset
, destval
);
9925 DECODE_PRINTF("MUL\tBYTE PTR ");
9926 destoffset
= decode_rm00_address(rl
);
9927 DECODE_PRINTF("\n");
9928 destval
= fetch_data_byte(destoffset
);
9933 DECODE_PRINTF("IMUL\tBYTE PTR ");
9934 destoffset
= decode_rm00_address(rl
);
9935 DECODE_PRINTF("\n");
9936 destval
= fetch_data_byte(destoffset
);
9941 DECODE_PRINTF("DIV\tBYTE PTR ");
9942 destoffset
= decode_rm00_address(rl
);
9943 DECODE_PRINTF("\n");
9944 destval
= fetch_data_byte(destoffset
);
9949 DECODE_PRINTF("IDIV\tBYTE PTR ");
9950 destoffset
= decode_rm00_address(rl
);
9951 DECODE_PRINTF("\n");
9952 destval
= fetch_data_byte(destoffset
);
9957 break; /* end mod==00 */
9958 case 1: /* mod=01 */
9960 case 0: /* test byte imm */
9961 DECODE_PRINTF("TEST\tBYTE PTR ");
9962 destoffset
= decode_rm01_address(rl
);
9964 srcval
= fetch_byte_imm();
9965 DECODE_PRINTF2("%02x\n", srcval
);
9966 destval
= fetch_data_byte(destoffset
);
9968 test_byte(destval
, srcval
);
9971 DECODE_PRINTF("ILLEGAL OP MOD=01 RH=01 OP=F6\n");
9975 DECODE_PRINTF("NOT\tBYTE PTR ");
9976 destoffset
= decode_rm01_address(rl
);
9977 DECODE_PRINTF("\n");
9978 destval
= fetch_data_byte(destoffset
);
9980 destval
= not_byte(destval
);
9981 store_data_byte(destoffset
, destval
);
9984 DECODE_PRINTF("NEG\tBYTE PTR ");
9985 destoffset
= decode_rm01_address(rl
);
9986 DECODE_PRINTF("\n");
9987 destval
= fetch_data_byte(destoffset
);
9989 destval
= neg_byte(destval
);
9990 store_data_byte(destoffset
, destval
);
9993 DECODE_PRINTF("MUL\tBYTE PTR ");
9994 destoffset
= decode_rm01_address(rl
);
9995 DECODE_PRINTF("\n");
9996 destval
= fetch_data_byte(destoffset
);
10001 DECODE_PRINTF("IMUL\tBYTE PTR ");
10002 destoffset
= decode_rm01_address(rl
);
10003 DECODE_PRINTF("\n");
10004 destval
= fetch_data_byte(destoffset
);
10006 imul_byte(destval
);
10009 DECODE_PRINTF("DIV\tBYTE PTR ");
10010 destoffset
= decode_rm01_address(rl
);
10011 DECODE_PRINTF("\n");
10012 destval
= fetch_data_byte(destoffset
);
10017 DECODE_PRINTF("IDIV\tBYTE PTR ");
10018 destoffset
= decode_rm01_address(rl
);
10019 DECODE_PRINTF("\n");
10020 destval
= fetch_data_byte(destoffset
);
10022 idiv_byte(destval
);
10025 break; /* end mod==01 */
10026 case 2: /* mod=10 */
10028 case 0: /* test byte imm */
10029 DECODE_PRINTF("TEST\tBYTE PTR ");
10030 destoffset
= decode_rm10_address(rl
);
10031 DECODE_PRINTF(",");
10032 srcval
= fetch_byte_imm();
10033 DECODE_PRINTF2("%02x\n", srcval
);
10034 destval
= fetch_data_byte(destoffset
);
10036 test_byte(destval
, srcval
);
10039 DECODE_PRINTF("ILLEGAL OP MOD=10 RH=01 OP=F6\n");
10043 DECODE_PRINTF("NOT\tBYTE PTR ");
10044 destoffset
= decode_rm10_address(rl
);
10045 DECODE_PRINTF("\n");
10046 destval
= fetch_data_byte(destoffset
);
10048 destval
= not_byte(destval
);
10049 store_data_byte(destoffset
, destval
);
10052 DECODE_PRINTF("NEG\tBYTE PTR ");
10053 destoffset
= decode_rm10_address(rl
);
10054 DECODE_PRINTF("\n");
10055 destval
= fetch_data_byte(destoffset
);
10057 destval
= neg_byte(destval
);
10058 store_data_byte(destoffset
, destval
);
10061 DECODE_PRINTF("MUL\tBYTE PTR ");
10062 destoffset
= decode_rm10_address(rl
);
10063 DECODE_PRINTF("\n");
10064 destval
= fetch_data_byte(destoffset
);
10069 DECODE_PRINTF("IMUL\tBYTE PTR ");
10070 destoffset
= decode_rm10_address(rl
);
10071 DECODE_PRINTF("\n");
10072 destval
= fetch_data_byte(destoffset
);
10074 imul_byte(destval
);
10077 DECODE_PRINTF("DIV\tBYTE PTR ");
10078 destoffset
= decode_rm10_address(rl
);
10079 DECODE_PRINTF("\n");
10080 destval
= fetch_data_byte(destoffset
);
10085 DECODE_PRINTF("IDIV\tBYTE PTR ");
10086 destoffset
= decode_rm10_address(rl
);
10087 DECODE_PRINTF("\n");
10088 destval
= fetch_data_byte(destoffset
);
10090 idiv_byte(destval
);
10093 break; /* end mod==10 */
10094 case 3: /* mod=11 */
10096 case 0: /* test byte imm */
10097 DECODE_PRINTF("TEST\t");
10098 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
10099 DECODE_PRINTF(",");
10100 srcval
= fetch_byte_imm();
10101 DECODE_PRINTF2("%02x\n", srcval
);
10103 test_byte(*destreg
, srcval
);
10106 DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F6\n");
10110 DECODE_PRINTF("NOT\t");
10111 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
10112 DECODE_PRINTF("\n");
10114 *destreg
= not_byte(*destreg
);
10117 DECODE_PRINTF("NEG\t");
10118 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
10119 DECODE_PRINTF("\n");
10121 *destreg
= neg_byte(*destreg
);
10124 DECODE_PRINTF("MUL\t");
10125 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
10126 DECODE_PRINTF("\n");
10128 mul_byte(*destreg
); /*!!! */
10131 DECODE_PRINTF("IMUL\t");
10132 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
10133 DECODE_PRINTF("\n");
10135 imul_byte(*destreg
);
10138 DECODE_PRINTF("DIV\t");
10139 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
10140 DECODE_PRINTF("\n");
10142 div_byte(*destreg
);
10145 DECODE_PRINTF("IDIV\t");
10146 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
10147 DECODE_PRINTF("\n");
10149 idiv_byte(*destreg
);
10152 break; /* end mod==11 */
10154 DECODE_CLEAR_SEGOVR();
10158 /****************************************************************************
10160 Handles opcode 0xf7
10161 ****************************************************************************/
10162 static void x86emuOp_opcF7_word_RM(u8
X86EMU_UNUSED(op1
))
10167 /* long, drawn out code follows. Double switch for a total
10170 FETCH_DECODE_MODRM(mod
, rh
, rl
);
10172 case 0: /* mod=00 */
10174 case 0: /* test word imm */
10175 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10176 u32 destval
,srcval
;
10178 DECODE_PRINTF("TEST\tDWORD PTR ");
10179 destoffset
= decode_rm00_address(rl
);
10180 DECODE_PRINTF(",");
10181 srcval
= fetch_long_imm();
10182 DECODE_PRINTF2("%x\n", srcval
);
10183 destval
= fetch_data_long(destoffset
);
10185 test_long(destval
, srcval
);
10187 u16 destval
,srcval
;
10189 DECODE_PRINTF("TEST\tWORD PTR ");
10190 destoffset
= decode_rm00_address(rl
);
10191 DECODE_PRINTF(",");
10192 srcval
= fetch_word_imm();
10193 DECODE_PRINTF2("%x\n", srcval
);
10194 destval
= fetch_data_word(destoffset
);
10196 test_word(destval
, srcval
);
10200 DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F7\n");
10204 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10207 DECODE_PRINTF("NOT\tDWORD PTR ");
10208 destoffset
= decode_rm00_address(rl
);
10209 DECODE_PRINTF("\n");
10210 destval
= fetch_data_long(destoffset
);
10212 destval
= not_long(destval
);
10213 store_data_long(destoffset
, destval
);
10217 DECODE_PRINTF("NOT\tWORD PTR ");
10218 destoffset
= decode_rm00_address(rl
);
10219 DECODE_PRINTF("\n");
10220 destval
= fetch_data_word(destoffset
);
10222 destval
= not_word(destval
);
10223 store_data_word(destoffset
, destval
);
10227 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10230 DECODE_PRINTF("NEG\tDWORD PTR ");
10231 destoffset
= decode_rm00_address(rl
);
10232 DECODE_PRINTF("\n");
10233 destval
= fetch_data_long(destoffset
);
10235 destval
= neg_long(destval
);
10236 store_data_long(destoffset
, destval
);
10240 DECODE_PRINTF("NEG\tWORD PTR ");
10241 destoffset
= decode_rm00_address(rl
);
10242 DECODE_PRINTF("\n");
10243 destval
= fetch_data_word(destoffset
);
10245 destval
= neg_word(destval
);
10246 store_data_word(destoffset
, destval
);
10250 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10253 DECODE_PRINTF("MUL\tDWORD PTR ");
10254 destoffset
= decode_rm00_address(rl
);
10255 DECODE_PRINTF("\n");
10256 destval
= fetch_data_long(destoffset
);
10262 DECODE_PRINTF("MUL\tWORD PTR ");
10263 destoffset
= decode_rm00_address(rl
);
10264 DECODE_PRINTF("\n");
10265 destval
= fetch_data_word(destoffset
);
10271 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10274 DECODE_PRINTF("IMUL\tDWORD PTR ");
10275 destoffset
= decode_rm00_address(rl
);
10276 DECODE_PRINTF("\n");
10277 destval
= fetch_data_long(destoffset
);
10279 imul_long(destval
);
10283 DECODE_PRINTF("IMUL\tWORD PTR ");
10284 destoffset
= decode_rm00_address(rl
);
10285 DECODE_PRINTF("\n");
10286 destval
= fetch_data_word(destoffset
);
10288 imul_word(destval
);
10292 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10295 DECODE_PRINTF("DIV\tDWORD PTR ");
10296 destoffset
= decode_rm00_address(rl
);
10297 DECODE_PRINTF("\n");
10298 destval
= fetch_data_long(destoffset
);
10304 DECODE_PRINTF("DIV\tWORD PTR ");
10305 destoffset
= decode_rm00_address(rl
);
10306 DECODE_PRINTF("\n");
10307 destval
= fetch_data_word(destoffset
);
10313 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10316 DECODE_PRINTF("IDIV\tDWORD PTR ");
10317 destoffset
= decode_rm00_address(rl
);
10318 DECODE_PRINTF("\n");
10319 destval
= fetch_data_long(destoffset
);
10321 idiv_long(destval
);
10325 DECODE_PRINTF("IDIV\tWORD PTR ");
10326 destoffset
= decode_rm00_address(rl
);
10327 DECODE_PRINTF("\n");
10328 destval
= fetch_data_word(destoffset
);
10330 idiv_word(destval
);
10334 break; /* end mod==00 */
10335 case 1: /* mod=01 */
10337 case 0: /* test word imm */
10338 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10339 u32 destval
,srcval
;
10341 DECODE_PRINTF("TEST\tDWORD PTR ");
10342 destoffset
= decode_rm01_address(rl
);
10343 DECODE_PRINTF(",");
10344 srcval
= fetch_long_imm();
10345 DECODE_PRINTF2("%x\n", srcval
);
10346 destval
= fetch_data_long(destoffset
);
10348 test_long(destval
, srcval
);
10350 u16 destval
,srcval
;
10352 DECODE_PRINTF("TEST\tWORD PTR ");
10353 destoffset
= decode_rm01_address(rl
);
10354 DECODE_PRINTF(",");
10355 srcval
= fetch_word_imm();
10356 DECODE_PRINTF2("%x\n", srcval
);
10357 destval
= fetch_data_word(destoffset
);
10359 test_word(destval
, srcval
);
10363 DECODE_PRINTF("ILLEGAL OP MOD=01 RH=01 OP=F6\n");
10367 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10370 DECODE_PRINTF("NOT\tDWORD PTR ");
10371 destoffset
= decode_rm01_address(rl
);
10372 DECODE_PRINTF("\n");
10373 destval
= fetch_data_long(destoffset
);
10375 destval
= not_long(destval
);
10376 store_data_long(destoffset
, destval
);
10380 DECODE_PRINTF("NOT\tWORD PTR ");
10381 destoffset
= decode_rm01_address(rl
);
10382 DECODE_PRINTF("\n");
10383 destval
= fetch_data_word(destoffset
);
10385 destval
= not_word(destval
);
10386 store_data_word(destoffset
, destval
);
10390 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10393 DECODE_PRINTF("NEG\tDWORD PTR ");
10394 destoffset
= decode_rm01_address(rl
);
10395 DECODE_PRINTF("\n");
10396 destval
= fetch_data_long(destoffset
);
10398 destval
= neg_long(destval
);
10399 store_data_long(destoffset
, destval
);
10403 DECODE_PRINTF("NEG\tWORD PTR ");
10404 destoffset
= decode_rm01_address(rl
);
10405 DECODE_PRINTF("\n");
10406 destval
= fetch_data_word(destoffset
);
10408 destval
= neg_word(destval
);
10409 store_data_word(destoffset
, destval
);
10413 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10416 DECODE_PRINTF("MUL\tDWORD PTR ");
10417 destoffset
= decode_rm01_address(rl
);
10418 DECODE_PRINTF("\n");
10419 destval
= fetch_data_long(destoffset
);
10425 DECODE_PRINTF("MUL\tWORD PTR ");
10426 destoffset
= decode_rm01_address(rl
);
10427 DECODE_PRINTF("\n");
10428 destval
= fetch_data_word(destoffset
);
10434 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10437 DECODE_PRINTF("IMUL\tDWORD PTR ");
10438 destoffset
= decode_rm01_address(rl
);
10439 DECODE_PRINTF("\n");
10440 destval
= fetch_data_long(destoffset
);
10442 imul_long(destval
);
10446 DECODE_PRINTF("IMUL\tWORD PTR ");
10447 destoffset
= decode_rm01_address(rl
);
10448 DECODE_PRINTF("\n");
10449 destval
= fetch_data_word(destoffset
);
10451 imul_word(destval
);
10455 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10458 DECODE_PRINTF("DIV\tDWORD PTR ");
10459 destoffset
= decode_rm01_address(rl
);
10460 DECODE_PRINTF("\n");
10461 destval
= fetch_data_long(destoffset
);
10467 DECODE_PRINTF("DIV\tWORD PTR ");
10468 destoffset
= decode_rm01_address(rl
);
10469 DECODE_PRINTF("\n");
10470 destval
= fetch_data_word(destoffset
);
10476 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10479 DECODE_PRINTF("IDIV\tDWORD PTR ");
10480 destoffset
= decode_rm01_address(rl
);
10481 DECODE_PRINTF("\n");
10482 destval
= fetch_data_long(destoffset
);
10484 idiv_long(destval
);
10488 DECODE_PRINTF("IDIV\tWORD PTR ");
10489 destoffset
= decode_rm01_address(rl
);
10490 DECODE_PRINTF("\n");
10491 destval
= fetch_data_word(destoffset
);
10493 idiv_word(destval
);
10497 break; /* end mod==01 */
10498 case 2: /* mod=10 */
10500 case 0: /* test word imm */
10501 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10502 u32 destval
,srcval
;
10504 DECODE_PRINTF("TEST\tDWORD PTR ");
10505 destoffset
= decode_rm10_address(rl
);
10506 DECODE_PRINTF(",");
10507 srcval
= fetch_long_imm();
10508 DECODE_PRINTF2("%x\n", srcval
);
10509 destval
= fetch_data_long(destoffset
);
10511 test_long(destval
, srcval
);
10513 u16 destval
,srcval
;
10515 DECODE_PRINTF("TEST\tWORD PTR ");
10516 destoffset
= decode_rm10_address(rl
);
10517 DECODE_PRINTF(",");
10518 srcval
= fetch_word_imm();
10519 DECODE_PRINTF2("%x\n", srcval
);
10520 destval
= fetch_data_word(destoffset
);
10522 test_word(destval
, srcval
);
10526 DECODE_PRINTF("ILLEGAL OP MOD=10 RH=01 OP=F6\n");
10530 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10533 DECODE_PRINTF("NOT\tDWORD PTR ");
10534 destoffset
= decode_rm10_address(rl
);
10535 DECODE_PRINTF("\n");
10536 destval
= fetch_data_long(destoffset
);
10538 destval
= not_long(destval
);
10539 store_data_long(destoffset
, destval
);
10543 DECODE_PRINTF("NOT\tWORD PTR ");
10544 destoffset
= decode_rm10_address(rl
);
10545 DECODE_PRINTF("\n");
10546 destval
= fetch_data_word(destoffset
);
10548 destval
= not_word(destval
);
10549 store_data_word(destoffset
, destval
);
10553 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10556 DECODE_PRINTF("NEG\tDWORD PTR ");
10557 destoffset
= decode_rm10_address(rl
);
10558 DECODE_PRINTF("\n");
10559 destval
= fetch_data_long(destoffset
);
10561 destval
= neg_long(destval
);
10562 store_data_long(destoffset
, destval
);
10566 DECODE_PRINTF("NEG\tWORD PTR ");
10567 destoffset
= decode_rm10_address(rl
);
10568 DECODE_PRINTF("\n");
10569 destval
= fetch_data_word(destoffset
);
10571 destval
= neg_word(destval
);
10572 store_data_word(destoffset
, destval
);
10576 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10579 DECODE_PRINTF("MUL\tDWORD PTR ");
10580 destoffset
= decode_rm10_address(rl
);
10581 DECODE_PRINTF("\n");
10582 destval
= fetch_data_long(destoffset
);
10588 DECODE_PRINTF("MUL\tWORD PTR ");
10589 destoffset
= decode_rm10_address(rl
);
10590 DECODE_PRINTF("\n");
10591 destval
= fetch_data_word(destoffset
);
10597 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10600 DECODE_PRINTF("IMUL\tDWORD PTR ");
10601 destoffset
= decode_rm10_address(rl
);
10602 DECODE_PRINTF("\n");
10603 destval
= fetch_data_long(destoffset
);
10605 imul_long(destval
);
10609 DECODE_PRINTF("IMUL\tWORD PTR ");
10610 destoffset
= decode_rm10_address(rl
);
10611 DECODE_PRINTF("\n");
10612 destval
= fetch_data_word(destoffset
);
10614 imul_word(destval
);
10618 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10621 DECODE_PRINTF("DIV\tDWORD PTR ");
10622 destoffset
= decode_rm10_address(rl
);
10623 DECODE_PRINTF("\n");
10624 destval
= fetch_data_long(destoffset
);
10630 DECODE_PRINTF("DIV\tWORD PTR ");
10631 destoffset
= decode_rm10_address(rl
);
10632 DECODE_PRINTF("\n");
10633 destval
= fetch_data_word(destoffset
);
10639 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10642 DECODE_PRINTF("IDIV\tDWORD PTR ");
10643 destoffset
= decode_rm10_address(rl
);
10644 DECODE_PRINTF("\n");
10645 destval
= fetch_data_long(destoffset
);
10647 idiv_long(destval
);
10651 DECODE_PRINTF("IDIV\tWORD PTR ");
10652 destoffset
= decode_rm10_address(rl
);
10653 DECODE_PRINTF("\n");
10654 destval
= fetch_data_word(destoffset
);
10656 idiv_word(destval
);
10660 break; /* end mod==10 */
10661 case 3: /* mod=11 */
10663 case 0: /* test word imm */
10664 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10668 DECODE_PRINTF("TEST\t");
10669 destreg
= DECODE_RM_LONG_REGISTER(rl
);
10670 DECODE_PRINTF(",");
10671 srcval
= fetch_long_imm();
10672 DECODE_PRINTF2("%x\n", srcval
);
10674 test_long(*destreg
, srcval
);
10679 DECODE_PRINTF("TEST\t");
10680 destreg
= DECODE_RM_WORD_REGISTER(rl
);
10681 DECODE_PRINTF(",");
10682 srcval
= fetch_word_imm();
10683 DECODE_PRINTF2("%x\n", srcval
);
10685 test_word(*destreg
, srcval
);
10689 DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F6\n");
10693 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10696 DECODE_PRINTF("NOT\t");
10697 destreg
= DECODE_RM_LONG_REGISTER(rl
);
10698 DECODE_PRINTF("\n");
10700 *destreg
= not_long(*destreg
);
10704 DECODE_PRINTF("NOT\t");
10705 destreg
= DECODE_RM_WORD_REGISTER(rl
);
10706 DECODE_PRINTF("\n");
10708 *destreg
= not_word(*destreg
);
10712 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10715 DECODE_PRINTF("NEG\t");
10716 destreg
= DECODE_RM_LONG_REGISTER(rl
);
10717 DECODE_PRINTF("\n");
10719 *destreg
= neg_long(*destreg
);
10723 DECODE_PRINTF("NEG\t");
10724 destreg
= DECODE_RM_WORD_REGISTER(rl
);
10725 DECODE_PRINTF("\n");
10727 *destreg
= neg_word(*destreg
);
10731 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10734 DECODE_PRINTF("MUL\t");
10735 destreg
= DECODE_RM_LONG_REGISTER(rl
);
10736 DECODE_PRINTF("\n");
10738 mul_long(*destreg
); /*!!! */
10742 DECODE_PRINTF("MUL\t");
10743 destreg
= DECODE_RM_WORD_REGISTER(rl
);
10744 DECODE_PRINTF("\n");
10746 mul_word(*destreg
); /*!!! */
10750 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10753 DECODE_PRINTF("IMUL\t");
10754 destreg
= DECODE_RM_LONG_REGISTER(rl
);
10755 DECODE_PRINTF("\n");
10757 imul_long(*destreg
);
10761 DECODE_PRINTF("IMUL\t");
10762 destreg
= DECODE_RM_WORD_REGISTER(rl
);
10763 DECODE_PRINTF("\n");
10765 imul_word(*destreg
);
10769 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10772 DECODE_PRINTF("DIV\t");
10773 destreg
= DECODE_RM_LONG_REGISTER(rl
);
10774 DECODE_PRINTF("\n");
10776 div_long(*destreg
);
10780 DECODE_PRINTF("DIV\t");
10781 destreg
= DECODE_RM_WORD_REGISTER(rl
);
10782 DECODE_PRINTF("\n");
10784 div_word(*destreg
);
10788 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
10791 DECODE_PRINTF("IDIV\t");
10792 destreg
= DECODE_RM_LONG_REGISTER(rl
);
10793 DECODE_PRINTF("\n");
10795 idiv_long(*destreg
);
10799 DECODE_PRINTF("IDIV\t");
10800 destreg
= DECODE_RM_WORD_REGISTER(rl
);
10801 DECODE_PRINTF("\n");
10803 idiv_word(*destreg
);
10807 break; /* end mod==11 */
10809 DECODE_CLEAR_SEGOVR();
10813 /****************************************************************************
10815 Handles opcode 0xf8
10816 ****************************************************************************/
10817 static void x86emuOp_clc(u8
X86EMU_UNUSED(op1
))
10819 /* clear the carry flag. */
10821 DECODE_PRINTF("CLC\n");
10824 DECODE_CLEAR_SEGOVR();
10828 /****************************************************************************
10830 Handles opcode 0xf9
10831 ****************************************************************************/
10832 static void x86emuOp_stc(u8
X86EMU_UNUSED(op1
))
10834 /* set the carry flag. */
10836 DECODE_PRINTF("STC\n");
10839 DECODE_CLEAR_SEGOVR();
10843 /****************************************************************************
10845 Handles opcode 0xfa
10846 ****************************************************************************/
10847 static void x86emuOp_cli(u8
X86EMU_UNUSED(op1
))
10849 /* clear interrupts. */
10851 DECODE_PRINTF("CLI\n");
10854 DECODE_CLEAR_SEGOVR();
10858 /****************************************************************************
10860 Handles opcode 0xfb
10861 ****************************************************************************/
10862 static void x86emuOp_sti(u8
X86EMU_UNUSED(op1
))
10864 /* enable interrupts. */
10866 DECODE_PRINTF("STI\n");
10869 DECODE_CLEAR_SEGOVR();
10873 /****************************************************************************
10875 Handles opcode 0xfc
10876 ****************************************************************************/
10877 static void x86emuOp_cld(u8
X86EMU_UNUSED(op1
))
10879 /* clear interrupts. */
10881 DECODE_PRINTF("CLD\n");
10884 DECODE_CLEAR_SEGOVR();
10888 /****************************************************************************
10890 Handles opcode 0xfd
10891 ****************************************************************************/
10892 static void x86emuOp_std(u8
X86EMU_UNUSED(op1
))
10894 /* clear interrupts. */
10896 DECODE_PRINTF("STD\n");
10899 DECODE_CLEAR_SEGOVR();
10903 /****************************************************************************
10905 Handles opcode 0xfe
10906 ****************************************************************************/
10907 static void x86emuOp_opcFE_byte_RM(u8
X86EMU_UNUSED(op1
))
10914 /* Yet another special case instruction. */
10916 FETCH_DECODE_MODRM(mod
, rh
, rl
);
10918 if (DEBUG_DECODE()) {
10919 /* XXX DECODE_PRINTF may be changed to something more
10920 general, so that it is important to leave the strings
10921 in the same format, even though the result is that the
10922 above test is done twice. */
10926 DECODE_PRINTF("INC\t");
10929 DECODE_PRINTF("DEC\t");
10937 DECODE_PRINTF2("ILLEGAL OP MAJOR OP 0xFE MINOR OP %x \n", mod
);
10945 DECODE_PRINTF("BYTE PTR ");
10946 destoffset
= decode_rm00_address(rl
);
10947 DECODE_PRINTF("\n");
10949 case 0: /* inc word ptr ... */
10950 destval
= fetch_data_byte(destoffset
);
10952 destval
= inc_byte(destval
);
10953 store_data_byte(destoffset
, destval
);
10955 case 1: /* dec word ptr ... */
10956 destval
= fetch_data_byte(destoffset
);
10958 destval
= dec_byte(destval
);
10959 store_data_byte(destoffset
, destval
);
10964 DECODE_PRINTF("BYTE PTR ");
10965 destoffset
= decode_rm01_address(rl
);
10966 DECODE_PRINTF("\n");
10969 destval
= fetch_data_byte(destoffset
);
10971 destval
= inc_byte(destval
);
10972 store_data_byte(destoffset
, destval
);
10975 destval
= fetch_data_byte(destoffset
);
10977 destval
= dec_byte(destval
);
10978 store_data_byte(destoffset
, destval
);
10983 DECODE_PRINTF("BYTE PTR ");
10984 destoffset
= decode_rm10_address(rl
);
10985 DECODE_PRINTF("\n");
10988 destval
= fetch_data_byte(destoffset
);
10990 destval
= inc_byte(destval
);
10991 store_data_byte(destoffset
, destval
);
10994 destval
= fetch_data_byte(destoffset
);
10996 destval
= dec_byte(destval
);
10997 store_data_byte(destoffset
, destval
);
11002 destreg
= DECODE_RM_BYTE_REGISTER(rl
);
11003 DECODE_PRINTF("\n");
11007 *destreg
= inc_byte(*destreg
);
11011 *destreg
= dec_byte(*destreg
);
11016 DECODE_CLEAR_SEGOVR();
11020 /****************************************************************************
11022 Handles opcode 0xff
11023 ****************************************************************************/
11024 static void x86emuOp_opcFF_word_RM(u8
X86EMU_UNUSED(op1
))
11027 uint destoffset
= 0;
11029 u16 destval
,destval2
;
11031 /* Yet another special case instruction. */
11033 FETCH_DECODE_MODRM(mod
, rh
, rl
);
11035 if (DEBUG_DECODE()) {
11036 /* XXX DECODE_PRINTF may be changed to something more
11037 general, so that it is important to leave the strings
11038 in the same format, even though the result is that the
11039 above test is done twice. */
11043 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
11044 DECODE_PRINTF("INC\tDWORD PTR ");
11046 DECODE_PRINTF("INC\tWORD PTR ");
11050 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
11051 DECODE_PRINTF("DEC\tDWORD PTR ");
11053 DECODE_PRINTF("DEC\tWORD PTR ");
11057 DECODE_PRINTF("CALL\t");
11060 DECODE_PRINTF("CALL\tFAR ");
11063 DECODE_PRINTF("JMP\t");
11066 DECODE_PRINTF("JMP\tFAR ");
11069 DECODE_PRINTF("PUSH\t");
11072 DECODE_PRINTF("ILLEGAL DECODING OF OPCODE FF\t");
11080 destoffset
= decode_rm00_address(rl
);
11081 DECODE_PRINTF("\n");
11083 case 0: /* inc word ptr ... */
11084 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
11087 destval
= fetch_data_long(destoffset
);
11089 destval
= inc_long(destval
);
11090 store_data_long(destoffset
, destval
);
11094 destval
= fetch_data_word(destoffset
);
11096 destval
= inc_word(destval
);
11097 store_data_word(destoffset
, destval
);
11100 case 1: /* dec word ptr ... */
11101 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
11104 destval
= fetch_data_long(destoffset
);
11106 destval
= dec_long(destval
);
11107 store_data_long(destoffset
, destval
);
11111 destval
= fetch_data_word(destoffset
);
11113 destval
= dec_word(destval
);
11114 store_data_word(destoffset
, destval
);
11117 case 2: /* call word ptr ... */
11118 destval
= fetch_data_word(destoffset
);
11120 push_word(M
.x86
.R_IP
);
11121 M
.x86
.R_IP
= destval
;
11123 case 3: /* call far ptr ... */
11124 destval
= fetch_data_word(destoffset
);
11125 destval2
= fetch_data_word(destoffset
+ 2);
11127 push_word(M
.x86
.R_CS
);
11128 M
.x86
.R_CS
= destval2
;
11129 push_word(M
.x86
.R_IP
);
11130 M
.x86
.R_IP
= destval
;
11132 case 4: /* jmp word ptr ... */
11133 destval
= fetch_data_word(destoffset
);
11135 M
.x86
.R_IP
= destval
;
11137 case 5: /* jmp far ptr ... */
11138 destval
= fetch_data_word(destoffset
);
11139 destval2
= fetch_data_word(destoffset
+ 2);
11141 M
.x86
.R_IP
= destval
;
11142 M
.x86
.R_CS
= destval2
;
11144 case 6: /* push word ptr ... */
11145 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
11148 destval
= fetch_data_long(destoffset
);
11150 push_long(destval
);
11154 destval
= fetch_data_word(destoffset
);
11156 push_word(destval
);
11162 destoffset
= decode_rm01_address(rl
);
11163 DECODE_PRINTF("\n");
11166 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
11169 destval
= fetch_data_long(destoffset
);
11171 destval
= inc_long(destval
);
11172 store_data_long(destoffset
, destval
);
11176 destval
= fetch_data_word(destoffset
);
11178 destval
= inc_word(destval
);
11179 store_data_word(destoffset
, destval
);
11183 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
11186 destval
= fetch_data_long(destoffset
);
11188 destval
= dec_long(destval
);
11189 store_data_long(destoffset
, destval
);
11193 destval
= fetch_data_word(destoffset
);
11195 destval
= dec_word(destval
);
11196 store_data_word(destoffset
, destval
);
11199 case 2: /* call word ptr ... */
11200 destval
= fetch_data_word(destoffset
);
11202 push_word(M
.x86
.R_IP
);
11203 M
.x86
.R_IP
= destval
;
11205 case 3: /* call far ptr ... */
11206 destval
= fetch_data_word(destoffset
);
11207 destval2
= fetch_data_word(destoffset
+ 2);
11209 push_word(M
.x86
.R_CS
);
11210 M
.x86
.R_CS
= destval2
;
11211 push_word(M
.x86
.R_IP
);
11212 M
.x86
.R_IP
= destval
;
11214 case 4: /* jmp word ptr ... */
11215 destval
= fetch_data_word(destoffset
);
11217 M
.x86
.R_IP
= destval
;
11219 case 5: /* jmp far ptr ... */
11220 destval
= fetch_data_word(destoffset
);
11221 destval2
= fetch_data_word(destoffset
+ 2);
11223 M
.x86
.R_IP
= destval
;
11224 M
.x86
.R_CS
= destval2
;
11226 case 6: /* push word ptr ... */
11227 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
11230 destval
= fetch_data_long(destoffset
);
11232 push_long(destval
);
11236 destval
= fetch_data_word(destoffset
);
11238 push_word(destval
);
11244 destoffset
= decode_rm10_address(rl
);
11245 DECODE_PRINTF("\n");
11248 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
11251 destval
= fetch_data_long(destoffset
);
11253 destval
= inc_long(destval
);
11254 store_data_long(destoffset
, destval
);
11258 destval
= fetch_data_word(destoffset
);
11260 destval
= inc_word(destval
);
11261 store_data_word(destoffset
, destval
);
11265 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
11268 destval
= fetch_data_long(destoffset
);
11270 destval
= dec_long(destval
);
11271 store_data_long(destoffset
, destval
);
11275 destval
= fetch_data_word(destoffset
);
11277 destval
= dec_word(destval
);
11278 store_data_word(destoffset
, destval
);
11281 case 2: /* call word ptr ... */
11282 destval
= fetch_data_word(destoffset
);
11284 push_word(M
.x86
.R_IP
);
11285 M
.x86
.R_IP
= destval
;
11287 case 3: /* call far ptr ... */
11288 destval
= fetch_data_word(destoffset
);
11289 destval2
= fetch_data_word(destoffset
+ 2);
11291 push_word(M
.x86
.R_CS
);
11292 M
.x86
.R_CS
= destval2
;
11293 push_word(M
.x86
.R_IP
);
11294 M
.x86
.R_IP
= destval
;
11296 case 4: /* jmp word ptr ... */
11297 destval
= fetch_data_word(destoffset
);
11299 M
.x86
.R_IP
= destval
;
11301 case 5: /* jmp far ptr ... */
11302 destval
= fetch_data_word(destoffset
);
11303 destval2
= fetch_data_word(destoffset
+ 2);
11305 M
.x86
.R_IP
= destval
;
11306 M
.x86
.R_CS
= destval2
;
11308 case 6: /* push word ptr ... */
11309 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
11312 destval
= fetch_data_long(destoffset
);
11314 push_long(destval
);
11318 destval
= fetch_data_word(destoffset
);
11320 push_word(destval
);
11328 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
11331 destreg
= DECODE_RM_LONG_REGISTER(rl
);
11332 DECODE_PRINTF("\n");
11334 *destreg
= inc_long(*destreg
);
11338 destreg
= DECODE_RM_WORD_REGISTER(rl
);
11339 DECODE_PRINTF("\n");
11341 *destreg
= inc_word(*destreg
);
11345 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
11348 destreg
= DECODE_RM_LONG_REGISTER(rl
);
11349 DECODE_PRINTF("\n");
11351 *destreg
= dec_long(*destreg
);
11355 destreg
= DECODE_RM_WORD_REGISTER(rl
);
11356 DECODE_PRINTF("\n");
11358 *destreg
= dec_word(*destreg
);
11361 case 2: /* call word ptr ... */
11362 destreg
= DECODE_RM_WORD_REGISTER(rl
);
11363 DECODE_PRINTF("\n");
11365 push_word(M
.x86
.R_IP
);
11366 M
.x86
.R_IP
= *destreg
;
11368 case 3: /* jmp far ptr ... */
11369 DECODE_PRINTF("OPERATION UNDEFINED 0XFF \n");
11374 case 4: /* jmp ... */
11375 destreg
= DECODE_RM_WORD_REGISTER(rl
);
11376 DECODE_PRINTF("\n");
11378 M
.x86
.R_IP
= (u16
) (*destreg
);
11380 case 5: /* jmp far ptr ... */
11381 DECODE_PRINTF("OPERATION UNDEFINED 0XFF \n");
11386 if (M
.x86
.mode
& SYSMODE_PREFIX_DATA
) {
11389 destreg
= DECODE_RM_LONG_REGISTER(rl
);
11390 DECODE_PRINTF("\n");
11392 push_long(*destreg
);
11396 destreg
= DECODE_RM_WORD_REGISTER(rl
);
11397 DECODE_PRINTF("\n");
11399 push_word(*destreg
);
11405 DECODE_CLEAR_SEGOVR();
11409 /***************************************************************************
11410 * Single byte operation code table:
11411 **************************************************************************/
11412 void (*x86emu_optab
[256])(u8
) =
11414 /* 0x00 */ x86emuOp_add_byte_RM_R
,
11415 /* 0x01 */ x86emuOp_add_word_RM_R
,
11416 /* 0x02 */ x86emuOp_add_byte_R_RM
,
11417 /* 0x03 */ x86emuOp_add_word_R_RM
,
11418 /* 0x04 */ x86emuOp_add_byte_AL_IMM
,
11419 /* 0x05 */ x86emuOp_add_word_AX_IMM
,
11420 /* 0x06 */ x86emuOp_push_ES
,
11421 /* 0x07 */ x86emuOp_pop_ES
,
11423 /* 0x08 */ x86emuOp_or_byte_RM_R
,
11424 /* 0x09 */ x86emuOp_or_word_RM_R
,
11425 /* 0x0a */ x86emuOp_or_byte_R_RM
,
11426 /* 0x0b */ x86emuOp_or_word_R_RM
,
11427 /* 0x0c */ x86emuOp_or_byte_AL_IMM
,
11428 /* 0x0d */ x86emuOp_or_word_AX_IMM
,
11429 /* 0x0e */ x86emuOp_push_CS
,
11430 /* 0x0f */ x86emuOp_two_byte
,
11432 /* 0x10 */ x86emuOp_adc_byte_RM_R
,
11433 /* 0x11 */ x86emuOp_adc_word_RM_R
,
11434 /* 0x12 */ x86emuOp_adc_byte_R_RM
,
11435 /* 0x13 */ x86emuOp_adc_word_R_RM
,
11436 /* 0x14 */ x86emuOp_adc_byte_AL_IMM
,
11437 /* 0x15 */ x86emuOp_adc_word_AX_IMM
,
11438 /* 0x16 */ x86emuOp_push_SS
,
11439 /* 0x17 */ x86emuOp_pop_SS
,
11441 /* 0x18 */ x86emuOp_sbb_byte_RM_R
,
11442 /* 0x19 */ x86emuOp_sbb_word_RM_R
,
11443 /* 0x1a */ x86emuOp_sbb_byte_R_RM
,
11444 /* 0x1b */ x86emuOp_sbb_word_R_RM
,
11445 /* 0x1c */ x86emuOp_sbb_byte_AL_IMM
,
11446 /* 0x1d */ x86emuOp_sbb_word_AX_IMM
,
11447 /* 0x1e */ x86emuOp_push_DS
,
11448 /* 0x1f */ x86emuOp_pop_DS
,
11450 /* 0x20 */ x86emuOp_and_byte_RM_R
,
11451 /* 0x21 */ x86emuOp_and_word_RM_R
,
11452 /* 0x22 */ x86emuOp_and_byte_R_RM
,
11453 /* 0x23 */ x86emuOp_and_word_R_RM
,
11454 /* 0x24 */ x86emuOp_and_byte_AL_IMM
,
11455 /* 0x25 */ x86emuOp_and_word_AX_IMM
,
11456 /* 0x26 */ x86emuOp_segovr_ES
,
11457 /* 0x27 */ x86emuOp_daa
,
11459 /* 0x28 */ x86emuOp_sub_byte_RM_R
,
11460 /* 0x29 */ x86emuOp_sub_word_RM_R
,
11461 /* 0x2a */ x86emuOp_sub_byte_R_RM
,
11462 /* 0x2b */ x86emuOp_sub_word_R_RM
,
11463 /* 0x2c */ x86emuOp_sub_byte_AL_IMM
,
11464 /* 0x2d */ x86emuOp_sub_word_AX_IMM
,
11465 /* 0x2e */ x86emuOp_segovr_CS
,
11466 /* 0x2f */ x86emuOp_das
,
11468 /* 0x30 */ x86emuOp_xor_byte_RM_R
,
11469 /* 0x31 */ x86emuOp_xor_word_RM_R
,
11470 /* 0x32 */ x86emuOp_xor_byte_R_RM
,
11471 /* 0x33 */ x86emuOp_xor_word_R_RM
,
11472 /* 0x34 */ x86emuOp_xor_byte_AL_IMM
,
11473 /* 0x35 */ x86emuOp_xor_word_AX_IMM
,
11474 /* 0x36 */ x86emuOp_segovr_SS
,
11475 /* 0x37 */ x86emuOp_aaa
,
11477 /* 0x38 */ x86emuOp_cmp_byte_RM_R
,
11478 /* 0x39 */ x86emuOp_cmp_word_RM_R
,
11479 /* 0x3a */ x86emuOp_cmp_byte_R_RM
,
11480 /* 0x3b */ x86emuOp_cmp_word_R_RM
,
11481 /* 0x3c */ x86emuOp_cmp_byte_AL_IMM
,
11482 /* 0x3d */ x86emuOp_cmp_word_AX_IMM
,
11483 /* 0x3e */ x86emuOp_segovr_DS
,
11484 /* 0x3f */ x86emuOp_aas
,
11486 /* 0x40 */ x86emuOp_inc_AX
,
11487 /* 0x41 */ x86emuOp_inc_CX
,
11488 /* 0x42 */ x86emuOp_inc_DX
,
11489 /* 0x43 */ x86emuOp_inc_BX
,
11490 /* 0x44 */ x86emuOp_inc_SP
,
11491 /* 0x45 */ x86emuOp_inc_BP
,
11492 /* 0x46 */ x86emuOp_inc_SI
,
11493 /* 0x47 */ x86emuOp_inc_DI
,
11495 /* 0x48 */ x86emuOp_dec_AX
,
11496 /* 0x49 */ x86emuOp_dec_CX
,
11497 /* 0x4a */ x86emuOp_dec_DX
,
11498 /* 0x4b */ x86emuOp_dec_BX
,
11499 /* 0x4c */ x86emuOp_dec_SP
,
11500 /* 0x4d */ x86emuOp_dec_BP
,
11501 /* 0x4e */ x86emuOp_dec_SI
,
11502 /* 0x4f */ x86emuOp_dec_DI
,
11504 /* 0x50 */ x86emuOp_push_AX
,
11505 /* 0x51 */ x86emuOp_push_CX
,
11506 /* 0x52 */ x86emuOp_push_DX
,
11507 /* 0x53 */ x86emuOp_push_BX
,
11508 /* 0x54 */ x86emuOp_push_SP
,
11509 /* 0x55 */ x86emuOp_push_BP
,
11510 /* 0x56 */ x86emuOp_push_SI
,
11511 /* 0x57 */ x86emuOp_push_DI
,
11513 /* 0x58 */ x86emuOp_pop_AX
,
11514 /* 0x59 */ x86emuOp_pop_CX
,
11515 /* 0x5a */ x86emuOp_pop_DX
,
11516 /* 0x5b */ x86emuOp_pop_BX
,
11517 /* 0x5c */ x86emuOp_pop_SP
,
11518 /* 0x5d */ x86emuOp_pop_BP
,
11519 /* 0x5e */ x86emuOp_pop_SI
,
11520 /* 0x5f */ x86emuOp_pop_DI
,
11522 /* 0x60 */ x86emuOp_push_all
,
11523 /* 0x61 */ x86emuOp_pop_all
,
11524 /* 0x62 */ x86emuOp_illegal_op
, /* bound */
11525 /* 0x63 */ x86emuOp_illegal_op
, /* arpl */
11526 /* 0x64 */ x86emuOp_segovr_FS
,
11527 /* 0x65 */ x86emuOp_segovr_GS
,
11528 /* 0x66 */ x86emuOp_prefix_data
,
11529 /* 0x67 */ x86emuOp_prefix_addr
,
11531 /* 0x68 */ x86emuOp_push_word_IMM
,
11532 /* 0x69 */ x86emuOp_imul_word_IMM
,
11533 /* 0x6a */ x86emuOp_push_byte_IMM
,
11534 /* 0x6b */ x86emuOp_imul_byte_IMM
,
11535 /* 0x6c */ x86emuOp_ins_byte
,
11536 /* 0x6d */ x86emuOp_ins_word
,
11537 /* 0x6e */ x86emuOp_outs_byte
,
11538 /* 0x6f */ x86emuOp_outs_word
,
11540 /* 0x70 */ x86emuOp_jump_near_O
,
11541 /* 0x71 */ x86emuOp_jump_near_NO
,
11542 /* 0x72 */ x86emuOp_jump_near_B
,
11543 /* 0x73 */ x86emuOp_jump_near_NB
,
11544 /* 0x74 */ x86emuOp_jump_near_Z
,
11545 /* 0x75 */ x86emuOp_jump_near_NZ
,
11546 /* 0x76 */ x86emuOp_jump_near_BE
,
11547 /* 0x77 */ x86emuOp_jump_near_NBE
,
11549 /* 0x78 */ x86emuOp_jump_near_S
,
11550 /* 0x79 */ x86emuOp_jump_near_NS
,
11551 /* 0x7a */ x86emuOp_jump_near_P
,
11552 /* 0x7b */ x86emuOp_jump_near_NP
,
11553 /* 0x7c */ x86emuOp_jump_near_L
,
11554 /* 0x7d */ x86emuOp_jump_near_NL
,
11555 /* 0x7e */ x86emuOp_jump_near_LE
,
11556 /* 0x7f */ x86emuOp_jump_near_NLE
,
11558 /* 0x80 */ x86emuOp_opc80_byte_RM_IMM
,
11559 /* 0x81 */ x86emuOp_opc81_word_RM_IMM
,
11560 /* 0x82 */ x86emuOp_opc82_byte_RM_IMM
,
11561 /* 0x83 */ x86emuOp_opc83_word_RM_IMM
,
11562 /* 0x84 */ x86emuOp_test_byte_RM_R
,
11563 /* 0x85 */ x86emuOp_test_word_RM_R
,
11564 /* 0x86 */ x86emuOp_xchg_byte_RM_R
,
11565 /* 0x87 */ x86emuOp_xchg_word_RM_R
,
11567 /* 0x88 */ x86emuOp_mov_byte_RM_R
,
11568 /* 0x89 */ x86emuOp_mov_word_RM_R
,
11569 /* 0x8a */ x86emuOp_mov_byte_R_RM
,
11570 /* 0x8b */ x86emuOp_mov_word_R_RM
,
11571 /* 0x8c */ x86emuOp_mov_word_RM_SR
,
11572 /* 0x8d */ x86emuOp_lea_word_R_M
,
11573 /* 0x8e */ x86emuOp_mov_word_SR_RM
,
11574 /* 0x8f */ x86emuOp_pop_RM
,
11576 /* 0x90 */ x86emuOp_nop
,
11577 /* 0x91 */ x86emuOp_xchg_word_AX_CX
,
11578 /* 0x92 */ x86emuOp_xchg_word_AX_DX
,
11579 /* 0x93 */ x86emuOp_xchg_word_AX_BX
,
11580 /* 0x94 */ x86emuOp_xchg_word_AX_SP
,
11581 /* 0x95 */ x86emuOp_xchg_word_AX_BP
,
11582 /* 0x96 */ x86emuOp_xchg_word_AX_SI
,
11583 /* 0x97 */ x86emuOp_xchg_word_AX_DI
,
11585 /* 0x98 */ x86emuOp_cbw
,
11586 /* 0x99 */ x86emuOp_cwd
,
11587 /* 0x9a */ x86emuOp_call_far_IMM
,
11588 /* 0x9b */ x86emuOp_wait
,
11589 /* 0x9c */ x86emuOp_pushf_word
,
11590 /* 0x9d */ x86emuOp_popf_word
,
11591 /* 0x9e */ x86emuOp_sahf
,
11592 /* 0x9f */ x86emuOp_lahf
,
11594 /* 0xa0 */ x86emuOp_mov_AL_M_IMM
,
11595 /* 0xa1 */ x86emuOp_mov_AX_M_IMM
,
11596 /* 0xa2 */ x86emuOp_mov_M_AL_IMM
,
11597 /* 0xa3 */ x86emuOp_mov_M_AX_IMM
,
11598 /* 0xa4 */ x86emuOp_movs_byte
,
11599 /* 0xa5 */ x86emuOp_movs_word
,
11600 /* 0xa6 */ x86emuOp_cmps_byte
,
11601 /* 0xa7 */ x86emuOp_cmps_word
,
11602 /* 0xa8 */ x86emuOp_test_AL_IMM
,
11603 /* 0xa9 */ x86emuOp_test_AX_IMM
,
11604 /* 0xaa */ x86emuOp_stos_byte
,
11605 /* 0xab */ x86emuOp_stos_word
,
11606 /* 0xac */ x86emuOp_lods_byte
,
11607 /* 0xad */ x86emuOp_lods_word
,
11608 /* 0xac */ x86emuOp_scas_byte
,
11609 /* 0xad */ x86emuOp_scas_word
,
11612 /* 0xb0 */ x86emuOp_mov_byte_AL_IMM
,
11613 /* 0xb1 */ x86emuOp_mov_byte_CL_IMM
,
11614 /* 0xb2 */ x86emuOp_mov_byte_DL_IMM
,
11615 /* 0xb3 */ x86emuOp_mov_byte_BL_IMM
,
11616 /* 0xb4 */ x86emuOp_mov_byte_AH_IMM
,
11617 /* 0xb5 */ x86emuOp_mov_byte_CH_IMM
,
11618 /* 0xb6 */ x86emuOp_mov_byte_DH_IMM
,
11619 /* 0xb7 */ x86emuOp_mov_byte_BH_IMM
,
11621 /* 0xb8 */ x86emuOp_mov_word_AX_IMM
,
11622 /* 0xb9 */ x86emuOp_mov_word_CX_IMM
,
11623 /* 0xba */ x86emuOp_mov_word_DX_IMM
,
11624 /* 0xbb */ x86emuOp_mov_word_BX_IMM
,
11625 /* 0xbc */ x86emuOp_mov_word_SP_IMM
,
11626 /* 0xbd */ x86emuOp_mov_word_BP_IMM
,
11627 /* 0xbe */ x86emuOp_mov_word_SI_IMM
,
11628 /* 0xbf */ x86emuOp_mov_word_DI_IMM
,
11630 /* 0xc0 */ x86emuOp_opcC0_byte_RM_MEM
,
11631 /* 0xc1 */ x86emuOp_opcC1_word_RM_MEM
,
11632 /* 0xc2 */ x86emuOp_ret_near_IMM
,
11633 /* 0xc3 */ x86emuOp_ret_near
,
11634 /* 0xc4 */ x86emuOp_les_R_IMM
,
11635 /* 0xc5 */ x86emuOp_lds_R_IMM
,
11636 /* 0xc6 */ x86emuOp_mov_byte_RM_IMM
,
11637 /* 0xc7 */ x86emuOp_mov_word_RM_IMM
,
11638 /* 0xc8 */ x86emuOp_enter
,
11639 /* 0xc9 */ x86emuOp_leave
,
11640 /* 0xca */ x86emuOp_ret_far_IMM
,
11641 /* 0xcb */ x86emuOp_ret_far
,
11642 /* 0xcc */ x86emuOp_int3
,
11643 /* 0xcd */ x86emuOp_int_IMM
,
11644 /* 0xce */ x86emuOp_into
,
11645 /* 0xcf */ x86emuOp_iret
,
11647 /* 0xd0 */ x86emuOp_opcD0_byte_RM_1
,
11648 /* 0xd1 */ x86emuOp_opcD1_word_RM_1
,
11649 /* 0xd2 */ x86emuOp_opcD2_byte_RM_CL
,
11650 /* 0xd3 */ x86emuOp_opcD3_word_RM_CL
,
11651 /* 0xd4 */ x86emuOp_aam
,
11652 /* 0xd5 */ x86emuOp_aad
,
11653 /* 0xd6 */ x86emuOp_illegal_op
, /* Undocumented SETALC instruction */
11654 /* 0xd7 */ x86emuOp_xlat
,
11655 /* 0xd8 */ x86emuOp_esc_coprocess_d8
,
11656 /* 0xd9 */ x86emuOp_esc_coprocess_d9
,
11657 /* 0xda */ x86emuOp_esc_coprocess_da
,
11658 /* 0xdb */ x86emuOp_esc_coprocess_db
,
11659 /* 0xdc */ x86emuOp_esc_coprocess_dc
,
11660 /* 0xdd */ x86emuOp_esc_coprocess_dd
,
11661 /* 0xde */ x86emuOp_esc_coprocess_de
,
11662 /* 0xdf */ x86emuOp_esc_coprocess_df
,
11664 /* 0xe0 */ x86emuOp_loopne
,
11665 /* 0xe1 */ x86emuOp_loope
,
11666 /* 0xe2 */ x86emuOp_loop
,
11667 /* 0xe3 */ x86emuOp_jcxz
,
11668 /* 0xe4 */ x86emuOp_in_byte_AL_IMM
,
11669 /* 0xe5 */ x86emuOp_in_word_AX_IMM
,
11670 /* 0xe6 */ x86emuOp_out_byte_IMM_AL
,
11671 /* 0xe7 */ x86emuOp_out_word_IMM_AX
,
11673 /* 0xe8 */ x86emuOp_call_near_IMM
,
11674 /* 0xe9 */ x86emuOp_jump_near_IMM
,
11675 /* 0xea */ x86emuOp_jump_far_IMM
,
11676 /* 0xeb */ x86emuOp_jump_byte_IMM
,
11677 /* 0xec */ x86emuOp_in_byte_AL_DX
,
11678 /* 0xed */ x86emuOp_in_word_AX_DX
,
11679 /* 0xee */ x86emuOp_out_byte_DX_AL
,
11680 /* 0xef */ x86emuOp_out_word_DX_AX
,
11682 /* 0xf0 */ x86emuOp_lock
,
11683 /* 0xf1 */ x86emuOp_illegal_op
,
11684 /* 0xf2 */ x86emuOp_repne
,
11685 /* 0xf3 */ x86emuOp_repe
,
11686 /* 0xf4 */ x86emuOp_halt
,
11687 /* 0xf5 */ x86emuOp_cmc
,
11688 /* 0xf6 */ x86emuOp_opcF6_byte_RM
,
11689 /* 0xf7 */ x86emuOp_opcF7_word_RM
,
11691 /* 0xf8 */ x86emuOp_clc
,
11692 /* 0xf9 */ x86emuOp_stc
,
11693 /* 0xfa */ x86emuOp_cli
,
11694 /* 0xfb */ x86emuOp_sti
,
11695 /* 0xfc */ x86emuOp_cld
,
11696 /* 0xfd */ x86emuOp_std
,
11697 /* 0xfe */ x86emuOp_opcFE_byte_RM
,
11698 /* 0xff */ x86emuOp_opcFF_word_RM
,