src/hwinfo/src/x86emu/ops.c

   1 /****************************************************************************
   2 *
   3 *                                               Realmode X86 Emulator Library
   4 *
   5 *               Copyright (C) 1996-1999 SciTech Software, Inc.
   6 *                                    Copyright (C) David Mosberger-Tang
   7 *                                          Copyright (C) 1999 Egbert Eich
   8 *
   9 *  ========================================================================
  10 *
  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.
  20 *
  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.
  28 *
  29 *  ========================================================================
  30 *
  31 * Language:             ANSI C
  32 * Environment:  Any
  33 * Developer:    Kendall Bennett
  34 *
  35 * Description:  This file includes subroutines to implement the decoding
  36 *               and emulation of all the x86 processor instructions.
  37 *
  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].
  41 *
  42 * Each opcode proc has a comment preceeding it which gives it's table
  43 * address.  Several opcodes are missing (undefined) in the table.
  44 *
  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).
  48 *
  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.
  70 *
  71 ****************************************************************************/
  72
  73 /* $XFree86: xc/extras/x86emu/src/x86emu/ops.c,v 1.8tsi Exp $ */
  74
  75 #include "x86emu/x86emui.h"
  76
  77 /*----------------------------- Implementation ----------------------------*/
  78
  79 /****************************************************************************
  80 PARAMETERS:
  81 op1 - Instruction op code
  82
  83 REMARKS:
  84 Handles illegal opcodes.
  85 ****************************************************************************/
  86 static void x86emuOp_illegal_op(
  87     u8 op1)
  88 {
  89     START_OF_INSTR();
  90     if (M.x86.R_SP != 0) {
  91     DECODE_PRINTF("ILLEGAL X86 OPCODE\n");
  92     TRACE_REGS();
  93     printk("%04x:%04x: %02X ILLEGAL X86 OPCODE!\n",
  94         M.x86.R_CS, M.x86.R_IP-1,op1);
  95     HALT_SYS();
  96         }
  97     else {
  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
 102          * call.
 103          */
 104         X86EMU_halt_sys();
 105         }
 106     END_OF_INSTR();
 107 }
 108
 109 /****************************************************************************
 110 REMARKS:
 111 Handles opcode 0x00
 112 ****************************************************************************/
 113 static void x86emuOp_add_byte_RM_R(u8 X86EMU_UNUSED(op1))
 114 {
 115     int mod, rl, rh;
 116     uint destoffset;
 117     u8 *destreg, *srcreg;
 118     u8 destval;
 119
 120     START_OF_INSTR();
 121     DECODE_PRINTF("ADD\t");
 122     FETCH_DECODE_MODRM(mod, rh, rl);
 123     switch (mod) {
 124     case 0:
 125         destoffset = decode_rm00_address(rl);
 126         DECODE_PRINTF(",");
 127         destval = fetch_data_byte(destoffset);
 128         srcreg = DECODE_RM_BYTE_REGISTER(rh);
 129         DECODE_PRINTF("\n");
 130         TRACE_AND_STEP();
 131         destval = add_byte(destval, *srcreg);
 132         store_data_byte(destoffset, destval);
 133         break;
 134     case 1:
 135         destoffset = decode_rm01_address(rl);
 136         DECODE_PRINTF(",");
 137         destval = fetch_data_byte(destoffset);
 138         srcreg = DECODE_RM_BYTE_REGISTER(rh);
 139         DECODE_PRINTF("\n");
 140         TRACE_AND_STEP();
 141         destval = add_byte(destval, *srcreg);
 142         store_data_byte(destoffset, destval);
 143         break;
 144     case 2:
 145         destoffset = decode_rm10_address(rl);
 146         DECODE_PRINTF(",");
 147         destval = fetch_data_byte(destoffset);
 148         srcreg = DECODE_RM_BYTE_REGISTER(rh);
 149         DECODE_PRINTF("\n");
 150         TRACE_AND_STEP();
 151         destval = add_byte(destval, *srcreg);
 152         store_data_byte(destoffset, destval);
 153         break;
 154     case 3:                     /* register to register */
 155         destreg = DECODE_RM_BYTE_REGISTER(rl);
 156         DECODE_PRINTF(",");
 157         srcreg = DECODE_RM_BYTE_REGISTER(rh);
 158         DECODE_PRINTF("\n");
 159         TRACE_AND_STEP();
 160         *destreg = add_byte(*destreg, *srcreg);
 161         break;
 162     }
 163     DECODE_CLEAR_SEGOVR();
 164     END_OF_INSTR();
 165 }
 166
 167 /****************************************************************************
 168 REMARKS:
 169 Handles opcode 0x01
 170 ****************************************************************************/
 171 static void x86emuOp_add_word_RM_R(u8 X86EMU_UNUSED(op1))
 172 {
 173     int mod, rl, rh;
 174     uint destoffset;
 175
 176     START_OF_INSTR();
 177     DECODE_PRINTF("ADD\t");
 178     FETCH_DECODE_MODRM(mod, rh, rl);
 179     switch (mod) {
 180     case 0:
 181         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 182             u32 destval;
 183             u32 *srcreg;
 184
 185             destoffset = decode_rm00_address(rl);
 186             DECODE_PRINTF(",");
 187             destval = fetch_data_long(destoffset);
 188             srcreg = DECODE_RM_LONG_REGISTER(rh);
 189             DECODE_PRINTF("\n");
 190             TRACE_AND_STEP();
 191             destval = add_long(destval, *srcreg);
 192             store_data_long(destoffset, destval);
 193         } else {
 194             u16 destval;
 195             u16 *srcreg;
 196
 197             destoffset = decode_rm00_address(rl);
 198             DECODE_PRINTF(",");
 199             destval = fetch_data_word(destoffset);
 200             srcreg = DECODE_RM_WORD_REGISTER(rh);
 201             DECODE_PRINTF("\n");
 202             TRACE_AND_STEP();
 203             destval = add_word(destval, *srcreg);
 204             store_data_word(destoffset, destval);
 205         }
 206         break;
 207     case 1:
 208         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 209             u32 destval;
 210             u32 *srcreg;
 211
 212             destoffset = decode_rm01_address(rl);
 213             DECODE_PRINTF(",");
 214             destval = fetch_data_long(destoffset);
 215             srcreg = DECODE_RM_LONG_REGISTER(rh);
 216             DECODE_PRINTF("\n");
 217             TRACE_AND_STEP();
 218             destval = add_long(destval, *srcreg);
 219             store_data_long(destoffset, destval);
 220         } else {
 221             u16 destval;
 222             u16 *srcreg;
 223
 224             destoffset = decode_rm01_address(rl);
 225             DECODE_PRINTF(",");
 226             destval = fetch_data_word(destoffset);
 227             srcreg = DECODE_RM_WORD_REGISTER(rh);
 228             DECODE_PRINTF("\n");
 229             TRACE_AND_STEP();
 230             destval = add_word(destval, *srcreg);
 231             store_data_word(destoffset, destval);
 232         }
 233         break;
 234     case 2:
 235         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 236             u32 destval;
 237             u32 *srcreg;
 238
 239             destoffset = decode_rm10_address(rl);
 240             DECODE_PRINTF(",");
 241             destval = fetch_data_long(destoffset);
 242             srcreg = DECODE_RM_LONG_REGISTER(rh);
 243             DECODE_PRINTF("\n");
 244             TRACE_AND_STEP();
 245             destval = add_long(destval, *srcreg);
 246             store_data_long(destoffset, destval);
 247         } else {
 248             u16 destval;
 249             u16 *srcreg;
 250
 251             destoffset = decode_rm10_address(rl);
 252             DECODE_PRINTF(",");
 253             destval = fetch_data_word(destoffset);
 254             srcreg = DECODE_RM_WORD_REGISTER(rh);
 255             DECODE_PRINTF("\n");
 256             TRACE_AND_STEP();
 257             destval = add_word(destval, *srcreg);
 258             store_data_word(destoffset, destval);
 259         }
 260         break;
 261     case 3:                     /* register to register */
 262         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 263             u32 *destreg,*srcreg;
 264
 265             destreg = DECODE_RM_LONG_REGISTER(rl);
 266             DECODE_PRINTF(",");
 267             srcreg = DECODE_RM_LONG_REGISTER(rh);
 268             DECODE_PRINTF("\n");
 269             TRACE_AND_STEP();
 270             *destreg = add_long(*destreg, *srcreg);
 271         } else {
 272             u16 *destreg,*srcreg;
 273
 274             destreg = DECODE_RM_WORD_REGISTER(rl);
 275             DECODE_PRINTF(",");
 276             srcreg = DECODE_RM_WORD_REGISTER(rh);
 277             DECODE_PRINTF("\n");
 278             TRACE_AND_STEP();
 279             *destreg = add_word(*destreg, *srcreg);
 280         }
 281         break;
 282     }
 283     DECODE_CLEAR_SEGOVR();
 284     END_OF_INSTR();
 285 }
 286
 287 /****************************************************************************
 288 REMARKS:
 289 Handles opcode 0x02
 290 ****************************************************************************/
 291 static void x86emuOp_add_byte_R_RM(u8 X86EMU_UNUSED(op1))
 292 {
 293     int mod, rl, rh;
 294     u8 *destreg, *srcreg;
 295     uint srcoffset;
 296     u8 srcval;
 297
 298     START_OF_INSTR();
 299     DECODE_PRINTF("ADD\t");
 300     FETCH_DECODE_MODRM(mod, rh, rl);
 301     switch (mod) {
 302     case 0:
 303         destreg = DECODE_RM_BYTE_REGISTER(rh);
 304         DECODE_PRINTF(",");
 305         srcoffset = decode_rm00_address(rl);
 306         srcval = fetch_data_byte(srcoffset);
 307         DECODE_PRINTF("\n");
 308         TRACE_AND_STEP();
 309         *destreg = add_byte(*destreg, srcval);
 310         break;
 311     case 1:
 312         destreg = DECODE_RM_BYTE_REGISTER(rh);
 313         DECODE_PRINTF(",");
 314         srcoffset = decode_rm01_address(rl);
 315         srcval = fetch_data_byte(srcoffset);
 316         DECODE_PRINTF("\n");
 317         TRACE_AND_STEP();
 318         *destreg = add_byte(*destreg, srcval);
 319         break;
 320     case 2:
 321         destreg = DECODE_RM_BYTE_REGISTER(rh);
 322         DECODE_PRINTF(",");
 323         srcoffset = decode_rm10_address(rl);
 324         srcval = fetch_data_byte(srcoffset);
 325         DECODE_PRINTF("\n");
 326         TRACE_AND_STEP();
 327         *destreg = add_byte(*destreg, srcval);
 328         break;
 329     case 3:                     /* register to register */
 330         destreg = DECODE_RM_BYTE_REGISTER(rh);
 331         DECODE_PRINTF(",");
 332         srcreg = DECODE_RM_BYTE_REGISTER(rl);
 333         DECODE_PRINTF("\n");
 334         TRACE_AND_STEP();
 335         *destreg = add_byte(*destreg, *srcreg);
 336         break;
 337     }
 338     DECODE_CLEAR_SEGOVR();
 339     END_OF_INSTR();
 340 }
 341
 342 /****************************************************************************
 343 REMARKS:
 344 Handles opcode 0x03
 345 ****************************************************************************/
 346 static void x86emuOp_add_word_R_RM(u8 X86EMU_UNUSED(op1))
 347 {
 348     int mod, rl, rh;
 349     uint srcoffset;
 350
 351     START_OF_INSTR();
 352     DECODE_PRINTF("ADD\t");
 353     FETCH_DECODE_MODRM(mod, rh, rl);
 354     switch (mod) {
 355     case 0:
 356         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 357             u32 *destreg;
 358             u32 srcval;
 359
 360             destreg = DECODE_RM_LONG_REGISTER(rh);
 361             DECODE_PRINTF(",");
 362             srcoffset = decode_rm00_address(rl);
 363             srcval = fetch_data_long(srcoffset);
 364             DECODE_PRINTF("\n");
 365             TRACE_AND_STEP();
 366             *destreg = add_long(*destreg, srcval);
 367         } else {
 368             u16 *destreg;
 369             u16 srcval;
 370
 371             destreg = DECODE_RM_WORD_REGISTER(rh);
 372             DECODE_PRINTF(",");
 373             srcoffset = decode_rm00_address(rl);
 374             srcval = fetch_data_word(srcoffset);
 375             DECODE_PRINTF("\n");
 376             TRACE_AND_STEP();
 377             *destreg = add_word(*destreg, srcval);
 378         }
 379         break;
 380     case 1:
 381         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 382             u32 *destreg;
 383             u32 srcval;
 384
 385             destreg = DECODE_RM_LONG_REGISTER(rh);
 386             DECODE_PRINTF(",");
 387             srcoffset = decode_rm01_address(rl);
 388             srcval = fetch_data_long(srcoffset);
 389             DECODE_PRINTF("\n");
 390             TRACE_AND_STEP();
 391             *destreg = add_long(*destreg, srcval);
 392         } else {
 393             u16 *destreg;
 394             u16 srcval;
 395
 396             destreg = DECODE_RM_WORD_REGISTER(rh);
 397             DECODE_PRINTF(",");
 398             srcoffset = decode_rm01_address(rl);
 399             srcval = fetch_data_word(srcoffset);
 400             DECODE_PRINTF("\n");
 401             TRACE_AND_STEP();
 402             *destreg = add_word(*destreg, srcval);
 403         }
 404         break;
 405     case 2:
 406         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 407             u32 *destreg;
 408             u32 srcval;
 409
 410             destreg = DECODE_RM_LONG_REGISTER(rh);
 411             DECODE_PRINTF(",");
 412             srcoffset = decode_rm10_address(rl);
 413             srcval = fetch_data_long(srcoffset);
 414             DECODE_PRINTF("\n");
 415             TRACE_AND_STEP();
 416             *destreg = add_long(*destreg, srcval);
 417         } else {
 418             u16 *destreg;
 419             u16 srcval;
 420
 421             destreg = DECODE_RM_WORD_REGISTER(rh);
 422             DECODE_PRINTF(",");
 423             srcoffset = decode_rm10_address(rl);
 424             srcval = fetch_data_word(srcoffset);
 425             DECODE_PRINTF("\n");
 426             TRACE_AND_STEP();
 427             *destreg = add_word(*destreg, srcval);
 428         }
 429         break;
 430     case 3:                     /* register to register */
 431         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 432             u32 *destreg,*srcreg;
 433
 434             destreg = DECODE_RM_LONG_REGISTER(rh);
 435             DECODE_PRINTF(",");
 436             srcreg = DECODE_RM_LONG_REGISTER(rl);
 437             DECODE_PRINTF("\n");
 438             TRACE_AND_STEP();
 439             *destreg = add_long(*destreg, *srcreg);
 440         } else {
 441             u16 *destreg,*srcreg;
 442
 443             destreg = DECODE_RM_WORD_REGISTER(rh);
 444             DECODE_PRINTF(",");
 445             srcreg = DECODE_RM_WORD_REGISTER(rl);
 446             DECODE_PRINTF("\n");
 447             TRACE_AND_STEP();
 448             *destreg = add_word(*destreg, *srcreg);
 449         }
 450         break;
 451     }
 452     DECODE_CLEAR_SEGOVR();
 453     END_OF_INSTR();
 454 }
 455
 456 /****************************************************************************
 457 REMARKS:
 458 Handles opcode 0x04
 459 ****************************************************************************/
 460 static void x86emuOp_add_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
 461 {
 462     u8 srcval;
 463
 464     START_OF_INSTR();
 465     DECODE_PRINTF("ADD\tAL,");
 466     srcval = fetch_byte_imm();
 467     DECODE_PRINTF2("%x\n", srcval);
 468     TRACE_AND_STEP();
 469     M.x86.R_AL = add_byte(M.x86.R_AL, srcval);
 470     DECODE_CLEAR_SEGOVR();
 471     END_OF_INSTR();
 472 }
 473
 474 /****************************************************************************
 475 REMARKS:
 476 Handles opcode 0x05
 477 ****************************************************************************/
 478 static void x86emuOp_add_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 479 {
 480     u32 srcval;
 481
 482     START_OF_INSTR();
 483     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 484         DECODE_PRINTF("ADD\tEAX,");
 485         srcval = fetch_long_imm();
 486     } else {
 487         DECODE_PRINTF("ADD\tAX,");
 488         srcval = fetch_word_imm();
 489     }
 490     DECODE_PRINTF2("%x\n", srcval);
 491     TRACE_AND_STEP();
 492     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 493         M.x86.R_EAX = add_long(M.x86.R_EAX, srcval);
 494     } else {
 495         M.x86.R_AX = add_word(M.x86.R_AX, (u16)srcval);
 496     }
 497     DECODE_CLEAR_SEGOVR();
 498     END_OF_INSTR();
 499 }
 500
 501 /****************************************************************************
 502 REMARKS:
 503 Handles opcode 0x06
 504 ****************************************************************************/
 505 static void x86emuOp_push_ES(u8 X86EMU_UNUSED(op1))
 506 {
 507     START_OF_INSTR();
 508     DECODE_PRINTF("PUSH\tES\n");
 509     TRACE_AND_STEP();
 510     push_word(M.x86.R_ES);
 511     DECODE_CLEAR_SEGOVR();
 512     END_OF_INSTR();
 513 }
 514
 515 /****************************************************************************
 516 REMARKS:
 517 Handles opcode 0x07
 518 ****************************************************************************/
 519 static void x86emuOp_pop_ES(u8 X86EMU_UNUSED(op1))
 520 {
 521     START_OF_INSTR();
 522     DECODE_PRINTF("POP\tES\n");
 523     TRACE_AND_STEP();
 524     M.x86.R_ES = pop_word();
 525     DECODE_CLEAR_SEGOVR();
 526     END_OF_INSTR();
 527 }
 528
 529 /****************************************************************************
 530 REMARKS:
 531 Handles opcode 0x08
 532 ****************************************************************************/
 533 static void x86emuOp_or_byte_RM_R(u8 X86EMU_UNUSED(op1))
 534 {
 535     int mod, rl, rh;
 536     u8 *destreg, *srcreg;
 537     uint destoffset;
 538     u8 destval;
 539
 540     START_OF_INSTR();
 541     DECODE_PRINTF("OR\t");
 542     FETCH_DECODE_MODRM(mod, rh, rl);
 543     switch (mod) {
 544     case 0:
 545         destoffset = decode_rm00_address(rl);
 546         DECODE_PRINTF(",");
 547         destval = fetch_data_byte(destoffset);
 548         srcreg = DECODE_RM_BYTE_REGISTER(rh);
 549         DECODE_PRINTF("\n");
 550         TRACE_AND_STEP();
 551         destval = or_byte(destval, *srcreg);
 552         store_data_byte(destoffset, destval);
 553         break;
 554     case 1:
 555         destoffset = decode_rm01_address(rl);
 556         DECODE_PRINTF(",");
 557         destval = fetch_data_byte(destoffset);
 558         srcreg = DECODE_RM_BYTE_REGISTER(rh);
 559         DECODE_PRINTF("\n");
 560         TRACE_AND_STEP();
 561         destval = or_byte(destval, *srcreg);
 562         store_data_byte(destoffset, destval);
 563         break;
 564     case 2:
 565         destoffset = decode_rm10_address(rl);
 566         DECODE_PRINTF(",");
 567         destval = fetch_data_byte(destoffset);
 568         srcreg = DECODE_RM_BYTE_REGISTER(rh);
 569         DECODE_PRINTF("\n");
 570         TRACE_AND_STEP();
 571         destval = or_byte(destval, *srcreg);
 572         store_data_byte(destoffset, destval);
 573         break;
 574     case 3:                     /* register to register */
 575         destreg = DECODE_RM_BYTE_REGISTER(rl);
 576         DECODE_PRINTF(",");
 577         srcreg = DECODE_RM_BYTE_REGISTER(rh);
 578         DECODE_PRINTF("\n");
 579         TRACE_AND_STEP();
 580         *destreg = or_byte(*destreg, *srcreg);
 581         break;
 582     }
 583     DECODE_CLEAR_SEGOVR();
 584     END_OF_INSTR();
 585 }
 586
 587 /****************************************************************************
 588 REMARKS:
 589 Handles opcode 0x09
 590 ****************************************************************************/
 591 static void x86emuOp_or_word_RM_R(u8 X86EMU_UNUSED(op1))
 592 {
 593     int mod, rl, rh;
 594     uint destoffset;
 595
 596     START_OF_INSTR();
 597     DECODE_PRINTF("OR\t");
 598     FETCH_DECODE_MODRM(mod, rh, rl);
 599     switch (mod) {
 600     case 0:
 601         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 602             u32 destval;
 603             u32 *srcreg;
 604
 605             destoffset = decode_rm00_address(rl);
 606             DECODE_PRINTF(",");
 607             destval = fetch_data_long(destoffset);
 608             srcreg = DECODE_RM_LONG_REGISTER(rh);
 609             DECODE_PRINTF("\n");
 610             TRACE_AND_STEP();
 611             destval = or_long(destval, *srcreg);
 612             store_data_long(destoffset, destval);
 613         } else {
 614             u16 destval;
 615             u16 *srcreg;
 616
 617             destoffset = decode_rm00_address(rl);
 618             DECODE_PRINTF(",");
 619             destval = fetch_data_word(destoffset);
 620             srcreg = DECODE_RM_WORD_REGISTER(rh);
 621             DECODE_PRINTF("\n");
 622             TRACE_AND_STEP();
 623             destval = or_word(destval, *srcreg);
 624             store_data_word(destoffset, destval);
 625         }
 626         break;
 627     case 1:
 628         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 629             u32 destval;
 630             u32 *srcreg;
 631
 632             destoffset = decode_rm01_address(rl);
 633             DECODE_PRINTF(",");
 634             destval = fetch_data_long(destoffset);
 635             srcreg = DECODE_RM_LONG_REGISTER(rh);
 636             DECODE_PRINTF("\n");
 637             TRACE_AND_STEP();
 638             destval = or_long(destval, *srcreg);
 639             store_data_long(destoffset, destval);
 640         } else {
 641             u16 destval;
 642             u16 *srcreg;
 643
 644             destoffset = decode_rm01_address(rl);
 645             DECODE_PRINTF(",");
 646             destval = fetch_data_word(destoffset);
 647             srcreg = DECODE_RM_WORD_REGISTER(rh);
 648             DECODE_PRINTF("\n");
 649             TRACE_AND_STEP();
 650             destval = or_word(destval, *srcreg);
 651             store_data_word(destoffset, destval);
 652         }
 653         break;
 654     case 2:
 655         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 656             u32 destval;
 657             u32 *srcreg;
 658
 659             destoffset = decode_rm10_address(rl);
 660             DECODE_PRINTF(",");
 661             destval = fetch_data_long(destoffset);
 662             srcreg = DECODE_RM_LONG_REGISTER(rh);
 663             DECODE_PRINTF("\n");
 664             TRACE_AND_STEP();
 665             destval = or_long(destval, *srcreg);
 666             store_data_long(destoffset, destval);
 667         } else {
 668             u16 destval;
 669             u16 *srcreg;
 670
 671             destoffset = decode_rm10_address(rl);
 672             DECODE_PRINTF(",");
 673             destval = fetch_data_word(destoffset);
 674             srcreg = DECODE_RM_WORD_REGISTER(rh);
 675             DECODE_PRINTF("\n");
 676             TRACE_AND_STEP();
 677             destval = or_word(destval, *srcreg);
 678             store_data_word(destoffset, destval);
 679         }
 680         break;
 681     case 3:                     /* register to register */
 682         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 683             u32 *destreg,*srcreg;
 684
 685             destreg = DECODE_RM_LONG_REGISTER(rl);
 686             DECODE_PRINTF(",");
 687             srcreg = DECODE_RM_LONG_REGISTER(rh);
 688             DECODE_PRINTF("\n");
 689             TRACE_AND_STEP();
 690             *destreg = or_long(*destreg, *srcreg);
 691         } else {
 692             u16 *destreg,*srcreg;
 693
 694             destreg = DECODE_RM_WORD_REGISTER(rl);
 695             DECODE_PRINTF(",");
 696             srcreg = DECODE_RM_WORD_REGISTER(rh);
 697             DECODE_PRINTF("\n");
 698             TRACE_AND_STEP();
 699             *destreg = or_word(*destreg, *srcreg);
 700         }
 701         break;
 702     }
 703     DECODE_CLEAR_SEGOVR();
 704     END_OF_INSTR();
 705 }
 706
 707 /****************************************************************************
 708 REMARKS:
 709 Handles opcode 0x0a
 710 ****************************************************************************/
 711 static void x86emuOp_or_byte_R_RM(u8 X86EMU_UNUSED(op1))
 712 {
 713     int mod, rl, rh;
 714     u8 *destreg, *srcreg;
 715     uint srcoffset;
 716     u8 srcval;
 717
 718     START_OF_INSTR();
 719     DECODE_PRINTF("OR\t");
 720     FETCH_DECODE_MODRM(mod, rh, rl);
 721     switch (mod) {
 722     case 0:
 723         destreg = DECODE_RM_BYTE_REGISTER(rh);
 724         DECODE_PRINTF(",");
 725         srcoffset = decode_rm00_address(rl);
 726         srcval = fetch_data_byte(srcoffset);
 727         DECODE_PRINTF("\n");
 728         TRACE_AND_STEP();
 729         *destreg = or_byte(*destreg, srcval);
 730         break;
 731     case 1:
 732         destreg = DECODE_RM_BYTE_REGISTER(rh);
 733         DECODE_PRINTF(",");
 734         srcoffset = decode_rm01_address(rl);
 735         srcval = fetch_data_byte(srcoffset);
 736         DECODE_PRINTF("\n");
 737         TRACE_AND_STEP();
 738         *destreg = or_byte(*destreg, srcval);
 739         break;
 740     case 2:
 741         destreg = DECODE_RM_BYTE_REGISTER(rh);
 742         DECODE_PRINTF(",");
 743         srcoffset = decode_rm10_address(rl);
 744         srcval = fetch_data_byte(srcoffset);
 745         DECODE_PRINTF("\n");
 746         TRACE_AND_STEP();
 747         *destreg = or_byte(*destreg, srcval);
 748         break;
 749     case 3:                     /* register to register */
 750         destreg = DECODE_RM_BYTE_REGISTER(rh);
 751         DECODE_PRINTF(",");
 752         srcreg = DECODE_RM_BYTE_REGISTER(rl);
 753         DECODE_PRINTF("\n");
 754         TRACE_AND_STEP();
 755         *destreg = or_byte(*destreg, *srcreg);
 756         break;
 757     }
 758     DECODE_CLEAR_SEGOVR();
 759     END_OF_INSTR();
 760 }
 761
 762 /****************************************************************************
 763 REMARKS:
 764 Handles opcode 0x0b
 765 ****************************************************************************/
 766 static void x86emuOp_or_word_R_RM(u8 X86EMU_UNUSED(op1))
 767 {
 768     int mod, rl, rh;
 769     uint srcoffset;
 770
 771     START_OF_INSTR();
 772     DECODE_PRINTF("OR\t");
 773     FETCH_DECODE_MODRM(mod, rh, rl);
 774     switch (mod) {
 775     case 0:
 776         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 777             u32 *destreg;
 778             u32 srcval;
 779
 780             destreg = DECODE_RM_LONG_REGISTER(rh);
 781             DECODE_PRINTF(",");
 782             srcoffset = decode_rm00_address(rl);
 783             srcval = fetch_data_long(srcoffset);
 784             DECODE_PRINTF("\n");
 785             TRACE_AND_STEP();
 786             *destreg = or_long(*destreg, srcval);
 787         } else {
 788             u16 *destreg;
 789             u16 srcval;
 790
 791             destreg = DECODE_RM_WORD_REGISTER(rh);
 792             DECODE_PRINTF(",");
 793             srcoffset = decode_rm00_address(rl);
 794             srcval = fetch_data_word(srcoffset);
 795             DECODE_PRINTF("\n");
 796             TRACE_AND_STEP();
 797             *destreg = or_word(*destreg, srcval);
 798         }
 799         break;
 800     case 1:
 801         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 802             u32 *destreg;
 803             u32 srcval;
 804
 805             destreg = DECODE_RM_LONG_REGISTER(rh);
 806             DECODE_PRINTF(",");
 807             srcoffset = decode_rm01_address(rl);
 808             srcval = fetch_data_long(srcoffset);
 809             DECODE_PRINTF("\n");
 810             TRACE_AND_STEP();
 811             *destreg = or_long(*destreg, srcval);
 812         } else {
 813             u16 *destreg;
 814             u16 srcval;
 815
 816             destreg = DECODE_RM_WORD_REGISTER(rh);
 817             DECODE_PRINTF(",");
 818             srcoffset = decode_rm01_address(rl);
 819             srcval = fetch_data_word(srcoffset);
 820             DECODE_PRINTF("\n");
 821             TRACE_AND_STEP();
 822             *destreg = or_word(*destreg, srcval);
 823         }
 824         break;
 825     case 2:
 826         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 827             u32 *destreg;
 828             u32 srcval;
 829
 830             destreg = DECODE_RM_LONG_REGISTER(rh);
 831             DECODE_PRINTF(",");
 832             srcoffset = decode_rm10_address(rl);
 833             srcval = fetch_data_long(srcoffset);
 834             DECODE_PRINTF("\n");
 835             TRACE_AND_STEP();
 836             *destreg = or_long(*destreg, srcval);
 837         } else {
 838             u16 *destreg;
 839             u16 srcval;
 840
 841             destreg = DECODE_RM_WORD_REGISTER(rh);
 842             DECODE_PRINTF(",");
 843             srcoffset = decode_rm10_address(rl);
 844             srcval = fetch_data_word(srcoffset);
 845             DECODE_PRINTF("\n");
 846             TRACE_AND_STEP();
 847             *destreg = or_word(*destreg, srcval);
 848         }
 849         break;
 850     case 3:                     /* register to register */
 851         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 852             u32 *destreg,*srcreg;
 853
 854             destreg = DECODE_RM_LONG_REGISTER(rh);
 855             DECODE_PRINTF(",");
 856             srcreg = DECODE_RM_LONG_REGISTER(rl);
 857             DECODE_PRINTF("\n");
 858             TRACE_AND_STEP();
 859             *destreg = or_long(*destreg, *srcreg);
 860         } else {
 861             u16 *destreg,*srcreg;
 862
 863             destreg = DECODE_RM_WORD_REGISTER(rh);
 864             DECODE_PRINTF(",");
 865             srcreg = DECODE_RM_WORD_REGISTER(rl);
 866             DECODE_PRINTF("\n");
 867             TRACE_AND_STEP();
 868             *destreg = or_word(*destreg, *srcreg);
 869         }
 870         break;
 871     }
 872     DECODE_CLEAR_SEGOVR();
 873     END_OF_INSTR();
 874 }
 875
 876 /****************************************************************************
 877 REMARKS:
 878 Handles opcode 0x0c
 879 ****************************************************************************/
 880 static void x86emuOp_or_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
 881 {
 882     u8 srcval;
 883
 884     START_OF_INSTR();
 885     DECODE_PRINTF("OR\tAL,");
 886     srcval = fetch_byte_imm();
 887     DECODE_PRINTF2("%x\n", srcval);
 888     TRACE_AND_STEP();
 889     M.x86.R_AL = or_byte(M.x86.R_AL, srcval);
 890     DECODE_CLEAR_SEGOVR();
 891     END_OF_INSTR();
 892 }
 893
 894 /****************************************************************************
 895 REMARKS:
 896 Handles opcode 0x0d
 897 ****************************************************************************/
 898 static void x86emuOp_or_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 899 {
 900     u32 srcval;
 901
 902     START_OF_INSTR();
 903     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 904         DECODE_PRINTF("OR\tEAX,");
 905         srcval = fetch_long_imm();
 906     } else {
 907         DECODE_PRINTF("OR\tAX,");
 908         srcval = fetch_word_imm();
 909     }
 910     DECODE_PRINTF2("%x\n", srcval);
 911     TRACE_AND_STEP();
 912     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
 913         M.x86.R_EAX = or_long(M.x86.R_EAX, srcval);
 914     } else {
 915         M.x86.R_AX = or_word(M.x86.R_AX, (u16)srcval);
 916     }
 917     DECODE_CLEAR_SEGOVR();
 918     END_OF_INSTR();
 919 }
 920
 921 /****************************************************************************
 922 REMARKS:
 923 Handles opcode 0x0e
 924 ****************************************************************************/
 925 static void x86emuOp_push_CS(u8 X86EMU_UNUSED(op1))
 926 {
 927     START_OF_INSTR();
 928     DECODE_PRINTF("PUSH\tCS\n");
 929     TRACE_AND_STEP();
 930     push_word(M.x86.R_CS);
 931     DECODE_CLEAR_SEGOVR();
 932     END_OF_INSTR();
 933 }
 934
 935 /****************************************************************************
 936 REMARKS:
 937 Handles opcode 0x0f. Escape for two-byte opcode (286 or better)
 938 ****************************************************************************/
 939 static void x86emuOp_two_byte(u8 X86EMU_UNUSED(op1))
 940 {
 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);
 944 }
 945
 946 /****************************************************************************
 947 REMARKS:
 948 Handles opcode 0x10
 949 ****************************************************************************/
 950 static void x86emuOp_adc_byte_RM_R(u8 X86EMU_UNUSED(op1))
 951 {
 952     int mod, rl, rh;
 953     u8 *destreg, *srcreg;
 954     uint destoffset;
 955     u8 destval;
 956
 957     START_OF_INSTR();
 958     DECODE_PRINTF("ADC\t");
 959     FETCH_DECODE_MODRM(mod, rh, rl);
 960     switch (mod) {
 961     case 0:
 962         destoffset = decode_rm00_address(rl);
 963         DECODE_PRINTF(",");
 964         destval = fetch_data_byte(destoffset);
 965         srcreg = DECODE_RM_BYTE_REGISTER(rh);
 966         DECODE_PRINTF("\n");
 967         TRACE_AND_STEP();
 968         destval = adc_byte(destval, *srcreg);
 969         store_data_byte(destoffset, destval);
 970         break;
 971     case 1:
 972         destoffset = decode_rm01_address(rl);
 973         DECODE_PRINTF(",");
 974         destval = fetch_data_byte(destoffset);
 975         srcreg = DECODE_RM_BYTE_REGISTER(rh);
 976         DECODE_PRINTF("\n");
 977         TRACE_AND_STEP();
 978         destval = adc_byte(destval, *srcreg);
 979         store_data_byte(destoffset, destval);
 980         break;
 981     case 2:
 982         destoffset = decode_rm10_address(rl);
 983         DECODE_PRINTF(",");
 984         destval = fetch_data_byte(destoffset);
 985         srcreg = DECODE_RM_BYTE_REGISTER(rh);
 986         DECODE_PRINTF("\n");
 987         TRACE_AND_STEP();
 988         destval = adc_byte(destval, *srcreg);
 989         store_data_byte(destoffset, destval);
 990         break;
 991     case 3:                     /* register to register */
 992         destreg = DECODE_RM_BYTE_REGISTER(rl);
 993         DECODE_PRINTF(",");
 994         srcreg = DECODE_RM_BYTE_REGISTER(rh);
 995         DECODE_PRINTF("\n");
 996         TRACE_AND_STEP();
 997         *destreg = adc_byte(*destreg, *srcreg);
 998         break;
 999     }
1000     DECODE_CLEAR_SEGOVR();
1001     END_OF_INSTR();
1002 }
1003
1004 /****************************************************************************
1005 REMARKS:
1006 Handles opcode 0x11
1007 ****************************************************************************/
1008 static void x86emuOp_adc_word_RM_R(u8 X86EMU_UNUSED(op1))
1009 {
1010     int mod, rl, rh;
1011     uint destoffset;
1012
1013     START_OF_INSTR();
1014     DECODE_PRINTF("ADC\t");
1015     FETCH_DECODE_MODRM(mod, rh, rl);
1016     switch (mod) {
1017     case 0:
1018         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1019             u32 destval;
1020             u32 *srcreg;
1021
1022             destoffset = decode_rm00_address(rl);
1023             DECODE_PRINTF(",");
1024             destval = fetch_data_long(destoffset);
1025             srcreg = DECODE_RM_LONG_REGISTER(rh);
1026             DECODE_PRINTF("\n");
1027             TRACE_AND_STEP();
1028             destval = adc_long(destval, *srcreg);
1029             store_data_long(destoffset, destval);
1030         } else {
1031             u16 destval;
1032             u16 *srcreg;
1033
1034             destoffset = decode_rm00_address(rl);
1035             DECODE_PRINTF(",");
1036             destval = fetch_data_word(destoffset);
1037             srcreg = DECODE_RM_WORD_REGISTER(rh);
1038             DECODE_PRINTF("\n");
1039             TRACE_AND_STEP();
1040             destval = adc_word(destval, *srcreg);
1041             store_data_word(destoffset, destval);
1042         }
1043         break;
1044     case 1:
1045         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1046             u32 destval;
1047             u32 *srcreg;
1048
1049             destoffset = decode_rm01_address(rl);
1050             DECODE_PRINTF(",");
1051             destval = fetch_data_long(destoffset);
1052             srcreg = DECODE_RM_LONG_REGISTER(rh);
1053             DECODE_PRINTF("\n");
1054             TRACE_AND_STEP();
1055             destval = adc_long(destval, *srcreg);
1056             store_data_long(destoffset, destval);
1057         } else {
1058             u16 destval;
1059             u16 *srcreg;
1060
1061             destoffset = decode_rm01_address(rl);
1062             DECODE_PRINTF(",");
1063             destval = fetch_data_word(destoffset);
1064             srcreg = DECODE_RM_WORD_REGISTER(rh);
1065             DECODE_PRINTF("\n");
1066             TRACE_AND_STEP();
1067             destval = adc_word(destval, *srcreg);
1068             store_data_word(destoffset, destval);
1069         }
1070         break;
1071     case 2:
1072         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1073             u32 destval;
1074             u32 *srcreg;
1075
1076             destoffset = decode_rm10_address(rl);
1077             DECODE_PRINTF(",");
1078             destval = fetch_data_long(destoffset);
1079             srcreg = DECODE_RM_LONG_REGISTER(rh);
1080             DECODE_PRINTF("\n");
1081             TRACE_AND_STEP();
1082             destval = adc_long(destval, *srcreg);
1083             store_data_long(destoffset, destval);
1084         } else {
1085             u16 destval;
1086             u16 *srcreg;
1087
1088             destoffset = decode_rm10_address(rl);
1089             DECODE_PRINTF(",");
1090             destval = fetch_data_word(destoffset);
1091             srcreg = DECODE_RM_WORD_REGISTER(rh);
1092             DECODE_PRINTF("\n");
1093             TRACE_AND_STEP();
1094             destval = adc_word(destval, *srcreg);
1095             store_data_word(destoffset, destval);
1096         }
1097         break;
1098     case 3:                     /* register to register */
1099         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1100             u32 *destreg,*srcreg;
1101
1102             destreg = DECODE_RM_LONG_REGISTER(rl);
1103             DECODE_PRINTF(",");
1104             srcreg = DECODE_RM_LONG_REGISTER(rh);
1105             DECODE_PRINTF("\n");
1106             TRACE_AND_STEP();
1107             *destreg = adc_long(*destreg, *srcreg);
1108         } else {
1109             u16 *destreg,*srcreg;
1110
1111             destreg = DECODE_RM_WORD_REGISTER(rl);
1112             DECODE_PRINTF(",");
1113             srcreg = DECODE_RM_WORD_REGISTER(rh);
1114             DECODE_PRINTF("\n");
1115             TRACE_AND_STEP();
1116             *destreg = adc_word(*destreg, *srcreg);
1117         }
1118         break;
1119     }
1120     DECODE_CLEAR_SEGOVR();
1121     END_OF_INSTR();
1122 }
1123
1124 /****************************************************************************
1125 REMARKS:
1126 Handles opcode 0x12
1127 ****************************************************************************/
1128 static void x86emuOp_adc_byte_R_RM(u8 X86EMU_UNUSED(op1))
1129 {
1130     int mod, rl, rh;
1131     u8 *destreg, *srcreg;
1132     uint srcoffset;
1133     u8 srcval;
1134
1135     START_OF_INSTR();
1136     DECODE_PRINTF("ADC\t");
1137     FETCH_DECODE_MODRM(mod, rh, rl);
1138     switch (mod) {
1139     case 0:
1140         destreg = DECODE_RM_BYTE_REGISTER(rh);
1141         DECODE_PRINTF(",");
1142         srcoffset = decode_rm00_address(rl);
1143         srcval = fetch_data_byte(srcoffset);
1144         DECODE_PRINTF("\n");
1145         TRACE_AND_STEP();
1146         *destreg = adc_byte(*destreg, srcval);
1147         break;
1148     case 1:
1149         destreg = DECODE_RM_BYTE_REGISTER(rh);
1150         DECODE_PRINTF(",");
1151         srcoffset = decode_rm01_address(rl);
1152         srcval = fetch_data_byte(srcoffset);
1153         DECODE_PRINTF("\n");
1154         TRACE_AND_STEP();
1155         *destreg = adc_byte(*destreg, srcval);
1156         break;
1157     case 2:
1158         destreg = DECODE_RM_BYTE_REGISTER(rh);
1159         DECODE_PRINTF(",");
1160         srcoffset = decode_rm10_address(rl);
1161         srcval = fetch_data_byte(srcoffset);
1162         DECODE_PRINTF("\n");
1163         TRACE_AND_STEP();
1164         *destreg = adc_byte(*destreg, srcval);
1165         break;
1166     case 3:                     /* register to register */
1167         destreg = DECODE_RM_BYTE_REGISTER(rh);
1168         DECODE_PRINTF(",");
1169         srcreg = DECODE_RM_BYTE_REGISTER(rl);
1170         DECODE_PRINTF("\n");
1171         TRACE_AND_STEP();
1172         *destreg = adc_byte(*destreg, *srcreg);
1173         break;
1174     }
1175     DECODE_CLEAR_SEGOVR();
1176     END_OF_INSTR();
1177 }
1178
1179 /****************************************************************************
1180 REMARKS:
1181 Handles opcode 0x13
1182 ****************************************************************************/
1183 static void x86emuOp_adc_word_R_RM(u8 X86EMU_UNUSED(op1))
1184 {
1185     int mod, rl, rh;
1186     uint srcoffset;
1187
1188     START_OF_INSTR();
1189     DECODE_PRINTF("ADC\t");
1190     FETCH_DECODE_MODRM(mod, rh, rl);
1191     switch (mod) {
1192     case 0:
1193         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1194             u32 *destreg;
1195             u32 srcval;
1196
1197             destreg = DECODE_RM_LONG_REGISTER(rh);
1198             DECODE_PRINTF(",");
1199             srcoffset = decode_rm00_address(rl);
1200             srcval = fetch_data_long(srcoffset);
1201             DECODE_PRINTF("\n");
1202             TRACE_AND_STEP();
1203             *destreg = adc_long(*destreg, srcval);
1204         } else {
1205             u16 *destreg;
1206             u16 srcval;
1207
1208             destreg = DECODE_RM_WORD_REGISTER(rh);
1209             DECODE_PRINTF(",");
1210             srcoffset = decode_rm00_address(rl);
1211             srcval = fetch_data_word(srcoffset);
1212             DECODE_PRINTF("\n");
1213             TRACE_AND_STEP();
1214             *destreg = adc_word(*destreg, srcval);
1215         }
1216         break;
1217     case 1:
1218         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1219             u32 *destreg;
1220             u32 srcval;
1221
1222             destreg = DECODE_RM_LONG_REGISTER(rh);
1223             DECODE_PRINTF(",");
1224             srcoffset = decode_rm01_address(rl);
1225             srcval = fetch_data_long(srcoffset);
1226             DECODE_PRINTF("\n");
1227             TRACE_AND_STEP();
1228             *destreg = adc_long(*destreg, srcval);
1229         } else {
1230             u16 *destreg;
1231             u16 srcval;
1232
1233             destreg = DECODE_RM_WORD_REGISTER(rh);
1234             DECODE_PRINTF(",");
1235             srcoffset = decode_rm01_address(rl);
1236             srcval = fetch_data_word(srcoffset);
1237             DECODE_PRINTF("\n");
1238             TRACE_AND_STEP();
1239             *destreg = adc_word(*destreg, srcval);
1240         }
1241         break;
1242     case 2:
1243         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1244             u32 *destreg;
1245             u32 srcval;
1246
1247             destreg = DECODE_RM_LONG_REGISTER(rh);
1248             DECODE_PRINTF(",");
1249             srcoffset = decode_rm10_address(rl);
1250             srcval = fetch_data_long(srcoffset);
1251             DECODE_PRINTF("\n");
1252             TRACE_AND_STEP();
1253             *destreg = adc_long(*destreg, srcval);
1254         } else {
1255             u16 *destreg;
1256             u16 srcval;
1257
1258             destreg = DECODE_RM_WORD_REGISTER(rh);
1259             DECODE_PRINTF(",");
1260             srcoffset = decode_rm10_address(rl);
1261             srcval = fetch_data_word(srcoffset);
1262             DECODE_PRINTF("\n");
1263             TRACE_AND_STEP();
1264             *destreg = adc_word(*destreg, srcval);
1265         }
1266         break;
1267     case 3:                     /* register to register */
1268         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1269             u32 *destreg,*srcreg;
1270
1271             destreg = DECODE_RM_LONG_REGISTER(rh);
1272             DECODE_PRINTF(",");
1273             srcreg = DECODE_RM_LONG_REGISTER(rl);
1274             DECODE_PRINTF("\n");
1275             TRACE_AND_STEP();
1276             *destreg = adc_long(*destreg, *srcreg);
1277         } else {
1278             u16 *destreg,*srcreg;
1279
1280             destreg = DECODE_RM_WORD_REGISTER(rh);
1281             DECODE_PRINTF(",");
1282             srcreg = DECODE_RM_WORD_REGISTER(rl);
1283             DECODE_PRINTF("\n");
1284             TRACE_AND_STEP();
1285             *destreg = adc_word(*destreg, *srcreg);
1286         }
1287         break;
1288     }
1289     DECODE_CLEAR_SEGOVR();
1290     END_OF_INSTR();
1291 }
1292
1293 /****************************************************************************
1294 REMARKS:
1295 Handles opcode 0x14
1296 ****************************************************************************/
1297 static void x86emuOp_adc_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
1298 {
1299     u8 srcval;
1300
1301     START_OF_INSTR();
1302     DECODE_PRINTF("ADC\tAL,");
1303     srcval = fetch_byte_imm();
1304     DECODE_PRINTF2("%x\n", srcval);
1305     TRACE_AND_STEP();
1306     M.x86.R_AL = adc_byte(M.x86.R_AL, srcval);
1307     DECODE_CLEAR_SEGOVR();
1308     END_OF_INSTR();
1309 }
1310
1311 /****************************************************************************
1312 REMARKS:
1313 Handles opcode 0x15
1314 ****************************************************************************/
1315 static void x86emuOp_adc_word_AX_IMM(u8 X86EMU_UNUSED(op1))
1316 {
1317     u32 srcval;
1318
1319     START_OF_INSTR();
1320     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1321         DECODE_PRINTF("ADC\tEAX,");
1322         srcval = fetch_long_imm();
1323     } else {
1324         DECODE_PRINTF("ADC\tAX,");
1325         srcval = fetch_word_imm();
1326     }
1327     DECODE_PRINTF2("%x\n", srcval);
1328     TRACE_AND_STEP();
1329     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1330         M.x86.R_EAX = adc_long(M.x86.R_EAX, srcval);
1331     } else {
1332         M.x86.R_AX = adc_word(M.x86.R_AX, (u16)srcval);
1333     }
1334     DECODE_CLEAR_SEGOVR();
1335     END_OF_INSTR();
1336 }
1337
1338 /****************************************************************************
1339 REMARKS:
1340 Handles opcode 0x16
1341 ****************************************************************************/
1342 static void x86emuOp_push_SS(u8 X86EMU_UNUSED(op1))
1343 {
1344     START_OF_INSTR();
1345     DECODE_PRINTF("PUSH\tSS\n");
1346     TRACE_AND_STEP();
1347     push_word(M.x86.R_SS);
1348     DECODE_CLEAR_SEGOVR();
1349     END_OF_INSTR();
1350 }
1351
1352 /****************************************************************************
1353 REMARKS:
1354 Handles opcode 0x17
1355 ****************************************************************************/
1356 static void x86emuOp_pop_SS(u8 X86EMU_UNUSED(op1))
1357 {
1358     START_OF_INSTR();
1359     DECODE_PRINTF("POP\tSS\n");
1360     TRACE_AND_STEP();
1361     M.x86.R_SS = pop_word();
1362     DECODE_CLEAR_SEGOVR();
1363     END_OF_INSTR();
1364 }
1365
1366 /****************************************************************************
1367 REMARKS:
1368 Handles opcode 0x18
1369 ****************************************************************************/
1370 static void x86emuOp_sbb_byte_RM_R(u8 X86EMU_UNUSED(op1))
1371 {
1372     int mod, rl, rh;
1373     u8 *destreg, *srcreg;
1374     uint destoffset;
1375     u8 destval;
1376
1377     START_OF_INSTR();
1378     DECODE_PRINTF("SBB\t");
1379     FETCH_DECODE_MODRM(mod, rh, rl);
1380     switch (mod) {
1381     case 0:
1382         destoffset = decode_rm00_address(rl);
1383         DECODE_PRINTF(",");
1384         destval = fetch_data_byte(destoffset);
1385         srcreg = DECODE_RM_BYTE_REGISTER(rh);
1386         DECODE_PRINTF("\n");
1387         TRACE_AND_STEP();
1388         destval = sbb_byte(destval, *srcreg);
1389         store_data_byte(destoffset, destval);
1390         break;
1391     case 1:
1392         destoffset = decode_rm01_address(rl);
1393         DECODE_PRINTF(",");
1394         destval = fetch_data_byte(destoffset);
1395         srcreg = DECODE_RM_BYTE_REGISTER(rh);
1396         DECODE_PRINTF("\n");
1397         TRACE_AND_STEP();
1398         destval = sbb_byte(destval, *srcreg);
1399         store_data_byte(destoffset, destval);
1400         break;
1401     case 2:
1402         destoffset = decode_rm10_address(rl);
1403         DECODE_PRINTF(",");
1404         destval = fetch_data_byte(destoffset);
1405         srcreg = DECODE_RM_BYTE_REGISTER(rh);
1406         DECODE_PRINTF("\n");
1407         TRACE_AND_STEP();
1408         destval = sbb_byte(destval, *srcreg);
1409         store_data_byte(destoffset, destval);
1410         break;
1411     case 3:                     /* register to register */
1412         destreg = DECODE_RM_BYTE_REGISTER(rl);
1413         DECODE_PRINTF(",");
1414         srcreg = DECODE_RM_BYTE_REGISTER(rh);
1415         DECODE_PRINTF("\n");
1416         TRACE_AND_STEP();
1417         *destreg = sbb_byte(*destreg, *srcreg);
1418         break;
1419     }
1420     DECODE_CLEAR_SEGOVR();
1421     END_OF_INSTR();
1422 }
1423
1424 /****************************************************************************
1425 REMARKS:
1426 Handles opcode 0x19
1427 ****************************************************************************/
1428 static void x86emuOp_sbb_word_RM_R(u8 X86EMU_UNUSED(op1))
1429 {
1430     int mod, rl, rh;
1431     uint destoffset;
1432
1433     START_OF_INSTR();
1434     DECODE_PRINTF("SBB\t");
1435     FETCH_DECODE_MODRM(mod, rh, rl);
1436     switch (mod) {
1437     case 0:
1438         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1439             u32 destval;
1440             u32 *srcreg;
1441
1442             destoffset = decode_rm00_address(rl);
1443             DECODE_PRINTF(",");
1444             destval = fetch_data_long(destoffset);
1445             srcreg = DECODE_RM_LONG_REGISTER(rh);
1446             DECODE_PRINTF("\n");
1447             TRACE_AND_STEP();
1448             destval = sbb_long(destval, *srcreg);
1449             store_data_long(destoffset, destval);
1450         } else {
1451             u16 destval;
1452             u16 *srcreg;
1453
1454             destoffset = decode_rm00_address(rl);
1455             DECODE_PRINTF(",");
1456             destval = fetch_data_word(destoffset);
1457             srcreg = DECODE_RM_WORD_REGISTER(rh);
1458             DECODE_PRINTF("\n");
1459             TRACE_AND_STEP();
1460             destval = sbb_word(destval, *srcreg);
1461             store_data_word(destoffset, destval);
1462         }
1463         break;
1464     case 1:
1465         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1466             u32 destval;
1467             u32 *srcreg;
1468
1469             destoffset = decode_rm01_address(rl);
1470             DECODE_PRINTF(",");
1471             destval = fetch_data_long(destoffset);
1472             srcreg = DECODE_RM_LONG_REGISTER(rh);
1473             DECODE_PRINTF("\n");
1474             TRACE_AND_STEP();
1475             destval = sbb_long(destval, *srcreg);
1476             store_data_long(destoffset, destval);
1477         } else {
1478             u16 destval;
1479             u16 *srcreg;
1480
1481             destoffset = decode_rm01_address(rl);
1482             DECODE_PRINTF(",");
1483             destval = fetch_data_word(destoffset);
1484             srcreg = DECODE_RM_WORD_REGISTER(rh);
1485             DECODE_PRINTF("\n");
1486             TRACE_AND_STEP();
1487             destval = sbb_word(destval, *srcreg);
1488             store_data_word(destoffset, destval);
1489         }
1490         break;
1491     case 2:
1492         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1493             u32 destval;
1494             u32 *srcreg;
1495
1496             destoffset = decode_rm10_address(rl);
1497             DECODE_PRINTF(",");
1498             destval = fetch_data_long(destoffset);
1499             srcreg = DECODE_RM_LONG_REGISTER(rh);
1500             DECODE_PRINTF("\n");
1501             TRACE_AND_STEP();
1502             destval = sbb_long(destval, *srcreg);
1503             store_data_long(destoffset, destval);
1504         } else {
1505             u16 destval;
1506             u16 *srcreg;
1507
1508             destoffset = decode_rm10_address(rl);
1509             DECODE_PRINTF(",");
1510             destval = fetch_data_word(destoffset);
1511             srcreg = DECODE_RM_WORD_REGISTER(rh);
1512             DECODE_PRINTF("\n");
1513             TRACE_AND_STEP();
1514             destval = sbb_word(destval, *srcreg);
1515             store_data_word(destoffset, destval);
1516         }
1517         break;
1518     case 3:                     /* register to register */
1519         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1520             u32 *destreg,*srcreg;
1521
1522             destreg = DECODE_RM_LONG_REGISTER(rl);
1523             DECODE_PRINTF(",");
1524             srcreg = DECODE_RM_LONG_REGISTER(rh);
1525             DECODE_PRINTF("\n");
1526             TRACE_AND_STEP();
1527             *destreg = sbb_long(*destreg, *srcreg);
1528         } else {
1529             u16 *destreg,*srcreg;
1530
1531             destreg = DECODE_RM_WORD_REGISTER(rl);
1532             DECODE_PRINTF(",");
1533             srcreg = DECODE_RM_WORD_REGISTER(rh);
1534             DECODE_PRINTF("\n");
1535             TRACE_AND_STEP();
1536             *destreg = sbb_word(*destreg, *srcreg);
1537         }
1538         break;
1539     }
1540     DECODE_CLEAR_SEGOVR();
1541     END_OF_INSTR();
1542 }
1543
1544 /****************************************************************************
1545 REMARKS:
1546 Handles opcode 0x1a
1547 ****************************************************************************/
1548 static void x86emuOp_sbb_byte_R_RM(u8 X86EMU_UNUSED(op1))
1549 {
1550     int mod, rl, rh;
1551     u8 *destreg, *srcreg;
1552     uint srcoffset;
1553     u8 srcval;
1554
1555     START_OF_INSTR();
1556     DECODE_PRINTF("SBB\t");
1557     FETCH_DECODE_MODRM(mod, rh, rl);
1558     switch (mod) {
1559     case 0:
1560         destreg = DECODE_RM_BYTE_REGISTER(rh);
1561         DECODE_PRINTF(",");
1562         srcoffset = decode_rm00_address(rl);
1563         srcval = fetch_data_byte(srcoffset);
1564         DECODE_PRINTF("\n");
1565         TRACE_AND_STEP();
1566         *destreg = sbb_byte(*destreg, srcval);
1567         break;
1568     case 1:
1569         destreg = DECODE_RM_BYTE_REGISTER(rh);
1570         DECODE_PRINTF(",");
1571         srcoffset = decode_rm01_address(rl);
1572         srcval = fetch_data_byte(srcoffset);
1573         DECODE_PRINTF("\n");
1574         TRACE_AND_STEP();
1575         *destreg = sbb_byte(*destreg, srcval);
1576         break;
1577     case 2:
1578         destreg = DECODE_RM_BYTE_REGISTER(rh);
1579         DECODE_PRINTF(",");
1580         srcoffset = decode_rm10_address(rl);
1581         srcval = fetch_data_byte(srcoffset);
1582         DECODE_PRINTF("\n");
1583         TRACE_AND_STEP();
1584         *destreg = sbb_byte(*destreg, srcval);
1585         break;
1586     case 3:                     /* register to register */
1587         destreg = DECODE_RM_BYTE_REGISTER(rh);
1588         DECODE_PRINTF(",");
1589         srcreg = DECODE_RM_BYTE_REGISTER(rl);
1590         DECODE_PRINTF("\n");
1591         TRACE_AND_STEP();
1592         *destreg = sbb_byte(*destreg, *srcreg);
1593         break;
1594     }
1595     DECODE_CLEAR_SEGOVR();
1596     END_OF_INSTR();
1597 }
1598
1599 /****************************************************************************
1600 REMARKS:
1601 Handles opcode 0x1b
1602 ****************************************************************************/
1603 static void x86emuOp_sbb_word_R_RM(u8 X86EMU_UNUSED(op1))
1604 {
1605     int mod, rl, rh;
1606     uint srcoffset;
1607
1608     START_OF_INSTR();
1609     DECODE_PRINTF("SBB\t");
1610     FETCH_DECODE_MODRM(mod, rh, rl);
1611     switch (mod) {
1612     case 0:
1613         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1614             u32 *destreg;
1615             u32 srcval;
1616
1617             destreg = DECODE_RM_LONG_REGISTER(rh);
1618             DECODE_PRINTF(",");
1619             srcoffset = decode_rm00_address(rl);
1620             srcval = fetch_data_long(srcoffset);
1621             DECODE_PRINTF("\n");
1622             TRACE_AND_STEP();
1623             *destreg = sbb_long(*destreg, srcval);
1624         } else {
1625             u16 *destreg;
1626             u16 srcval;
1627
1628             destreg = DECODE_RM_WORD_REGISTER(rh);
1629             DECODE_PRINTF(",");
1630             srcoffset = decode_rm00_address(rl);
1631             srcval = fetch_data_word(srcoffset);
1632             DECODE_PRINTF("\n");
1633             TRACE_AND_STEP();
1634             *destreg = sbb_word(*destreg, srcval);
1635         }
1636         break;
1637     case 1:
1638         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1639             u32 *destreg;
1640             u32 srcval;
1641
1642             destreg = DECODE_RM_LONG_REGISTER(rh);
1643             DECODE_PRINTF(",");
1644             srcoffset = decode_rm01_address(rl);
1645             srcval = fetch_data_long(srcoffset);
1646             DECODE_PRINTF("\n");
1647             TRACE_AND_STEP();
1648             *destreg = sbb_long(*destreg, srcval);
1649         } else {
1650             u16 *destreg;
1651             u16 srcval;
1652
1653             destreg = DECODE_RM_WORD_REGISTER(rh);
1654             DECODE_PRINTF(",");
1655             srcoffset = decode_rm01_address(rl);
1656             srcval = fetch_data_word(srcoffset);
1657             DECODE_PRINTF("\n");
1658             TRACE_AND_STEP();
1659             *destreg = sbb_word(*destreg, srcval);
1660         }
1661         break;
1662     case 2:
1663         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1664             u32 *destreg;
1665             u32 srcval;
1666
1667             destreg = DECODE_RM_LONG_REGISTER(rh);
1668             DECODE_PRINTF(",");
1669             srcoffset = decode_rm10_address(rl);
1670             srcval = fetch_data_long(srcoffset);
1671             DECODE_PRINTF("\n");
1672             TRACE_AND_STEP();
1673             *destreg = sbb_long(*destreg, srcval);
1674         } else {
1675             u16 *destreg;
1676             u16 srcval;
1677
1678             destreg = DECODE_RM_WORD_REGISTER(rh);
1679             DECODE_PRINTF(",");
1680             srcoffset = decode_rm10_address(rl);
1681             srcval = fetch_data_word(srcoffset);
1682             DECODE_PRINTF("\n");
1683             TRACE_AND_STEP();
1684             *destreg = sbb_word(*destreg, srcval);
1685         }
1686         break;
1687     case 3:                     /* register to register */
1688         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1689             u32 *destreg,*srcreg;
1690
1691             destreg = DECODE_RM_LONG_REGISTER(rh);
1692             DECODE_PRINTF(",");
1693             srcreg = DECODE_RM_LONG_REGISTER(rl);
1694             DECODE_PRINTF("\n");
1695             TRACE_AND_STEP();
1696             *destreg = sbb_long(*destreg, *srcreg);
1697         } else {
1698             u16 *destreg,*srcreg;
1699
1700             destreg = DECODE_RM_WORD_REGISTER(rh);
1701             DECODE_PRINTF(",");
1702             srcreg = DECODE_RM_WORD_REGISTER(rl);
1703             DECODE_PRINTF("\n");
1704             TRACE_AND_STEP();
1705             *destreg = sbb_word(*destreg, *srcreg);
1706         }
1707         break;
1708     }
1709     DECODE_CLEAR_SEGOVR();
1710     END_OF_INSTR();
1711 }
1712
1713 /****************************************************************************
1714 REMARKS:
1715 Handles opcode 0x1c
1716 ****************************************************************************/
1717 static void x86emuOp_sbb_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
1718 {
1719     u8 srcval;
1720
1721     START_OF_INSTR();
1722     DECODE_PRINTF("SBB\tAL,");
1723     srcval = fetch_byte_imm();
1724     DECODE_PRINTF2("%x\n", srcval);
1725     TRACE_AND_STEP();
1726     M.x86.R_AL = sbb_byte(M.x86.R_AL, srcval);
1727     DECODE_CLEAR_SEGOVR();
1728     END_OF_INSTR();
1729 }
1730
1731 /****************************************************************************
1732 REMARKS:
1733 Handles opcode 0x1d
1734 ****************************************************************************/
1735 static void x86emuOp_sbb_word_AX_IMM(u8 X86EMU_UNUSED(op1))
1736 {
1737     u32 srcval;
1738
1739     START_OF_INSTR();
1740     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1741         DECODE_PRINTF("SBB\tEAX,");
1742         srcval = fetch_long_imm();
1743     } else {
1744         DECODE_PRINTF("SBB\tAX,");
1745         srcval = fetch_word_imm();
1746     }
1747     DECODE_PRINTF2("%x\n", srcval);
1748     TRACE_AND_STEP();
1749     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1750         M.x86.R_EAX = sbb_long(M.x86.R_EAX, srcval);
1751     } else {
1752         M.x86.R_AX = sbb_word(M.x86.R_AX, (u16)srcval);
1753     }
1754     DECODE_CLEAR_SEGOVR();
1755     END_OF_INSTR();
1756 }
1757
1758 /****************************************************************************
1759 REMARKS:
1760 Handles opcode 0x1e
1761 ****************************************************************************/
1762 static void x86emuOp_push_DS(u8 X86EMU_UNUSED(op1))
1763 {
1764     START_OF_INSTR();
1765     DECODE_PRINTF("PUSH\tDS\n");
1766     TRACE_AND_STEP();
1767     push_word(M.x86.R_DS);
1768     DECODE_CLEAR_SEGOVR();
1769     END_OF_INSTR();
1770 }
1771
1772 /****************************************************************************
1773 REMARKS:
1774 Handles opcode 0x1f
1775 ****************************************************************************/
1776 static void x86emuOp_pop_DS(u8 X86EMU_UNUSED(op1))
1777 {
1778     START_OF_INSTR();
1779     DECODE_PRINTF("POP\tDS\n");
1780     TRACE_AND_STEP();
1781     M.x86.R_DS = pop_word();
1782     DECODE_CLEAR_SEGOVR();
1783     END_OF_INSTR();
1784 }
1785
1786 /****************************************************************************
1787 REMARKS:
1788 Handles opcode 0x20
1789 ****************************************************************************/
1790 static void x86emuOp_and_byte_RM_R(u8 X86EMU_UNUSED(op1))
1791 {
1792     int mod, rl, rh;
1793     u8 *destreg, *srcreg;
1794     uint destoffset;
1795     u8 destval;
1796
1797     START_OF_INSTR();
1798     DECODE_PRINTF("AND\t");
1799     FETCH_DECODE_MODRM(mod, rh, rl);
1800
1801     switch (mod) {
1802     case 0:
1803         destoffset = decode_rm00_address(rl);
1804         DECODE_PRINTF(",");
1805         destval = fetch_data_byte(destoffset);
1806         srcreg = DECODE_RM_BYTE_REGISTER(rh);
1807         DECODE_PRINTF("\n");
1808         TRACE_AND_STEP();
1809         destval = and_byte(destval, *srcreg);
1810         store_data_byte(destoffset, destval);
1811         break;
1812
1813     case 1:
1814         destoffset = decode_rm01_address(rl);
1815         DECODE_PRINTF(",");
1816         destval = fetch_data_byte(destoffset);
1817         srcreg = DECODE_RM_BYTE_REGISTER(rh);
1818         DECODE_PRINTF("\n");
1819         TRACE_AND_STEP();
1820         destval = and_byte(destval, *srcreg);
1821         store_data_byte(destoffset, destval);
1822         break;
1823
1824     case 2:
1825         destoffset = decode_rm10_address(rl);
1826         DECODE_PRINTF(",");
1827         destval = fetch_data_byte(destoffset);
1828         srcreg = DECODE_RM_BYTE_REGISTER(rh);
1829         DECODE_PRINTF("\n");
1830         TRACE_AND_STEP();
1831         destval = and_byte(destval, *srcreg);
1832         store_data_byte(destoffset, destval);
1833         break;
1834
1835     case 3:                     /* register to register */
1836         destreg = DECODE_RM_BYTE_REGISTER(rl);
1837         DECODE_PRINTF(",");
1838         srcreg = DECODE_RM_BYTE_REGISTER(rh);
1839         DECODE_PRINTF("\n");
1840         TRACE_AND_STEP();
1841         *destreg = and_byte(*destreg, *srcreg);
1842         break;
1843     }
1844     DECODE_CLEAR_SEGOVR();
1845     END_OF_INSTR();
1846 }
1847
1848 /****************************************************************************
1849 REMARKS:
1850 Handles opcode 0x21
1851 ****************************************************************************/
1852 static void x86emuOp_and_word_RM_R(u8 X86EMU_UNUSED(op1))
1853 {
1854     int mod, rl, rh;
1855     uint destoffset;
1856
1857     START_OF_INSTR();
1858     DECODE_PRINTF("AND\t");
1859     FETCH_DECODE_MODRM(mod, rh, rl);
1860     switch (mod) {
1861     case 0:
1862         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1863             u32 destval;
1864             u32 *srcreg;
1865
1866             destoffset = decode_rm00_address(rl);
1867             DECODE_PRINTF(",");
1868             destval = fetch_data_long(destoffset);
1869             srcreg = DECODE_RM_LONG_REGISTER(rh);
1870             DECODE_PRINTF("\n");
1871             TRACE_AND_STEP();
1872             destval = and_long(destval, *srcreg);
1873             store_data_long(destoffset, destval);
1874         } else {
1875             u16 destval;
1876             u16 *srcreg;
1877
1878             destoffset = decode_rm00_address(rl);
1879             DECODE_PRINTF(",");
1880             destval = fetch_data_word(destoffset);
1881             srcreg = DECODE_RM_WORD_REGISTER(rh);
1882             DECODE_PRINTF("\n");
1883             TRACE_AND_STEP();
1884             destval = and_word(destval, *srcreg);
1885             store_data_word(destoffset, destval);
1886         }
1887         break;
1888     case 1:
1889         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1890             u32 destval;
1891             u32 *srcreg;
1892
1893             destoffset = decode_rm01_address(rl);
1894             DECODE_PRINTF(",");
1895             destval = fetch_data_long(destoffset);
1896             srcreg = DECODE_RM_LONG_REGISTER(rh);
1897             DECODE_PRINTF("\n");
1898             TRACE_AND_STEP();
1899             destval = and_long(destval, *srcreg);
1900             store_data_long(destoffset, destval);
1901         } else {
1902             u16 destval;
1903             u16 *srcreg;
1904
1905             destoffset = decode_rm01_address(rl);
1906             DECODE_PRINTF(",");
1907             destval = fetch_data_word(destoffset);
1908             srcreg = DECODE_RM_WORD_REGISTER(rh);
1909             DECODE_PRINTF("\n");
1910             TRACE_AND_STEP();
1911             destval = and_word(destval, *srcreg);
1912             store_data_word(destoffset, destval);
1913         }
1914         break;
1915     case 2:
1916         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1917             u32 destval;
1918             u32 *srcreg;
1919
1920             destoffset = decode_rm10_address(rl);
1921             DECODE_PRINTF(",");
1922             destval = fetch_data_long(destoffset);
1923             srcreg = DECODE_RM_LONG_REGISTER(rh);
1924             DECODE_PRINTF("\n");
1925             TRACE_AND_STEP();
1926             destval = and_long(destval, *srcreg);
1927             store_data_long(destoffset, destval);
1928         } else {
1929             u16 destval;
1930             u16 *srcreg;
1931
1932             destoffset = decode_rm10_address(rl);
1933             DECODE_PRINTF(",");
1934             destval = fetch_data_word(destoffset);
1935             srcreg = DECODE_RM_WORD_REGISTER(rh);
1936             DECODE_PRINTF("\n");
1937             TRACE_AND_STEP();
1938             destval = and_word(destval, *srcreg);
1939             store_data_word(destoffset, destval);
1940         }
1941         break;
1942     case 3:                     /* register to register */
1943         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
1944             u32 *destreg,*srcreg;
1945
1946             destreg = DECODE_RM_LONG_REGISTER(rl);
1947             DECODE_PRINTF(",");
1948             srcreg = DECODE_RM_LONG_REGISTER(rh);
1949             DECODE_PRINTF("\n");
1950             TRACE_AND_STEP();
1951             *destreg = and_long(*destreg, *srcreg);
1952         } else {
1953             u16 *destreg,*srcreg;
1954
1955             destreg = DECODE_RM_WORD_REGISTER(rl);
1956             DECODE_PRINTF(",");
1957             srcreg = DECODE_RM_WORD_REGISTER(rh);
1958             DECODE_PRINTF("\n");
1959             TRACE_AND_STEP();
1960             *destreg = and_word(*destreg, *srcreg);
1961         }
1962         break;
1963     }
1964     DECODE_CLEAR_SEGOVR();
1965     END_OF_INSTR();
1966 }
1967
1968 /****************************************************************************
1969 REMARKS:
1970 Handles opcode 0x22
1971 ****************************************************************************/
1972 static void x86emuOp_and_byte_R_RM(u8 X86EMU_UNUSED(op1))
1973 {
1974     int mod, rl, rh;
1975     u8 *destreg, *srcreg;
1976     uint srcoffset;
1977     u8 srcval;
1978
1979     START_OF_INSTR();
1980     DECODE_PRINTF("AND\t");
1981     FETCH_DECODE_MODRM(mod, rh, rl);
1982     switch (mod) {
1983     case 0:
1984         destreg = DECODE_RM_BYTE_REGISTER(rh);
1985         DECODE_PRINTF(",");
1986         srcoffset = decode_rm00_address(rl);
1987         srcval = fetch_data_byte(srcoffset);
1988         DECODE_PRINTF("\n");
1989         TRACE_AND_STEP();
1990         *destreg = and_byte(*destreg, srcval);
1991         break;
1992     case 1:
1993         destreg = DECODE_RM_BYTE_REGISTER(rh);
1994         DECODE_PRINTF(",");
1995         srcoffset = decode_rm01_address(rl);
1996         srcval = fetch_data_byte(srcoffset);
1997         DECODE_PRINTF("\n");
1998         TRACE_AND_STEP();
1999         *destreg = and_byte(*destreg, srcval);
2000         break;
2001     case 2:
2002         destreg = DECODE_RM_BYTE_REGISTER(rh);
2003         DECODE_PRINTF(",");
2004         srcoffset = decode_rm10_address(rl);
2005         srcval = fetch_data_byte(srcoffset);
2006         DECODE_PRINTF("\n");
2007         TRACE_AND_STEP();
2008         *destreg = and_byte(*destreg, srcval);
2009         break;
2010     case 3:                     /* register to register */
2011         destreg = DECODE_RM_BYTE_REGISTER(rh);
2012         DECODE_PRINTF(",");
2013         srcreg = DECODE_RM_BYTE_REGISTER(rl);
2014         DECODE_PRINTF("\n");
2015         TRACE_AND_STEP();
2016         *destreg = and_byte(*destreg, *srcreg);
2017         break;
2018     }
2019     DECODE_CLEAR_SEGOVR();
2020     END_OF_INSTR();
2021 }
2022
2023 /****************************************************************************
2024 REMARKS:
2025 Handles opcode 0x23
2026 ****************************************************************************/
2027 static void x86emuOp_and_word_R_RM(u8 X86EMU_UNUSED(op1))
2028 {
2029     int mod, rl, rh;
2030     uint srcoffset;
2031
2032     START_OF_INSTR();
2033     DECODE_PRINTF("AND\t");
2034     FETCH_DECODE_MODRM(mod, rh, rl);
2035     switch (mod) {
2036     case 0:
2037         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2038             u32 *destreg;
2039             u32 srcval;
2040
2041             destreg = DECODE_RM_LONG_REGISTER(rh);
2042             DECODE_PRINTF(",");
2043             srcoffset = decode_rm00_address(rl);
2044             srcval = fetch_data_long(srcoffset);
2045             DECODE_PRINTF("\n");
2046             TRACE_AND_STEP();
2047             *destreg = and_long(*destreg, srcval);
2048         } else {
2049             u16 *destreg;
2050             u16 srcval;
2051
2052             destreg = DECODE_RM_WORD_REGISTER(rh);
2053             DECODE_PRINTF(",");
2054             srcoffset = decode_rm00_address(rl);
2055             srcval = fetch_data_word(srcoffset);
2056             DECODE_PRINTF("\n");
2057             TRACE_AND_STEP();
2058             *destreg = and_word(*destreg, srcval);
2059         }
2060         break;
2061     case 1:
2062         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2063             u32 *destreg;
2064             u32 srcval;
2065
2066             destreg = DECODE_RM_LONG_REGISTER(rh);
2067             DECODE_PRINTF(",");
2068             srcoffset = decode_rm01_address(rl);
2069             srcval = fetch_data_long(srcoffset);
2070             DECODE_PRINTF("\n");
2071             TRACE_AND_STEP();
2072             *destreg = and_long(*destreg, srcval);
2073             break;
2074         } else {
2075             u16 *destreg;
2076             u16 srcval;
2077
2078             destreg = DECODE_RM_WORD_REGISTER(rh);
2079             DECODE_PRINTF(",");
2080             srcoffset = decode_rm01_address(rl);
2081             srcval = fetch_data_word(srcoffset);
2082             DECODE_PRINTF("\n");
2083             TRACE_AND_STEP();
2084             *destreg = and_word(*destreg, srcval);
2085             break;
2086         }
2087     case 2:
2088         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2089             u32 *destreg;
2090             u32 srcval;
2091
2092             destreg = DECODE_RM_LONG_REGISTER(rh);
2093             DECODE_PRINTF(",");
2094             srcoffset = decode_rm10_address(rl);
2095             srcval = fetch_data_long(srcoffset);
2096             DECODE_PRINTF("\n");
2097             TRACE_AND_STEP();
2098             *destreg = and_long(*destreg, srcval);
2099         } else {
2100             u16 *destreg;
2101             u16 srcval;
2102
2103             destreg = DECODE_RM_WORD_REGISTER(rh);
2104             DECODE_PRINTF(",");
2105             srcoffset = decode_rm10_address(rl);
2106             srcval = fetch_data_word(srcoffset);
2107             DECODE_PRINTF("\n");
2108             TRACE_AND_STEP();
2109             *destreg = and_word(*destreg, srcval);
2110         }
2111         break;
2112     case 3:                     /* register to register */
2113         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2114             u32 *destreg,*srcreg;
2115
2116             destreg = DECODE_RM_LONG_REGISTER(rh);
2117             DECODE_PRINTF(",");
2118             srcreg = DECODE_RM_LONG_REGISTER(rl);
2119             DECODE_PRINTF("\n");
2120             TRACE_AND_STEP();
2121             *destreg = and_long(*destreg, *srcreg);
2122         } else {
2123             u16 *destreg,*srcreg;
2124
2125             destreg = DECODE_RM_WORD_REGISTER(rh);
2126             DECODE_PRINTF(",");
2127             srcreg = DECODE_RM_WORD_REGISTER(rl);
2128             DECODE_PRINTF("\n");
2129             TRACE_AND_STEP();
2130             *destreg = and_word(*destreg, *srcreg);
2131         }
2132         break;
2133     }
2134     DECODE_CLEAR_SEGOVR();
2135     END_OF_INSTR();
2136 }
2137
2138 /****************************************************************************
2139 REMARKS:
2140 Handles opcode 0x24
2141 ****************************************************************************/
2142 static void x86emuOp_and_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
2143 {
2144     u8 srcval;
2145
2146     START_OF_INSTR();
2147     DECODE_PRINTF("AND\tAL,");
2148     srcval = fetch_byte_imm();
2149     DECODE_PRINTF2("%x\n", srcval);
2150     TRACE_AND_STEP();
2151     M.x86.R_AL = and_byte(M.x86.R_AL, srcval);
2152     DECODE_CLEAR_SEGOVR();
2153     END_OF_INSTR();
2154 }
2155
2156 /****************************************************************************
2157 REMARKS:
2158 Handles opcode 0x25
2159 ****************************************************************************/
2160 static void x86emuOp_and_word_AX_IMM(u8 X86EMU_UNUSED(op1))
2161 {
2162     u32 srcval;
2163
2164     START_OF_INSTR();
2165     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2166         DECODE_PRINTF("AND\tEAX,");
2167         srcval = fetch_long_imm();
2168     } else {
2169         DECODE_PRINTF("AND\tAX,");
2170         srcval = fetch_word_imm();
2171     }
2172     DECODE_PRINTF2("%x\n", srcval);
2173     TRACE_AND_STEP();
2174     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2175         M.x86.R_EAX = and_long(M.x86.R_EAX, srcval);
2176     } else {
2177         M.x86.R_AX = and_word(M.x86.R_AX, (u16)srcval);
2178     }
2179     DECODE_CLEAR_SEGOVR();
2180     END_OF_INSTR();
2181 }
2182
2183 /****************************************************************************
2184 REMARKS:
2185 Handles opcode 0x26
2186 ****************************************************************************/
2187 static void x86emuOp_segovr_ES(u8 X86EMU_UNUSED(op1))
2188 {
2189     START_OF_INSTR();
2190     DECODE_PRINTF("ES:\n");
2191     TRACE_AND_STEP();
2192     M.x86.mode |= SYSMODE_SEGOVR_ES;
2193     /*
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.
2196      */
2197     END_OF_INSTR();
2198 }
2199
2200 /****************************************************************************
2201 REMARKS:
2202 Handles opcode 0x27
2203 ****************************************************************************/
2204 static void x86emuOp_daa(u8 X86EMU_UNUSED(op1))
2205 {
2206     START_OF_INSTR();
2207     DECODE_PRINTF("DAA\n");
2208     TRACE_AND_STEP();
2209     M.x86.R_AL = daa_byte(M.x86.R_AL);
2210     DECODE_CLEAR_SEGOVR();
2211     END_OF_INSTR();
2212 }
2213
2214 /****************************************************************************
2215 REMARKS:
2216 Handles opcode 0x28
2217 ****************************************************************************/
2218 static void x86emuOp_sub_byte_RM_R(u8 X86EMU_UNUSED(op1))
2219 {
2220     int mod, rl, rh;
2221     u8 *destreg, *srcreg;
2222     uint destoffset;
2223     u8 destval;
2224
2225     START_OF_INSTR();
2226     DECODE_PRINTF("SUB\t");
2227     FETCH_DECODE_MODRM(mod, rh, rl);
2228     switch (mod) {
2229     case 0:
2230         destoffset = decode_rm00_address(rl);
2231         DECODE_PRINTF(",");
2232         destval = fetch_data_byte(destoffset);
2233         srcreg = DECODE_RM_BYTE_REGISTER(rh);
2234         DECODE_PRINTF("\n");
2235         TRACE_AND_STEP();
2236         destval = sub_byte(destval, *srcreg);
2237         store_data_byte(destoffset, destval);
2238         break;
2239     case 1:
2240         destoffset = decode_rm01_address(rl);
2241         DECODE_PRINTF(",");
2242         destval = fetch_data_byte(destoffset);
2243         srcreg = DECODE_RM_BYTE_REGISTER(rh);
2244         DECODE_PRINTF("\n");
2245         TRACE_AND_STEP();
2246         destval = sub_byte(destval, *srcreg);
2247         store_data_byte(destoffset, destval);
2248         break;
2249     case 2:
2250         destoffset = decode_rm10_address(rl);
2251         DECODE_PRINTF(",");
2252         destval = fetch_data_byte(destoffset);
2253         srcreg = DECODE_RM_BYTE_REGISTER(rh);
2254         DECODE_PRINTF("\n");
2255         TRACE_AND_STEP();
2256         destval = sub_byte(destval, *srcreg);
2257         store_data_byte(destoffset, destval);
2258         break;
2259     case 3:                     /* register to register */
2260         destreg = DECODE_RM_BYTE_REGISTER(rl);
2261         DECODE_PRINTF(",");
2262         srcreg = DECODE_RM_BYTE_REGISTER(rh);
2263         DECODE_PRINTF("\n");
2264         TRACE_AND_STEP();
2265         *destreg = sub_byte(*destreg, *srcreg);
2266         break;
2267     }
2268     DECODE_CLEAR_SEGOVR();
2269     END_OF_INSTR();
2270 }
2271
2272 /****************************************************************************
2273 REMARKS:
2274 Handles opcode 0x29
2275 ****************************************************************************/
2276 static void x86emuOp_sub_word_RM_R(u8 X86EMU_UNUSED(op1))
2277 {
2278     int mod, rl, rh;
2279     uint destoffset;
2280
2281     START_OF_INSTR();
2282     DECODE_PRINTF("SUB\t");
2283     FETCH_DECODE_MODRM(mod, rh, rl);
2284     switch (mod) {
2285     case 0:
2286         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2287             u32 destval;
2288             u32 *srcreg;
2289
2290             destoffset = decode_rm00_address(rl);
2291             DECODE_PRINTF(",");
2292             destval = fetch_data_long(destoffset);
2293             srcreg = DECODE_RM_LONG_REGISTER(rh);
2294             DECODE_PRINTF("\n");
2295             TRACE_AND_STEP();
2296             destval = sub_long(destval, *srcreg);
2297             store_data_long(destoffset, destval);
2298         } else {
2299             u16 destval;
2300             u16 *srcreg;
2301
2302             destoffset = decode_rm00_address(rl);
2303             DECODE_PRINTF(",");
2304             destval = fetch_data_word(destoffset);
2305             srcreg = DECODE_RM_WORD_REGISTER(rh);
2306             DECODE_PRINTF("\n");
2307             TRACE_AND_STEP();
2308             destval = sub_word(destval, *srcreg);
2309             store_data_word(destoffset, destval);
2310         }
2311         break;
2312     case 1:
2313         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2314             u32 destval;
2315             u32 *srcreg;
2316
2317             destoffset = decode_rm01_address(rl);
2318             DECODE_PRINTF(",");
2319             destval = fetch_data_long(destoffset);
2320             srcreg = DECODE_RM_LONG_REGISTER(rh);
2321             DECODE_PRINTF("\n");
2322             TRACE_AND_STEP();
2323             destval = sub_long(destval, *srcreg);
2324             store_data_long(destoffset, destval);
2325         } else {
2326             u16 destval;
2327             u16 *srcreg;
2328
2329             destoffset = decode_rm01_address(rl);
2330             DECODE_PRINTF(",");
2331             destval = fetch_data_word(destoffset);
2332             srcreg = DECODE_RM_WORD_REGISTER(rh);
2333             DECODE_PRINTF("\n");
2334             TRACE_AND_STEP();
2335             destval = sub_word(destval, *srcreg);
2336             store_data_word(destoffset, destval);
2337         }
2338         break;
2339     case 2:
2340         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2341             u32 destval;
2342             u32 *srcreg;
2343
2344             destoffset = decode_rm10_address(rl);
2345             DECODE_PRINTF(",");
2346             destval = fetch_data_long(destoffset);
2347             srcreg = DECODE_RM_LONG_REGISTER(rh);
2348             DECODE_PRINTF("\n");
2349             TRACE_AND_STEP();
2350             destval = sub_long(destval, *srcreg);
2351             store_data_long(destoffset, destval);
2352         } else {
2353             u16 destval;
2354             u16 *srcreg;
2355
2356             destoffset = decode_rm10_address(rl);
2357             DECODE_PRINTF(",");
2358             destval = fetch_data_word(destoffset);
2359             srcreg = DECODE_RM_WORD_REGISTER(rh);
2360             DECODE_PRINTF("\n");
2361             TRACE_AND_STEP();
2362             destval = sub_word(destval, *srcreg);
2363             store_data_word(destoffset, destval);
2364         }
2365         break;
2366     case 3:                     /* register to register */
2367         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2368             u32 *destreg,*srcreg;
2369
2370             destreg = DECODE_RM_LONG_REGISTER(rl);
2371             DECODE_PRINTF(",");
2372             srcreg = DECODE_RM_LONG_REGISTER(rh);
2373             DECODE_PRINTF("\n");
2374             TRACE_AND_STEP();
2375             *destreg = sub_long(*destreg, *srcreg);
2376         } else {
2377             u16 *destreg,*srcreg;
2378
2379             destreg = DECODE_RM_WORD_REGISTER(rl);
2380             DECODE_PRINTF(",");
2381             srcreg = DECODE_RM_WORD_REGISTER(rh);
2382             DECODE_PRINTF("\n");
2383             TRACE_AND_STEP();
2384             *destreg = sub_word(*destreg, *srcreg);
2385         }
2386         break;
2387     }
2388     DECODE_CLEAR_SEGOVR();
2389     END_OF_INSTR();
2390 }
2391
2392 /****************************************************************************
2393 REMARKS:
2394 Handles opcode 0x2a
2395 ****************************************************************************/
2396 static void x86emuOp_sub_byte_R_RM(u8 X86EMU_UNUSED(op1))
2397 {
2398     int mod, rl, rh;
2399     u8 *destreg, *srcreg;
2400     uint srcoffset;
2401     u8 srcval;
2402
2403     START_OF_INSTR();
2404     DECODE_PRINTF("SUB\t");
2405     FETCH_DECODE_MODRM(mod, rh, rl);
2406     switch (mod) {
2407     case 0:
2408         destreg = DECODE_RM_BYTE_REGISTER(rh);
2409         DECODE_PRINTF(",");
2410         srcoffset = decode_rm00_address(rl);
2411         srcval = fetch_data_byte(srcoffset);
2412         DECODE_PRINTF("\n");
2413         TRACE_AND_STEP();
2414         *destreg = sub_byte(*destreg, srcval);
2415         break;
2416     case 1:
2417         destreg = DECODE_RM_BYTE_REGISTER(rh);
2418         DECODE_PRINTF(",");
2419         srcoffset = decode_rm01_address(rl);
2420         srcval = fetch_data_byte(srcoffset);
2421         DECODE_PRINTF("\n");
2422         TRACE_AND_STEP();
2423         *destreg = sub_byte(*destreg, srcval);
2424         break;
2425     case 2:
2426         destreg = DECODE_RM_BYTE_REGISTER(rh);
2427         DECODE_PRINTF(",");
2428         srcoffset = decode_rm10_address(rl);
2429         srcval = fetch_data_byte(srcoffset);
2430         DECODE_PRINTF("\n");
2431         TRACE_AND_STEP();
2432         *destreg = sub_byte(*destreg, srcval);
2433         break;
2434     case 3:                     /* register to register */
2435         destreg = DECODE_RM_BYTE_REGISTER(rh);
2436         DECODE_PRINTF(",");
2437         srcreg = DECODE_RM_BYTE_REGISTER(rl);
2438         DECODE_PRINTF("\n");
2439         TRACE_AND_STEP();
2440         *destreg = sub_byte(*destreg, *srcreg);
2441         break;
2442     }
2443     DECODE_CLEAR_SEGOVR();
2444     END_OF_INSTR();
2445 }
2446
2447 /****************************************************************************
2448 REMARKS:
2449 Handles opcode 0x2b
2450 ****************************************************************************/
2451 static void x86emuOp_sub_word_R_RM(u8 X86EMU_UNUSED(op1))
2452 {
2453     int mod, rl, rh;
2454     uint srcoffset;
2455
2456     START_OF_INSTR();
2457     DECODE_PRINTF("SUB\t");
2458     FETCH_DECODE_MODRM(mod, rh, rl);
2459     switch (mod) {
2460     case 0:
2461         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2462             u32 *destreg;
2463             u32 srcval;
2464
2465             destreg = DECODE_RM_LONG_REGISTER(rh);
2466             DECODE_PRINTF(",");
2467             srcoffset = decode_rm00_address(rl);
2468             srcval = fetch_data_long(srcoffset);
2469             DECODE_PRINTF("\n");
2470             TRACE_AND_STEP();
2471             *destreg = sub_long(*destreg, srcval);
2472         } else {
2473             u16 *destreg;
2474             u16 srcval;
2475
2476             destreg = DECODE_RM_WORD_REGISTER(rh);
2477             DECODE_PRINTF(",");
2478             srcoffset = decode_rm00_address(rl);
2479             srcval = fetch_data_word(srcoffset);
2480             DECODE_PRINTF("\n");
2481             TRACE_AND_STEP();
2482             *destreg = sub_word(*destreg, srcval);
2483         }
2484         break;
2485     case 1:
2486         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2487             u32 *destreg;
2488             u32 srcval;
2489
2490             destreg = DECODE_RM_LONG_REGISTER(rh);
2491             DECODE_PRINTF(",");
2492             srcoffset = decode_rm01_address(rl);
2493             srcval = fetch_data_long(srcoffset);
2494             DECODE_PRINTF("\n");
2495             TRACE_AND_STEP();
2496             *destreg = sub_long(*destreg, srcval);
2497         } else {
2498             u16 *destreg;
2499             u16 srcval;
2500
2501             destreg = DECODE_RM_WORD_REGISTER(rh);
2502             DECODE_PRINTF(",");
2503             srcoffset = decode_rm01_address(rl);
2504             srcval = fetch_data_word(srcoffset);
2505             DECODE_PRINTF("\n");
2506             TRACE_AND_STEP();
2507             *destreg = sub_word(*destreg, srcval);
2508         }
2509         break;
2510     case 2:
2511         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2512             u32 *destreg;
2513             u32 srcval;
2514
2515             destreg = DECODE_RM_LONG_REGISTER(rh);
2516             DECODE_PRINTF(",");
2517             srcoffset = decode_rm10_address(rl);
2518             srcval = fetch_data_long(srcoffset);
2519             DECODE_PRINTF("\n");
2520             TRACE_AND_STEP();
2521             *destreg = sub_long(*destreg, srcval);
2522         } else {
2523             u16 *destreg;
2524             u16 srcval;
2525
2526             destreg = DECODE_RM_WORD_REGISTER(rh);
2527             DECODE_PRINTF(",");
2528             srcoffset = decode_rm10_address(rl);
2529             srcval = fetch_data_word(srcoffset);
2530             DECODE_PRINTF("\n");
2531             TRACE_AND_STEP();
2532             *destreg = sub_word(*destreg, srcval);
2533         }
2534         break;
2535     case 3:                     /* register to register */
2536         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2537             u32 *destreg,*srcreg;
2538
2539             destreg = DECODE_RM_LONG_REGISTER(rh);
2540             DECODE_PRINTF(",");
2541             srcreg = DECODE_RM_LONG_REGISTER(rl);
2542             DECODE_PRINTF("\n");
2543             TRACE_AND_STEP();
2544             *destreg = sub_long(*destreg, *srcreg);
2545         } else {
2546             u16 *destreg,*srcreg;
2547
2548             destreg = DECODE_RM_WORD_REGISTER(rh);
2549             DECODE_PRINTF(",");
2550             srcreg = DECODE_RM_WORD_REGISTER(rl);
2551             DECODE_PRINTF("\n");
2552             TRACE_AND_STEP();
2553             *destreg = sub_word(*destreg, *srcreg);
2554         }
2555         break;
2556     }
2557     DECODE_CLEAR_SEGOVR();
2558     END_OF_INSTR();
2559 }
2560
2561 /****************************************************************************
2562 REMARKS:
2563 Handles opcode 0x2c
2564 ****************************************************************************/
2565 static void x86emuOp_sub_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
2566 {
2567     u8 srcval;
2568
2569     START_OF_INSTR();
2570     DECODE_PRINTF("SUB\tAL,");
2571     srcval = fetch_byte_imm();
2572     DECODE_PRINTF2("%x\n", srcval);
2573     TRACE_AND_STEP();
2574     M.x86.R_AL = sub_byte(M.x86.R_AL, srcval);
2575     DECODE_CLEAR_SEGOVR();
2576     END_OF_INSTR();
2577 }
2578
2579 /****************************************************************************
2580 REMARKS:
2581 Handles opcode 0x2d
2582 ****************************************************************************/
2583 static void x86emuOp_sub_word_AX_IMM(u8 X86EMU_UNUSED(op1))
2584 {
2585     u32 srcval;
2586
2587     START_OF_INSTR();
2588     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2589         DECODE_PRINTF("SUB\tEAX,");
2590         srcval = fetch_long_imm();
2591     } else {
2592         DECODE_PRINTF("SUB\tAX,");
2593         srcval = fetch_word_imm();
2594     }
2595     DECODE_PRINTF2("%x\n", srcval);
2596     TRACE_AND_STEP();
2597     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2598         M.x86.R_EAX = sub_long(M.x86.R_EAX, srcval);
2599     } else {
2600         M.x86.R_AX = sub_word(M.x86.R_AX, (u16)srcval);
2601     }
2602     DECODE_CLEAR_SEGOVR();
2603     END_OF_INSTR();
2604 }
2605
2606 /****************************************************************************
2607 REMARKS:
2608 Handles opcode 0x2e
2609 ****************************************************************************/
2610 static void x86emuOp_segovr_CS(u8 X86EMU_UNUSED(op1))
2611 {
2612     START_OF_INSTR();
2613     DECODE_PRINTF("CS:\n");
2614     TRACE_AND_STEP();
2615     M.x86.mode |= SYSMODE_SEGOVR_CS;
2616     /* note no DECODE_CLEAR_SEGOVR here. */
2617     END_OF_INSTR();
2618 }
2619
2620 /****************************************************************************
2621 REMARKS:
2622 Handles opcode 0x2f
2623 ****************************************************************************/
2624 static void x86emuOp_das(u8 X86EMU_UNUSED(op1))
2625 {
2626     START_OF_INSTR();
2627     DECODE_PRINTF("DAS\n");
2628     TRACE_AND_STEP();
2629     M.x86.R_AL = das_byte(M.x86.R_AL);
2630     DECODE_CLEAR_SEGOVR();
2631     END_OF_INSTR();
2632 }
2633
2634 /****************************************************************************
2635 REMARKS:
2636 Handles opcode 0x30
2637 ****************************************************************************/
2638 static void x86emuOp_xor_byte_RM_R(u8 X86EMU_UNUSED(op1))
2639 {
2640     int mod, rl, rh;
2641     u8 *destreg, *srcreg;
2642     uint destoffset;
2643     u8 destval;
2644
2645     START_OF_INSTR();
2646     DECODE_PRINTF("XOR\t");
2647     FETCH_DECODE_MODRM(mod, rh, rl);
2648     switch (mod) {
2649     case 0:
2650         destoffset = decode_rm00_address(rl);
2651         DECODE_PRINTF(",");
2652         destval = fetch_data_byte(destoffset);
2653         srcreg = DECODE_RM_BYTE_REGISTER(rh);
2654         DECODE_PRINTF("\n");
2655         TRACE_AND_STEP();
2656         destval = xor_byte(destval, *srcreg);
2657         store_data_byte(destoffset, destval);
2658         break;
2659     case 1:
2660         destoffset = decode_rm01_address(rl);
2661         DECODE_PRINTF(",");
2662         destval = fetch_data_byte(destoffset);
2663         srcreg = DECODE_RM_BYTE_REGISTER(rh);
2664         DECODE_PRINTF("\n");
2665         TRACE_AND_STEP();
2666         destval = xor_byte(destval, *srcreg);
2667         store_data_byte(destoffset, destval);
2668         break;
2669     case 2:
2670         destoffset = decode_rm10_address(rl);
2671         DECODE_PRINTF(",");
2672         destval = fetch_data_byte(destoffset);
2673         srcreg = DECODE_RM_BYTE_REGISTER(rh);
2674         DECODE_PRINTF("\n");
2675         TRACE_AND_STEP();
2676         destval = xor_byte(destval, *srcreg);
2677         store_data_byte(destoffset, destval);
2678         break;
2679     case 3:                     /* register to register */
2680         destreg = DECODE_RM_BYTE_REGISTER(rl);
2681         DECODE_PRINTF(",");
2682         srcreg = DECODE_RM_BYTE_REGISTER(rh);
2683         DECODE_PRINTF("\n");
2684         TRACE_AND_STEP();
2685         *destreg = xor_byte(*destreg, *srcreg);
2686         break;
2687     }
2688     DECODE_CLEAR_SEGOVR();
2689     END_OF_INSTR();
2690 }
2691
2692 /****************************************************************************
2693 REMARKS:
2694 Handles opcode 0x31
2695 ****************************************************************************/
2696 static void x86emuOp_xor_word_RM_R(u8 X86EMU_UNUSED(op1))
2697 {
2698     int mod, rl, rh;
2699     uint destoffset;
2700
2701     START_OF_INSTR();
2702     DECODE_PRINTF("XOR\t");
2703     FETCH_DECODE_MODRM(mod, rh, rl);
2704     switch (mod) {
2705     case 0:
2706         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2707             u32 destval;
2708             u32 *srcreg;
2709
2710             destoffset = decode_rm00_address(rl);
2711             DECODE_PRINTF(",");
2712             destval = fetch_data_long(destoffset);
2713             srcreg = DECODE_RM_LONG_REGISTER(rh);
2714             DECODE_PRINTF("\n");
2715             TRACE_AND_STEP();
2716             destval = xor_long(destval, *srcreg);
2717             store_data_long(destoffset, destval);
2718         } else {
2719             u16 destval;
2720             u16 *srcreg;
2721
2722             destoffset = decode_rm00_address(rl);
2723             DECODE_PRINTF(",");
2724             destval = fetch_data_word(destoffset);
2725             srcreg = DECODE_RM_WORD_REGISTER(rh);
2726             DECODE_PRINTF("\n");
2727             TRACE_AND_STEP();
2728             destval = xor_word(destval, *srcreg);
2729             store_data_word(destoffset, destval);
2730         }
2731         break;
2732     case 1:
2733         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2734             u32 destval;
2735             u32 *srcreg;
2736
2737             destoffset = decode_rm01_address(rl);
2738             DECODE_PRINTF(",");
2739             destval = fetch_data_long(destoffset);
2740             srcreg = DECODE_RM_LONG_REGISTER(rh);
2741             DECODE_PRINTF("\n");
2742             TRACE_AND_STEP();
2743             destval = xor_long(destval, *srcreg);
2744             store_data_long(destoffset, destval);
2745         } else {
2746             u16 destval;
2747             u16 *srcreg;
2748
2749             destoffset = decode_rm01_address(rl);
2750             DECODE_PRINTF(",");
2751             destval = fetch_data_word(destoffset);
2752             srcreg = DECODE_RM_WORD_REGISTER(rh);
2753             DECODE_PRINTF("\n");
2754             TRACE_AND_STEP();
2755             destval = xor_word(destval, *srcreg);
2756             store_data_word(destoffset, destval);
2757         }
2758         break;
2759     case 2:
2760         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2761             u32 destval;
2762             u32 *srcreg;
2763
2764             destoffset = decode_rm10_address(rl);
2765             DECODE_PRINTF(",");
2766             destval = fetch_data_long(destoffset);
2767             srcreg = DECODE_RM_LONG_REGISTER(rh);
2768             DECODE_PRINTF("\n");
2769             TRACE_AND_STEP();
2770             destval = xor_long(destval, *srcreg);
2771             store_data_long(destoffset, destval);
2772         } else {
2773             u16 destval;
2774             u16 *srcreg;
2775
2776             destoffset = decode_rm10_address(rl);
2777             DECODE_PRINTF(",");
2778             destval = fetch_data_word(destoffset);
2779             srcreg = DECODE_RM_WORD_REGISTER(rh);
2780             DECODE_PRINTF("\n");
2781             TRACE_AND_STEP();
2782             destval = xor_word(destval, *srcreg);
2783             store_data_word(destoffset, destval);
2784         }
2785         break;
2786     case 3:                     /* register to register */
2787         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2788             u32 *destreg,*srcreg;
2789
2790             destreg = DECODE_RM_LONG_REGISTER(rl);
2791             DECODE_PRINTF(",");
2792             srcreg = DECODE_RM_LONG_REGISTER(rh);
2793             DECODE_PRINTF("\n");
2794             TRACE_AND_STEP();
2795             *destreg = xor_long(*destreg, *srcreg);
2796         } else {
2797             u16 *destreg,*srcreg;
2798
2799             destreg = DECODE_RM_WORD_REGISTER(rl);
2800             DECODE_PRINTF(",");
2801             srcreg = DECODE_RM_WORD_REGISTER(rh);
2802             DECODE_PRINTF("\n");
2803             TRACE_AND_STEP();
2804             *destreg = xor_word(*destreg, *srcreg);
2805         }
2806         break;
2807     }
2808     DECODE_CLEAR_SEGOVR();
2809     END_OF_INSTR();
2810 }
2811
2812 /****************************************************************************
2813 REMARKS:
2814 Handles opcode 0x32
2815 ****************************************************************************/
2816 static void x86emuOp_xor_byte_R_RM(u8 X86EMU_UNUSED(op1))
2817 {
2818     int mod, rl, rh;
2819     u8 *destreg, *srcreg;
2820     uint srcoffset;
2821     u8 srcval;
2822
2823     START_OF_INSTR();
2824     DECODE_PRINTF("XOR\t");
2825     FETCH_DECODE_MODRM(mod, rh, rl);
2826     switch (mod) {
2827     case 0:
2828         destreg = DECODE_RM_BYTE_REGISTER(rh);
2829         DECODE_PRINTF(",");
2830         srcoffset = decode_rm00_address(rl);
2831         srcval = fetch_data_byte(srcoffset);
2832         DECODE_PRINTF("\n");
2833         TRACE_AND_STEP();
2834         *destreg = xor_byte(*destreg, srcval);
2835         break;
2836     case 1:
2837         destreg = DECODE_RM_BYTE_REGISTER(rh);
2838         DECODE_PRINTF(",");
2839         srcoffset = decode_rm01_address(rl);
2840         srcval = fetch_data_byte(srcoffset);
2841         DECODE_PRINTF("\n");
2842         TRACE_AND_STEP();
2843         *destreg = xor_byte(*destreg, srcval);
2844         break;
2845     case 2:
2846         destreg = DECODE_RM_BYTE_REGISTER(rh);
2847         DECODE_PRINTF(",");
2848         srcoffset = decode_rm10_address(rl);
2849         srcval = fetch_data_byte(srcoffset);
2850         DECODE_PRINTF("\n");
2851         TRACE_AND_STEP();
2852         *destreg = xor_byte(*destreg, srcval);
2853         break;
2854     case 3:                     /* register to register */
2855         destreg = DECODE_RM_BYTE_REGISTER(rh);
2856         DECODE_PRINTF(",");
2857         srcreg = DECODE_RM_BYTE_REGISTER(rl);
2858         DECODE_PRINTF("\n");
2859         TRACE_AND_STEP();
2860         *destreg = xor_byte(*destreg, *srcreg);
2861         break;
2862     }
2863     DECODE_CLEAR_SEGOVR();
2864     END_OF_INSTR();
2865 }
2866
2867 /****************************************************************************
2868 REMARKS:
2869 Handles opcode 0x33
2870 ****************************************************************************/
2871 static void x86emuOp_xor_word_R_RM(u8 X86EMU_UNUSED(op1))
2872 {
2873     int mod, rl, rh;
2874     uint srcoffset;
2875
2876     START_OF_INSTR();
2877     DECODE_PRINTF("XOR\t");
2878     FETCH_DECODE_MODRM(mod, rh, rl);
2879     switch (mod) {
2880     case 0:
2881         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2882             u32 *destreg;
2883             u32 srcval;
2884
2885             destreg = DECODE_RM_LONG_REGISTER(rh);
2886             DECODE_PRINTF(",");
2887             srcoffset = decode_rm00_address(rl);
2888             srcval = fetch_data_long(srcoffset);
2889             DECODE_PRINTF("\n");
2890             TRACE_AND_STEP();
2891             *destreg = xor_long(*destreg, srcval);
2892         } else {
2893             u16 *destreg;
2894             u16 srcval;
2895
2896             destreg = DECODE_RM_WORD_REGISTER(rh);
2897             DECODE_PRINTF(",");
2898             srcoffset = decode_rm00_address(rl);
2899             srcval = fetch_data_word(srcoffset);
2900             DECODE_PRINTF("\n");
2901             TRACE_AND_STEP();
2902             *destreg = xor_word(*destreg, srcval);
2903         }
2904         break;
2905     case 1:
2906         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2907             u32 *destreg;
2908             u32 srcval;
2909
2910             destreg = DECODE_RM_LONG_REGISTER(rh);
2911             DECODE_PRINTF(",");
2912             srcoffset = decode_rm01_address(rl);
2913             srcval = fetch_data_long(srcoffset);
2914             DECODE_PRINTF("\n");
2915             TRACE_AND_STEP();
2916             *destreg = xor_long(*destreg, srcval);
2917         } else {
2918             u16 *destreg;
2919             u16 srcval;
2920
2921             destreg = DECODE_RM_WORD_REGISTER(rh);
2922             DECODE_PRINTF(",");
2923             srcoffset = decode_rm01_address(rl);
2924             srcval = fetch_data_word(srcoffset);
2925             DECODE_PRINTF("\n");
2926             TRACE_AND_STEP();
2927             *destreg = xor_word(*destreg, srcval);
2928         }
2929         break;
2930     case 2:
2931         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2932             u32 *destreg;
2933             u32 srcval;
2934
2935             destreg = DECODE_RM_LONG_REGISTER(rh);
2936             DECODE_PRINTF(",");
2937             srcoffset = decode_rm10_address(rl);
2938             srcval = fetch_data_long(srcoffset);
2939             DECODE_PRINTF("\n");
2940             TRACE_AND_STEP();
2941             *destreg = xor_long(*destreg, srcval);
2942         } else {
2943             u16 *destreg;
2944             u16 srcval;
2945
2946             destreg = DECODE_RM_WORD_REGISTER(rh);
2947             DECODE_PRINTF(",");
2948             srcoffset = decode_rm10_address(rl);
2949             srcval = fetch_data_word(srcoffset);
2950             DECODE_PRINTF("\n");
2951             TRACE_AND_STEP();
2952             *destreg = xor_word(*destreg, srcval);
2953         }
2954         break;
2955     case 3:                     /* register to register */
2956         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
2957             u32 *destreg,*srcreg;
2958
2959             destreg = DECODE_RM_LONG_REGISTER(rh);
2960             DECODE_PRINTF(",");
2961             srcreg = DECODE_RM_LONG_REGISTER(rl);
2962             DECODE_PRINTF("\n");
2963             TRACE_AND_STEP();
2964             *destreg = xor_long(*destreg, *srcreg);
2965         } else {
2966             u16 *destreg,*srcreg;
2967
2968             destreg = DECODE_RM_WORD_REGISTER(rh);
2969             DECODE_PRINTF(",");
2970             srcreg = DECODE_RM_WORD_REGISTER(rl);
2971             DECODE_PRINTF("\n");
2972             TRACE_AND_STEP();
2973             *destreg = xor_word(*destreg, *srcreg);
2974         }
2975         break;
2976     }
2977     DECODE_CLEAR_SEGOVR();
2978     END_OF_INSTR();
2979 }
2980
2981 /****************************************************************************
2982 REMARKS:
2983 Handles opcode 0x34
2984 ****************************************************************************/
2985 static void x86emuOp_xor_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
2986 {
2987     u8 srcval;
2988
2989     START_OF_INSTR();
2990     DECODE_PRINTF("XOR\tAL,");
2991     srcval = fetch_byte_imm();
2992     DECODE_PRINTF2("%x\n", srcval);
2993     TRACE_AND_STEP();
2994     M.x86.R_AL = xor_byte(M.x86.R_AL, srcval);
2995     DECODE_CLEAR_SEGOVR();
2996     END_OF_INSTR();
2997 }
2998
2999 /****************************************************************************
3000 REMARKS:
3001 Handles opcode 0x35
3002 ****************************************************************************/
3003 static void x86emuOp_xor_word_AX_IMM(u8 X86EMU_UNUSED(op1))
3004 {
3005     u32 srcval;
3006
3007     START_OF_INSTR();
3008     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3009         DECODE_PRINTF("XOR\tEAX,");
3010         srcval = fetch_long_imm();
3011     } else {
3012         DECODE_PRINTF("XOR\tAX,");
3013         srcval = fetch_word_imm();
3014     }
3015     DECODE_PRINTF2("%x\n", srcval);
3016     TRACE_AND_STEP();
3017     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3018         M.x86.R_EAX = xor_long(M.x86.R_EAX, srcval);
3019     } else {
3020         M.x86.R_AX = xor_word(M.x86.R_AX, (u16)srcval);
3021     }
3022     DECODE_CLEAR_SEGOVR();
3023     END_OF_INSTR();
3024 }
3025
3026 /****************************************************************************
3027 REMARKS:
3028 Handles opcode 0x36
3029 ****************************************************************************/
3030 static void x86emuOp_segovr_SS(u8 X86EMU_UNUSED(op1))
3031 {
3032     START_OF_INSTR();
3033     DECODE_PRINTF("SS:\n");
3034     TRACE_AND_STEP();
3035     M.x86.mode |= SYSMODE_SEGOVR_SS;
3036     /* no DECODE_CLEAR_SEGOVR ! */
3037     END_OF_INSTR();
3038 }
3039
3040 /****************************************************************************
3041 REMARKS:
3042 Handles opcode 0x37
3043 ****************************************************************************/
3044 static void x86emuOp_aaa(u8 X86EMU_UNUSED(op1))
3045 {
3046     START_OF_INSTR();
3047     DECODE_PRINTF("AAA\n");
3048     TRACE_AND_STEP();
3049     M.x86.R_AX = aaa_word(M.x86.R_AX);
3050     DECODE_CLEAR_SEGOVR();
3051     END_OF_INSTR();
3052 }
3053
3054 /****************************************************************************
3055 REMARKS:
3056 Handles opcode 0x38
3057 ****************************************************************************/
3058 static void x86emuOp_cmp_byte_RM_R(u8 X86EMU_UNUSED(op1))
3059 {
3060     int mod, rl, rh;
3061     uint destoffset;
3062     u8 *destreg, *srcreg;
3063     u8 destval;
3064
3065     START_OF_INSTR();
3066     DECODE_PRINTF("CMP\t");
3067     FETCH_DECODE_MODRM(mod, rh, rl);
3068     switch (mod) {
3069     case 0:
3070         destoffset = decode_rm00_address(rl);
3071         DECODE_PRINTF(",");
3072         destval = fetch_data_byte(destoffset);
3073         srcreg = DECODE_RM_BYTE_REGISTER(rh);
3074         DECODE_PRINTF("\n");
3075         TRACE_AND_STEP();
3076         cmp_byte(destval, *srcreg);
3077         break;
3078     case 1:
3079         destoffset = decode_rm01_address(rl);
3080         DECODE_PRINTF(",");
3081         destval = fetch_data_byte(destoffset);
3082         srcreg = DECODE_RM_BYTE_REGISTER(rh);
3083         DECODE_PRINTF("\n");
3084         TRACE_AND_STEP();
3085         cmp_byte(destval, *srcreg);
3086         break;
3087     case 2:
3088         destoffset = decode_rm10_address(rl);
3089         DECODE_PRINTF(",");
3090         destval = fetch_data_byte(destoffset);
3091         srcreg = DECODE_RM_BYTE_REGISTER(rh);
3092         DECODE_PRINTF("\n");
3093         TRACE_AND_STEP();
3094         cmp_byte(destval, *srcreg);
3095         break;
3096     case 3:                     /* register to register */
3097         destreg = DECODE_RM_BYTE_REGISTER(rl);
3098         DECODE_PRINTF(",");
3099         srcreg = DECODE_RM_BYTE_REGISTER(rh);
3100         DECODE_PRINTF("\n");
3101         TRACE_AND_STEP();
3102         cmp_byte(*destreg, *srcreg);
3103         break;
3104     }
3105     DECODE_CLEAR_SEGOVR();
3106     END_OF_INSTR();
3107 }
3108
3109 /****************************************************************************
3110 REMARKS:
3111 Handles opcode 0x39
3112 ****************************************************************************/
3113 static void x86emuOp_cmp_word_RM_R(u8 X86EMU_UNUSED(op1))
3114 {
3115     int mod, rl, rh;
3116     uint destoffset;
3117
3118     START_OF_INSTR();
3119     DECODE_PRINTF("CMP\t");
3120     FETCH_DECODE_MODRM(mod, rh, rl);
3121     switch (mod) {
3122     case 0:
3123         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3124             u32 destval;
3125             u32 *srcreg;
3126
3127             destoffset = decode_rm00_address(rl);
3128             DECODE_PRINTF(",");
3129             destval = fetch_data_long(destoffset);
3130             srcreg = DECODE_RM_LONG_REGISTER(rh);
3131             DECODE_PRINTF("\n");
3132             TRACE_AND_STEP();
3133             cmp_long(destval, *srcreg);
3134         } else {
3135             u16 destval;
3136             u16 *srcreg;
3137
3138             destoffset = decode_rm00_address(rl);
3139             DECODE_PRINTF(",");
3140             destval = fetch_data_word(destoffset);
3141             srcreg = DECODE_RM_WORD_REGISTER(rh);
3142             DECODE_PRINTF("\n");
3143             TRACE_AND_STEP();
3144             cmp_word(destval, *srcreg);
3145         }
3146         break;
3147     case 1:
3148         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3149             u32 destval;
3150             u32 *srcreg;
3151
3152             destoffset = decode_rm01_address(rl);
3153             DECODE_PRINTF(",");
3154             destval = fetch_data_long(destoffset);
3155             srcreg = DECODE_RM_LONG_REGISTER(rh);
3156             DECODE_PRINTF("\n");
3157             TRACE_AND_STEP();
3158             cmp_long(destval, *srcreg);
3159         } else {
3160             u16 destval;
3161             u16 *srcreg;
3162
3163             destoffset = decode_rm01_address(rl);
3164             DECODE_PRINTF(",");
3165             destval = fetch_data_word(destoffset);
3166             srcreg = DECODE_RM_WORD_REGISTER(rh);
3167             DECODE_PRINTF("\n");
3168             TRACE_AND_STEP();
3169             cmp_word(destval, *srcreg);
3170         }
3171         break;
3172     case 2:
3173         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3174             u32 destval;
3175             u32 *srcreg;
3176
3177             destoffset = decode_rm10_address(rl);
3178             DECODE_PRINTF(",");
3179             destval = fetch_data_long(destoffset);
3180             srcreg = DECODE_RM_LONG_REGISTER(rh);
3181             DECODE_PRINTF("\n");
3182             TRACE_AND_STEP();
3183             cmp_long(destval, *srcreg);
3184         } else {
3185             u16 destval;
3186             u16 *srcreg;
3187
3188             destoffset = decode_rm10_address(rl);
3189             DECODE_PRINTF(",");
3190             destval = fetch_data_word(destoffset);
3191             srcreg = DECODE_RM_WORD_REGISTER(rh);
3192             DECODE_PRINTF("\n");
3193             TRACE_AND_STEP();
3194             cmp_word(destval, *srcreg);
3195         }
3196         break;
3197     case 3:                     /* register to register */
3198         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3199             u32 *destreg,*srcreg;
3200
3201             destreg = DECODE_RM_LONG_REGISTER(rl);
3202             DECODE_PRINTF(",");
3203             srcreg = DECODE_RM_LONG_REGISTER(rh);
3204             DECODE_PRINTF("\n");
3205             TRACE_AND_STEP();
3206             cmp_long(*destreg, *srcreg);
3207         } else {
3208             u16 *destreg,*srcreg;
3209
3210             destreg = DECODE_RM_WORD_REGISTER(rl);
3211             DECODE_PRINTF(",");
3212             srcreg = DECODE_RM_WORD_REGISTER(rh);
3213             DECODE_PRINTF("\n");
3214             TRACE_AND_STEP();
3215             cmp_word(*destreg, *srcreg);
3216         }
3217         break;
3218     }
3219     DECODE_CLEAR_SEGOVR();
3220     END_OF_INSTR();
3221 }
3222
3223 /****************************************************************************
3224 REMARKS:
3225 Handles opcode 0x3a
3226 ****************************************************************************/
3227 static void x86emuOp_cmp_byte_R_RM(u8 X86EMU_UNUSED(op1))
3228 {
3229     int mod, rl, rh;
3230     u8 *destreg, *srcreg;
3231     uint srcoffset;
3232     u8 srcval;
3233
3234     START_OF_INSTR();
3235     DECODE_PRINTF("CMP\t");
3236     FETCH_DECODE_MODRM(mod, rh, rl);
3237     switch (mod) {
3238     case 0:
3239         destreg = DECODE_RM_BYTE_REGISTER(rh);
3240         DECODE_PRINTF(",");
3241         srcoffset = decode_rm00_address(rl);
3242         srcval = fetch_data_byte(srcoffset);
3243         DECODE_PRINTF("\n");
3244         TRACE_AND_STEP();
3245         cmp_byte(*destreg, srcval);
3246         break;
3247     case 1:
3248         destreg = DECODE_RM_BYTE_REGISTER(rh);
3249         DECODE_PRINTF(",");
3250         srcoffset = decode_rm01_address(rl);
3251         srcval = fetch_data_byte(srcoffset);
3252         DECODE_PRINTF("\n");
3253         TRACE_AND_STEP();
3254         cmp_byte(*destreg, srcval);
3255         break;
3256     case 2:
3257         destreg = DECODE_RM_BYTE_REGISTER(rh);
3258         DECODE_PRINTF(",");
3259         srcoffset = decode_rm10_address(rl);
3260         srcval = fetch_data_byte(srcoffset);
3261         DECODE_PRINTF("\n");
3262         TRACE_AND_STEP();
3263         cmp_byte(*destreg, srcval);
3264         break;
3265     case 3:                     /* register to register */
3266         destreg = DECODE_RM_BYTE_REGISTER(rh);
3267         DECODE_PRINTF(",");
3268         srcreg = DECODE_RM_BYTE_REGISTER(rl);
3269         DECODE_PRINTF("\n");
3270         TRACE_AND_STEP();
3271         cmp_byte(*destreg, *srcreg);
3272         break;
3273     }
3274     DECODE_CLEAR_SEGOVR();
3275     END_OF_INSTR();
3276 }
3277
3278 /****************************************************************************
3279 REMARKS:
3280 Handles opcode 0x3b
3281 ****************************************************************************/
3282 static void x86emuOp_cmp_word_R_RM(u8 X86EMU_UNUSED(op1))
3283 {
3284     int mod, rl, rh;
3285     uint srcoffset;
3286
3287     START_OF_INSTR();
3288     DECODE_PRINTF("CMP\t");
3289     FETCH_DECODE_MODRM(mod, rh, rl);
3290     switch (mod) {
3291     case 0:
3292         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3293             u32 *destreg;
3294             u32 srcval;
3295
3296             destreg = DECODE_RM_LONG_REGISTER(rh);
3297             DECODE_PRINTF(",");
3298             srcoffset = decode_rm00_address(rl);
3299             srcval = fetch_data_long(srcoffset);
3300             DECODE_PRINTF("\n");
3301             TRACE_AND_STEP();
3302             cmp_long(*destreg, srcval);
3303         } else {
3304             u16 *destreg;
3305             u16 srcval;
3306
3307             destreg = DECODE_RM_WORD_REGISTER(rh);
3308             DECODE_PRINTF(",");
3309             srcoffset = decode_rm00_address(rl);
3310             srcval = fetch_data_word(srcoffset);
3311             DECODE_PRINTF("\n");
3312             TRACE_AND_STEP();
3313             cmp_word(*destreg, srcval);
3314         }
3315         break;
3316     case 1:
3317         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3318             u32 *destreg;
3319             u32 srcval;
3320
3321             destreg = DECODE_RM_LONG_REGISTER(rh);
3322             DECODE_PRINTF(",");
3323             srcoffset = decode_rm01_address(rl);
3324             srcval = fetch_data_long(srcoffset);
3325             DECODE_PRINTF("\n");
3326             TRACE_AND_STEP();
3327             cmp_long(*destreg, srcval);
3328         } else {
3329             u16 *destreg;
3330             u16 srcval;
3331
3332             destreg = DECODE_RM_WORD_REGISTER(rh);
3333             DECODE_PRINTF(",");
3334             srcoffset = decode_rm01_address(rl);
3335             srcval = fetch_data_word(srcoffset);
3336             DECODE_PRINTF("\n");
3337             TRACE_AND_STEP();
3338             cmp_word(*destreg, srcval);
3339         }
3340         break;
3341     case 2:
3342         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3343             u32 *destreg;
3344             u32 srcval;
3345
3346             destreg = DECODE_RM_LONG_REGISTER(rh);
3347             DECODE_PRINTF(",");
3348             srcoffset = decode_rm10_address(rl);
3349             srcval = fetch_data_long(srcoffset);
3350             DECODE_PRINTF("\n");
3351             TRACE_AND_STEP();
3352             cmp_long(*destreg, srcval);
3353         } else {
3354             u16 *destreg;
3355             u16 srcval;
3356
3357             destreg = DECODE_RM_WORD_REGISTER(rh);
3358             DECODE_PRINTF(",");
3359             srcoffset = decode_rm10_address(rl);
3360             srcval = fetch_data_word(srcoffset);
3361             DECODE_PRINTF("\n");
3362             TRACE_AND_STEP();
3363             cmp_word(*destreg, srcval);
3364         }
3365         break;
3366     case 3:                     /* register to register */
3367         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3368             u32 *destreg,*srcreg;
3369
3370             destreg = DECODE_RM_LONG_REGISTER(rh);
3371             DECODE_PRINTF(",");
3372             srcreg = DECODE_RM_LONG_REGISTER(rl);
3373             DECODE_PRINTF("\n");
3374             TRACE_AND_STEP();
3375             cmp_long(*destreg, *srcreg);
3376         } else {
3377             u16 *destreg,*srcreg;
3378
3379             destreg = DECODE_RM_WORD_REGISTER(rh);
3380             DECODE_PRINTF(",");
3381             srcreg = DECODE_RM_WORD_REGISTER(rl);
3382             DECODE_PRINTF("\n");
3383             TRACE_AND_STEP();
3384             cmp_word(*destreg, *srcreg);
3385         }
3386         break;
3387     }
3388     DECODE_CLEAR_SEGOVR();
3389     END_OF_INSTR();
3390 }
3391
3392 /****************************************************************************
3393 REMARKS:
3394 Handles opcode 0x3c
3395 ****************************************************************************/
3396 static void x86emuOp_cmp_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
3397 {
3398     u8 srcval;
3399
3400     START_OF_INSTR();
3401     DECODE_PRINTF("CMP\tAL,");
3402     srcval = fetch_byte_imm();
3403     DECODE_PRINTF2("%x\n", srcval);
3404     TRACE_AND_STEP();
3405     cmp_byte(M.x86.R_AL, srcval);
3406     DECODE_CLEAR_SEGOVR();
3407     END_OF_INSTR();
3408 }
3409
3410 /****************************************************************************
3411 REMARKS:
3412 Handles opcode 0x3d
3413 ****************************************************************************/
3414 static void x86emuOp_cmp_word_AX_IMM(u8 X86EMU_UNUSED(op1))
3415 {
3416     u32 srcval;
3417
3418     START_OF_INSTR();
3419     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3420         DECODE_PRINTF("CMP\tEAX,");
3421         srcval = fetch_long_imm();
3422     } else {
3423         DECODE_PRINTF("CMP\tAX,");
3424         srcval = fetch_word_imm();
3425     }
3426     DECODE_PRINTF2("%x\n", srcval);
3427     TRACE_AND_STEP();
3428     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3429         cmp_long(M.x86.R_EAX, srcval);
3430     } else {
3431         cmp_word(M.x86.R_AX, (u16)srcval);
3432     }
3433     DECODE_CLEAR_SEGOVR();
3434     END_OF_INSTR();
3435 }
3436
3437 /****************************************************************************
3438 REMARKS:
3439 Handles opcode 0x3e
3440 ****************************************************************************/
3441 static void x86emuOp_segovr_DS(u8 X86EMU_UNUSED(op1))
3442 {
3443     START_OF_INSTR();
3444     DECODE_PRINTF("DS:\n");
3445     TRACE_AND_STEP();
3446     M.x86.mode |= SYSMODE_SEGOVR_DS;
3447     /* NO DECODE_CLEAR_SEGOVR! */
3448     END_OF_INSTR();
3449 }
3450
3451 /****************************************************************************
3452 REMARKS:
3453 Handles opcode 0x3f
3454 ****************************************************************************/
3455 static void x86emuOp_aas(u8 X86EMU_UNUSED(op1))
3456 {
3457     START_OF_INSTR();
3458     DECODE_PRINTF("AAS\n");
3459     TRACE_AND_STEP();
3460     M.x86.R_AX = aas_word(M.x86.R_AX);
3461     DECODE_CLEAR_SEGOVR();
3462     END_OF_INSTR();
3463 }
3464
3465 /****************************************************************************
3466 REMARKS:
3467 Handles opcode 0x40
3468 ****************************************************************************/
3469 static void x86emuOp_inc_AX(u8 X86EMU_UNUSED(op1))
3470 {
3471     START_OF_INSTR();
3472     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3473         DECODE_PRINTF("INC\tEAX\n");
3474     } else {
3475         DECODE_PRINTF("INC\tAX\n");
3476     }
3477     TRACE_AND_STEP();
3478     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3479         M.x86.R_EAX = inc_long(M.x86.R_EAX);
3480     } else {
3481         M.x86.R_AX = inc_word(M.x86.R_AX);
3482     }
3483     DECODE_CLEAR_SEGOVR();
3484     END_OF_INSTR();
3485 }
3486
3487 /****************************************************************************
3488 REMARKS:
3489 Handles opcode 0x41
3490 ****************************************************************************/
3491 static void x86emuOp_inc_CX(u8 X86EMU_UNUSED(op1))
3492 {
3493     START_OF_INSTR();
3494     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3495         DECODE_PRINTF("INC\tECX\n");
3496     } else {
3497         DECODE_PRINTF("INC\tCX\n");
3498     }
3499     TRACE_AND_STEP();
3500     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3501         M.x86.R_ECX = inc_long(M.x86.R_ECX);
3502     } else {
3503         M.x86.R_CX = inc_word(M.x86.R_CX);
3504     }
3505     DECODE_CLEAR_SEGOVR();
3506     END_OF_INSTR();
3507 }
3508
3509 /****************************************************************************
3510 REMARKS:
3511 Handles opcode 0x42
3512 ****************************************************************************/
3513 static void x86emuOp_inc_DX(u8 X86EMU_UNUSED(op1))
3514 {
3515     START_OF_INSTR();
3516     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3517         DECODE_PRINTF("INC\tEDX\n");
3518     } else {
3519         DECODE_PRINTF("INC\tDX\n");
3520     }
3521     TRACE_AND_STEP();
3522     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3523         M.x86.R_EDX = inc_long(M.x86.R_EDX);
3524     } else {
3525         M.x86.R_DX = inc_word(M.x86.R_DX);
3526     }
3527     DECODE_CLEAR_SEGOVR();
3528     END_OF_INSTR();
3529 }
3530
3531 /****************************************************************************
3532 REMARKS:
3533 Handles opcode 0x43
3534 ****************************************************************************/
3535 static void x86emuOp_inc_BX(u8 X86EMU_UNUSED(op1))
3536 {
3537     START_OF_INSTR();
3538     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3539         DECODE_PRINTF("INC\tEBX\n");
3540     } else {
3541         DECODE_PRINTF("INC\tBX\n");
3542     }
3543     TRACE_AND_STEP();
3544     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3545         M.x86.R_EBX = inc_long(M.x86.R_EBX);
3546     } else {
3547         M.x86.R_BX = inc_word(M.x86.R_BX);
3548     }
3549     DECODE_CLEAR_SEGOVR();
3550     END_OF_INSTR();
3551 }
3552
3553 /****************************************************************************
3554 REMARKS:
3555 Handles opcode 0x44
3556 ****************************************************************************/
3557 static void x86emuOp_inc_SP(u8 X86EMU_UNUSED(op1))
3558 {
3559     START_OF_INSTR();
3560     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3561         DECODE_PRINTF("INC\tESP\n");
3562     } else {
3563         DECODE_PRINTF("INC\tSP\n");
3564     }
3565     TRACE_AND_STEP();
3566     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3567         M.x86.R_ESP = inc_long(M.x86.R_ESP);
3568     } else {
3569         M.x86.R_SP = inc_word(M.x86.R_SP);
3570     }
3571     DECODE_CLEAR_SEGOVR();
3572     END_OF_INSTR();
3573 }
3574
3575 /****************************************************************************
3576 REMARKS:
3577 Handles opcode 0x45
3578 ****************************************************************************/
3579 static void x86emuOp_inc_BP(u8 X86EMU_UNUSED(op1))
3580 {
3581     START_OF_INSTR();
3582     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3583         DECODE_PRINTF("INC\tEBP\n");
3584     } else {
3585         DECODE_PRINTF("INC\tBP\n");
3586     }
3587     TRACE_AND_STEP();
3588     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3589         M.x86.R_EBP = inc_long(M.x86.R_EBP);
3590     } else {
3591         M.x86.R_BP = inc_word(M.x86.R_BP);
3592     }
3593     DECODE_CLEAR_SEGOVR();
3594     END_OF_INSTR();
3595 }
3596
3597 /****************************************************************************
3598 REMARKS:
3599 Handles opcode 0x46
3600 ****************************************************************************/
3601 static void x86emuOp_inc_SI(u8 X86EMU_UNUSED(op1))
3602 {
3603     START_OF_INSTR();
3604     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3605         DECODE_PRINTF("INC\tESI\n");
3606     } else {
3607         DECODE_PRINTF("INC\tSI\n");
3608     }
3609     TRACE_AND_STEP();
3610     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3611         M.x86.R_ESI = inc_long(M.x86.R_ESI);
3612     } else {
3613         M.x86.R_SI = inc_word(M.x86.R_SI);
3614     }
3615     DECODE_CLEAR_SEGOVR();
3616     END_OF_INSTR();
3617 }
3618
3619 /****************************************************************************
3620 REMARKS:
3621 Handles opcode 0x47
3622 ****************************************************************************/
3623 static void x86emuOp_inc_DI(u8 X86EMU_UNUSED(op1))
3624 {
3625     START_OF_INSTR();
3626     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3627         DECODE_PRINTF("INC\tEDI\n");
3628     } else {
3629         DECODE_PRINTF("INC\tDI\n");
3630     }
3631     TRACE_AND_STEP();
3632     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3633         M.x86.R_EDI = inc_long(M.x86.R_EDI);
3634     } else {
3635         M.x86.R_DI = inc_word(M.x86.R_DI);
3636     }
3637     DECODE_CLEAR_SEGOVR();
3638     END_OF_INSTR();
3639 }
3640
3641 /****************************************************************************
3642 REMARKS:
3643 Handles opcode 0x48
3644 ****************************************************************************/
3645 static void x86emuOp_dec_AX(u8 X86EMU_UNUSED(op1))
3646 {
3647     START_OF_INSTR();
3648     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3649         DECODE_PRINTF("DEC\tEAX\n");
3650     } else {
3651         DECODE_PRINTF("DEC\tAX\n");
3652     }
3653     TRACE_AND_STEP();
3654     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3655         M.x86.R_EAX = dec_long(M.x86.R_EAX);
3656     } else {
3657         M.x86.R_AX = dec_word(M.x86.R_AX);
3658     }
3659     DECODE_CLEAR_SEGOVR();
3660     END_OF_INSTR();
3661 }
3662
3663 /****************************************************************************
3664 REMARKS:
3665 Handles opcode 0x49
3666 ****************************************************************************/
3667 static void x86emuOp_dec_CX(u8 X86EMU_UNUSED(op1))
3668 {
3669     START_OF_INSTR();
3670     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3671         DECODE_PRINTF("DEC\tECX\n");
3672     } else {
3673         DECODE_PRINTF("DEC\tCX\n");
3674     }
3675     TRACE_AND_STEP();
3676     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3677         M.x86.R_ECX = dec_long(M.x86.R_ECX);
3678     } else {
3679         M.x86.R_CX = dec_word(M.x86.R_CX);
3680     }
3681     DECODE_CLEAR_SEGOVR();
3682     END_OF_INSTR();
3683 }
3684
3685 /****************************************************************************
3686 REMARKS:
3687 Handles opcode 0x4a
3688 ****************************************************************************/
3689 static void x86emuOp_dec_DX(u8 X86EMU_UNUSED(op1))
3690 {
3691     START_OF_INSTR();
3692     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3693         DECODE_PRINTF("DEC\tEDX\n");
3694     } else {
3695         DECODE_PRINTF("DEC\tDX\n");
3696     }
3697     TRACE_AND_STEP();
3698     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3699         M.x86.R_EDX = dec_long(M.x86.R_EDX);
3700     } else {
3701         M.x86.R_DX = dec_word(M.x86.R_DX);
3702     }
3703     DECODE_CLEAR_SEGOVR();
3704     END_OF_INSTR();
3705 }
3706
3707 /****************************************************************************
3708 REMARKS:
3709 Handles opcode 0x4b
3710 ****************************************************************************/
3711 static void x86emuOp_dec_BX(u8 X86EMU_UNUSED(op1))
3712 {
3713     START_OF_INSTR();
3714     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3715         DECODE_PRINTF("DEC\tEBX\n");
3716     } else {
3717         DECODE_PRINTF("DEC\tBX\n");
3718     }
3719     TRACE_AND_STEP();
3720     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3721         M.x86.R_EBX = dec_long(M.x86.R_EBX);
3722     } else {
3723         M.x86.R_BX = dec_word(M.x86.R_BX);
3724     }
3725     DECODE_CLEAR_SEGOVR();
3726     END_OF_INSTR();
3727 }
3728
3729 /****************************************************************************
3730 REMARKS:
3731 Handles opcode 0x4c
3732 ****************************************************************************/
3733 static void x86emuOp_dec_SP(u8 X86EMU_UNUSED(op1))
3734 {
3735     START_OF_INSTR();
3736     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3737         DECODE_PRINTF("DEC\tESP\n");
3738     } else {
3739         DECODE_PRINTF("DEC\tSP\n");
3740     }
3741     TRACE_AND_STEP();
3742     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3743         M.x86.R_ESP = dec_long(M.x86.R_ESP);
3744     } else {
3745         M.x86.R_SP = dec_word(M.x86.R_SP);
3746     }
3747     DECODE_CLEAR_SEGOVR();
3748     END_OF_INSTR();
3749 }
3750
3751 /****************************************************************************
3752 REMARKS:
3753 Handles opcode 0x4d
3754 ****************************************************************************/
3755 static void x86emuOp_dec_BP(u8 X86EMU_UNUSED(op1))
3756 {
3757     START_OF_INSTR();
3758     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3759         DECODE_PRINTF("DEC\tEBP\n");
3760     } else {
3761         DECODE_PRINTF("DEC\tBP\n");
3762     }
3763     TRACE_AND_STEP();
3764     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3765         M.x86.R_EBP = dec_long(M.x86.R_EBP);
3766     } else {
3767         M.x86.R_BP = dec_word(M.x86.R_BP);
3768     }
3769     DECODE_CLEAR_SEGOVR();
3770     END_OF_INSTR();
3771 }
3772
3773 /****************************************************************************
3774 REMARKS:
3775 Handles opcode 0x4e
3776 ****************************************************************************/
3777 static void x86emuOp_dec_SI(u8 X86EMU_UNUSED(op1))
3778 {
3779     START_OF_INSTR();
3780     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3781         DECODE_PRINTF("DEC\tESI\n");
3782     } else {
3783         DECODE_PRINTF("DEC\tSI\n");
3784     }
3785     TRACE_AND_STEP();
3786     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3787         M.x86.R_ESI = dec_long(M.x86.R_ESI);
3788     } else {
3789         M.x86.R_SI = dec_word(M.x86.R_SI);
3790     }
3791     DECODE_CLEAR_SEGOVR();
3792     END_OF_INSTR();
3793 }
3794
3795 /****************************************************************************
3796 REMARKS:
3797 Handles opcode 0x4f
3798 ****************************************************************************/
3799 static void x86emuOp_dec_DI(u8 X86EMU_UNUSED(op1))
3800 {
3801     START_OF_INSTR();
3802     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3803         DECODE_PRINTF("DEC\tEDI\n");
3804     } else {
3805         DECODE_PRINTF("DEC\tDI\n");
3806     }
3807     TRACE_AND_STEP();
3808     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3809         M.x86.R_EDI = dec_long(M.x86.R_EDI);
3810     } else {
3811         M.x86.R_DI = dec_word(M.x86.R_DI);
3812     }
3813     DECODE_CLEAR_SEGOVR();
3814     END_OF_INSTR();
3815 }
3816
3817 /****************************************************************************
3818 REMARKS:
3819 Handles opcode 0x50
3820 ****************************************************************************/
3821 static void x86emuOp_push_AX(u8 X86EMU_UNUSED(op1))
3822 {
3823     START_OF_INSTR();
3824     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3825         DECODE_PRINTF("PUSH\tEAX\n");
3826     } else {
3827         DECODE_PRINTF("PUSH\tAX\n");
3828     }
3829     TRACE_AND_STEP();
3830     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3831         push_long(M.x86.R_EAX);
3832     } else {
3833         push_word(M.x86.R_AX);
3834     }
3835     DECODE_CLEAR_SEGOVR();
3836     END_OF_INSTR();
3837 }
3838
3839 /****************************************************************************
3840 REMARKS:
3841 Handles opcode 0x51
3842 ****************************************************************************/
3843 static void x86emuOp_push_CX(u8 X86EMU_UNUSED(op1))
3844 {
3845     START_OF_INSTR();
3846     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3847         DECODE_PRINTF("PUSH\tECX\n");
3848     } else {
3849         DECODE_PRINTF("PUSH\tCX\n");
3850     }
3851     TRACE_AND_STEP();
3852     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3853         push_long(M.x86.R_ECX);
3854     } else {
3855         push_word(M.x86.R_CX);
3856     }
3857     DECODE_CLEAR_SEGOVR();
3858     END_OF_INSTR();
3859 }
3860
3861 /****************************************************************************
3862 REMARKS:
3863 Handles opcode 0x52
3864 ****************************************************************************/
3865 static void x86emuOp_push_DX(u8 X86EMU_UNUSED(op1))
3866 {
3867     START_OF_INSTR();
3868     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3869         DECODE_PRINTF("PUSH\tEDX\n");
3870     } else {
3871         DECODE_PRINTF("PUSH\tDX\n");
3872     }
3873     TRACE_AND_STEP();
3874     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3875         push_long(M.x86.R_EDX);
3876     } else {
3877         push_word(M.x86.R_DX);
3878     }
3879     DECODE_CLEAR_SEGOVR();
3880     END_OF_INSTR();
3881 }
3882
3883 /****************************************************************************
3884 REMARKS:
3885 Handles opcode 0x53
3886 ****************************************************************************/
3887 static void x86emuOp_push_BX(u8 X86EMU_UNUSED(op1))
3888 {
3889     START_OF_INSTR();
3890     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3891         DECODE_PRINTF("PUSH\tEBX\n");
3892     } else {
3893         DECODE_PRINTF("PUSH\tBX\n");
3894     }
3895     TRACE_AND_STEP();
3896     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3897         push_long(M.x86.R_EBX);
3898     } else {
3899         push_word(M.x86.R_BX);
3900     }
3901     DECODE_CLEAR_SEGOVR();
3902     END_OF_INSTR();
3903 }
3904
3905 /****************************************************************************
3906 REMARKS:
3907 Handles opcode 0x54
3908 ****************************************************************************/
3909 static void x86emuOp_push_SP(u8 X86EMU_UNUSED(op1))
3910 {
3911     START_OF_INSTR();
3912     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3913         DECODE_PRINTF("PUSH\tESP\n");
3914     } else {
3915         DECODE_PRINTF("PUSH\tSP\n");
3916     }
3917     TRACE_AND_STEP();
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.
3921          */
3922         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3923                 push_long(M.x86.R_ESP);
3924         } else {
3925                 push_word((u16)(M.x86.R_SP));
3926     }
3927     DECODE_CLEAR_SEGOVR();
3928     END_OF_INSTR();
3929 }
3930
3931 /****************************************************************************
3932 REMARKS:
3933 Handles opcode 0x55
3934 ****************************************************************************/
3935 static void x86emuOp_push_BP(u8 X86EMU_UNUSED(op1))
3936 {
3937     START_OF_INSTR();
3938     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3939         DECODE_PRINTF("PUSH\tEBP\n");
3940     } else {
3941         DECODE_PRINTF("PUSH\tBP\n");
3942     }
3943     TRACE_AND_STEP();
3944     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3945         push_long(M.x86.R_EBP);
3946     } else {
3947         push_word(M.x86.R_BP);
3948     }
3949     DECODE_CLEAR_SEGOVR();
3950     END_OF_INSTR();
3951 }
3952
3953 /****************************************************************************
3954 REMARKS:
3955 Handles opcode 0x56
3956 ****************************************************************************/
3957 static void x86emuOp_push_SI(u8 X86EMU_UNUSED(op1))
3958 {
3959     START_OF_INSTR();
3960     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3961         DECODE_PRINTF("PUSH\tESI\n");
3962     } else {
3963         DECODE_PRINTF("PUSH\tSI\n");
3964     }
3965     TRACE_AND_STEP();
3966     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3967         push_long(M.x86.R_ESI);
3968     } else {
3969         push_word(M.x86.R_SI);
3970     }
3971     DECODE_CLEAR_SEGOVR();
3972     END_OF_INSTR();
3973 }
3974
3975 /****************************************************************************
3976 REMARKS:
3977 Handles opcode 0x57
3978 ****************************************************************************/
3979 static void x86emuOp_push_DI(u8 X86EMU_UNUSED(op1))
3980 {
3981     START_OF_INSTR();
3982     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3983         DECODE_PRINTF("PUSH\tEDI\n");
3984     } else {
3985         DECODE_PRINTF("PUSH\tDI\n");
3986     }
3987     TRACE_AND_STEP();
3988     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
3989         push_long(M.x86.R_EDI);
3990     } else {
3991         push_word(M.x86.R_DI);
3992     }
3993     DECODE_CLEAR_SEGOVR();
3994     END_OF_INSTR();
3995 }
3996
3997 /****************************************************************************
3998 REMARKS:
3999 Handles opcode 0x58
4000 ****************************************************************************/
4001 static void x86emuOp_pop_AX(u8 X86EMU_UNUSED(op1))
4002 {
4003     START_OF_INSTR();
4004     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4005         DECODE_PRINTF("POP\tEAX\n");
4006     } else {
4007         DECODE_PRINTF("POP\tAX\n");
4008     }
4009     TRACE_AND_STEP();
4010     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4011         M.x86.R_EAX = pop_long();
4012     } else {
4013         M.x86.R_AX = pop_word();
4014     }
4015     DECODE_CLEAR_SEGOVR();
4016     END_OF_INSTR();
4017 }
4018
4019 /****************************************************************************
4020 REMARKS:
4021 Handles opcode 0x59
4022 ****************************************************************************/
4023 static void x86emuOp_pop_CX(u8 X86EMU_UNUSED(op1))
4024 {
4025     START_OF_INSTR();
4026     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4027         DECODE_PRINTF("POP\tECX\n");
4028     } else {
4029         DECODE_PRINTF("POP\tCX\n");
4030     }
4031     TRACE_AND_STEP();
4032     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4033         M.x86.R_ECX = pop_long();
4034     } else {
4035         M.x86.R_CX = pop_word();
4036     }
4037     DECODE_CLEAR_SEGOVR();
4038     END_OF_INSTR();
4039 }
4040
4041 /****************************************************************************
4042 REMARKS:
4043 Handles opcode 0x5a
4044 ****************************************************************************/
4045 static void x86emuOp_pop_DX(u8 X86EMU_UNUSED(op1))
4046 {
4047     START_OF_INSTR();
4048     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4049         DECODE_PRINTF("POP\tEDX\n");
4050     } else {
4051         DECODE_PRINTF("POP\tDX\n");
4052     }
4053     TRACE_AND_STEP();
4054     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4055         M.x86.R_EDX = pop_long();
4056     } else {
4057         M.x86.R_DX = pop_word();
4058     }
4059     DECODE_CLEAR_SEGOVR();
4060     END_OF_INSTR();
4061 }
4062
4063 /****************************************************************************
4064 REMARKS:
4065 Handles opcode 0x5b
4066 ****************************************************************************/
4067 static void x86emuOp_pop_BX(u8 X86EMU_UNUSED(op1))
4068 {
4069     START_OF_INSTR();
4070     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4071         DECODE_PRINTF("POP\tEBX\n");
4072     } else {
4073         DECODE_PRINTF("POP\tBX\n");
4074     }
4075     TRACE_AND_STEP();
4076     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4077         M.x86.R_EBX = pop_long();
4078     } else {
4079         M.x86.R_BX = pop_word();
4080     }
4081     DECODE_CLEAR_SEGOVR();
4082     END_OF_INSTR();
4083 }
4084
4085 /****************************************************************************
4086 REMARKS:
4087 Handles opcode 0x5c
4088 ****************************************************************************/
4089 static void x86emuOp_pop_SP(u8 X86EMU_UNUSED(op1))
4090 {
4091     START_OF_INSTR();
4092     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4093         DECODE_PRINTF("POP\tESP\n");
4094     } else {
4095         DECODE_PRINTF("POP\tSP\n");
4096     }
4097     TRACE_AND_STEP();
4098     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4099         M.x86.R_ESP = pop_long();
4100     } else {
4101         M.x86.R_SP = pop_word();
4102     }
4103     DECODE_CLEAR_SEGOVR();
4104     END_OF_INSTR();
4105 }
4106
4107 /****************************************************************************
4108 REMARKS:
4109 Handles opcode 0x5d
4110 ****************************************************************************/
4111 static void x86emuOp_pop_BP(u8 X86EMU_UNUSED(op1))
4112 {
4113     START_OF_INSTR();
4114     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4115         DECODE_PRINTF("POP\tEBP\n");
4116     } else {
4117         DECODE_PRINTF("POP\tBP\n");
4118     }
4119     TRACE_AND_STEP();
4120     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4121         M.x86.R_EBP = pop_long();
4122     } else {
4123         M.x86.R_BP = pop_word();
4124     }
4125     DECODE_CLEAR_SEGOVR();
4126     END_OF_INSTR();
4127 }
4128
4129 /****************************************************************************
4130 REMARKS:
4131 Handles opcode 0x5e
4132 ****************************************************************************/
4133 static void x86emuOp_pop_SI(u8 X86EMU_UNUSED(op1))
4134 {
4135     START_OF_INSTR();
4136     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4137         DECODE_PRINTF("POP\tESI\n");
4138     } else {
4139         DECODE_PRINTF("POP\tSI\n");
4140     }
4141     TRACE_AND_STEP();
4142     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4143         M.x86.R_ESI = pop_long();
4144     } else {
4145         M.x86.R_SI = pop_word();
4146     }
4147     DECODE_CLEAR_SEGOVR();
4148     END_OF_INSTR();
4149 }
4150
4151 /****************************************************************************
4152 REMARKS:
4153 Handles opcode 0x5f
4154 ****************************************************************************/
4155 static void x86emuOp_pop_DI(u8 X86EMU_UNUSED(op1))
4156 {
4157     START_OF_INSTR();
4158     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4159         DECODE_PRINTF("POP\tEDI\n");
4160     } else {
4161         DECODE_PRINTF("POP\tDI\n");
4162     }
4163     TRACE_AND_STEP();
4164     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4165         M.x86.R_EDI = pop_long();
4166     } else {
4167         M.x86.R_DI = pop_word();
4168     }
4169     DECODE_CLEAR_SEGOVR();
4170     END_OF_INSTR();
4171 }
4172
4173 /****************************************************************************
4174 REMARKS:
4175 Handles opcode 0x60
4176 ****************************************************************************/
4177 static void x86emuOp_push_all(u8 X86EMU_UNUSED(op1))
4178 {
4179     START_OF_INSTR();
4180     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4181         DECODE_PRINTF("PUSHAD\n");
4182     } else {
4183         DECODE_PRINTF("PUSHA\n");
4184     }
4185     TRACE_AND_STEP();
4186     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4187         u32 old_sp = M.x86.R_ESP;
4188
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);
4193         push_long(old_sp);
4194         push_long(M.x86.R_EBP);
4195         push_long(M.x86.R_ESI);
4196         push_long(M.x86.R_EDI);
4197     } else {
4198         u16 old_sp = M.x86.R_SP;
4199
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);
4204         push_word(old_sp);
4205         push_word(M.x86.R_BP);
4206         push_word(M.x86.R_SI);
4207         push_word(M.x86.R_DI);
4208     }
4209     DECODE_CLEAR_SEGOVR();
4210     END_OF_INSTR();
4211 }
4212
4213 /****************************************************************************
4214 REMARKS:
4215 Handles opcode 0x61
4216 ****************************************************************************/
4217 static void x86emuOp_pop_all(u8 X86EMU_UNUSED(op1))
4218 {
4219     START_OF_INSTR();
4220     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4221         DECODE_PRINTF("POPAD\n");
4222     } else {
4223         DECODE_PRINTF("POPA\n");
4224     }
4225     TRACE_AND_STEP();
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();
4235     } else {
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();
4244     }
4245     DECODE_CLEAR_SEGOVR();
4246     END_OF_INSTR();
4247 }
4248
4249 /*opcode 0x62   ILLEGAL OP, calls x86emuOp_illegal_op() */
4250 /*opcode 0x63   ILLEGAL OP, calls x86emuOp_illegal_op() */
4251
4252 /****************************************************************************
4253 REMARKS:
4254 Handles opcode 0x64
4255 ****************************************************************************/
4256 static void x86emuOp_segovr_FS(u8 X86EMU_UNUSED(op1))
4257 {
4258     START_OF_INSTR();
4259     DECODE_PRINTF("FS:\n");
4260     TRACE_AND_STEP();
4261     M.x86.mode |= SYSMODE_SEGOVR_FS;
4262     /*
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.
4265      */
4266     END_OF_INSTR();
4267 }
4268
4269 /****************************************************************************
4270 REMARKS:
4271 Handles opcode 0x65
4272 ****************************************************************************/
4273 static void x86emuOp_segovr_GS(u8 X86EMU_UNUSED(op1))
4274 {
4275     START_OF_INSTR();
4276     DECODE_PRINTF("GS:\n");
4277     TRACE_AND_STEP();
4278     M.x86.mode |= SYSMODE_SEGOVR_GS;
4279     /*
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.
4282      */
4283     END_OF_INSTR();
4284 }
4285
4286 /****************************************************************************
4287 REMARKS:
4288 Handles opcode 0x66 - prefix for 32-bit register
4289 ****************************************************************************/
4290 static void x86emuOp_prefix_data(u8 X86EMU_UNUSED(op1))
4291 {
4292     START_OF_INSTR();
4293     DECODE_PRINTF("DATA:\n");
4294     TRACE_AND_STEP();
4295     M.x86.mode |= SYSMODE_PREFIX_DATA;
4296     /* note no DECODE_CLEAR_SEGOVR here. */
4297     END_OF_INSTR();
4298 }
4299
4300 /****************************************************************************
4301 REMARKS:
4302 Handles opcode 0x67 - prefix for 32-bit address
4303 ****************************************************************************/
4304 static void x86emuOp_prefix_addr(u8 X86EMU_UNUSED(op1))
4305 {
4306     START_OF_INSTR();
4307     DECODE_PRINTF("ADDR:\n");
4308     TRACE_AND_STEP();
4309     M.x86.mode |= SYSMODE_PREFIX_ADDR;
4310     /* note no DECODE_CLEAR_SEGOVR here. */
4311     END_OF_INSTR();
4312 }
4313
4314 /****************************************************************************
4315 REMARKS:
4316 Handles opcode 0x68
4317 ****************************************************************************/
4318 static void x86emuOp_push_word_IMM(u8 X86EMU_UNUSED(op1))
4319 {
4320     u32 imm;
4321
4322     START_OF_INSTR();
4323     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4324         imm = fetch_long_imm();
4325     } else {
4326         imm = fetch_word_imm();
4327     }
4328     DECODE_PRINTF2("PUSH\t%x\n", imm);
4329     TRACE_AND_STEP();
4330     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4331         push_long(imm);
4332     } else {
4333         push_word((u16)imm);
4334     }
4335     DECODE_CLEAR_SEGOVR();
4336     END_OF_INSTR();
4337 }
4338
4339 /****************************************************************************
4340 REMARKS:
4341 Handles opcode 0x69
4342 ****************************************************************************/
4343 static void x86emuOp_imul_word_IMM(u8 X86EMU_UNUSED(op1))
4344 {
4345     int mod, rl, rh;
4346     uint srcoffset;
4347
4348     START_OF_INSTR();
4349     DECODE_PRINTF("IMUL\t");
4350     FETCH_DECODE_MODRM(mod, rh, rl);
4351     switch (mod) {
4352     case 0:
4353         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4354             u32 *destreg;
4355             u32 srcval;
4356             u32 res_lo,res_hi;
4357             s32 imm;
4358
4359             destreg = DECODE_RM_LONG_REGISTER(rh);
4360             DECODE_PRINTF(",");
4361             srcoffset = decode_rm00_address(rl);
4362             srcval = fetch_data_long(srcoffset);
4363             imm = fetch_long_imm();
4364             DECODE_PRINTF2(",%d\n", (s32)imm);
4365             TRACE_AND_STEP();
4366             imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
4367             if (res_hi != 0) {
4368                 SET_FLAG(F_CF);
4369                 SET_FLAG(F_OF);
4370             } else {
4371                 CLEAR_FLAG(F_CF);
4372                 CLEAR_FLAG(F_OF);
4373             }
4374             *destreg = (u32)res_lo;
4375         } else {
4376             u16 *destreg;
4377             u16 srcval;
4378             u32 res;
4379             s16 imm;
4380
4381             destreg = DECODE_RM_WORD_REGISTER(rh);
4382             DECODE_PRINTF(",");
4383             srcoffset = decode_rm00_address(rl);
4384             srcval = fetch_data_word(srcoffset);
4385             imm = fetch_word_imm();
4386             DECODE_PRINTF2(",%d\n", (s32)imm);
4387             TRACE_AND_STEP();
4388             res = (s16)srcval * (s16)imm;
4389             if (res > 0xFFFF) {
4390                 SET_FLAG(F_CF);
4391                 SET_FLAG(F_OF);
4392             } else {
4393                 CLEAR_FLAG(F_CF);
4394                 CLEAR_FLAG(F_OF);
4395             }
4396             *destreg = (u16)res;
4397         }
4398         break;
4399     case 1:
4400         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4401             u32 *destreg;
4402             u32 srcval;
4403             u32 res_lo,res_hi;
4404             s32 imm;
4405
4406             destreg = DECODE_RM_LONG_REGISTER(rh);
4407             DECODE_PRINTF(",");
4408             srcoffset = decode_rm01_address(rl);
4409             srcval = fetch_data_long(srcoffset);
4410             imm = fetch_long_imm();
4411             DECODE_PRINTF2(",%d\n", (s32)imm);
4412             TRACE_AND_STEP();
4413             imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
4414             if (res_hi != 0) {
4415                 SET_FLAG(F_CF);
4416                 SET_FLAG(F_OF);
4417             } else {
4418                 CLEAR_FLAG(F_CF);
4419                 CLEAR_FLAG(F_OF);
4420             }
4421             *destreg = (u32)res_lo;
4422         } else {
4423             u16 *destreg;
4424             u16 srcval;
4425             u32 res;
4426             s16 imm;
4427
4428             destreg = DECODE_RM_WORD_REGISTER(rh);
4429             DECODE_PRINTF(",");
4430             srcoffset = decode_rm01_address(rl);
4431             srcval = fetch_data_word(srcoffset);
4432             imm = fetch_word_imm();
4433             DECODE_PRINTF2(",%d\n", (s32)imm);
4434             TRACE_AND_STEP();
4435             res = (s16)srcval * (s16)imm;
4436             if (res > 0xFFFF) {
4437                 SET_FLAG(F_CF);
4438                 SET_FLAG(F_OF);
4439             } else {
4440                 CLEAR_FLAG(F_CF);
4441                 CLEAR_FLAG(F_OF);
4442             }
4443             *destreg = (u16)res;
4444         }
4445         break;
4446     case 2:
4447         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4448             u32 *destreg;
4449             u32 srcval;
4450             u32 res_lo,res_hi;
4451             s32 imm;
4452
4453             destreg = DECODE_RM_LONG_REGISTER(rh);
4454             DECODE_PRINTF(",");
4455             srcoffset = decode_rm10_address(rl);
4456             srcval = fetch_data_long(srcoffset);
4457             imm = fetch_long_imm();
4458             DECODE_PRINTF2(",%d\n", (s32)imm);
4459             TRACE_AND_STEP();
4460             imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
4461             if (res_hi != 0) {
4462                 SET_FLAG(F_CF);
4463                 SET_FLAG(F_OF);
4464             } else {
4465                 CLEAR_FLAG(F_CF);
4466                 CLEAR_FLAG(F_OF);
4467             }
4468             *destreg = (u32)res_lo;
4469         } else {
4470             u16 *destreg;
4471             u16 srcval;
4472             u32 res;
4473             s16 imm;
4474
4475             destreg = DECODE_RM_WORD_REGISTER(rh);
4476             DECODE_PRINTF(",");
4477             srcoffset = decode_rm10_address(rl);
4478             srcval = fetch_data_word(srcoffset);
4479             imm = fetch_word_imm();
4480             DECODE_PRINTF2(",%d\n", (s32)imm);
4481             TRACE_AND_STEP();
4482             res = (s16)srcval * (s16)imm;
4483             if (res > 0xFFFF) {
4484                 SET_FLAG(F_CF);
4485                 SET_FLAG(F_OF);
4486             } else {
4487                 CLEAR_FLAG(F_CF);
4488                 CLEAR_FLAG(F_OF);
4489             }
4490             *destreg = (u16)res;
4491         }
4492         break;
4493     case 3:                     /* register to register */
4494         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4495             u32 *destreg,*srcreg;
4496             u32 res_lo,res_hi;
4497             s32 imm;
4498
4499             destreg = DECODE_RM_LONG_REGISTER(rh);
4500             DECODE_PRINTF(",");
4501             srcreg = DECODE_RM_LONG_REGISTER(rl);
4502             imm = fetch_long_imm();
4503             DECODE_PRINTF2(",%d\n", (s32)imm);
4504             TRACE_AND_STEP();
4505             imul_long_direct(&res_lo,&res_hi,(s32)*srcreg,(s32)imm);
4506             if (res_hi != 0) {
4507                 SET_FLAG(F_CF);
4508                 SET_FLAG(F_OF);
4509             } else {
4510                 CLEAR_FLAG(F_CF);
4511                 CLEAR_FLAG(F_OF);
4512             }
4513             *destreg = (u32)res_lo;
4514         } else {
4515             u16 *destreg,*srcreg;
4516             u32 res;
4517             s16 imm;
4518
4519             destreg = DECODE_RM_WORD_REGISTER(rh);
4520             DECODE_PRINTF(",");
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;
4525             if (res > 0xFFFF) {
4526                 SET_FLAG(F_CF);
4527                 SET_FLAG(F_OF);
4528             } else {
4529                 CLEAR_FLAG(F_CF);
4530                 CLEAR_FLAG(F_OF);
4531             }
4532             *destreg = (u16)res;
4533         }
4534         break;
4535     }
4536     DECODE_CLEAR_SEGOVR();
4537     END_OF_INSTR();
4538 }
4539
4540 /****************************************************************************
4541 REMARKS:
4542 Handles opcode 0x6a
4543 ****************************************************************************/
4544 static void x86emuOp_push_byte_IMM(u8 X86EMU_UNUSED(op1))
4545 {
4546     s16 imm;
4547
4548     START_OF_INSTR();
4549     imm = (s8)fetch_byte_imm();
4550     DECODE_PRINTF2("PUSH\t%d\n", imm);
4551     TRACE_AND_STEP();
4552     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4553         push_long((s32)imm);
4554     } else {
4555         push_word(imm);
4556     }
4557     DECODE_CLEAR_SEGOVR();
4558     END_OF_INSTR();
4559 }
4560
4561 /****************************************************************************
4562 REMARKS:
4563 Handles opcode 0x6b
4564 ****************************************************************************/
4565 static void x86emuOp_imul_byte_IMM(u8 X86EMU_UNUSED(op1))
4566 {
4567     int mod, rl, rh;
4568     uint srcoffset;
4569     s8  imm;
4570
4571     START_OF_INSTR();
4572     DECODE_PRINTF("IMUL\t");
4573     FETCH_DECODE_MODRM(mod, rh, rl);
4574     switch (mod) {
4575     case 0:
4576         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4577             u32 *destreg;
4578             u32 srcval;
4579             u32 res_lo,res_hi;
4580
4581             destreg = DECODE_RM_LONG_REGISTER(rh);
4582             DECODE_PRINTF(",");
4583             srcoffset = decode_rm00_address(rl);
4584             srcval = fetch_data_long(srcoffset);
4585             imm = fetch_byte_imm();
4586             DECODE_PRINTF2(",%d\n", (s32)imm);
4587             TRACE_AND_STEP();
4588             imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
4589             if (res_hi != 0) {
4590                 SET_FLAG(F_CF);
4591                 SET_FLAG(F_OF);
4592             } else {
4593                 CLEAR_FLAG(F_CF);
4594                 CLEAR_FLAG(F_OF);
4595             }
4596             *destreg = (u32)res_lo;
4597         } else {
4598             u16 *destreg;
4599             u16 srcval;
4600             u32 res;
4601
4602             destreg = DECODE_RM_WORD_REGISTER(rh);
4603             DECODE_PRINTF(",");
4604             srcoffset = decode_rm00_address(rl);
4605             srcval = fetch_data_word(srcoffset);
4606             imm = fetch_byte_imm();
4607             DECODE_PRINTF2(",%d\n", (s32)imm);
4608             TRACE_AND_STEP();
4609             res = (s16)srcval * (s16)imm;
4610             if (res > 0xFFFF) {
4611                 SET_FLAG(F_CF);
4612                 SET_FLAG(F_OF);
4613             } else {
4614                 CLEAR_FLAG(F_CF);
4615                 CLEAR_FLAG(F_OF);
4616             }
4617             *destreg = (u16)res;
4618         }
4619         break;
4620     case 1:
4621         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4622             u32 *destreg;
4623             u32 srcval;
4624             u32 res_lo,res_hi;
4625
4626             destreg = DECODE_RM_LONG_REGISTER(rh);
4627             DECODE_PRINTF(",");
4628             srcoffset = decode_rm01_address(rl);
4629             srcval = fetch_data_long(srcoffset);
4630             imm = fetch_byte_imm();
4631             DECODE_PRINTF2(",%d\n", (s32)imm);
4632             TRACE_AND_STEP();
4633             imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
4634             if (res_hi != 0) {
4635                 SET_FLAG(F_CF);
4636                 SET_FLAG(F_OF);
4637             } else {
4638                 CLEAR_FLAG(F_CF);
4639                 CLEAR_FLAG(F_OF);
4640             }
4641             *destreg = (u32)res_lo;
4642         } else {
4643             u16 *destreg;
4644             u16 srcval;
4645             u32 res;
4646
4647             destreg = DECODE_RM_WORD_REGISTER(rh);
4648             DECODE_PRINTF(",");
4649             srcoffset = decode_rm01_address(rl);
4650             srcval = fetch_data_word(srcoffset);
4651             imm = fetch_byte_imm();
4652             DECODE_PRINTF2(",%d\n", (s32)imm);
4653             TRACE_AND_STEP();
4654             res = (s16)srcval * (s16)imm;
4655             if (res > 0xFFFF) {
4656                 SET_FLAG(F_CF);
4657                 SET_FLAG(F_OF);
4658             } else {
4659                 CLEAR_FLAG(F_CF);
4660                 CLEAR_FLAG(F_OF);
4661             }
4662             *destreg = (u16)res;
4663         }
4664         break;
4665     case 2:
4666         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4667             u32 *destreg;
4668             u32 srcval;
4669             u32 res_lo,res_hi;
4670
4671             destreg = DECODE_RM_LONG_REGISTER(rh);
4672             DECODE_PRINTF(",");
4673             srcoffset = decode_rm10_address(rl);
4674             srcval = fetch_data_long(srcoffset);
4675             imm = fetch_byte_imm();
4676             DECODE_PRINTF2(",%d\n", (s32)imm);
4677             TRACE_AND_STEP();
4678             imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
4679             if (res_hi != 0) {
4680                 SET_FLAG(F_CF);
4681                 SET_FLAG(F_OF);
4682             } else {
4683                 CLEAR_FLAG(F_CF);
4684                 CLEAR_FLAG(F_OF);
4685             }
4686             *destreg = (u32)res_lo;
4687         } else {
4688             u16 *destreg;
4689             u16 srcval;
4690             u32 res;
4691
4692             destreg = DECODE_RM_WORD_REGISTER(rh);
4693             DECODE_PRINTF(",");
4694             srcoffset = decode_rm10_address(rl);
4695             srcval = fetch_data_word(srcoffset);
4696             imm = fetch_byte_imm();
4697             DECODE_PRINTF2(",%d\n", (s32)imm);
4698             TRACE_AND_STEP();
4699             res = (s16)srcval * (s16)imm;
4700             if (res > 0xFFFF) {
4701                 SET_FLAG(F_CF);
4702                 SET_FLAG(F_OF);
4703             } else {
4704                 CLEAR_FLAG(F_CF);
4705                 CLEAR_FLAG(F_OF);
4706             }
4707             *destreg = (u16)res;
4708         }
4709         break;
4710     case 3:                     /* register to register */
4711         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4712             u32 *destreg,*srcreg;
4713             u32 res_lo,res_hi;
4714
4715             destreg = DECODE_RM_LONG_REGISTER(rh);
4716             DECODE_PRINTF(",");
4717             srcreg = DECODE_RM_LONG_REGISTER(rl);
4718             imm = fetch_byte_imm();
4719             DECODE_PRINTF2(",%d\n", (s32)imm);
4720             TRACE_AND_STEP();
4721             imul_long_direct(&res_lo,&res_hi,(s32)*srcreg,(s32)imm);
4722             if (res_hi != 0) {
4723                 SET_FLAG(F_CF);
4724                 SET_FLAG(F_OF);
4725             } else {
4726                 CLEAR_FLAG(F_CF);
4727                 CLEAR_FLAG(F_OF);
4728             }
4729             *destreg = (u32)res_lo;
4730         } else {
4731             u16 *destreg,*srcreg;
4732             u32 res;
4733
4734             destreg = DECODE_RM_WORD_REGISTER(rh);
4735             DECODE_PRINTF(",");
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;
4740             if (res > 0xFFFF) {
4741                 SET_FLAG(F_CF);
4742                 SET_FLAG(F_OF);
4743             } else {
4744                 CLEAR_FLAG(F_CF);
4745                 CLEAR_FLAG(F_OF);
4746             }
4747             *destreg = (u16)res;
4748         }
4749         break;
4750     }
4751     DECODE_CLEAR_SEGOVR();
4752     END_OF_INSTR();
4753 }
4754
4755 /****************************************************************************
4756 REMARKS:
4757 Handles opcode 0x6c
4758 ****************************************************************************/
4759 static void x86emuOp_ins_byte(u8 X86EMU_UNUSED(op1))
4760 {
4761     START_OF_INSTR();
4762     DECODE_PRINTF("INSB\n");
4763     ins(1);
4764     TRACE_AND_STEP();
4765     DECODE_CLEAR_SEGOVR();
4766     END_OF_INSTR();
4767 }
4768
4769 /****************************************************************************
4770 REMARKS:
4771 Handles opcode 0x6d
4772 ****************************************************************************/
4773 static void x86emuOp_ins_word(u8 X86EMU_UNUSED(op1))
4774 {
4775     START_OF_INSTR();
4776     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4777         DECODE_PRINTF("INSD\n");
4778         ins(4);
4779     } else {
4780         DECODE_PRINTF("INSW\n");
4781         ins(2);
4782     }
4783     TRACE_AND_STEP();
4784     DECODE_CLEAR_SEGOVR();
4785     END_OF_INSTR();
4786 }
4787
4788 /****************************************************************************
4789 REMARKS:
4790 Handles opcode 0x6e
4791 ****************************************************************************/
4792 static void x86emuOp_outs_byte(u8 X86EMU_UNUSED(op1))
4793 {
4794     START_OF_INSTR();
4795     DECODE_PRINTF("OUTSB\n");
4796     outs(1);
4797     TRACE_AND_STEP();
4798     DECODE_CLEAR_SEGOVR();
4799     END_OF_INSTR();
4800 }
4801
4802 /****************************************************************************
4803 REMARKS:
4804 Handles opcode 0x6f
4805 ****************************************************************************/
4806 static void x86emuOp_outs_word(u8 X86EMU_UNUSED(op1))
4807 {
4808     START_OF_INSTR();
4809     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
4810         DECODE_PRINTF("OUTSD\n");
4811         outs(4);
4812     } else {
4813         DECODE_PRINTF("OUTSW\n");
4814         outs(2);
4815     }
4816     TRACE_AND_STEP();
4817     DECODE_CLEAR_SEGOVR();
4818     END_OF_INSTR();
4819 }
4820
4821 /****************************************************************************
4822 REMARKS:
4823 Handles opcode 0x70
4824 ****************************************************************************/
4825 static void x86emuOp_jump_near_O(u8 X86EMU_UNUSED(op1))
4826 {
4827     s8 offset;
4828     u16 target;
4829
4830     /* jump to byte offset if overflow flag is set */
4831     START_OF_INSTR();
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);
4836     TRACE_AND_STEP();
4837     if (ACCESS_FLAG(F_OF))
4838         M.x86.R_IP = target;
4839     DECODE_CLEAR_SEGOVR();
4840     END_OF_INSTR();
4841 }
4842
4843 /****************************************************************************
4844 REMARKS:
4845 Handles opcode 0x71
4846 ****************************************************************************/
4847 static void x86emuOp_jump_near_NO(u8 X86EMU_UNUSED(op1))
4848 {
4849     s8 offset;
4850     u16 target;
4851
4852     /* jump to byte offset if overflow is not set */
4853     START_OF_INSTR();
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);
4858     TRACE_AND_STEP();
4859     if (!ACCESS_FLAG(F_OF))
4860         M.x86.R_IP = target;
4861     DECODE_CLEAR_SEGOVR();
4862     END_OF_INSTR();
4863 }
4864
4865 /****************************************************************************
4866 REMARKS:
4867 Handles opcode 0x72
4868 ****************************************************************************/
4869 static void x86emuOp_jump_near_B(u8 X86EMU_UNUSED(op1))
4870 {
4871     s8 offset;
4872     u16 target;
4873
4874     /* jump to byte offset if carry flag is set. */
4875     START_OF_INSTR();
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);
4880     TRACE_AND_STEP();
4881     if (ACCESS_FLAG(F_CF))
4882         M.x86.R_IP = target;
4883     DECODE_CLEAR_SEGOVR();
4884     END_OF_INSTR();
4885 }
4886
4887 /****************************************************************************
4888 REMARKS:
4889 Handles opcode 0x73
4890 ****************************************************************************/
4891 static void x86emuOp_jump_near_NB(u8 X86EMU_UNUSED(op1))
4892 {
4893     s8 offset;
4894     u16 target;
4895
4896     /* jump to byte offset if carry flag is clear. */
4897     START_OF_INSTR();
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);
4902     TRACE_AND_STEP();
4903     if (!ACCESS_FLAG(F_CF))
4904         M.x86.R_IP = target;
4905     DECODE_CLEAR_SEGOVR();
4906     END_OF_INSTR();
4907 }
4908
4909 /****************************************************************************
4910 REMARKS:
4911 Handles opcode 0x74
4912 ****************************************************************************/
4913 static void x86emuOp_jump_near_Z(u8 X86EMU_UNUSED(op1))
4914 {
4915     s8 offset;
4916     u16 target;
4917
4918     /* jump to byte offset if zero flag is set. */
4919     START_OF_INSTR();
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);
4924     TRACE_AND_STEP();
4925     if (ACCESS_FLAG(F_ZF))
4926         M.x86.R_IP = target;
4927     DECODE_CLEAR_SEGOVR();
4928     END_OF_INSTR();
4929 }
4930
4931 /****************************************************************************
4932 REMARKS:
4933 Handles opcode 0x75
4934 ****************************************************************************/
4935 static void x86emuOp_jump_near_NZ(u8 X86EMU_UNUSED(op1))
4936 {
4937     s8 offset;
4938     u16 target;
4939
4940     /* jump to byte offset if zero flag is clear. */
4941     START_OF_INSTR();
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);
4946     TRACE_AND_STEP();
4947     if (!ACCESS_FLAG(F_ZF))
4948         M.x86.R_IP = target;
4949     DECODE_CLEAR_SEGOVR();
4950     END_OF_INSTR();
4951 }
4952
4953 /****************************************************************************
4954 REMARKS:
4955 Handles opcode 0x76
4956 ****************************************************************************/
4957 static void x86emuOp_jump_near_BE(u8 X86EMU_UNUSED(op1))
4958 {
4959     s8 offset;
4960     u16 target;
4961
4962     /* jump to byte offset if carry flag is set or if the zero
4963        flag is set. */
4964     START_OF_INSTR();
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);
4969     TRACE_AND_STEP();
4970     if (ACCESS_FLAG(F_CF) || ACCESS_FLAG(F_ZF))
4971         M.x86.R_IP = target;
4972     DECODE_CLEAR_SEGOVR();
4973     END_OF_INSTR();
4974 }
4975
4976 /****************************************************************************
4977 REMARKS:
4978 Handles opcode 0x77
4979 ****************************************************************************/
4980 static void x86emuOp_jump_near_NBE(u8 X86EMU_UNUSED(op1))
4981 {
4982     s8 offset;
4983     u16 target;
4984
4985     /* jump to byte offset if carry flag is clear and if the zero
4986        flag is clear */
4987     START_OF_INSTR();
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);
4992     TRACE_AND_STEP();
4993     if (!(ACCESS_FLAG(F_CF) || ACCESS_FLAG(F_ZF)))
4994         M.x86.R_IP = target;
4995     DECODE_CLEAR_SEGOVR();
4996     END_OF_INSTR();
4997 }
4998
4999 /****************************************************************************
5000 REMARKS:
5001 Handles opcode 0x78
5002 ****************************************************************************/
5003 static void x86emuOp_jump_near_S(u8 X86EMU_UNUSED(op1))
5004 {
5005     s8 offset;
5006     u16 target;
5007
5008     /* jump to byte offset if sign flag is set */
5009     START_OF_INSTR();
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);
5014     TRACE_AND_STEP();
5015     if (ACCESS_FLAG(F_SF))
5016         M.x86.R_IP = target;
5017     DECODE_CLEAR_SEGOVR();
5018     END_OF_INSTR();
5019 }
5020
5021 /****************************************************************************
5022 REMARKS:
5023 Handles opcode 0x79
5024 ****************************************************************************/
5025 static void x86emuOp_jump_near_NS(u8 X86EMU_UNUSED(op1))
5026 {
5027     s8 offset;
5028     u16 target;
5029
5030     /* jump to byte offset if sign flag is clear */
5031     START_OF_INSTR();
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);
5036     TRACE_AND_STEP();
5037     if (!ACCESS_FLAG(F_SF))
5038         M.x86.R_IP = target;
5039     DECODE_CLEAR_SEGOVR();
5040     END_OF_INSTR();
5041 }
5042
5043 /****************************************************************************
5044 REMARKS:
5045 Handles opcode 0x7a
5046 ****************************************************************************/
5047 static void x86emuOp_jump_near_P(u8 X86EMU_UNUSED(op1))
5048 {
5049     s8 offset;
5050     u16 target;
5051
5052     /* jump to byte offset if parity flag is set (even parity) */
5053     START_OF_INSTR();
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);
5058     TRACE_AND_STEP();
5059     if (ACCESS_FLAG(F_PF))
5060         M.x86.R_IP = target;
5061     DECODE_CLEAR_SEGOVR();
5062     END_OF_INSTR();
5063 }
5064
5065 /****************************************************************************
5066 REMARKS:
5067 Handles opcode 0x7b
5068 ****************************************************************************/
5069 static void x86emuOp_jump_near_NP(u8 X86EMU_UNUSED(op1))
5070 {
5071     s8 offset;
5072     u16 target;
5073
5074     /* jump to byte offset if parity flag is clear (odd parity) */
5075     START_OF_INSTR();
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);
5080     TRACE_AND_STEP();
5081     if (!ACCESS_FLAG(F_PF))
5082         M.x86.R_IP = target;
5083     DECODE_CLEAR_SEGOVR();
5084     END_OF_INSTR();
5085 }
5086
5087 /****************************************************************************
5088 REMARKS:
5089 Handles opcode 0x7c
5090 ****************************************************************************/
5091 static void x86emuOp_jump_near_L(u8 X86EMU_UNUSED(op1))
5092 {
5093     s8 offset;
5094     u16 target;
5095     int sf, of;
5096
5097     /* jump to byte offset if sign flag not equal to overflow flag. */
5098     START_OF_INSTR();
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);
5103     TRACE_AND_STEP();
5104     sf = ACCESS_FLAG(F_SF) != 0;
5105     of = ACCESS_FLAG(F_OF) != 0;
5106     if (sf ^ of)
5107         M.x86.R_IP = target;
5108     DECODE_CLEAR_SEGOVR();
5109     END_OF_INSTR();
5110 }
5111
5112 /****************************************************************************
5113 REMARKS:
5114 Handles opcode 0x7d
5115 ****************************************************************************/
5116 static void x86emuOp_jump_near_NL(u8 X86EMU_UNUSED(op1))
5117 {
5118     s8 offset;
5119     u16 target;
5120     int sf, of;
5121
5122     /* jump to byte offset if sign flag not equal to overflow flag. */
5123     START_OF_INSTR();
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);
5128     TRACE_AND_STEP();
5129     sf = ACCESS_FLAG(F_SF) != 0;
5130     of = ACCESS_FLAG(F_OF) != 0;
5131     /* note: inverse of above, but using == instead of xor. */
5132     if (sf == of)
5133         M.x86.R_IP = target;
5134     DECODE_CLEAR_SEGOVR();
5135     END_OF_INSTR();
5136 }
5137
5138 /****************************************************************************
5139 REMARKS:
5140 Handles opcode 0x7e
5141 ****************************************************************************/
5142 static void x86emuOp_jump_near_LE(u8 X86EMU_UNUSED(op1))
5143 {
5144     s8 offset;
5145     u16 target;
5146     int sf, of;
5147
5148     /* jump to byte offset if sign flag not equal to overflow flag
5149        or the zero flag is set */
5150     START_OF_INSTR();
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);
5155     TRACE_AND_STEP();
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();
5161     END_OF_INSTR();
5162 }
5163
5164 /****************************************************************************
5165 REMARKS:
5166 Handles opcode 0x7f
5167 ****************************************************************************/
5168 static void x86emuOp_jump_near_NLE(u8 X86EMU_UNUSED(op1))
5169 {
5170     s8 offset;
5171     u16 target;
5172     int sf, of;
5173
5174     /* jump to byte offset if sign flag equal to overflow flag.
5175        and the zero flag is clear */
5176     START_OF_INSTR();
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);
5181     TRACE_AND_STEP();
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();
5187     END_OF_INSTR();
5188 }
5189
5190 static u8 (*opc80_byte_operation[])(u8 d, u8 s) =
5191 {
5192     add_byte,           /* 00 */
5193     or_byte,            /* 01 */
5194     adc_byte,           /* 02 */
5195     sbb_byte,           /* 03 */
5196     and_byte,           /* 04 */
5197     sub_byte,           /* 05 */
5198     xor_byte,           /* 06 */
5199     cmp_byte,           /* 07 */
5200 };
5201
5202 /****************************************************************************
5203 REMARKS:
5204 Handles opcode 0x80
5205 ****************************************************************************/
5206 static void x86emuOp_opc80_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
5207 {
5208     int mod, rl, rh;
5209     u8 *destreg;
5210     uint destoffset;
5211     u8 imm;
5212     u8 destval;
5213
5214     /*
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
5218      */
5219     START_OF_INSTR();
5220     FETCH_DECODE_MODRM(mod, rh, rl);
5221 #ifdef DEBUG
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. */
5227
5228         switch (rh) {
5229         case 0:
5230             DECODE_PRINTF("ADD\t");
5231             break;
5232         case 1:
5233             DECODE_PRINTF("OR\t");
5234             break;
5235         case 2:
5236             DECODE_PRINTF("ADC\t");
5237             break;
5238         case 3:
5239             DECODE_PRINTF("SBB\t");
5240             break;
5241         case 4:
5242             DECODE_PRINTF("AND\t");
5243             break;
5244         case 5:
5245             DECODE_PRINTF("SUB\t");
5246             break;
5247         case 6:
5248             DECODE_PRINTF("XOR\t");
5249             break;
5250         case 7:
5251             DECODE_PRINTF("CMP\t");
5252             break;
5253         }
5254     }
5255 #endif
5256     /* know operation, decode the mod byte to find the addressing
5257        mode. */
5258     switch (mod) {
5259     case 0:
5260         DECODE_PRINTF("BYTE PTR ");
5261         destoffset = decode_rm00_address(rl);
5262         DECODE_PRINTF(",");
5263         destval = fetch_data_byte(destoffset);
5264         imm = fetch_byte_imm();
5265         DECODE_PRINTF2("%x\n", imm);
5266         TRACE_AND_STEP();
5267         destval = (*opc80_byte_operation[rh]) (destval, imm);
5268         if (rh != 7)
5269             store_data_byte(destoffset, destval);
5270         break;
5271     case 1:
5272         DECODE_PRINTF("BYTE PTR ");
5273         destoffset = decode_rm01_address(rl);
5274         DECODE_PRINTF(",");
5275         destval = fetch_data_byte(destoffset);
5276         imm = fetch_byte_imm();
5277         DECODE_PRINTF2("%x\n", imm);
5278         TRACE_AND_STEP();
5279         destval = (*opc80_byte_operation[rh]) (destval, imm);
5280         if (rh != 7)
5281             store_data_byte(destoffset, destval);
5282         break;
5283     case 2:
5284         DECODE_PRINTF("BYTE PTR ");
5285         destoffset = decode_rm10_address(rl);
5286         DECODE_PRINTF(",");
5287         destval = fetch_data_byte(destoffset);
5288         imm = fetch_byte_imm();
5289         DECODE_PRINTF2("%x\n", imm);
5290         TRACE_AND_STEP();
5291         destval = (*opc80_byte_operation[rh]) (destval, imm);
5292         if (rh != 7)
5293             store_data_byte(destoffset, destval);
5294         break;
5295     case 3:                     /* register to register */
5296         destreg = DECODE_RM_BYTE_REGISTER(rl);
5297         DECODE_PRINTF(",");
5298         imm = fetch_byte_imm();
5299         DECODE_PRINTF2("%x\n", imm);
5300         TRACE_AND_STEP();
5301         destval = (*opc80_byte_operation[rh]) (*destreg, imm);
5302         if (rh != 7)
5303             *destreg = destval;
5304         break;
5305     }
5306     DECODE_CLEAR_SEGOVR();
5307     END_OF_INSTR();
5308 }
5309
5310 static u16 (*opc81_word_operation[])(u16 d, u16 s) =
5311 {
5312     add_word,           /*00 */
5313     or_word,            /*01 */
5314     adc_word,           /*02 */
5315     sbb_word,           /*03 */
5316     and_word,           /*04 */
5317     sub_word,           /*05 */
5318     xor_word,           /*06 */
5319     cmp_word,           /*07 */
5320 };
5321
5322 static u32 (*opc81_long_operation[])(u32 d, u32 s) =
5323 {
5324     add_long,           /*00 */
5325     or_long,            /*01 */
5326     adc_long,           /*02 */
5327     sbb_long,           /*03 */
5328     and_long,           /*04 */
5329     sub_long,           /*05 */
5330     xor_long,           /*06 */
5331     cmp_long,           /*07 */
5332 };
5333
5334 /****************************************************************************
5335 REMARKS:
5336 Handles opcode 0x81
5337 ****************************************************************************/
5338 static void x86emuOp_opc81_word_RM_IMM(u8 X86EMU_UNUSED(op1))
5339 {
5340     int mod, rl, rh;
5341     uint destoffset;
5342
5343     /*
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
5347      */
5348     START_OF_INSTR();
5349     FETCH_DECODE_MODRM(mod, rh, rl);
5350 #ifdef DEBUG
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. */
5356
5357         switch (rh) {
5358         case 0:
5359             DECODE_PRINTF("ADD\t");
5360             break;
5361         case 1:
5362             DECODE_PRINTF("OR\t");
5363             break;
5364         case 2:
5365             DECODE_PRINTF("ADC\t");
5366             break;
5367         case 3:
5368             DECODE_PRINTF("SBB\t");
5369             break;
5370         case 4:
5371             DECODE_PRINTF("AND\t");
5372             break;
5373         case 5:
5374             DECODE_PRINTF("SUB\t");
5375             break;
5376         case 6:
5377             DECODE_PRINTF("XOR\t");
5378             break;
5379         case 7:
5380             DECODE_PRINTF("CMP\t");
5381             break;
5382         }
5383     }
5384 #endif
5385     /*
5386      * Know operation, decode the mod byte to find the addressing
5387      * mode.
5388      */
5389     switch (mod) {
5390     case 0:
5391         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
5392             u32 destval,imm;
5393
5394             DECODE_PRINTF("DWORD PTR ");
5395             destoffset = decode_rm00_address(rl);
5396             DECODE_PRINTF(",");
5397             destval = fetch_data_long(destoffset);
5398             imm = fetch_long_imm();
5399             DECODE_PRINTF2("%x\n", imm);
5400             TRACE_AND_STEP();
5401             destval = (*opc81_long_operation[rh]) (destval, imm);
5402             if (rh != 7)
5403                 store_data_long(destoffset, destval);
5404         } else {
5405             u16 destval,imm;
5406
5407             DECODE_PRINTF("WORD PTR ");
5408             destoffset = decode_rm00_address(rl);
5409             DECODE_PRINTF(",");
5410             destval = fetch_data_word(destoffset);
5411             imm = fetch_word_imm();
5412             DECODE_PRINTF2("%x\n", imm);
5413             TRACE_AND_STEP();
5414             destval = (*opc81_word_operation[rh]) (destval, imm);
5415             if (rh != 7)
5416                 store_data_word(destoffset, destval);
5417         }
5418         break;
5419     case 1:
5420         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
5421             u32 destval,imm;
5422
5423             DECODE_PRINTF("DWORD PTR ");
5424             destoffset = decode_rm01_address(rl);
5425             DECODE_PRINTF(",");
5426             destval = fetch_data_long(destoffset);
5427             imm = fetch_long_imm();
5428             DECODE_PRINTF2("%x\n", imm);
5429             TRACE_AND_STEP();
5430             destval = (*opc81_long_operation[rh]) (destval, imm);
5431             if (rh != 7)
5432                 store_data_long(destoffset, destval);
5433         } else {
5434             u16 destval,imm;
5435
5436             DECODE_PRINTF("WORD PTR ");
5437             destoffset = decode_rm01_address(rl);
5438             DECODE_PRINTF(",");
5439             destval = fetch_data_word(destoffset);
5440             imm = fetch_word_imm();
5441             DECODE_PRINTF2("%x\n", imm);
5442             TRACE_AND_STEP();
5443             destval = (*opc81_word_operation[rh]) (destval, imm);
5444             if (rh != 7)
5445                 store_data_word(destoffset, destval);
5446         }
5447         break;
5448     case 2:
5449         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
5450             u32 destval,imm;
5451
5452             DECODE_PRINTF("DWORD PTR ");
5453             destoffset = decode_rm10_address(rl);
5454             DECODE_PRINTF(",");
5455             destval = fetch_data_long(destoffset);
5456             imm = fetch_long_imm();
5457             DECODE_PRINTF2("%x\n", imm);
5458             TRACE_AND_STEP();
5459             destval = (*opc81_long_operation[rh]) (destval, imm);
5460             if (rh != 7)
5461                 store_data_long(destoffset, destval);
5462         } else {
5463             u16 destval,imm;
5464
5465             DECODE_PRINTF("WORD PTR ");
5466             destoffset = decode_rm10_address(rl);
5467             DECODE_PRINTF(",");
5468             destval = fetch_data_word(destoffset);
5469             imm = fetch_word_imm();
5470             DECODE_PRINTF2("%x\n", imm);
5471             TRACE_AND_STEP();
5472             destval = (*opc81_word_operation[rh]) (destval, imm);
5473             if (rh != 7)
5474                 store_data_word(destoffset, destval);
5475         }
5476         break;
5477     case 3:                     /* register to register */
5478         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
5479             u32 *destreg;
5480             u32 destval,imm;
5481
5482             destreg = DECODE_RM_LONG_REGISTER(rl);
5483             DECODE_PRINTF(",");
5484             imm = fetch_long_imm();
5485             DECODE_PRINTF2("%x\n", imm);
5486             TRACE_AND_STEP();
5487             destval = (*opc81_long_operation[rh]) (*destreg, imm);
5488             if (rh != 7)
5489                 *destreg = destval;
5490         } else {
5491             u16 *destreg;
5492             u16 destval,imm;
5493
5494             destreg = DECODE_RM_WORD_REGISTER(rl);
5495             DECODE_PRINTF(",");
5496             imm = fetch_word_imm();
5497             DECODE_PRINTF2("%x\n", imm);
5498             TRACE_AND_STEP();
5499             destval = (*opc81_word_operation[rh]) (*destreg, imm);
5500             if (rh != 7)
5501                 *destreg = destval;
5502         }
5503         break;
5504     }
5505     DECODE_CLEAR_SEGOVR();
5506     END_OF_INSTR();
5507 }
5508
5509 static u8 (*opc82_byte_operation[])(u8 s, u8 d) =
5510 {
5511     add_byte,           /*00 */
5512     or_byte,            /*01 *//*YYY UNUSED ???? */
5513     adc_byte,           /*02 */
5514     sbb_byte,           /*03 */
5515     and_byte,           /*04 *//*YYY UNUSED ???? */
5516     sub_byte,           /*05 */
5517     xor_byte,           /*06 *//*YYY UNUSED ???? */
5518     cmp_byte,           /*07 */
5519 };
5520
5521 /****************************************************************************
5522 REMARKS:
5523 Handles opcode 0x82
5524 ****************************************************************************/
5525 static void x86emuOp_opc82_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
5526 {
5527     int mod, rl, rh;
5528     u8 *destreg;
5529     uint destoffset;
5530     u8 imm;
5531     u8 destval;
5532
5533     /*
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.
5538      */
5539     START_OF_INSTR();
5540     FETCH_DECODE_MODRM(mod, rh, rl);
5541 #ifdef DEBUG
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. */
5547         switch (rh) {
5548         case 0:
5549             DECODE_PRINTF("ADD\t");
5550             break;
5551         case 1:
5552             DECODE_PRINTF("OR\t");
5553             break;
5554         case 2:
5555             DECODE_PRINTF("ADC\t");
5556             break;
5557         case 3:
5558             DECODE_PRINTF("SBB\t");
5559             break;
5560         case 4:
5561             DECODE_PRINTF("AND\t");
5562             break;
5563         case 5:
5564             DECODE_PRINTF("SUB\t");
5565             break;
5566         case 6:
5567             DECODE_PRINTF("XOR\t");
5568             break;
5569         case 7:
5570             DECODE_PRINTF("CMP\t");
5571             break;
5572         }
5573     }
5574 #endif
5575     /* know operation, decode the mod byte to find the addressing
5576        mode. */
5577     switch (mod) {
5578     case 0:
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);
5584         TRACE_AND_STEP();
5585         destval = (*opc82_byte_operation[rh]) (destval, imm);
5586         if (rh != 7)
5587             store_data_byte(destoffset, destval);
5588         break;
5589     case 1:
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);
5595         TRACE_AND_STEP();
5596         destval = (*opc82_byte_operation[rh]) (destval, imm);
5597         if (rh != 7)
5598             store_data_byte(destoffset, destval);
5599         break;
5600     case 2:
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);
5606         TRACE_AND_STEP();
5607         destval = (*opc82_byte_operation[rh]) (destval, imm);
5608         if (rh != 7)
5609             store_data_byte(destoffset, destval);
5610         break;
5611     case 3:                     /* register to register */
5612         destreg = DECODE_RM_BYTE_REGISTER(rl);
5613         imm = fetch_byte_imm();
5614         DECODE_PRINTF2(",%x\n", imm);
5615         TRACE_AND_STEP();
5616         destval = (*opc82_byte_operation[rh]) (*destreg, imm);
5617         if (rh != 7)
5618             *destreg = destval;
5619         break;
5620     }
5621     DECODE_CLEAR_SEGOVR();
5622     END_OF_INSTR();
5623 }
5624
5625 static u16 (*opc83_word_operation[])(u16 s, u16 d) =
5626 {
5627     add_word,           /*00 */
5628     or_word,            /*01 *//*YYY UNUSED ???? */
5629     adc_word,           /*02 */
5630     sbb_word,           /*03 */
5631     and_word,           /*04 *//*YYY UNUSED ???? */
5632     sub_word,           /*05 */
5633     xor_word,           /*06 *//*YYY UNUSED ???? */
5634     cmp_word,           /*07 */
5635 };
5636
5637 static u32 (*opc83_long_operation[])(u32 s, u32 d) =
5638 {
5639     add_long,           /*00 */
5640     or_long,            /*01 *//*YYY UNUSED ???? */
5641     adc_long,           /*02 */
5642     sbb_long,           /*03 */
5643     and_long,           /*04 *//*YYY UNUSED ???? */
5644     sub_long,           /*05 */
5645     xor_long,           /*06 *//*YYY UNUSED ???? */
5646     cmp_long,           /*07 */
5647 };
5648
5649 /****************************************************************************
5650 REMARKS:
5651 Handles opcode 0x83
5652 ****************************************************************************/
5653 static void x86emuOp_opc83_word_RM_IMM(u8 X86EMU_UNUSED(op1))
5654 {
5655     int mod, rl, rh;
5656     uint destoffset;
5657
5658     /*
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.
5663      */
5664     START_OF_INSTR();
5665     FETCH_DECODE_MODRM(mod, rh, rl);
5666 #ifdef DEBUG
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. */
5672        switch (rh) {
5673         case 0:
5674             DECODE_PRINTF("ADD\t");
5675             break;
5676         case 1:
5677             DECODE_PRINTF("OR\t");
5678             break;
5679         case 2:
5680             DECODE_PRINTF("ADC\t");
5681             break;
5682         case 3:
5683             DECODE_PRINTF("SBB\t");
5684             break;
5685         case 4:
5686             DECODE_PRINTF("AND\t");
5687             break;
5688         case 5:
5689             DECODE_PRINTF("SUB\t");
5690             break;
5691         case 6:
5692             DECODE_PRINTF("XOR\t");
5693             break;
5694         case 7:
5695             DECODE_PRINTF("CMP\t");
5696             break;
5697         }
5698     }
5699 #endif
5700     /* know operation, decode the mod byte to find the addressing
5701        mode. */
5702     switch (mod) {
5703     case 0:
5704         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
5705             u32 destval,imm;
5706
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);
5712             TRACE_AND_STEP();
5713             destval = (*opc83_long_operation[rh]) (destval, imm);
5714             if (rh != 7)
5715                 store_data_long(destoffset, destval);
5716         } else {
5717             u16 destval,imm;
5718
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);
5724             TRACE_AND_STEP();
5725             destval = (*opc83_word_operation[rh]) (destval, imm);
5726             if (rh != 7)
5727                 store_data_word(destoffset, destval);
5728         }
5729         break;
5730     case 1:
5731         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
5732             u32 destval,imm;
5733
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);
5739             TRACE_AND_STEP();
5740             destval = (*opc83_long_operation[rh]) (destval, imm);
5741             if (rh != 7)
5742                 store_data_long(destoffset, destval);
5743         } else {
5744             u16 destval,imm;
5745
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);
5751             TRACE_AND_STEP();
5752             destval = (*opc83_word_operation[rh]) (destval, imm);
5753             if (rh != 7)
5754                 store_data_word(destoffset, destval);
5755         }
5756         break;
5757     case 2:
5758         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
5759             u32 destval,imm;
5760
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);
5766             TRACE_AND_STEP();
5767             destval = (*opc83_long_operation[rh]) (destval, imm);
5768             if (rh != 7)
5769                 store_data_long(destoffset, destval);
5770         } else {
5771             u16 destval,imm;
5772
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);
5778             TRACE_AND_STEP();
5779             destval = (*opc83_word_operation[rh]) (destval, imm);
5780             if (rh != 7)
5781                 store_data_word(destoffset, destval);
5782         }
5783         break;
5784     case 3:                     /* register to register */
5785         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
5786             u32 *destreg;
5787             u32 destval,imm;
5788
5789             destreg = DECODE_RM_LONG_REGISTER(rl);
5790             imm = (s8) fetch_byte_imm();
5791             DECODE_PRINTF2(",%x\n", imm);
5792             TRACE_AND_STEP();
5793             destval = (*opc83_long_operation[rh]) (*destreg, imm);
5794             if (rh != 7)
5795                 *destreg = destval;
5796         } else {
5797             u16 *destreg;
5798             u16 destval,imm;
5799
5800             destreg = DECODE_RM_WORD_REGISTER(rl);
5801             imm = (s8) fetch_byte_imm();
5802             DECODE_PRINTF2(",%x\n", imm);
5803             TRACE_AND_STEP();
5804             destval = (*opc83_word_operation[rh]) (*destreg, imm);
5805             if (rh != 7)
5806                 *destreg = destval;
5807         }
5808         break;
5809     }
5810     DECODE_CLEAR_SEGOVR();
5811     END_OF_INSTR();
5812 }
5813
5814 /****************************************************************************
5815 REMARKS:
5816 Handles opcode 0x84
5817 ****************************************************************************/
5818 static void x86emuOp_test_byte_RM_R(u8 X86EMU_UNUSED(op1))
5819 {
5820     int mod, rl, rh;
5821     u8 *destreg, *srcreg;
5822     uint destoffset;
5823     u8 destval;
5824
5825     START_OF_INSTR();
5826     DECODE_PRINTF("TEST\t");
5827     FETCH_DECODE_MODRM(mod, rh, rl);
5828     switch (mod) {
5829     case 0:
5830         destoffset = decode_rm00_address(rl);
5831         DECODE_PRINTF(",");
5832         destval = fetch_data_byte(destoffset);
5833         srcreg = DECODE_RM_BYTE_REGISTER(rh);
5834         DECODE_PRINTF("\n");
5835         TRACE_AND_STEP();
5836         test_byte(destval, *srcreg);
5837         break;
5838     case 1:
5839         destoffset = decode_rm01_address(rl);
5840         DECODE_PRINTF(",");
5841         destval = fetch_data_byte(destoffset);
5842         srcreg = DECODE_RM_BYTE_REGISTER(rh);
5843         DECODE_PRINTF("\n");
5844         TRACE_AND_STEP();
5845         test_byte(destval, *srcreg);
5846         break;
5847     case 2:
5848         destoffset = decode_rm10_address(rl);
5849         DECODE_PRINTF(",");
5850         destval = fetch_data_byte(destoffset);
5851         srcreg = DECODE_RM_BYTE_REGISTER(rh);
5852         DECODE_PRINTF("\n");
5853         TRACE_AND_STEP();
5854         test_byte(destval, *srcreg);
5855         break;
5856     case 3:                     /* register to register */
5857         destreg = DECODE_RM_BYTE_REGISTER(rl);
5858         DECODE_PRINTF(",");
5859         srcreg = DECODE_RM_BYTE_REGISTER(rh);
5860         DECODE_PRINTF("\n");
5861         TRACE_AND_STEP();
5862         test_byte(*destreg, *srcreg);
5863         break;
5864     }
5865     DECODE_CLEAR_SEGOVR();
5866     END_OF_INSTR();
5867 }
5868
5869 /****************************************************************************
5870 REMARKS:
5871 Handles opcode 0x85
5872 ****************************************************************************/
5873 static void x86emuOp_test_word_RM_R(u8 X86EMU_UNUSED(op1))
5874 {
5875     int mod, rl, rh;
5876     uint destoffset;
5877
5878     START_OF_INSTR();
5879     DECODE_PRINTF("TEST\t");
5880     FETCH_DECODE_MODRM(mod, rh, rl);
5881     switch (mod) {
5882     case 0:
5883         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
5884             u32 destval;
5885             u32 *srcreg;
5886
5887             destoffset = decode_rm00_address(rl);
5888             DECODE_PRINTF(",");
5889             destval = fetch_data_long(destoffset);
5890             srcreg = DECODE_RM_LONG_REGISTER(rh);
5891             DECODE_PRINTF("\n");
5892             TRACE_AND_STEP();
5893             test_long(destval, *srcreg);
5894         } else {
5895             u16 destval;
5896             u16 *srcreg;
5897
5898             destoffset = decode_rm00_address(rl);
5899             DECODE_PRINTF(",");
5900             destval = fetch_data_word(destoffset);
5901             srcreg = DECODE_RM_WORD_REGISTER(rh);
5902             DECODE_PRINTF("\n");
5903             TRACE_AND_STEP();
5904             test_word(destval, *srcreg);
5905         }
5906         break;
5907     case 1:
5908         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
5909             u32 destval;
5910             u32 *srcreg;
5911
5912             destoffset = decode_rm01_address(rl);
5913             DECODE_PRINTF(",");
5914             destval = fetch_data_long(destoffset);
5915             srcreg = DECODE_RM_LONG_REGISTER(rh);
5916             DECODE_PRINTF("\n");
5917             TRACE_AND_STEP();
5918             test_long(destval, *srcreg);
5919         } else {
5920             u16 destval;
5921             u16 *srcreg;
5922
5923             destoffset = decode_rm01_address(rl);
5924             DECODE_PRINTF(",");
5925             destval = fetch_data_word(destoffset);
5926             srcreg = DECODE_RM_WORD_REGISTER(rh);
5927             DECODE_PRINTF("\n");
5928             TRACE_AND_STEP();
5929             test_word(destval, *srcreg);
5930         }
5931         break;
5932     case 2:
5933         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
5934             u32 destval;
5935             u32 *srcreg;
5936
5937             destoffset = decode_rm10_address(rl);
5938             DECODE_PRINTF(",");
5939             destval = fetch_data_long(destoffset);
5940             srcreg = DECODE_RM_LONG_REGISTER(rh);
5941             DECODE_PRINTF("\n");
5942             TRACE_AND_STEP();
5943             test_long(destval, *srcreg);
5944         } else {
5945             u16 destval;
5946             u16 *srcreg;
5947
5948             destoffset = decode_rm10_address(rl);
5949             DECODE_PRINTF(",");
5950             destval = fetch_data_word(destoffset);
5951             srcreg = DECODE_RM_WORD_REGISTER(rh);
5952             DECODE_PRINTF("\n");
5953             TRACE_AND_STEP();
5954             test_word(destval, *srcreg);
5955         }
5956         break;
5957     case 3:                     /* register to register */
5958         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
5959             u32 *destreg,*srcreg;
5960
5961             destreg = DECODE_RM_LONG_REGISTER(rl);
5962             DECODE_PRINTF(",");
5963             srcreg = DECODE_RM_LONG_REGISTER(rh);
5964             DECODE_PRINTF("\n");
5965             TRACE_AND_STEP();
5966             test_long(*destreg, *srcreg);
5967         } else {
5968             u16 *destreg,*srcreg;
5969
5970             destreg = DECODE_RM_WORD_REGISTER(rl);
5971             DECODE_PRINTF(",");
5972             srcreg = DECODE_RM_WORD_REGISTER(rh);
5973             DECODE_PRINTF("\n");
5974             TRACE_AND_STEP();
5975             test_word(*destreg, *srcreg);
5976         }
5977         break;
5978     }
5979     DECODE_CLEAR_SEGOVR();
5980     END_OF_INSTR();
5981 }
5982
5983 /****************************************************************************
5984 REMARKS:
5985 Handles opcode 0x86
5986 ****************************************************************************/
5987 static void x86emuOp_xchg_byte_RM_R(u8 X86EMU_UNUSED(op1))
5988 {
5989     int mod, rl, rh;
5990     u8 *destreg, *srcreg;
5991     uint destoffset;
5992     u8 destval;
5993     u8 tmp;
5994
5995     START_OF_INSTR();
5996     DECODE_PRINTF("XCHG\t");
5997     FETCH_DECODE_MODRM(mod, rh, rl);
5998     switch (mod) {
5999     case 0:
6000         destoffset = decode_rm00_address(rl);
6001         DECODE_PRINTF(",");
6002         destval = fetch_data_byte(destoffset);
6003         srcreg = DECODE_RM_BYTE_REGISTER(rh);
6004         DECODE_PRINTF("\n");
6005         TRACE_AND_STEP();
6006         tmp = *srcreg;
6007         *srcreg = destval;
6008         destval = tmp;
6009         store_data_byte(destoffset, destval);
6010         break;
6011     case 1:
6012         destoffset = decode_rm01_address(rl);
6013         DECODE_PRINTF(",");
6014         destval = fetch_data_byte(destoffset);
6015         srcreg = DECODE_RM_BYTE_REGISTER(rh);
6016         DECODE_PRINTF("\n");
6017         TRACE_AND_STEP();
6018         tmp = *srcreg;
6019         *srcreg = destval;
6020         destval = tmp;
6021         store_data_byte(destoffset, destval);
6022         break;
6023     case 2:
6024         destoffset = decode_rm10_address(rl);
6025         DECODE_PRINTF(",");
6026         destval = fetch_data_byte(destoffset);
6027         srcreg = DECODE_RM_BYTE_REGISTER(rh);
6028         DECODE_PRINTF("\n");
6029         TRACE_AND_STEP();
6030         tmp = *srcreg;
6031         *srcreg = destval;
6032         destval = tmp;
6033         store_data_byte(destoffset, destval);
6034         break;
6035     case 3:                     /* register to register */
6036         destreg = DECODE_RM_BYTE_REGISTER(rl);
6037         DECODE_PRINTF(",");
6038         srcreg = DECODE_RM_BYTE_REGISTER(rh);
6039         DECODE_PRINTF("\n");
6040         TRACE_AND_STEP();
6041         tmp = *srcreg;
6042         *srcreg = *destreg;
6043         *destreg = tmp;
6044         break;
6045     }
6046     DECODE_CLEAR_SEGOVR();
6047     END_OF_INSTR();
6048 }
6049
6050 /****************************************************************************
6051 REMARKS:
6052 Handles opcode 0x87
6053 ****************************************************************************/
6054 static void x86emuOp_xchg_word_RM_R(u8 X86EMU_UNUSED(op1))
6055 {
6056     int mod, rl, rh;
6057     uint destoffset;
6058
6059     START_OF_INSTR();
6060     DECODE_PRINTF("XCHG\t");
6061     FETCH_DECODE_MODRM(mod, rh, rl);
6062     switch (mod) {
6063     case 0:
6064         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6065             u32 *srcreg;
6066             u32 destval,tmp;
6067
6068             destoffset = decode_rm00_address(rl);
6069             DECODE_PRINTF(",");
6070             destval = fetch_data_long(destoffset);
6071             srcreg = DECODE_RM_LONG_REGISTER(rh);
6072             DECODE_PRINTF("\n");
6073             TRACE_AND_STEP();
6074             tmp = *srcreg;
6075             *srcreg = destval;
6076             destval = tmp;
6077             store_data_long(destoffset, destval);
6078         } else {
6079             u16 *srcreg;
6080             u16 destval,tmp;
6081
6082             destoffset = decode_rm00_address(rl);
6083             DECODE_PRINTF(",");
6084             destval = fetch_data_word(destoffset);
6085             srcreg = DECODE_RM_WORD_REGISTER(rh);
6086             DECODE_PRINTF("\n");
6087             TRACE_AND_STEP();
6088             tmp = *srcreg;
6089             *srcreg = destval;
6090             destval = tmp;
6091             store_data_word(destoffset, destval);
6092         }
6093         break;
6094     case 1:
6095         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6096             u32 *srcreg;
6097             u32 destval,tmp;
6098
6099             destoffset = decode_rm01_address(rl);
6100             DECODE_PRINTF(",");
6101             destval = fetch_data_long(destoffset);
6102             srcreg = DECODE_RM_LONG_REGISTER(rh);
6103             DECODE_PRINTF("\n");
6104             TRACE_AND_STEP();
6105             tmp = *srcreg;
6106             *srcreg = destval;
6107             destval = tmp;
6108             store_data_long(destoffset, destval);
6109         } else {
6110             u16 *srcreg;
6111             u16 destval,tmp;
6112
6113             destoffset = decode_rm01_address(rl);
6114             DECODE_PRINTF(",");
6115             destval = fetch_data_word(destoffset);
6116             srcreg = DECODE_RM_WORD_REGISTER(rh);
6117             DECODE_PRINTF("\n");
6118             TRACE_AND_STEP();
6119             tmp = *srcreg;
6120             *srcreg = destval;
6121             destval = tmp;
6122             store_data_word(destoffset, destval);
6123         }
6124         break;
6125     case 2:
6126         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6127             u32 *srcreg;
6128             u32 destval,tmp;
6129
6130             destoffset = decode_rm10_address(rl);
6131             DECODE_PRINTF(",");
6132             destval = fetch_data_long(destoffset);
6133             srcreg = DECODE_RM_LONG_REGISTER(rh);
6134             DECODE_PRINTF("\n");
6135             TRACE_AND_STEP();
6136             tmp = *srcreg;
6137             *srcreg = destval;
6138             destval = tmp;
6139             store_data_long(destoffset, destval);
6140         } else {
6141             u16 *srcreg;
6142             u16 destval,tmp;
6143
6144             destoffset = decode_rm10_address(rl);
6145             DECODE_PRINTF(",");
6146             destval = fetch_data_word(destoffset);
6147             srcreg = DECODE_RM_WORD_REGISTER(rh);
6148             DECODE_PRINTF("\n");
6149             TRACE_AND_STEP();
6150             tmp = *srcreg;
6151             *srcreg = destval;
6152             destval = tmp;
6153             store_data_word(destoffset, destval);
6154         }
6155         break;
6156     case 3:                     /* register to register */
6157         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6158             u32 *destreg,*srcreg;
6159             u32 tmp;
6160
6161             destreg = DECODE_RM_LONG_REGISTER(rl);
6162             DECODE_PRINTF(",");
6163             srcreg = DECODE_RM_LONG_REGISTER(rh);
6164             DECODE_PRINTF("\n");
6165             TRACE_AND_STEP();
6166             tmp = *srcreg;
6167             *srcreg = *destreg;
6168             *destreg = tmp;
6169         } else {
6170             u16 *destreg,*srcreg;
6171             u16 tmp;
6172
6173             destreg = DECODE_RM_WORD_REGISTER(rl);
6174             DECODE_PRINTF(",");
6175             srcreg = DECODE_RM_WORD_REGISTER(rh);
6176             DECODE_PRINTF("\n");
6177             TRACE_AND_STEP();
6178             tmp = *srcreg;
6179             *srcreg = *destreg;
6180             *destreg = tmp;
6181         }
6182         break;
6183     }
6184     DECODE_CLEAR_SEGOVR();
6185     END_OF_INSTR();
6186 }
6187
6188 /****************************************************************************
6189 REMARKS:
6190 Handles opcode 0x88
6191 ****************************************************************************/
6192 static void x86emuOp_mov_byte_RM_R(u8 X86EMU_UNUSED(op1))
6193 {
6194     int mod, rl, rh;
6195     u8 *destreg, *srcreg;
6196     uint destoffset;
6197
6198     START_OF_INSTR();
6199     DECODE_PRINTF("MOV\t");
6200     FETCH_DECODE_MODRM(mod, rh, rl);
6201     switch (mod) {
6202     case 0:
6203         destoffset = decode_rm00_address(rl);
6204         DECODE_PRINTF(",");
6205         srcreg = DECODE_RM_BYTE_REGISTER(rh);
6206         DECODE_PRINTF("\n");
6207         TRACE_AND_STEP();
6208         store_data_byte(destoffset, *srcreg);
6209         break;
6210     case 1:
6211         destoffset = decode_rm01_address(rl);
6212         DECODE_PRINTF(",");
6213         srcreg = DECODE_RM_BYTE_REGISTER(rh);
6214         DECODE_PRINTF("\n");
6215         TRACE_AND_STEP();
6216         store_data_byte(destoffset, *srcreg);
6217         break;
6218     case 2:
6219         destoffset = decode_rm10_address(rl);
6220         DECODE_PRINTF(",");
6221         srcreg = DECODE_RM_BYTE_REGISTER(rh);
6222         DECODE_PRINTF("\n");
6223         TRACE_AND_STEP();
6224         store_data_byte(destoffset, *srcreg);
6225         break;
6226     case 3:                     /* register to register */
6227         destreg = DECODE_RM_BYTE_REGISTER(rl);
6228         DECODE_PRINTF(",");
6229         srcreg = DECODE_RM_BYTE_REGISTER(rh);
6230         DECODE_PRINTF("\n");
6231         TRACE_AND_STEP();
6232         *destreg = *srcreg;
6233         break;
6234     }
6235     DECODE_CLEAR_SEGOVR();
6236     END_OF_INSTR();
6237 }
6238
6239 /****************************************************************************
6240 REMARKS:
6241 Handles opcode 0x89
6242 ****************************************************************************/
6243 static void x86emuOp_mov_word_RM_R(u8 X86EMU_UNUSED(op1))
6244 {
6245     int mod, rl, rh;
6246     u32 destoffset;
6247
6248     START_OF_INSTR();
6249     DECODE_PRINTF("MOV\t");
6250     FETCH_DECODE_MODRM(mod, rh, rl);
6251     switch (mod) {
6252     case 0:
6253         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6254             u32 *srcreg;
6255
6256             destoffset = decode_rm00_address(rl);
6257             DECODE_PRINTF(",");
6258             srcreg = DECODE_RM_LONG_REGISTER(rh);
6259             DECODE_PRINTF("\n");
6260             TRACE_AND_STEP();
6261             store_data_long(destoffset, *srcreg);
6262         } else {
6263             u16 *srcreg;
6264
6265             destoffset = decode_rm00_address(rl);
6266             DECODE_PRINTF(",");
6267             srcreg = DECODE_RM_WORD_REGISTER(rh);
6268             DECODE_PRINTF("\n");
6269             TRACE_AND_STEP();
6270             store_data_word(destoffset, *srcreg);
6271         }
6272         break;
6273     case 1:
6274         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6275             u32 *srcreg;
6276
6277             destoffset = decode_rm01_address(rl);
6278             DECODE_PRINTF(",");
6279             srcreg = DECODE_RM_LONG_REGISTER(rh);
6280             DECODE_PRINTF("\n");
6281             TRACE_AND_STEP();
6282             store_data_long(destoffset, *srcreg);
6283         } else {
6284             u16 *srcreg;
6285
6286             destoffset = decode_rm01_address(rl);
6287             DECODE_PRINTF(",");
6288             srcreg = DECODE_RM_WORD_REGISTER(rh);
6289             DECODE_PRINTF("\n");
6290             TRACE_AND_STEP();
6291             store_data_word(destoffset, *srcreg);
6292         }
6293         break;
6294     case 2:
6295         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6296             u32 *srcreg;
6297
6298             destoffset = decode_rm10_address(rl);
6299             DECODE_PRINTF(",");
6300             srcreg = DECODE_RM_LONG_REGISTER(rh);
6301             DECODE_PRINTF("\n");
6302             TRACE_AND_STEP();
6303             store_data_long(destoffset, *srcreg);
6304         } else {
6305             u16 *srcreg;
6306
6307             destoffset = decode_rm10_address(rl);
6308             DECODE_PRINTF(",");
6309             srcreg = DECODE_RM_WORD_REGISTER(rh);
6310             DECODE_PRINTF("\n");
6311             TRACE_AND_STEP();
6312             store_data_word(destoffset, *srcreg);
6313         }
6314         break;
6315     case 3:                     /* register to register */
6316         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6317             u32 *destreg,*srcreg;
6318
6319             destreg = DECODE_RM_LONG_REGISTER(rl);
6320             DECODE_PRINTF(",");
6321             srcreg = DECODE_RM_LONG_REGISTER(rh);
6322             DECODE_PRINTF("\n");
6323             TRACE_AND_STEP();
6324             *destreg = *srcreg;
6325         } else {
6326             u16 *destreg,*srcreg;
6327
6328             destreg = DECODE_RM_WORD_REGISTER(rl);
6329             DECODE_PRINTF(",");
6330             srcreg = DECODE_RM_WORD_REGISTER(rh);
6331             DECODE_PRINTF("\n");
6332             TRACE_AND_STEP();
6333             *destreg = *srcreg;
6334         }
6335         break;
6336     }
6337     DECODE_CLEAR_SEGOVR();
6338     END_OF_INSTR();
6339 }
6340
6341 /****************************************************************************
6342 REMARKS:
6343 Handles opcode 0x8a
6344 ****************************************************************************/
6345 static void x86emuOp_mov_byte_R_RM(u8 X86EMU_UNUSED(op1))
6346 {
6347     int mod, rl, rh;
6348     u8 *destreg, *srcreg;
6349     uint srcoffset;
6350     u8 srcval;
6351
6352     START_OF_INSTR();
6353     DECODE_PRINTF("MOV\t");
6354     FETCH_DECODE_MODRM(mod, rh, rl);
6355     switch (mod) {
6356     case 0:
6357         destreg = DECODE_RM_BYTE_REGISTER(rh);
6358         DECODE_PRINTF(",");
6359         srcoffset = decode_rm00_address(rl);
6360         srcval = fetch_data_byte(srcoffset);
6361         DECODE_PRINTF("\n");
6362         TRACE_AND_STEP();
6363         *destreg = srcval;
6364         break;
6365     case 1:
6366         destreg = DECODE_RM_BYTE_REGISTER(rh);
6367         DECODE_PRINTF(",");
6368         srcoffset = decode_rm01_address(rl);
6369         srcval = fetch_data_byte(srcoffset);
6370         DECODE_PRINTF("\n");
6371         TRACE_AND_STEP();
6372         *destreg = srcval;
6373         break;
6374     case 2:
6375         destreg = DECODE_RM_BYTE_REGISTER(rh);
6376         DECODE_PRINTF(",");
6377         srcoffset = decode_rm10_address(rl);
6378         srcval = fetch_data_byte(srcoffset);
6379         DECODE_PRINTF("\n");
6380         TRACE_AND_STEP();
6381         *destreg = srcval;
6382         break;
6383     case 3:                     /* register to register */
6384         destreg = DECODE_RM_BYTE_REGISTER(rh);
6385         DECODE_PRINTF(",");
6386         srcreg = DECODE_RM_BYTE_REGISTER(rl);
6387         DECODE_PRINTF("\n");
6388         TRACE_AND_STEP();
6389         *destreg = *srcreg;
6390         break;
6391     }
6392     DECODE_CLEAR_SEGOVR();
6393     END_OF_INSTR();
6394 }
6395
6396 /****************************************************************************
6397 REMARKS:
6398 Handles opcode 0x8b
6399 ****************************************************************************/
6400 static void x86emuOp_mov_word_R_RM(u8 X86EMU_UNUSED(op1))
6401 {
6402     int mod, rl, rh;
6403     uint srcoffset;
6404
6405     START_OF_INSTR();
6406     DECODE_PRINTF("MOV\t");
6407     FETCH_DECODE_MODRM(mod, rh, rl);
6408     switch (mod) {
6409     case 0:
6410         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6411             u32 *destreg;
6412             u32 srcval;
6413
6414             destreg = DECODE_RM_LONG_REGISTER(rh);
6415             DECODE_PRINTF(",");
6416             srcoffset = decode_rm00_address(rl);
6417             srcval = fetch_data_long(srcoffset);
6418             DECODE_PRINTF("\n");
6419             TRACE_AND_STEP();
6420             *destreg = srcval;
6421         } else {
6422             u16 *destreg;
6423             u16 srcval;
6424
6425             destreg = DECODE_RM_WORD_REGISTER(rh);
6426             DECODE_PRINTF(",");
6427             srcoffset = decode_rm00_address(rl);
6428             srcval = fetch_data_word(srcoffset);
6429             DECODE_PRINTF("\n");
6430             TRACE_AND_STEP();
6431             *destreg = srcval;
6432         }
6433         break;
6434     case 1:
6435         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6436             u32 *destreg;
6437             u32 srcval;
6438
6439             destreg = DECODE_RM_LONG_REGISTER(rh);
6440             DECODE_PRINTF(",");
6441             srcoffset = decode_rm01_address(rl);
6442             srcval = fetch_data_long(srcoffset);
6443             DECODE_PRINTF("\n");
6444             TRACE_AND_STEP();
6445             *destreg = srcval;
6446         } else {
6447             u16 *destreg;
6448             u16 srcval;
6449
6450             destreg = DECODE_RM_WORD_REGISTER(rh);
6451             DECODE_PRINTF(",");
6452             srcoffset = decode_rm01_address(rl);
6453             srcval = fetch_data_word(srcoffset);
6454             DECODE_PRINTF("\n");
6455             TRACE_AND_STEP();
6456             *destreg = srcval;
6457         }
6458         break;
6459     case 2:
6460         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6461             u32 *destreg;
6462             u32 srcval;
6463
6464             destreg = DECODE_RM_LONG_REGISTER(rh);
6465             DECODE_PRINTF(",");
6466             srcoffset = decode_rm10_address(rl);
6467             srcval = fetch_data_long(srcoffset);
6468             DECODE_PRINTF("\n");
6469             TRACE_AND_STEP();
6470             *destreg = srcval;
6471         } else {
6472             u16 *destreg;
6473             u16 srcval;
6474
6475             destreg = DECODE_RM_WORD_REGISTER(rh);
6476             DECODE_PRINTF(",");
6477             srcoffset = decode_rm10_address(rl);
6478             srcval = fetch_data_word(srcoffset);
6479             DECODE_PRINTF("\n");
6480             TRACE_AND_STEP();
6481             *destreg = srcval;
6482         }
6483         break;
6484     case 3:                     /* register to register */
6485         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6486             u32 *destreg, *srcreg;
6487
6488             destreg = DECODE_RM_LONG_REGISTER(rh);
6489             DECODE_PRINTF(",");
6490             srcreg = DECODE_RM_LONG_REGISTER(rl);
6491             DECODE_PRINTF("\n");
6492             TRACE_AND_STEP();
6493             *destreg = *srcreg;
6494         } else {
6495             u16 *destreg, *srcreg;
6496
6497             destreg = DECODE_RM_WORD_REGISTER(rh);
6498             DECODE_PRINTF(",");
6499             srcreg = DECODE_RM_WORD_REGISTER(rl);
6500             DECODE_PRINTF("\n");
6501             TRACE_AND_STEP();
6502             *destreg = *srcreg;
6503         }
6504         break;
6505     }
6506     DECODE_CLEAR_SEGOVR();
6507     END_OF_INSTR();
6508 }
6509
6510 /****************************************************************************
6511 REMARKS:
6512 Handles opcode 0x8c
6513 ****************************************************************************/
6514 static void x86emuOp_mov_word_RM_SR(u8 X86EMU_UNUSED(op1))
6515 {
6516     int mod, rl, rh;
6517     u16 *destreg, *srcreg;
6518     uint destoffset;
6519     u16 destval;
6520
6521     START_OF_INSTR();
6522     DECODE_PRINTF("MOV\t");
6523     FETCH_DECODE_MODRM(mod, rh, rl);
6524     switch (mod) {
6525     case 0:
6526         destoffset = decode_rm00_address(rl);
6527         DECODE_PRINTF(",");
6528         srcreg = decode_rm_seg_register(rh);
6529         DECODE_PRINTF("\n");
6530         TRACE_AND_STEP();
6531         destval = *srcreg;
6532         store_data_word(destoffset, destval);
6533         break;
6534     case 1:
6535         destoffset = decode_rm01_address(rl);
6536         DECODE_PRINTF(",");
6537         srcreg = decode_rm_seg_register(rh);
6538         DECODE_PRINTF("\n");
6539         TRACE_AND_STEP();
6540         destval = *srcreg;
6541         store_data_word(destoffset, destval);
6542         break;
6543     case 2:
6544         destoffset = decode_rm10_address(rl);
6545         DECODE_PRINTF(",");
6546         srcreg = decode_rm_seg_register(rh);
6547         DECODE_PRINTF("\n");
6548         TRACE_AND_STEP();
6549         destval = *srcreg;
6550         store_data_word(destoffset, destval);
6551         break;
6552     case 3:                     /* register to register */
6553         destreg = DECODE_RM_WORD_REGISTER(rl);
6554         DECODE_PRINTF(",");
6555         srcreg = decode_rm_seg_register(rh);
6556         DECODE_PRINTF("\n");
6557         TRACE_AND_STEP();
6558         *destreg = *srcreg;
6559         break;
6560     }
6561     DECODE_CLEAR_SEGOVR();
6562     END_OF_INSTR();
6563 }
6564
6565 /****************************************************************************
6566 REMARKS:
6567 Handles opcode 0x8d
6568 ****************************************************************************/
6569 static void x86emuOp_lea_word_R_M(u8 X86EMU_UNUSED(op1))
6570 {
6571     int mod, rl, rh;
6572     u16 *srcreg;
6573     uint destoffset;
6574
6575 /*
6576  * TODO: Need to handle address size prefix!
6577  *
6578  * lea  eax,[eax+ebx*2] ??
6579  */
6580
6581     START_OF_INSTR();
6582     DECODE_PRINTF("LEA\t");
6583     FETCH_DECODE_MODRM(mod, rh, rl);
6584     switch (mod) {
6585     case 0:
6586         srcreg = DECODE_RM_WORD_REGISTER(rh);
6587         DECODE_PRINTF(",");
6588         destoffset = decode_rm00_address(rl);
6589         DECODE_PRINTF("\n");
6590         TRACE_AND_STEP();
6591         *srcreg = (u16)destoffset;
6592         break;
6593     case 1:
6594         srcreg = DECODE_RM_WORD_REGISTER(rh);
6595         DECODE_PRINTF(",");
6596         destoffset = decode_rm01_address(rl);
6597         DECODE_PRINTF("\n");
6598         TRACE_AND_STEP();
6599         *srcreg = (u16)destoffset;
6600         break;
6601     case 2:
6602         srcreg = DECODE_RM_WORD_REGISTER(rh);
6603         DECODE_PRINTF(",");
6604         destoffset = decode_rm10_address(rl);
6605         DECODE_PRINTF("\n");
6606         TRACE_AND_STEP();
6607         *srcreg = (u16)destoffset;
6608         break;
6609     case 3:                     /* register to register */
6610         /* undefined.  Do nothing. */
6611         break;
6612     }
6613     DECODE_CLEAR_SEGOVR();
6614     END_OF_INSTR();
6615 }
6616
6617 /****************************************************************************
6618 REMARKS:
6619 Handles opcode 0x8e
6620 ****************************************************************************/
6621 static void x86emuOp_mov_word_SR_RM(u8 X86EMU_UNUSED(op1))
6622 {
6623     int mod, rl, rh;
6624     u16 *destreg, *srcreg;
6625     uint srcoffset;
6626     u16 srcval;
6627
6628     START_OF_INSTR();
6629     DECODE_PRINTF("MOV\t");
6630     FETCH_DECODE_MODRM(mod, rh, rl);
6631     switch (mod) {
6632     case 0:
6633         destreg = decode_rm_seg_register(rh);
6634         DECODE_PRINTF(",");
6635         srcoffset = decode_rm00_address(rl);
6636         srcval = fetch_data_word(srcoffset);
6637         DECODE_PRINTF("\n");
6638         TRACE_AND_STEP();
6639         *destreg = srcval;
6640         break;
6641     case 1:
6642         destreg = decode_rm_seg_register(rh);
6643         DECODE_PRINTF(",");
6644         srcoffset = decode_rm01_address(rl);
6645         srcval = fetch_data_word(srcoffset);
6646         DECODE_PRINTF("\n");
6647         TRACE_AND_STEP();
6648         *destreg = srcval;
6649         break;
6650     case 2:
6651         destreg = decode_rm_seg_register(rh);
6652         DECODE_PRINTF(",");
6653         srcoffset = decode_rm10_address(rl);
6654         srcval = fetch_data_word(srcoffset);
6655         DECODE_PRINTF("\n");
6656         TRACE_AND_STEP();
6657         *destreg = srcval;
6658         break;
6659     case 3:                     /* register to register */
6660         destreg = decode_rm_seg_register(rh);
6661         DECODE_PRINTF(",");
6662         srcreg = DECODE_RM_WORD_REGISTER(rl);
6663         DECODE_PRINTF("\n");
6664         TRACE_AND_STEP();
6665         *destreg = *srcreg;
6666         break;
6667     }
6668     /*
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.
6673      */
6674     DECODE_CLEAR_SEGOVR();
6675     END_OF_INSTR();
6676 }
6677
6678 /****************************************************************************
6679 REMARKS:
6680 Handles opcode 0x8f
6681 ****************************************************************************/
6682 static void x86emuOp_pop_RM(u8 X86EMU_UNUSED(op1))
6683 {
6684     int mod, rl, rh;
6685     uint destoffset;
6686
6687     START_OF_INSTR();
6688     DECODE_PRINTF("POP\t");
6689     FETCH_DECODE_MODRM(mod, rh, rl);
6690     if (rh != 0) {
6691         DECODE_PRINTF("ILLEGAL DECODE OF OPCODE 8F\n");
6692         HALT_SYS();
6693     }
6694     switch (mod) {
6695     case 0:
6696         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6697             u32 destval;
6698
6699             destoffset = decode_rm00_address(rl);
6700             DECODE_PRINTF("\n");
6701             TRACE_AND_STEP();
6702             destval = pop_long();
6703             store_data_long(destoffset, destval);
6704         } else {
6705             u16 destval;
6706
6707             destoffset = decode_rm00_address(rl);
6708             DECODE_PRINTF("\n");
6709             TRACE_AND_STEP();
6710             destval = pop_word();
6711             store_data_word(destoffset, destval);
6712         }
6713         break;
6714     case 1:
6715         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6716             u32 destval;
6717
6718             destoffset = decode_rm01_address(rl);
6719             DECODE_PRINTF("\n");
6720             TRACE_AND_STEP();
6721             destval = pop_long();
6722             store_data_long(destoffset, destval);
6723         } else {
6724             u16 destval;
6725
6726             destoffset = decode_rm01_address(rl);
6727             DECODE_PRINTF("\n");
6728             TRACE_AND_STEP();
6729             destval = pop_word();
6730             store_data_word(destoffset, destval);
6731         }
6732         break;
6733     case 2:
6734         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6735             u32 destval;
6736
6737             destoffset = decode_rm10_address(rl);
6738             DECODE_PRINTF("\n");
6739             TRACE_AND_STEP();
6740             destval = pop_long();
6741             store_data_long(destoffset, destval);
6742         } else {
6743             u16 destval;
6744
6745             destoffset = decode_rm10_address(rl);
6746             DECODE_PRINTF("\n");
6747             TRACE_AND_STEP();
6748             destval = pop_word();
6749             store_data_word(destoffset, destval);
6750         }
6751         break;
6752     case 3:                     /* register to register */
6753         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6754             u32 *destreg;
6755
6756             destreg = DECODE_RM_LONG_REGISTER(rl);
6757             DECODE_PRINTF("\n");
6758             TRACE_AND_STEP();
6759             *destreg = pop_long();
6760         } else {
6761             u16 *destreg;
6762
6763             destreg = DECODE_RM_WORD_REGISTER(rl);
6764             DECODE_PRINTF("\n");
6765             TRACE_AND_STEP();
6766             *destreg = pop_word();
6767         }
6768         break;
6769     }
6770     DECODE_CLEAR_SEGOVR();
6771     END_OF_INSTR();
6772 }
6773
6774 /****************************************************************************
6775 REMARKS:
6776 Handles opcode 0x90
6777 ****************************************************************************/
6778 static void x86emuOp_nop(u8 X86EMU_UNUSED(op1))
6779 {
6780     START_OF_INSTR();
6781     DECODE_PRINTF("NOP\n");
6782     TRACE_AND_STEP();
6783     DECODE_CLEAR_SEGOVR();
6784     END_OF_INSTR();
6785 }
6786
6787 /****************************************************************************
6788 REMARKS:
6789 Handles opcode 0x91
6790 ****************************************************************************/
6791 static void x86emuOp_xchg_word_AX_CX(u8 X86EMU_UNUSED(op1))
6792 {
6793     u32 tmp;
6794
6795     START_OF_INSTR();
6796     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6797         DECODE_PRINTF("XCHG\tEAX,ECX\n");
6798     } else {
6799         DECODE_PRINTF("XCHG\tAX,CX\n");
6800     }
6801     TRACE_AND_STEP();
6802     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6803         tmp = M.x86.R_EAX;
6804         M.x86.R_EAX = M.x86.R_ECX;
6805         M.x86.R_ECX = tmp;
6806     } else {
6807         tmp = M.x86.R_AX;
6808         M.x86.R_AX = M.x86.R_CX;
6809         M.x86.R_CX = (u16)tmp;
6810     }
6811     DECODE_CLEAR_SEGOVR();
6812     END_OF_INSTR();
6813 }
6814
6815 /****************************************************************************
6816 REMARKS:
6817 Handles opcode 0x92
6818 ****************************************************************************/
6819 static void x86emuOp_xchg_word_AX_DX(u8 X86EMU_UNUSED(op1))
6820 {
6821     u32 tmp;
6822
6823     START_OF_INSTR();
6824     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6825         DECODE_PRINTF("XCHG\tEAX,EDX\n");
6826     } else {
6827         DECODE_PRINTF("XCHG\tAX,DX\n");
6828     }
6829     TRACE_AND_STEP();
6830     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6831         tmp = M.x86.R_EAX;
6832         M.x86.R_EAX = M.x86.R_EDX;
6833         M.x86.R_EDX = tmp;
6834     } else {
6835         tmp = M.x86.R_AX;
6836         M.x86.R_AX = M.x86.R_DX;
6837         M.x86.R_DX = (u16)tmp;
6838     }
6839     DECODE_CLEAR_SEGOVR();
6840     END_OF_INSTR();
6841 }
6842
6843 /****************************************************************************
6844 REMARKS:
6845 Handles opcode 0x93
6846 ****************************************************************************/
6847 static void x86emuOp_xchg_word_AX_BX(u8 X86EMU_UNUSED(op1))
6848 {
6849     u32 tmp;
6850
6851     START_OF_INSTR();
6852     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6853         DECODE_PRINTF("XCHG\tEAX,EBX\n");
6854     } else {
6855         DECODE_PRINTF("XCHG\tAX,BX\n");
6856     }
6857     TRACE_AND_STEP();
6858     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6859         tmp = M.x86.R_EAX;
6860         M.x86.R_EAX = M.x86.R_EBX;
6861         M.x86.R_EBX = tmp;
6862     } else {
6863         tmp = M.x86.R_AX;
6864         M.x86.R_AX = M.x86.R_BX;
6865         M.x86.R_BX = (u16)tmp;
6866     }
6867     DECODE_CLEAR_SEGOVR();
6868     END_OF_INSTR();
6869 }
6870
6871 /****************************************************************************
6872 REMARKS:
6873 Handles opcode 0x94
6874 ****************************************************************************/
6875 static void x86emuOp_xchg_word_AX_SP(u8 X86EMU_UNUSED(op1))
6876 {
6877     u32 tmp;
6878
6879     START_OF_INSTR();
6880     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6881         DECODE_PRINTF("XCHG\tEAX,ESP\n");
6882     } else {
6883         DECODE_PRINTF("XCHG\tAX,SP\n");
6884     }
6885     TRACE_AND_STEP();
6886     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6887         tmp = M.x86.R_EAX;
6888         M.x86.R_EAX = M.x86.R_ESP;
6889         M.x86.R_ESP = tmp;
6890     } else {
6891         tmp = M.x86.R_AX;
6892         M.x86.R_AX = M.x86.R_SP;
6893         M.x86.R_SP = (u16)tmp;
6894     }
6895     DECODE_CLEAR_SEGOVR();
6896     END_OF_INSTR();
6897 }
6898
6899 /****************************************************************************
6900 REMARKS:
6901 Handles opcode 0x95
6902 ****************************************************************************/
6903 static void x86emuOp_xchg_word_AX_BP(u8 X86EMU_UNUSED(op1))
6904 {
6905     u32 tmp;
6906
6907     START_OF_INSTR();
6908     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6909         DECODE_PRINTF("XCHG\tEAX,EBP\n");
6910     } else {
6911         DECODE_PRINTF("XCHG\tAX,BP\n");
6912     }
6913     TRACE_AND_STEP();
6914     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6915         tmp = M.x86.R_EAX;
6916         M.x86.R_EAX = M.x86.R_EBP;
6917         M.x86.R_EBP = tmp;
6918     } else {
6919         tmp = M.x86.R_AX;
6920         M.x86.R_AX = M.x86.R_BP;
6921         M.x86.R_BP = (u16)tmp;
6922     }
6923     DECODE_CLEAR_SEGOVR();
6924     END_OF_INSTR();
6925 }
6926
6927 /****************************************************************************
6928 REMARKS:
6929 Handles opcode 0x96
6930 ****************************************************************************/
6931 static void x86emuOp_xchg_word_AX_SI(u8 X86EMU_UNUSED(op1))
6932 {
6933     u32 tmp;
6934
6935     START_OF_INSTR();
6936     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6937         DECODE_PRINTF("XCHG\tEAX,ESI\n");
6938     } else {
6939         DECODE_PRINTF("XCHG\tAX,SI\n");
6940     }
6941     TRACE_AND_STEP();
6942     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6943         tmp = M.x86.R_EAX;
6944         M.x86.R_EAX = M.x86.R_ESI;
6945         M.x86.R_ESI = tmp;
6946     } else {
6947         tmp = M.x86.R_AX;
6948         M.x86.R_AX = M.x86.R_SI;
6949         M.x86.R_SI = (u16)tmp;
6950     }
6951     DECODE_CLEAR_SEGOVR();
6952     END_OF_INSTR();
6953 }
6954
6955 /****************************************************************************
6956 REMARKS:
6957 Handles opcode 0x97
6958 ****************************************************************************/
6959 static void x86emuOp_xchg_word_AX_DI(u8 X86EMU_UNUSED(op1))
6960 {
6961     u32 tmp;
6962
6963     START_OF_INSTR();
6964     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6965         DECODE_PRINTF("XCHG\tEAX,EDI\n");
6966     } else {
6967         DECODE_PRINTF("XCHG\tAX,DI\n");
6968     }
6969     TRACE_AND_STEP();
6970     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6971         tmp = M.x86.R_EAX;
6972         M.x86.R_EAX = M.x86.R_EDI;
6973         M.x86.R_EDI = tmp;
6974     } else {
6975         tmp = M.x86.R_AX;
6976         M.x86.R_AX = M.x86.R_DI;
6977         M.x86.R_DI = (u16)tmp;
6978     }
6979     DECODE_CLEAR_SEGOVR();
6980     END_OF_INSTR();
6981 }
6982
6983 /****************************************************************************
6984 REMARKS:
6985 Handles opcode 0x98
6986 ****************************************************************************/
6987 static void x86emuOp_cbw(u8 X86EMU_UNUSED(op1))
6988 {
6989     START_OF_INSTR();
6990     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6991         DECODE_PRINTF("CWDE\n");
6992     } else {
6993         DECODE_PRINTF("CBW\n");
6994     }
6995     TRACE_AND_STEP();
6996     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
6997         if (M.x86.R_AX & 0x8000) {
6998             M.x86.R_EAX |= 0xffff0000;
6999         } else {
7000             M.x86.R_EAX &= 0x0000ffff;
7001         }
7002     } else {
7003         if (M.x86.R_AL & 0x80) {
7004             M.x86.R_AH = 0xff;
7005         } else {
7006             M.x86.R_AH = 0x0;
7007         }
7008     }
7009     DECODE_CLEAR_SEGOVR();
7010     END_OF_INSTR();
7011 }
7012
7013 /****************************************************************************
7014 REMARKS:
7015 Handles opcode 0x99
7016 ****************************************************************************/
7017 static void x86emuOp_cwd(u8 X86EMU_UNUSED(op1))
7018 {
7019     START_OF_INSTR();
7020     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7021         DECODE_PRINTF("CDQ\n");
7022     } else {
7023         DECODE_PRINTF("CWD\n");
7024     }
7025     DECODE_PRINTF("CWD\n");
7026     TRACE_AND_STEP();
7027     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7028         if (M.x86.R_EAX & 0x80000000) {
7029             M.x86.R_EDX = 0xffffffff;
7030         } else {
7031             M.x86.R_EDX = 0x0;
7032         }
7033     } else {
7034         if (M.x86.R_AX & 0x8000) {
7035             M.x86.R_DX = 0xffff;
7036         } else {
7037             M.x86.R_DX = 0x0;
7038         }
7039     }
7040     DECODE_CLEAR_SEGOVR();
7041     END_OF_INSTR();
7042 }
7043
7044 /****************************************************************************
7045 REMARKS:
7046 Handles opcode 0x9a
7047 ****************************************************************************/
7048 static void x86emuOp_call_far_IMM(u8 X86EMU_UNUSED(op1))
7049 {
7050     u16 farseg, faroff;
7051
7052     START_OF_INSTR();
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 ");
7059
7060     /* XXX
7061      *
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.
7065      */
7066     TRACE_AND_STEP();
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();
7072     END_OF_INSTR();
7073 }
7074
7075 /****************************************************************************
7076 REMARKS:
7077 Handles opcode 0x9b
7078 ****************************************************************************/
7079 static void x86emuOp_wait(u8 X86EMU_UNUSED(op1))
7080 {
7081     START_OF_INSTR();
7082     DECODE_PRINTF("WAIT");
7083     TRACE_AND_STEP();
7084     /* NADA.  */
7085     DECODE_CLEAR_SEGOVR();
7086     END_OF_INSTR();
7087 }
7088
7089 /****************************************************************************
7090 REMARKS:
7091 Handles opcode 0x9c
7092 ****************************************************************************/
7093 static void x86emuOp_pushf_word(u8 X86EMU_UNUSED(op1))
7094 {
7095     u32 flags;
7096
7097     START_OF_INSTR();
7098     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7099         DECODE_PRINTF("PUSHFD\n");
7100     } else {
7101         DECODE_PRINTF("PUSHF\n");
7102     }
7103     TRACE_AND_STEP();
7104
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) {
7108         push_long(flags);
7109     } else {
7110         push_word((u16)flags);
7111     }
7112     DECODE_CLEAR_SEGOVR();
7113     END_OF_INSTR();
7114 }
7115
7116 /****************************************************************************
7117 REMARKS:
7118 Handles opcode 0x9d
7119 ****************************************************************************/
7120 static void x86emuOp_popf_word(u8 X86EMU_UNUSED(op1))
7121 {
7122     START_OF_INSTR();
7123     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7124         DECODE_PRINTF("POPFD\n");
7125     } else {
7126         DECODE_PRINTF("POPF\n");
7127     }
7128     TRACE_AND_STEP();
7129     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7130         M.x86.R_EFLG = pop_long();
7131     } else {
7132         M.x86.R_FLG = pop_word();
7133     }
7134     DECODE_CLEAR_SEGOVR();
7135     END_OF_INSTR();
7136 }
7137
7138 /****************************************************************************
7139 REMARKS:
7140 Handles opcode 0x9e
7141 ****************************************************************************/
7142 static void x86emuOp_sahf(u8 X86EMU_UNUSED(op1))
7143 {
7144     START_OF_INSTR();
7145     DECODE_PRINTF("SAHF\n");
7146     TRACE_AND_STEP();
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();
7152     END_OF_INSTR();
7153 }
7154
7155 /****************************************************************************
7156 REMARKS:
7157 Handles opcode 0x9f
7158 ****************************************************************************/
7159 static void x86emuOp_lahf(u8 X86EMU_UNUSED(op1))
7160 {
7161     START_OF_INSTR();
7162     DECODE_PRINTF("LAHF\n");
7163     TRACE_AND_STEP();
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. */
7167     M.x86.R_AH |= 0x2;
7168     DECODE_CLEAR_SEGOVR();
7169     END_OF_INSTR();
7170 }
7171
7172 /****************************************************************************
7173 REMARKS:
7174 Handles opcode 0xa0
7175 ****************************************************************************/
7176 static void x86emuOp_mov_AL_M_IMM(u8 X86EMU_UNUSED(op1))
7177 {
7178     u16 offset;
7179
7180     START_OF_INSTR();
7181     DECODE_PRINTF("MOV\tAL,");
7182     offset = fetch_word_imm();
7183     DECODE_PRINTF2("[%04x]\n", offset);
7184     TRACE_AND_STEP();
7185     M.x86.R_AL = fetch_data_byte(offset);
7186     DECODE_CLEAR_SEGOVR();
7187     END_OF_INSTR();
7188 }
7189
7190 /****************************************************************************
7191 REMARKS:
7192 Handles opcode 0xa1
7193 ****************************************************************************/
7194 static void x86emuOp_mov_AX_M_IMM(u8 X86EMU_UNUSED(op1))
7195 {
7196     u16 offset;
7197
7198     START_OF_INSTR();
7199     offset = fetch_word_imm();
7200     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7201         DECODE_PRINTF2("MOV\tEAX,[%04x]\n", offset);
7202     } else {
7203         DECODE_PRINTF2("MOV\tAX,[%04x]\n", offset);
7204     }
7205     TRACE_AND_STEP();
7206     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7207         M.x86.R_EAX = fetch_data_long(offset);
7208     } else {
7209         M.x86.R_AX = fetch_data_word(offset);
7210     }
7211     DECODE_CLEAR_SEGOVR();
7212     END_OF_INSTR();
7213 }
7214
7215 /****************************************************************************
7216 REMARKS:
7217 Handles opcode 0xa2
7218 ****************************************************************************/
7219 static void x86emuOp_mov_M_AL_IMM(u8 X86EMU_UNUSED(op1))
7220 {
7221     u16 offset;
7222
7223     START_OF_INSTR();
7224     DECODE_PRINTF("MOV\t");
7225     offset = fetch_word_imm();
7226     DECODE_PRINTF2("[%04x],AL\n", offset);
7227     TRACE_AND_STEP();
7228     store_data_byte(offset, M.x86.R_AL);
7229     DECODE_CLEAR_SEGOVR();
7230     END_OF_INSTR();
7231 }
7232
7233 /****************************************************************************
7234 REMARKS:
7235 Handles opcode 0xa3
7236 ****************************************************************************/
7237 static void x86emuOp_mov_M_AX_IMM(u8 X86EMU_UNUSED(op1))
7238 {
7239     u16 offset;
7240
7241     START_OF_INSTR();
7242     offset = fetch_word_imm();
7243     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7244         DECODE_PRINTF2("MOV\t[%04x],EAX\n", offset);
7245     } else {
7246         DECODE_PRINTF2("MOV\t[%04x],AX\n", offset);
7247     }
7248     TRACE_AND_STEP();
7249     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7250         store_data_long(offset, M.x86.R_EAX);
7251     } else {
7252         store_data_word(offset, M.x86.R_AX);
7253     }
7254     DECODE_CLEAR_SEGOVR();
7255     END_OF_INSTR();
7256 }
7257
7258 /****************************************************************************
7259 REMARKS:
7260 Handles opcode 0xa4
7261 ****************************************************************************/
7262 static void x86emuOp_movs_byte(u8 X86EMU_UNUSED(op1))
7263 {
7264     u8  val;
7265     u32 count;
7266     int inc;
7267
7268     START_OF_INSTR();
7269     DECODE_PRINTF("MOVS\tBYTE\n");
7270     if (ACCESS_FLAG(F_DF))   /* down */
7271         inc = -1;
7272     else
7273         inc = 1;
7274     TRACE_AND_STEP();
7275     count = 1;
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. */
7279         count = M.x86.R_CX;
7280         M.x86.R_CX = 0;
7281         M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
7282     }
7283     while (count--) {
7284         val = fetch_data_byte(M.x86.R_SI);
7285         store_data_byte_abs(M.x86.R_ES, M.x86.R_DI, val);
7286         M.x86.R_SI += inc;
7287         M.x86.R_DI += inc;
7288     }
7289     DECODE_CLEAR_SEGOVR();
7290     END_OF_INSTR();
7291 }
7292
7293 /****************************************************************************
7294 REMARKS:
7295 Handles opcode 0xa5
7296 ****************************************************************************/
7297 static void x86emuOp_movs_word(u8 X86EMU_UNUSED(op1))
7298 {
7299     u32 val;
7300     int inc;
7301     u32 count;
7302
7303     START_OF_INSTR();
7304     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7305         DECODE_PRINTF("MOVS\tDWORD\n");
7306         if (ACCESS_FLAG(F_DF))      /* down */
7307             inc = -4;
7308         else
7309             inc = 4;
7310     } else {
7311         DECODE_PRINTF("MOVS\tWORD\n");
7312         if (ACCESS_FLAG(F_DF))      /* down */
7313             inc = -2;
7314         else
7315             inc = 2;
7316     }
7317     TRACE_AND_STEP();
7318     count = 1;
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. */
7322         count = M.x86.R_CX;
7323         M.x86.R_CX = 0;
7324         M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
7325     }
7326     while (count--) {
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);
7330         } else {
7331             val = fetch_data_word(M.x86.R_SI);
7332             store_data_word_abs(M.x86.R_ES, M.x86.R_DI, (u16)val);
7333         }
7334         M.x86.R_SI += inc;
7335         M.x86.R_DI += inc;
7336     }
7337     DECODE_CLEAR_SEGOVR();
7338     END_OF_INSTR();
7339 }
7340
7341 /****************************************************************************
7342 REMARKS:
7343 Handles opcode 0xa6
7344 ****************************************************************************/
7345 static void x86emuOp_cmps_byte(u8 X86EMU_UNUSED(op1))
7346 {
7347     s8 val1, val2;
7348     int inc;
7349
7350     START_OF_INSTR();
7351     DECODE_PRINTF("CMPS\tBYTE\n");
7352     TRACE_AND_STEP();
7353     if (ACCESS_FLAG(F_DF))   /* down */
7354         inc = -1;
7355     else
7356         inc = 1;
7357
7358     if (M.x86.mode & SYSMODE_PREFIX_REPE) {
7359         /* 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);
7365             M.x86.R_CX -= 1;
7366             M.x86.R_SI += inc;
7367             M.x86.R_DI += inc;
7368             if (ACCESS_FLAG(F_ZF) == 0)
7369                 break;
7370         }
7371         M.x86.mode &= ~SYSMODE_PREFIX_REPE;
7372     } else if (M.x86.mode & SYSMODE_PREFIX_REPNE) {
7373         /* 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);
7379             M.x86.R_CX -= 1;
7380             M.x86.R_SI += inc;
7381             M.x86.R_DI += inc;
7382             if (ACCESS_FLAG(F_ZF))
7383                 break;          /* zero flag set means equal */
7384         }
7385         M.x86.mode &= ~SYSMODE_PREFIX_REPNE;
7386     } else {
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);
7390         M.x86.R_SI += inc;
7391         M.x86.R_DI += inc;
7392     }
7393     DECODE_CLEAR_SEGOVR();
7394     END_OF_INSTR();
7395 }
7396
7397 /****************************************************************************
7398 REMARKS:
7399 Handles opcode 0xa7
7400 ****************************************************************************/
7401 static void x86emuOp_cmps_word(u8 X86EMU_UNUSED(op1))
7402 {
7403     u32 val1,val2;
7404     int inc;
7405
7406     START_OF_INSTR();
7407     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7408         DECODE_PRINTF("CMPS\tDWORD\n");
7409         if (ACCESS_FLAG(F_DF))   /* down */
7410             inc = -4;
7411         else
7412             inc = 4;
7413     } else {
7414         DECODE_PRINTF("CMPS\tWORD\n");
7415         if (ACCESS_FLAG(F_DF))   /* down */
7416             inc = -2;
7417         else
7418             inc = 2;
7419     }
7420     TRACE_AND_STEP();
7421     if (M.x86.mode & SYSMODE_PREFIX_REPE) {
7422         /* 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);
7429             } else {
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);
7433             }
7434             M.x86.R_CX -= 1;
7435             M.x86.R_SI += inc;
7436             M.x86.R_DI += inc;
7437             if (ACCESS_FLAG(F_ZF) == 0)
7438                 break;
7439         }
7440         M.x86.mode &= ~SYSMODE_PREFIX_REPE;
7441     } else if (M.x86.mode & SYSMODE_PREFIX_REPNE) {
7442         /* 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);
7449             } else {
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);
7453             }
7454             M.x86.R_CX -= 1;
7455             M.x86.R_SI += inc;
7456             M.x86.R_DI += inc;
7457             if (ACCESS_FLAG(F_ZF))
7458                 break;          /* zero flag set means equal */
7459         }
7460         M.x86.mode &= ~SYSMODE_PREFIX_REPNE;
7461     } else {
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);
7466         } else {
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);
7470         }
7471         M.x86.R_SI += inc;
7472         M.x86.R_DI += inc;
7473     }
7474     DECODE_CLEAR_SEGOVR();
7475     END_OF_INSTR();
7476 }
7477
7478 /****************************************************************************
7479 REMARKS:
7480 Handles opcode 0xa8
7481 ****************************************************************************/
7482 static void x86emuOp_test_AL_IMM(u8 X86EMU_UNUSED(op1))
7483 {
7484     int imm;
7485
7486     START_OF_INSTR();
7487     DECODE_PRINTF("TEST\tAL,");
7488     imm = fetch_byte_imm();
7489     DECODE_PRINTF2("%04x\n", imm);
7490     TRACE_AND_STEP();
7491         test_byte(M.x86.R_AL, (u8)imm);
7492     DECODE_CLEAR_SEGOVR();
7493     END_OF_INSTR();
7494 }
7495
7496 /****************************************************************************
7497 REMARKS:
7498 Handles opcode 0xa9
7499 ****************************************************************************/
7500 static void x86emuOp_test_AX_IMM(u8 X86EMU_UNUSED(op1))
7501 {
7502     u32 srcval;
7503
7504     START_OF_INSTR();
7505     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7506         DECODE_PRINTF("TEST\tEAX,");
7507         srcval = fetch_long_imm();
7508     } else {
7509         DECODE_PRINTF("TEST\tAX,");
7510         srcval = fetch_word_imm();
7511     }
7512     DECODE_PRINTF2("%x\n", srcval);
7513     TRACE_AND_STEP();
7514     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7515         test_long(M.x86.R_EAX, srcval);
7516     } else {
7517         test_word(M.x86.R_AX, (u16)srcval);
7518     }
7519     DECODE_CLEAR_SEGOVR();
7520     END_OF_INSTR();
7521 }
7522
7523 /****************************************************************************
7524 REMARKS:
7525 Handles opcode 0xaa
7526 ****************************************************************************/
7527 static void x86emuOp_stos_byte(u8 X86EMU_UNUSED(op1))
7528 {
7529     int inc;
7530
7531     START_OF_INSTR();
7532     DECODE_PRINTF("STOS\tBYTE\n");
7533     if (ACCESS_FLAG(F_DF))   /* down */
7534         inc = -1;
7535     else
7536         inc = 1;
7537     TRACE_AND_STEP();
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);
7543             M.x86.R_CX -= 1;
7544             M.x86.R_DI += inc;
7545         }
7546         M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
7547     } else {
7548         store_data_byte_abs(M.x86.R_ES, M.x86.R_DI, M.x86.R_AL);
7549         M.x86.R_DI += inc;
7550     }
7551     DECODE_CLEAR_SEGOVR();
7552     END_OF_INSTR();
7553 }
7554
7555 /****************************************************************************
7556 REMARKS:
7557 Handles opcode 0xab
7558 ****************************************************************************/
7559 static void x86emuOp_stos_word(u8 X86EMU_UNUSED(op1))
7560 {
7561     int inc;
7562     u32 count;
7563
7564     START_OF_INSTR();
7565     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7566         DECODE_PRINTF("STOS\tDWORD\n");
7567         if (ACCESS_FLAG(F_DF))   /* down */
7568             inc = -4;
7569         else
7570             inc = 4;
7571     } else {
7572         DECODE_PRINTF("STOS\tWORD\n");
7573         if (ACCESS_FLAG(F_DF))   /* down */
7574             inc = -2;
7575         else
7576             inc = 2;
7577     }
7578     TRACE_AND_STEP();
7579     count = 1;
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. */
7583         count = M.x86.R_CX;
7584         M.x86.R_CX = 0;
7585         M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
7586     }
7587     while (count--) {
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);
7590         } else {
7591             store_data_word_abs(M.x86.R_ES, M.x86.R_DI, M.x86.R_AX);
7592         }
7593         M.x86.R_DI += inc;
7594     }
7595     DECODE_CLEAR_SEGOVR();
7596     END_OF_INSTR();
7597 }
7598
7599 /****************************************************************************
7600 REMARKS:
7601 Handles opcode 0xac
7602 ****************************************************************************/
7603 static void x86emuOp_lods_byte(u8 X86EMU_UNUSED(op1))
7604 {
7605     int inc;
7606
7607     START_OF_INSTR();
7608     DECODE_PRINTF("LODS\tBYTE\n");
7609     TRACE_AND_STEP();
7610     if (ACCESS_FLAG(F_DF))   /* down */
7611         inc = -1;
7612     else
7613         inc = 1;
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);
7619             M.x86.R_CX -= 1;
7620             M.x86.R_SI += inc;
7621         }
7622         M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
7623     } else {
7624         M.x86.R_AL = fetch_data_byte(M.x86.R_SI);
7625         M.x86.R_SI += inc;
7626     }
7627     DECODE_CLEAR_SEGOVR();
7628     END_OF_INSTR();
7629 }
7630
7631 /****************************************************************************
7632 REMARKS:
7633 Handles opcode 0xad
7634 ****************************************************************************/
7635 static void x86emuOp_lods_word(u8 X86EMU_UNUSED(op1))
7636 {
7637     int inc;
7638     u32 count;
7639
7640     START_OF_INSTR();
7641     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7642         DECODE_PRINTF("LODS\tDWORD\n");
7643         if (ACCESS_FLAG(F_DF))   /* down */
7644             inc = -4;
7645         else
7646             inc = 4;
7647     } else {
7648         DECODE_PRINTF("LODS\tWORD\n");
7649         if (ACCESS_FLAG(F_DF))   /* down */
7650             inc = -2;
7651         else
7652             inc = 2;
7653     }
7654     TRACE_AND_STEP();
7655     count = 1;
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. */
7659         count = M.x86.R_CX;
7660         M.x86.R_CX = 0;
7661         M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
7662     }
7663     while (count--) {
7664         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7665             M.x86.R_EAX = fetch_data_long(M.x86.R_SI);
7666         } else {
7667             M.x86.R_AX = fetch_data_word(M.x86.R_SI);
7668         }
7669         M.x86.R_SI += inc;
7670     }
7671     DECODE_CLEAR_SEGOVR();
7672     END_OF_INSTR();
7673 }
7674
7675 /****************************************************************************
7676 REMARKS:
7677 Handles opcode 0xae
7678 ****************************************************************************/
7679 static void x86emuOp_scas_byte(u8 X86EMU_UNUSED(op1))
7680 {
7681     s8 val2;
7682     int inc;
7683
7684     START_OF_INSTR();
7685     DECODE_PRINTF("SCAS\tBYTE\n");
7686     TRACE_AND_STEP();
7687     if (ACCESS_FLAG(F_DF))   /* down */
7688         inc = -1;
7689     else
7690         inc = 1;
7691     if (M.x86.mode & SYSMODE_PREFIX_REPE) {
7692         /* 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);
7697             M.x86.R_CX -= 1;
7698             M.x86.R_DI += inc;
7699             if (ACCESS_FLAG(F_ZF) == 0)
7700                 break;
7701         }
7702         M.x86.mode &= ~SYSMODE_PREFIX_REPE;
7703     } else if (M.x86.mode & SYSMODE_PREFIX_REPNE) {
7704         /* 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);
7709             M.x86.R_CX -= 1;
7710             M.x86.R_DI += inc;
7711             if (ACCESS_FLAG(F_ZF))
7712                 break;          /* zero flag set means equal */
7713         }
7714         M.x86.mode &= ~SYSMODE_PREFIX_REPNE;
7715     } else {
7716         val2 = fetch_data_byte_abs(M.x86.R_ES, M.x86.R_DI);
7717         cmp_byte(M.x86.R_AL, val2);
7718         M.x86.R_DI += inc;
7719     }
7720     DECODE_CLEAR_SEGOVR();
7721     END_OF_INSTR();
7722 }
7723
7724 /****************************************************************************
7725 REMARKS:
7726 Handles opcode 0xaf
7727 ****************************************************************************/
7728 static void x86emuOp_scas_word(u8 X86EMU_UNUSED(op1))
7729 {
7730     int inc;
7731     u32 val;
7732
7733     START_OF_INSTR();
7734     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7735         DECODE_PRINTF("SCAS\tDWORD\n");
7736         if (ACCESS_FLAG(F_DF))   /* down */
7737             inc = -4;
7738         else
7739             inc = 4;
7740     } else {
7741         DECODE_PRINTF("SCAS\tWORD\n");
7742         if (ACCESS_FLAG(F_DF))   /* down */
7743             inc = -2;
7744         else
7745             inc = 2;
7746     }
7747     TRACE_AND_STEP();
7748     if (M.x86.mode & SYSMODE_PREFIX_REPE) {
7749         /* 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);
7755             } else {
7756                 val = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
7757                 cmp_word(M.x86.R_AX, (u16)val);
7758             }
7759             M.x86.R_CX -= 1;
7760             M.x86.R_DI += inc;
7761             if (ACCESS_FLAG(F_ZF) == 0)
7762                 break;
7763         }
7764         M.x86.mode &= ~SYSMODE_PREFIX_REPE;
7765     } else if (M.x86.mode & SYSMODE_PREFIX_REPNE) {
7766         /* 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);
7772             } else {
7773                 val = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
7774                 cmp_word(M.x86.R_AX, (u16)val);
7775             }
7776             M.x86.R_CX -= 1;
7777             M.x86.R_DI += inc;
7778             if (ACCESS_FLAG(F_ZF))
7779                 break;          /* zero flag set means equal */
7780         }
7781         M.x86.mode &= ~SYSMODE_PREFIX_REPNE;
7782     } else {
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);
7786         } else {
7787             val = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
7788             cmp_word(M.x86.R_AX, (u16)val);
7789         }
7790         M.x86.R_DI += inc;
7791     }
7792     DECODE_CLEAR_SEGOVR();
7793     END_OF_INSTR();
7794 }
7795
7796 /****************************************************************************
7797 REMARKS:
7798 Handles opcode 0xb0
7799 ****************************************************************************/
7800 static void x86emuOp_mov_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
7801 {
7802     u8 imm;
7803
7804     START_OF_INSTR();
7805     DECODE_PRINTF("MOV\tAL,");
7806     imm = fetch_byte_imm();
7807     DECODE_PRINTF2("%x\n", imm);
7808     TRACE_AND_STEP();
7809     M.x86.R_AL = imm;
7810     DECODE_CLEAR_SEGOVR();
7811     END_OF_INSTR();
7812 }
7813
7814 /****************************************************************************
7815 REMARKS:
7816 Handles opcode 0xb1
7817 ****************************************************************************/
7818 static void x86emuOp_mov_byte_CL_IMM(u8 X86EMU_UNUSED(op1))
7819 {
7820     u8 imm;
7821
7822     START_OF_INSTR();
7823     DECODE_PRINTF("MOV\tCL,");
7824     imm = fetch_byte_imm();
7825     DECODE_PRINTF2("%x\n", imm);
7826     TRACE_AND_STEP();
7827     M.x86.R_CL = imm;
7828     DECODE_CLEAR_SEGOVR();
7829     END_OF_INSTR();
7830 }
7831
7832 /****************************************************************************
7833 REMARKS:
7834 Handles opcode 0xb2
7835 ****************************************************************************/
7836 static void x86emuOp_mov_byte_DL_IMM(u8 X86EMU_UNUSED(op1))
7837 {
7838     u8 imm;
7839
7840     START_OF_INSTR();
7841     DECODE_PRINTF("MOV\tDL,");
7842     imm = fetch_byte_imm();
7843     DECODE_PRINTF2("%x\n", imm);
7844     TRACE_AND_STEP();
7845     M.x86.R_DL = imm;
7846     DECODE_CLEAR_SEGOVR();
7847     END_OF_INSTR();
7848 }
7849
7850 /****************************************************************************
7851 REMARKS:
7852 Handles opcode 0xb3
7853 ****************************************************************************/
7854 static void x86emuOp_mov_byte_BL_IMM(u8 X86EMU_UNUSED(op1))
7855 {
7856     u8 imm;
7857
7858     START_OF_INSTR();
7859     DECODE_PRINTF("MOV\tBL,");
7860     imm = fetch_byte_imm();
7861     DECODE_PRINTF2("%x\n", imm);
7862     TRACE_AND_STEP();
7863     M.x86.R_BL = imm;
7864     DECODE_CLEAR_SEGOVR();
7865     END_OF_INSTR();
7866 }
7867
7868 /****************************************************************************
7869 REMARKS:
7870 Handles opcode 0xb4
7871 ****************************************************************************/
7872 static void x86emuOp_mov_byte_AH_IMM(u8 X86EMU_UNUSED(op1))
7873 {
7874     u8 imm;
7875
7876     START_OF_INSTR();
7877     DECODE_PRINTF("MOV\tAH,");
7878     imm = fetch_byte_imm();
7879     DECODE_PRINTF2("%x\n", imm);
7880     TRACE_AND_STEP();
7881     M.x86.R_AH = imm;
7882     DECODE_CLEAR_SEGOVR();
7883     END_OF_INSTR();
7884 }
7885
7886 /****************************************************************************
7887 REMARKS:
7888 Handles opcode 0xb5
7889 ****************************************************************************/
7890 static void x86emuOp_mov_byte_CH_IMM(u8 X86EMU_UNUSED(op1))
7891 {
7892     u8 imm;
7893
7894     START_OF_INSTR();
7895     DECODE_PRINTF("MOV\tCH,");
7896     imm = fetch_byte_imm();
7897     DECODE_PRINTF2("%x\n", imm);
7898     TRACE_AND_STEP();
7899     M.x86.R_CH = imm;
7900     DECODE_CLEAR_SEGOVR();
7901     END_OF_INSTR();
7902 }
7903
7904 /****************************************************************************
7905 REMARKS:
7906 Handles opcode 0xb6
7907 ****************************************************************************/
7908 static void x86emuOp_mov_byte_DH_IMM(u8 X86EMU_UNUSED(op1))
7909 {
7910     u8 imm;
7911
7912     START_OF_INSTR();
7913     DECODE_PRINTF("MOV\tDH,");
7914     imm = fetch_byte_imm();
7915     DECODE_PRINTF2("%x\n", imm);
7916     TRACE_AND_STEP();
7917     M.x86.R_DH = imm;
7918     DECODE_CLEAR_SEGOVR();
7919     END_OF_INSTR();
7920 }
7921
7922 /****************************************************************************
7923 REMARKS:
7924 Handles opcode 0xb7
7925 ****************************************************************************/
7926 static void x86emuOp_mov_byte_BH_IMM(u8 X86EMU_UNUSED(op1))
7927 {
7928     u8 imm;
7929
7930     START_OF_INSTR();
7931     DECODE_PRINTF("MOV\tBH,");
7932     imm = fetch_byte_imm();
7933     DECODE_PRINTF2("%x\n", imm);
7934     TRACE_AND_STEP();
7935     M.x86.R_BH = imm;
7936     DECODE_CLEAR_SEGOVR();
7937     END_OF_INSTR();
7938 }
7939
7940 /****************************************************************************
7941 REMARKS:
7942 Handles opcode 0xb8
7943 ****************************************************************************/
7944 static void x86emuOp_mov_word_AX_IMM(u8 X86EMU_UNUSED(op1))
7945 {
7946     u32 srcval;
7947
7948     START_OF_INSTR();
7949     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7950         DECODE_PRINTF("MOV\tEAX,");
7951         srcval = fetch_long_imm();
7952     } else {
7953         DECODE_PRINTF("MOV\tAX,");
7954         srcval = fetch_word_imm();
7955     }
7956     DECODE_PRINTF2("%x\n", srcval);
7957     TRACE_AND_STEP();
7958     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7959         M.x86.R_EAX = srcval;
7960     } else {
7961         M.x86.R_AX = (u16)srcval;
7962     }
7963     DECODE_CLEAR_SEGOVR();
7964     END_OF_INSTR();
7965 }
7966
7967 /****************************************************************************
7968 REMARKS:
7969 Handles opcode 0xb9
7970 ****************************************************************************/
7971 static void x86emuOp_mov_word_CX_IMM(u8 X86EMU_UNUSED(op1))
7972 {
7973     u32 srcval;
7974
7975     START_OF_INSTR();
7976     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7977         DECODE_PRINTF("MOV\tECX,");
7978         srcval = fetch_long_imm();
7979     } else {
7980         DECODE_PRINTF("MOV\tCX,");
7981         srcval = fetch_word_imm();
7982     }
7983     DECODE_PRINTF2("%x\n", srcval);
7984     TRACE_AND_STEP();
7985     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
7986         M.x86.R_ECX = srcval;
7987     } else {
7988         M.x86.R_CX = (u16)srcval;
7989     }
7990     DECODE_CLEAR_SEGOVR();
7991     END_OF_INSTR();
7992 }
7993
7994 /****************************************************************************
7995 REMARKS:
7996 Handles opcode 0xba
7997 ****************************************************************************/
7998 static void x86emuOp_mov_word_DX_IMM(u8 X86EMU_UNUSED(op1))
7999 {
8000     u32 srcval;
8001
8002     START_OF_INSTR();
8003     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8004         DECODE_PRINTF("MOV\tEDX,");
8005         srcval = fetch_long_imm();
8006     } else {
8007         DECODE_PRINTF("MOV\tDX,");
8008         srcval = fetch_word_imm();
8009     }
8010     DECODE_PRINTF2("%x\n", srcval);
8011     TRACE_AND_STEP();
8012     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8013         M.x86.R_EDX = srcval;
8014     } else {
8015         M.x86.R_DX = (u16)srcval;
8016     }
8017     DECODE_CLEAR_SEGOVR();
8018     END_OF_INSTR();
8019 }
8020
8021 /****************************************************************************
8022 REMARKS:
8023 Handles opcode 0xbb
8024 ****************************************************************************/
8025 static void x86emuOp_mov_word_BX_IMM(u8 X86EMU_UNUSED(op1))
8026 {
8027     u32 srcval;
8028
8029     START_OF_INSTR();
8030     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8031         DECODE_PRINTF("MOV\tEBX,");
8032         srcval = fetch_long_imm();
8033     } else {
8034         DECODE_PRINTF("MOV\tBX,");
8035         srcval = fetch_word_imm();
8036     }
8037     DECODE_PRINTF2("%x\n", srcval);
8038     TRACE_AND_STEP();
8039     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8040         M.x86.R_EBX = srcval;
8041     } else {
8042         M.x86.R_BX = (u16)srcval;
8043     }
8044     DECODE_CLEAR_SEGOVR();
8045     END_OF_INSTR();
8046 }
8047
8048 /****************************************************************************
8049 REMARKS:
8050 Handles opcode 0xbc
8051 ****************************************************************************/
8052 static void x86emuOp_mov_word_SP_IMM(u8 X86EMU_UNUSED(op1))
8053 {
8054     u32 srcval;
8055
8056     START_OF_INSTR();
8057     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8058         DECODE_PRINTF("MOV\tESP,");
8059         srcval = fetch_long_imm();
8060     } else {
8061         DECODE_PRINTF("MOV\tSP,");
8062         srcval = fetch_word_imm();
8063     }
8064     DECODE_PRINTF2("%x\n", srcval);
8065     TRACE_AND_STEP();
8066     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8067         M.x86.R_ESP = srcval;
8068     } else {
8069         M.x86.R_SP = (u16)srcval;
8070     }
8071     DECODE_CLEAR_SEGOVR();
8072     END_OF_INSTR();
8073 }
8074
8075 /****************************************************************************
8076 REMARKS:
8077 Handles opcode 0xbd
8078 ****************************************************************************/
8079 static void x86emuOp_mov_word_BP_IMM(u8 X86EMU_UNUSED(op1))
8080 {
8081     u32 srcval;
8082
8083     START_OF_INSTR();
8084     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8085         DECODE_PRINTF("MOV\tEBP,");
8086         srcval = fetch_long_imm();
8087     } else {
8088         DECODE_PRINTF("MOV\tBP,");
8089         srcval = fetch_word_imm();
8090     }
8091     DECODE_PRINTF2("%x\n", srcval);
8092     TRACE_AND_STEP();
8093     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8094         M.x86.R_EBP = srcval;
8095     } else {
8096         M.x86.R_BP = (u16)srcval;
8097     }
8098     DECODE_CLEAR_SEGOVR();
8099     END_OF_INSTR();
8100 }
8101
8102 /****************************************************************************
8103 REMARKS:
8104 Handles opcode 0xbe
8105 ****************************************************************************/
8106 static void x86emuOp_mov_word_SI_IMM(u8 X86EMU_UNUSED(op1))
8107 {
8108     u32 srcval;
8109
8110     START_OF_INSTR();
8111     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8112         DECODE_PRINTF("MOV\tESI,");
8113         srcval = fetch_long_imm();
8114     } else {
8115         DECODE_PRINTF("MOV\tSI,");
8116         srcval = fetch_word_imm();
8117     }
8118     DECODE_PRINTF2("%x\n", srcval);
8119     TRACE_AND_STEP();
8120     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8121         M.x86.R_ESI = srcval;
8122     } else {
8123         M.x86.R_SI = (u16)srcval;
8124     }
8125     DECODE_CLEAR_SEGOVR();
8126     END_OF_INSTR();
8127 }
8128
8129 /****************************************************************************
8130 REMARKS:
8131 Handles opcode 0xbf
8132 ****************************************************************************/
8133 static void x86emuOp_mov_word_DI_IMM(u8 X86EMU_UNUSED(op1))
8134 {
8135     u32 srcval;
8136
8137     START_OF_INSTR();
8138     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8139         DECODE_PRINTF("MOV\tEDI,");
8140         srcval = fetch_long_imm();
8141     } else {
8142         DECODE_PRINTF("MOV\tDI,");
8143         srcval = fetch_word_imm();
8144     }
8145     DECODE_PRINTF2("%x\n", srcval);
8146     TRACE_AND_STEP();
8147     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8148         M.x86.R_EDI = srcval;
8149     } else {
8150         M.x86.R_DI = (u16)srcval;
8151     }
8152     DECODE_CLEAR_SEGOVR();
8153     END_OF_INSTR();
8154 }
8155
8156 /* used by opcodes c0, d0, and d2. */
8157 static u8(*opcD0_byte_operation[])(u8 d, u8 s) =
8158 {
8159     rol_byte,
8160     ror_byte,
8161     rcl_byte,
8162     rcr_byte,
8163     shl_byte,
8164     shr_byte,
8165     shl_byte,           /* sal_byte === shl_byte  by definition */
8166     sar_byte,
8167 };
8168
8169 /****************************************************************************
8170 REMARKS:
8171 Handles opcode 0xc0
8172 ****************************************************************************/
8173 static void x86emuOp_opcC0_byte_RM_MEM(u8 X86EMU_UNUSED(op1))
8174 {
8175     int mod, rl, rh;
8176     u8 *destreg;
8177     uint destoffset;
8178     u8 destval;
8179     u8 amt;
8180
8181     /*
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
8185      */
8186     START_OF_INSTR();
8187     FETCH_DECODE_MODRM(mod, rh, rl);
8188 #ifdef DEBUG
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. */
8194
8195         switch (rh) {
8196         case 0:
8197             DECODE_PRINTF("ROL\t");
8198             break;
8199         case 1:
8200             DECODE_PRINTF("ROR\t");
8201             break;
8202         case 2:
8203             DECODE_PRINTF("RCL\t");
8204             break;
8205         case 3:
8206             DECODE_PRINTF("RCR\t");
8207             break;
8208         case 4:
8209             DECODE_PRINTF("SHL\t");
8210             break;
8211         case 5:
8212             DECODE_PRINTF("SHR\t");
8213             break;
8214         case 6:
8215             DECODE_PRINTF("SAL\t");
8216             break;
8217         case 7:
8218             DECODE_PRINTF("SAR\t");
8219             break;
8220         }
8221     }
8222 #endif
8223     /* know operation, decode the mod byte to find the addressing
8224        mode. */
8225     switch (mod) {
8226     case 0:
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);
8232         TRACE_AND_STEP();
8233         destval = (*opcD0_byte_operation[rh]) (destval, amt);
8234         store_data_byte(destoffset, destval);
8235         break;
8236     case 1:
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);
8242         TRACE_AND_STEP();
8243         destval = (*opcD0_byte_operation[rh]) (destval, amt);
8244         store_data_byte(destoffset, destval);
8245         break;
8246     case 2:
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);
8252         TRACE_AND_STEP();
8253         destval = (*opcD0_byte_operation[rh]) (destval, amt);
8254         store_data_byte(destoffset, destval);
8255         break;
8256     case 3:                     /* register to register */
8257         destreg = DECODE_RM_BYTE_REGISTER(rl);
8258         amt = fetch_byte_imm();
8259         DECODE_PRINTF2(",%x\n", amt);
8260         TRACE_AND_STEP();
8261         destval = (*opcD0_byte_operation[rh]) (*destreg, amt);
8262         *destreg = destval;
8263         break;
8264     }
8265     DECODE_CLEAR_SEGOVR();
8266     END_OF_INSTR();
8267 }
8268
8269 /* used by opcodes c1, d1, and d3. */
8270 static u16(*opcD1_word_operation[])(u16 s, u8 d) =
8271 {
8272     rol_word,
8273     ror_word,
8274     rcl_word,
8275     rcr_word,
8276     shl_word,
8277     shr_word,
8278     shl_word,           /* sal_byte === shl_byte  by definition */
8279     sar_word,
8280 };
8281
8282 /* used by opcodes c1, d1, and d3. */
8283 static u32 (*opcD1_long_operation[])(u32 s, u8 d) =
8284 {
8285     rol_long,
8286     ror_long,
8287     rcl_long,
8288     rcr_long,
8289     shl_long,
8290     shr_long,
8291     shl_long,           /* sal_byte === shl_byte  by definition */
8292     sar_long,
8293 };
8294
8295 /****************************************************************************
8296 REMARKS:
8297 Handles opcode 0xc1
8298 ****************************************************************************/
8299 static void x86emuOp_opcC1_word_RM_MEM(u8 X86EMU_UNUSED(op1))
8300 {
8301     int mod, rl, rh;
8302     uint destoffset;
8303     u8 amt;
8304
8305     /*
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
8309      */
8310     START_OF_INSTR();
8311     FETCH_DECODE_MODRM(mod, rh, rl);
8312 #ifdef DEBUG
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. */
8318
8319         switch (rh) {
8320         case 0:
8321             DECODE_PRINTF("ROL\t");
8322             break;
8323         case 1:
8324             DECODE_PRINTF("ROR\t");
8325             break;
8326         case 2:
8327             DECODE_PRINTF("RCL\t");
8328             break;
8329         case 3:
8330             DECODE_PRINTF("RCR\t");
8331             break;
8332         case 4:
8333             DECODE_PRINTF("SHL\t");
8334             break;
8335         case 5:
8336             DECODE_PRINTF("SHR\t");
8337             break;
8338         case 6:
8339             DECODE_PRINTF("SAL\t");
8340             break;
8341         case 7:
8342             DECODE_PRINTF("SAR\t");
8343             break;
8344         }
8345     }
8346 #endif
8347     /* know operation, decode the mod byte to find the addressing
8348        mode. */
8349     switch (mod) {
8350     case 0:
8351         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8352             u32 destval;
8353
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);
8359             TRACE_AND_STEP();
8360             destval = (*opcD1_long_operation[rh]) (destval, amt);
8361             store_data_long(destoffset, destval);
8362         } else {
8363             u16 destval;
8364
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);
8370             TRACE_AND_STEP();
8371             destval = (*opcD1_word_operation[rh]) (destval, amt);
8372             store_data_word(destoffset, destval);
8373         }
8374         break;
8375     case 1:
8376         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8377             u32 destval;
8378
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);
8384             TRACE_AND_STEP();
8385             destval = (*opcD1_long_operation[rh]) (destval, amt);
8386             store_data_long(destoffset, destval);
8387         } else {
8388             u16 destval;
8389
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);
8395             TRACE_AND_STEP();
8396             destval = (*opcD1_word_operation[rh]) (destval, amt);
8397             store_data_word(destoffset, destval);
8398         }
8399         break;
8400     case 2:
8401         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8402             u32 destval;
8403
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);
8409             TRACE_AND_STEP();
8410             destval = (*opcD1_long_operation[rh]) (destval, amt);
8411             store_data_long(destoffset, destval);
8412         } else {
8413             u16 destval;
8414
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);
8420             TRACE_AND_STEP();
8421             destval = (*opcD1_word_operation[rh]) (destval, amt);
8422             store_data_word(destoffset, destval);
8423         }
8424         break;
8425     case 3:                     /* register to register */
8426         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8427             u32 *destreg;
8428
8429             destreg = DECODE_RM_LONG_REGISTER(rl);
8430             amt = fetch_byte_imm();
8431             DECODE_PRINTF2(",%x\n", amt);
8432             TRACE_AND_STEP();
8433             *destreg = (*opcD1_long_operation[rh]) (*destreg, amt);
8434         } else {
8435             u16 *destreg;
8436
8437             destreg = DECODE_RM_WORD_REGISTER(rl);
8438             amt = fetch_byte_imm();
8439             DECODE_PRINTF2(",%x\n", amt);
8440             TRACE_AND_STEP();
8441             *destreg = (*opcD1_word_operation[rh]) (*destreg, amt);
8442         }
8443         break;
8444     }
8445     DECODE_CLEAR_SEGOVR();
8446     END_OF_INSTR();
8447 }
8448
8449 /****************************************************************************
8450 REMARKS:
8451 Handles opcode 0xc2
8452 ****************************************************************************/
8453 static void x86emuOp_ret_near_IMM(u8 X86EMU_UNUSED(op1))
8454 {
8455     u16 imm;
8456
8457     START_OF_INSTR();
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);
8462         TRACE_AND_STEP();
8463     M.x86.R_IP = pop_word();
8464     M.x86.R_SP += imm;
8465     DECODE_CLEAR_SEGOVR();
8466     END_OF_INSTR();
8467 }
8468
8469 /****************************************************************************
8470 REMARKS:
8471 Handles opcode 0xc3
8472 ****************************************************************************/
8473 static void x86emuOp_ret_near(u8 X86EMU_UNUSED(op1))
8474 {
8475     START_OF_INSTR();
8476     DECODE_PRINTF("RET\n");
8477         RETURN_TRACE("RET",M.x86.saved_cs,M.x86.saved_ip);
8478         TRACE_AND_STEP();
8479     M.x86.R_IP = pop_word();
8480     DECODE_CLEAR_SEGOVR();
8481     END_OF_INSTR();
8482 }
8483
8484 /****************************************************************************
8485 REMARKS:
8486 Handles opcode 0xc4
8487 ****************************************************************************/
8488 static void x86emuOp_les_R_IMM(u8 X86EMU_UNUSED(op1))
8489 {
8490     int mod, rh, rl;
8491     u16 *dstreg;
8492     uint srcoffset;
8493
8494     START_OF_INSTR();
8495     DECODE_PRINTF("LES\t");
8496     FETCH_DECODE_MODRM(mod, rh, rl);
8497     switch (mod) {
8498     case 0:
8499         dstreg = DECODE_RM_WORD_REGISTER(rh);
8500         DECODE_PRINTF(",");
8501         srcoffset = decode_rm00_address(rl);
8502         DECODE_PRINTF("\n");
8503         TRACE_AND_STEP();
8504         *dstreg = fetch_data_word(srcoffset);
8505         M.x86.R_ES = fetch_data_word(srcoffset + 2);
8506         break;
8507     case 1:
8508         dstreg = DECODE_RM_WORD_REGISTER(rh);
8509         DECODE_PRINTF(",");
8510         srcoffset = decode_rm01_address(rl);
8511         DECODE_PRINTF("\n");
8512         TRACE_AND_STEP();
8513         *dstreg = fetch_data_word(srcoffset);
8514         M.x86.R_ES = fetch_data_word(srcoffset + 2);
8515         break;
8516     case 2:
8517         dstreg = DECODE_RM_WORD_REGISTER(rh);
8518         DECODE_PRINTF(",");
8519         srcoffset = decode_rm10_address(rl);
8520         DECODE_PRINTF("\n");
8521         TRACE_AND_STEP();
8522         *dstreg = fetch_data_word(srcoffset);
8523         M.x86.R_ES = fetch_data_word(srcoffset + 2);
8524         break;
8525     case 3:                     /* register to register */
8526         /* UNDEFINED! */
8527         TRACE_AND_STEP();
8528     }
8529     DECODE_CLEAR_SEGOVR();
8530     END_OF_INSTR();
8531 }
8532
8533 /****************************************************************************
8534 REMARKS:
8535 Handles opcode 0xc5
8536 ****************************************************************************/
8537 static void x86emuOp_lds_R_IMM(u8 X86EMU_UNUSED(op1))
8538 {
8539     int mod, rh, rl;
8540     u16 *dstreg;
8541     uint srcoffset;
8542
8543     START_OF_INSTR();
8544     DECODE_PRINTF("LDS\t");
8545     FETCH_DECODE_MODRM(mod, rh, rl);
8546     switch (mod) {
8547     case 0:
8548         dstreg = DECODE_RM_WORD_REGISTER(rh);
8549         DECODE_PRINTF(",");
8550         srcoffset = decode_rm00_address(rl);
8551         DECODE_PRINTF("\n");
8552         TRACE_AND_STEP();
8553         *dstreg = fetch_data_word(srcoffset);
8554         M.x86.R_DS = fetch_data_word(srcoffset + 2);
8555         break;
8556     case 1:
8557         dstreg = DECODE_RM_WORD_REGISTER(rh);
8558         DECODE_PRINTF(",");
8559         srcoffset = decode_rm01_address(rl);
8560         DECODE_PRINTF("\n");
8561         TRACE_AND_STEP();
8562         *dstreg = fetch_data_word(srcoffset);
8563         M.x86.R_DS = fetch_data_word(srcoffset + 2);
8564         break;
8565     case 2:
8566         dstreg = DECODE_RM_WORD_REGISTER(rh);
8567         DECODE_PRINTF(",");
8568         srcoffset = decode_rm10_address(rl);
8569         DECODE_PRINTF("\n");
8570         TRACE_AND_STEP();
8571         *dstreg = fetch_data_word(srcoffset);
8572         M.x86.R_DS = fetch_data_word(srcoffset + 2);
8573         break;
8574     case 3:                     /* register to register */
8575         /* UNDEFINED! */
8576         TRACE_AND_STEP();
8577     }
8578     DECODE_CLEAR_SEGOVR();
8579     END_OF_INSTR();
8580 }
8581
8582 /****************************************************************************
8583 REMARKS:
8584 Handles opcode 0xc6
8585 ****************************************************************************/
8586 static void x86emuOp_mov_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
8587 {
8588     int mod, rl, rh;
8589     u8 *destreg;
8590     uint destoffset;
8591     u8 imm;
8592
8593     START_OF_INSTR();
8594     DECODE_PRINTF("MOV\t");
8595     FETCH_DECODE_MODRM(mod, rh, rl);
8596     if (rh != 0) {
8597         DECODE_PRINTF("ILLEGAL DECODE OF OPCODE c6\n");
8598         HALT_SYS();
8599     }
8600     switch (mod) {
8601     case 0:
8602         DECODE_PRINTF("BYTE PTR ");
8603         destoffset = decode_rm00_address(rl);
8604         imm = fetch_byte_imm();
8605         DECODE_PRINTF2(",%2x\n", imm);
8606         TRACE_AND_STEP();
8607         store_data_byte(destoffset, imm);
8608         break;
8609     case 1:
8610         DECODE_PRINTF("BYTE PTR ");
8611         destoffset = decode_rm01_address(rl);
8612         imm = fetch_byte_imm();
8613         DECODE_PRINTF2(",%2x\n", imm);
8614         TRACE_AND_STEP();
8615         store_data_byte(destoffset, imm);
8616         break;
8617     case 2:
8618         DECODE_PRINTF("BYTE PTR ");
8619         destoffset = decode_rm10_address(rl);
8620         imm = fetch_byte_imm();
8621         DECODE_PRINTF2(",%2x\n", imm);
8622         TRACE_AND_STEP();
8623         store_data_byte(destoffset, imm);
8624         break;
8625     case 3:                     /* register to register */
8626         destreg = DECODE_RM_BYTE_REGISTER(rl);
8627         imm = fetch_byte_imm();
8628         DECODE_PRINTF2(",%2x\n", imm);
8629         TRACE_AND_STEP();
8630         *destreg = imm;
8631         break;
8632     }
8633     DECODE_CLEAR_SEGOVR();
8634     END_OF_INSTR();
8635 }
8636
8637 /****************************************************************************
8638 REMARKS:
8639 Handles opcode 0xc7
8640 ****************************************************************************/
8641 static void x86emuOp_mov_word_RM_IMM(u8 X86EMU_UNUSED(op1))
8642 {
8643     int mod, rl, rh;
8644     uint destoffset;
8645
8646     START_OF_INSTR();
8647     DECODE_PRINTF("MOV\t");
8648     FETCH_DECODE_MODRM(mod, rh, rl);
8649     if (rh != 0) {
8650         DECODE_PRINTF("ILLEGAL DECODE OF OPCODE 8F\n");
8651         HALT_SYS();
8652     }
8653     switch (mod) {
8654     case 0:
8655         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8656             u32 imm;
8657
8658             DECODE_PRINTF("DWORD PTR ");
8659             destoffset = decode_rm00_address(rl);
8660             imm = fetch_long_imm();
8661             DECODE_PRINTF2(",%x\n", imm);
8662             TRACE_AND_STEP();
8663             store_data_long(destoffset, imm);
8664         } else {
8665             u16 imm;
8666
8667             DECODE_PRINTF("WORD PTR ");
8668             destoffset = decode_rm00_address(rl);
8669             imm = fetch_word_imm();
8670             DECODE_PRINTF2(",%x\n", imm);
8671             TRACE_AND_STEP();
8672             store_data_word(destoffset, imm);
8673         }
8674         break;
8675     case 1:
8676         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8677             u32 imm;
8678
8679             DECODE_PRINTF("DWORD PTR ");
8680             destoffset = decode_rm01_address(rl);
8681             imm = fetch_long_imm();
8682             DECODE_PRINTF2(",%x\n", imm);
8683             TRACE_AND_STEP();
8684             store_data_long(destoffset, imm);
8685         } else {
8686             u16 imm;
8687
8688             DECODE_PRINTF("WORD PTR ");
8689             destoffset = decode_rm01_address(rl);
8690             imm = fetch_word_imm();
8691             DECODE_PRINTF2(",%x\n", imm);
8692             TRACE_AND_STEP();
8693             store_data_word(destoffset, imm);
8694         }
8695         break;
8696     case 2:
8697         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8698             u32 imm;
8699
8700             DECODE_PRINTF("DWORD PTR ");
8701             destoffset = decode_rm10_address(rl);
8702             imm = fetch_long_imm();
8703             DECODE_PRINTF2(",%x\n", imm);
8704             TRACE_AND_STEP();
8705             store_data_long(destoffset, imm);
8706         } else {
8707             u16 imm;
8708
8709             DECODE_PRINTF("WORD PTR ");
8710             destoffset = decode_rm10_address(rl);
8711             imm = fetch_word_imm();
8712             DECODE_PRINTF2(",%x\n", imm);
8713             TRACE_AND_STEP();
8714             store_data_word(destoffset, imm);
8715         }
8716         break;
8717     case 3:                     /* register to register */
8718         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
8719                         u32 *destreg;
8720                         u32 imm;
8721
8722             destreg = DECODE_RM_LONG_REGISTER(rl);
8723             imm = fetch_long_imm();
8724             DECODE_PRINTF2(",%x\n", imm);
8725             TRACE_AND_STEP();
8726             *destreg = imm;
8727         } else {
8728                         u16 *destreg;
8729                         u16 imm;
8730
8731             destreg = DECODE_RM_WORD_REGISTER(rl);
8732             imm = fetch_word_imm();
8733             DECODE_PRINTF2(",%x\n", imm);
8734             TRACE_AND_STEP();
8735             *destreg = imm;
8736         }
8737         break;
8738     }
8739     DECODE_CLEAR_SEGOVR();
8740     END_OF_INSTR();
8741 }
8742
8743 /****************************************************************************
8744 REMARKS:
8745 Handles opcode 0xc8
8746 ****************************************************************************/
8747 static void x86emuOp_enter(u8 X86EMU_UNUSED(op1))
8748 {
8749     u16 local,frame_pointer;
8750     u8  nesting;
8751     int i;
8752
8753     START_OF_INSTR();
8754     local = fetch_word_imm();
8755     nesting = fetch_byte_imm();
8756     DECODE_PRINTF2("ENTER %x\n", local);
8757     DECODE_PRINTF2(",%x\n", nesting);
8758     TRACE_AND_STEP();
8759     push_word(M.x86.R_BP);
8760     frame_pointer = M.x86.R_SP;
8761     if (nesting > 0) {
8762         for (i = 1; i < nesting; i++) {
8763             M.x86.R_BP -= 2;
8764             push_word(fetch_data_word_abs(M.x86.R_SS, M.x86.R_BP));
8765             }
8766         push_word(frame_pointer);
8767         }
8768     M.x86.R_BP = frame_pointer;
8769     M.x86.R_SP = (u16)(M.x86.R_SP - local);
8770     DECODE_CLEAR_SEGOVR();
8771     END_OF_INSTR();
8772 }
8773
8774 /****************************************************************************
8775 REMARKS:
8776 Handles opcode 0xc9
8777 ****************************************************************************/
8778 static void x86emuOp_leave(u8 X86EMU_UNUSED(op1))
8779 {
8780     START_OF_INSTR();
8781     DECODE_PRINTF("LEAVE\n");
8782     TRACE_AND_STEP();
8783     M.x86.R_SP = M.x86.R_BP;
8784     M.x86.R_BP = pop_word();
8785     DECODE_CLEAR_SEGOVR();
8786     END_OF_INSTR();
8787 }
8788
8789 /****************************************************************************
8790 REMARKS:
8791 Handles opcode 0xca
8792 ****************************************************************************/
8793 static void x86emuOp_ret_far_IMM(u8 X86EMU_UNUSED(op1))
8794 {
8795     u16 imm;
8796
8797     START_OF_INSTR();
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);
8802         TRACE_AND_STEP();
8803     M.x86.R_IP = pop_word();
8804     M.x86.R_CS = pop_word();
8805     M.x86.R_SP += imm;
8806     DECODE_CLEAR_SEGOVR();
8807     END_OF_INSTR();
8808 }
8809
8810 /****************************************************************************
8811 REMARKS:
8812 Handles opcode 0xcb
8813 ****************************************************************************/
8814 static void x86emuOp_ret_far(u8 X86EMU_UNUSED(op1))
8815 {
8816     START_OF_INSTR();
8817     DECODE_PRINTF("RETF\n");
8818         RETURN_TRACE("RETF",M.x86.saved_cs,M.x86.saved_ip);
8819         TRACE_AND_STEP();
8820     M.x86.R_IP = pop_word();
8821     M.x86.R_CS = pop_word();
8822     DECODE_CLEAR_SEGOVR();
8823     END_OF_INSTR();
8824 }
8825
8826 /****************************************************************************
8827 REMARKS:
8828 Handles opcode 0xcc
8829 ****************************************************************************/
8830 static void x86emuOp_int3(u8 X86EMU_UNUSED(op1))
8831 {
8832     START_OF_INSTR();
8833     DECODE_PRINTF("INT 3\n");
8834     TRACE_AND_STEP();
8835     if (_X86EMU_intrTab[3]) {
8836         (*_X86EMU_intrTab[3])(3);
8837     } else {
8838         push_word((u16)M.x86.R_FLG);
8839         CLEAR_FLAG(F_IF);
8840         CLEAR_FLAG(F_TF);
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);
8845     }
8846     DECODE_CLEAR_SEGOVR();
8847     END_OF_INSTR();
8848 }
8849
8850 /****************************************************************************
8851 REMARKS:
8852 Handles opcode 0xcd
8853 ****************************************************************************/
8854 static void x86emuOp_int_IMM(u8 X86EMU_UNUSED(op1))
8855 {
8856     u8 intnum;
8857
8858     START_OF_INSTR();
8859     DECODE_PRINTF("INT\t");
8860     intnum = fetch_byte_imm();
8861     DECODE_PRINTF2("%x\n", intnum);
8862     TRACE_AND_STEP();
8863     if (_X86EMU_intrTab[intnum]) {
8864         (*_X86EMU_intrTab[intnum])(intnum);
8865     } else {
8866         push_word((u16)M.x86.R_FLG);
8867         CLEAR_FLAG(F_IF);
8868         CLEAR_FLAG(F_TF);
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);
8873     }
8874     DECODE_CLEAR_SEGOVR();
8875     END_OF_INSTR();
8876 }
8877
8878 /****************************************************************************
8879 REMARKS:
8880 Handles opcode 0xce
8881 ****************************************************************************/
8882 static void x86emuOp_into(u8 X86EMU_UNUSED(op1))
8883 {
8884     START_OF_INSTR();
8885     DECODE_PRINTF("INTO\n");
8886     TRACE_AND_STEP();
8887     if (ACCESS_FLAG(F_OF)) {
8888         if (_X86EMU_intrTab[4]) {
8889             (*_X86EMU_intrTab[4])(4);
8890         } else {
8891             push_word((u16)M.x86.R_FLG);
8892             CLEAR_FLAG(F_IF);
8893             CLEAR_FLAG(F_TF);
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);
8898         }
8899     }
8900     DECODE_CLEAR_SEGOVR();
8901     END_OF_INSTR();
8902 }
8903
8904 /****************************************************************************
8905 REMARKS:
8906 Handles opcode 0xcf
8907 ****************************************************************************/
8908 static void x86emuOp_iret(u8 X86EMU_UNUSED(op1))
8909 {
8910     START_OF_INSTR();
8911     DECODE_PRINTF("IRET\n");
8912
8913     TRACE_AND_STEP();
8914
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();
8919     END_OF_INSTR();
8920 }
8921
8922 /****************************************************************************
8923 REMARKS:
8924 Handles opcode 0xd0
8925 ****************************************************************************/
8926 static void x86emuOp_opcD0_byte_RM_1(u8 X86EMU_UNUSED(op1))
8927 {
8928     int mod, rl, rh;
8929     u8 *destreg;
8930     uint destoffset;
8931     u8 destval;
8932
8933     /*
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
8937      */
8938     START_OF_INSTR();
8939     FETCH_DECODE_MODRM(mod, rh, rl);
8940 #ifdef DEBUG
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. */
8946         switch (rh) {
8947         case 0:
8948             DECODE_PRINTF("ROL\t");
8949             break;
8950         case 1:
8951             DECODE_PRINTF("ROR\t");
8952             break;
8953         case 2:
8954             DECODE_PRINTF("RCL\t");
8955             break;
8956         case 3:
8957             DECODE_PRINTF("RCR\t");
8958             break;
8959         case 4:
8960             DECODE_PRINTF("SHL\t");
8961             break;
8962         case 5:
8963             DECODE_PRINTF("SHR\t");
8964             break;
8965         case 6:
8966             DECODE_PRINTF("SAL\t");
8967             break;
8968         case 7:
8969             DECODE_PRINTF("SAR\t");
8970             break;
8971         }
8972     }
8973 #endif
8974     /* know operation, decode the mod byte to find the addressing
8975        mode. */
8976     switch (mod) {
8977     case 0:
8978         DECODE_PRINTF("BYTE PTR ");
8979         destoffset = decode_rm00_address(rl);
8980         DECODE_PRINTF(",1\n");
8981         destval = fetch_data_byte(destoffset);
8982         TRACE_AND_STEP();
8983         destval = (*opcD0_byte_operation[rh]) (destval, 1);
8984         store_data_byte(destoffset, destval);
8985         break;
8986     case 1:
8987         DECODE_PRINTF("BYTE PTR ");
8988         destoffset = decode_rm01_address(rl);
8989         DECODE_PRINTF(",1\n");
8990         destval = fetch_data_byte(destoffset);
8991         TRACE_AND_STEP();
8992         destval = (*opcD0_byte_operation[rh]) (destval, 1);
8993         store_data_byte(destoffset, destval);
8994         break;
8995     case 2:
8996         DECODE_PRINTF("BYTE PTR ");
8997         destoffset = decode_rm10_address(rl);
8998         DECODE_PRINTF(",1\n");
8999         destval = fetch_data_byte(destoffset);
9000         TRACE_AND_STEP();
9001         destval = (*opcD0_byte_operation[rh]) (destval, 1);
9002         store_data_byte(destoffset, destval);
9003         break;
9004     case 3:                     /* register to register */
9005         destreg = DECODE_RM_BYTE_REGISTER(rl);
9006         DECODE_PRINTF(",1\n");
9007         TRACE_AND_STEP();
9008         destval = (*opcD0_byte_operation[rh]) (*destreg, 1);
9009         *destreg = destval;
9010         break;
9011     }
9012     DECODE_CLEAR_SEGOVR();
9013     END_OF_INSTR();
9014 }
9015
9016 /****************************************************************************
9017 REMARKS:
9018 Handles opcode 0xd1
9019 ****************************************************************************/
9020 static void x86emuOp_opcD1_word_RM_1(u8 X86EMU_UNUSED(op1))
9021 {
9022     int mod, rl, rh;
9023     uint destoffset;
9024
9025     /*
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
9029      */
9030     START_OF_INSTR();
9031     FETCH_DECODE_MODRM(mod, rh, rl);
9032 #ifdef DEBUG
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. */
9038         switch (rh) {
9039         case 0:
9040             DECODE_PRINTF("ROL\t");
9041             break;
9042         case 1:
9043             DECODE_PRINTF("ROR\t");
9044             break;
9045         case 2:
9046             DECODE_PRINTF("RCL\t");
9047             break;
9048         case 3:
9049             DECODE_PRINTF("RCR\t");
9050             break;
9051         case 4:
9052             DECODE_PRINTF("SHL\t");
9053             break;
9054         case 5:
9055             DECODE_PRINTF("SHR\t");
9056             break;
9057         case 6:
9058             DECODE_PRINTF("SAL\t");
9059             break;
9060         case 7:
9061             DECODE_PRINTF("SAR\t");
9062             break;
9063         }
9064     }
9065 #endif
9066     /* know operation, decode the mod byte to find the addressing
9067        mode. */
9068     switch (mod) {
9069     case 0:
9070         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
9071             u32 destval;
9072
9073             DECODE_PRINTF("DWORD PTR ");
9074             destoffset = decode_rm00_address(rl);
9075             DECODE_PRINTF(",1\n");
9076             destval = fetch_data_long(destoffset);
9077             TRACE_AND_STEP();
9078             destval = (*opcD1_long_operation[rh]) (destval, 1);
9079             store_data_long(destoffset, destval);
9080         } else {
9081             u16 destval;
9082
9083             DECODE_PRINTF("WORD PTR ");
9084             destoffset = decode_rm00_address(rl);
9085             DECODE_PRINTF(",1\n");
9086             destval = fetch_data_word(destoffset);
9087             TRACE_AND_STEP();
9088             destval = (*opcD1_word_operation[rh]) (destval, 1);
9089             store_data_word(destoffset, destval);
9090         }
9091         break;
9092     case 1:
9093         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
9094             u32 destval;
9095
9096             DECODE_PRINTF("DWORD PTR ");
9097             destoffset = decode_rm01_address(rl);
9098             DECODE_PRINTF(",1\n");
9099             destval = fetch_data_long(destoffset);
9100             TRACE_AND_STEP();
9101             destval = (*opcD1_long_operation[rh]) (destval, 1);
9102             store_data_long(destoffset, destval);
9103         } else {
9104             u16 destval;
9105
9106             DECODE_PRINTF("WORD PTR ");
9107             destoffset = decode_rm01_address(rl);
9108             DECODE_PRINTF(",1\n");
9109             destval = fetch_data_word(destoffset);
9110             TRACE_AND_STEP();
9111             destval = (*opcD1_word_operation[rh]) (destval, 1);
9112             store_data_word(destoffset, destval);
9113         }
9114         break;
9115     case 2:
9116         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
9117             u32 destval;
9118
9119             DECODE_PRINTF("DWORD PTR ");
9120             destoffset = decode_rm10_address(rl);
9121             DECODE_PRINTF(",1\n");
9122             destval = fetch_data_long(destoffset);
9123             TRACE_AND_STEP();
9124             destval = (*opcD1_long_operation[rh]) (destval, 1);
9125             store_data_long(destoffset, destval);
9126         } else {
9127             u16 destval;
9128
9129             DECODE_PRINTF("BYTE PTR ");
9130             destoffset = decode_rm10_address(rl);
9131             DECODE_PRINTF(",1\n");
9132             destval = fetch_data_word(destoffset);
9133             TRACE_AND_STEP();
9134             destval = (*opcD1_word_operation[rh]) (destval, 1);
9135             store_data_word(destoffset, destval);
9136         }
9137         break;
9138     case 3:                     /* register to register */
9139         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
9140                         u32 destval;
9141                         u32 *destreg;
9142
9143             destreg = DECODE_RM_LONG_REGISTER(rl);
9144             DECODE_PRINTF(",1\n");
9145             TRACE_AND_STEP();
9146             destval = (*opcD1_long_operation[rh]) (*destreg, 1);
9147             *destreg = destval;
9148         } else {
9149                         u16 destval;
9150                         u16 *destreg;
9151
9152             destreg = DECODE_RM_WORD_REGISTER(rl);
9153             DECODE_PRINTF(",1\n");
9154             TRACE_AND_STEP();
9155             destval = (*opcD1_word_operation[rh]) (*destreg, 1);
9156             *destreg = destval;
9157         }
9158         break;
9159     }
9160     DECODE_CLEAR_SEGOVR();
9161     END_OF_INSTR();
9162 }
9163
9164 /****************************************************************************
9165 REMARKS:
9166 Handles opcode 0xd2
9167 ****************************************************************************/
9168 static void x86emuOp_opcD2_byte_RM_CL(u8 X86EMU_UNUSED(op1))
9169 {
9170     int mod, rl, rh;
9171     u8 *destreg;
9172     uint destoffset;
9173     u8 destval;
9174     u8 amt;
9175
9176     /*
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
9180      */
9181     START_OF_INSTR();
9182     FETCH_DECODE_MODRM(mod, rh, rl);
9183 #ifdef DEBUG
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. */
9189         switch (rh) {
9190         case 0:
9191             DECODE_PRINTF("ROL\t");
9192             break;
9193         case 1:
9194             DECODE_PRINTF("ROR\t");
9195             break;
9196         case 2:
9197             DECODE_PRINTF("RCL\t");
9198             break;
9199         case 3:
9200             DECODE_PRINTF("RCR\t");
9201             break;
9202         case 4:
9203             DECODE_PRINTF("SHL\t");
9204             break;
9205         case 5:
9206             DECODE_PRINTF("SHR\t");
9207             break;
9208         case 6:
9209             DECODE_PRINTF("SAL\t");
9210             break;
9211         case 7:
9212             DECODE_PRINTF("SAR\t");
9213             break;
9214         }
9215     }
9216 #endif
9217     /* know operation, decode the mod byte to find the addressing
9218        mode. */
9219     amt = M.x86.R_CL;
9220     switch (mod) {
9221     case 0:
9222         DECODE_PRINTF("BYTE PTR ");
9223         destoffset = decode_rm00_address(rl);
9224         DECODE_PRINTF(",CL\n");
9225         destval = fetch_data_byte(destoffset);
9226         TRACE_AND_STEP();
9227         destval = (*opcD0_byte_operation[rh]) (destval, amt);
9228         store_data_byte(destoffset, destval);
9229         break;
9230     case 1:
9231         DECODE_PRINTF("BYTE PTR ");
9232         destoffset = decode_rm01_address(rl);
9233         DECODE_PRINTF(",CL\n");
9234         destval = fetch_data_byte(destoffset);
9235         TRACE_AND_STEP();
9236         destval = (*opcD0_byte_operation[rh]) (destval, amt);
9237         store_data_byte(destoffset, destval);
9238         break;
9239     case 2:
9240         DECODE_PRINTF("BYTE PTR ");
9241         destoffset = decode_rm10_address(rl);
9242         DECODE_PRINTF(",CL\n");
9243         destval = fetch_data_byte(destoffset);
9244         TRACE_AND_STEP();
9245         destval = (*opcD0_byte_operation[rh]) (destval, amt);
9246         store_data_byte(destoffset, destval);
9247         break;
9248     case 3:                     /* register to register */
9249         destreg = DECODE_RM_BYTE_REGISTER(rl);
9250         DECODE_PRINTF(",CL\n");
9251         TRACE_AND_STEP();
9252         destval = (*opcD0_byte_operation[rh]) (*destreg, amt);
9253         *destreg = destval;
9254         break;
9255     }
9256     DECODE_CLEAR_SEGOVR();
9257     END_OF_INSTR();
9258 }
9259
9260 /****************************************************************************
9261 REMARKS:
9262 Handles opcode 0xd3
9263 ****************************************************************************/
9264 static void x86emuOp_opcD3_word_RM_CL(u8 X86EMU_UNUSED(op1))
9265 {
9266     int mod, rl, rh;
9267     uint destoffset;
9268     u8 amt;
9269
9270     /*
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
9274      */
9275     START_OF_INSTR();
9276     FETCH_DECODE_MODRM(mod, rh, rl);
9277 #ifdef DEBUG
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. */
9283         switch (rh) {
9284         case 0:
9285             DECODE_PRINTF("ROL\t");
9286             break;
9287         case 1:
9288             DECODE_PRINTF("ROR\t");
9289             break;
9290         case 2:
9291             DECODE_PRINTF("RCL\t");
9292             break;
9293         case 3:
9294             DECODE_PRINTF("RCR\t");
9295             break;
9296         case 4:
9297             DECODE_PRINTF("SHL\t");
9298             break;
9299         case 5:
9300             DECODE_PRINTF("SHR\t");
9301             break;
9302         case 6:
9303             DECODE_PRINTF("SAL\t");
9304             break;
9305         case 7:
9306             DECODE_PRINTF("SAR\t");
9307             break;
9308         }
9309     }
9310 #endif
9311     /* know operation, decode the mod byte to find the addressing
9312        mode. */
9313     amt = M.x86.R_CL;
9314     switch (mod) {
9315     case 0:
9316         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
9317             u32 destval;
9318
9319             DECODE_PRINTF("DWORD PTR ");
9320             destoffset = decode_rm00_address(rl);
9321             DECODE_PRINTF(",CL\n");
9322             destval = fetch_data_long(destoffset);
9323             TRACE_AND_STEP();
9324             destval = (*opcD1_long_operation[rh]) (destval, amt);
9325             store_data_long(destoffset, destval);
9326         } else {
9327             u16 destval;
9328
9329             DECODE_PRINTF("WORD PTR ");
9330             destoffset = decode_rm00_address(rl);
9331             DECODE_PRINTF(",CL\n");
9332             destval = fetch_data_word(destoffset);
9333             TRACE_AND_STEP();
9334             destval = (*opcD1_word_operation[rh]) (destval, amt);
9335             store_data_word(destoffset, destval);
9336         }
9337         break;
9338     case 1:
9339         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
9340             u32 destval;
9341
9342             DECODE_PRINTF("DWORD PTR ");
9343             destoffset = decode_rm01_address(rl);
9344             DECODE_PRINTF(",CL\n");
9345             destval = fetch_data_long(destoffset);
9346             TRACE_AND_STEP();
9347             destval = (*opcD1_long_operation[rh]) (destval, amt);
9348             store_data_long(destoffset, destval);
9349         } else {
9350             u16 destval;
9351
9352             DECODE_PRINTF("WORD PTR ");
9353             destoffset = decode_rm01_address(rl);
9354             DECODE_PRINTF(",CL\n");
9355             destval = fetch_data_word(destoffset);
9356             TRACE_AND_STEP();
9357             destval = (*opcD1_word_operation[rh]) (destval, amt);
9358             store_data_word(destoffset, destval);
9359         }
9360         break;
9361     case 2:
9362         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
9363             u32 destval;
9364
9365             DECODE_PRINTF("DWORD PTR ");
9366             destoffset = decode_rm10_address(rl);
9367             DECODE_PRINTF(",CL\n");
9368             destval = fetch_data_long(destoffset);
9369             TRACE_AND_STEP();
9370             destval = (*opcD1_long_operation[rh]) (destval, amt);
9371             store_data_long(destoffset, destval);
9372         } else {
9373             u16 destval;
9374
9375             DECODE_PRINTF("WORD PTR ");
9376             destoffset = decode_rm10_address(rl);
9377             DECODE_PRINTF(",CL\n");
9378             destval = fetch_data_word(destoffset);
9379             TRACE_AND_STEP();
9380             destval = (*opcD1_word_operation[rh]) (destval, amt);
9381             store_data_word(destoffset, destval);
9382         }
9383         break;
9384     case 3:                     /* register to register */
9385         if (M.x86.mode & SYSMODE_PREFIX_DATA) {
9386             u32 *destreg;
9387
9388             destreg = DECODE_RM_LONG_REGISTER(rl);
9389             DECODE_PRINTF(",CL\n");
9390             TRACE_AND_STEP();
9391             *destreg = (*opcD1_long_operation[rh]) (*destreg, amt);
9392         } else {
9393             u16 *destreg;
9394
9395             destreg = DECODE_RM_WORD_REGISTER(rl);
9396             DECODE_PRINTF(",CL\n");
9397             TRACE_AND_STEP();
9398             *destreg = (*opcD1_word_operation[rh]) (*destreg, amt);
9399         }
9400         break;
9401     }
9402     DECODE_CLEAR_SEGOVR();
9403     END_OF_INSTR();
9404 }
9405
9406 /****************************************************************************
9407 REMARKS:
9408 Handles opcode 0xd4
9409 ****************************************************************************/
9410 static void x86emuOp_aam(u8 X86EMU_UNUSED(op1))
9411 {
9412     u8 a;
9413
9414     START_OF_INSTR();
9415     DECODE_PRINTF("AAM\n");
9416     a = fetch_byte_imm();      /* this is a stupid encoding. */
9417     if (a != 10) {
9418         /* fix: add base decoding
9419            aam_word(u8 val, int base a) */
9420         DECODE_PRINTF("ERROR DECODING AAM\n");
9421         TRACE_REGS();
9422         HALT_SYS();
9423     }
9424     TRACE_AND_STEP();
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();
9428     END_OF_INSTR();
9429 }
9430
9431 /****************************************************************************
9432 REMARKS:
9433 Handles opcode 0xd5
9434 ****************************************************************************/
9435 static void x86emuOp_aad(u8 X86EMU_UNUSED(op1))
9436 {
9437     u8 a;
9438
9439     START_OF_INSTR();
9440     DECODE_PRINTF("AAD\n");
9441     a = fetch_byte_imm();
9442     if (a != 10) {
9443         /* fix: add base decoding
9444            aad_word(u16 val, int base a) */
9445         DECODE_PRINTF("ERROR DECODING AAM\n");
9446         TRACE_REGS();
9447         HALT_SYS();
9448     }
9449     TRACE_AND_STEP();
9450     M.x86.R_AX = aad_word(M.x86.R_AX);
9451     DECODE_CLEAR_SEGOVR();
9452     END_OF_INSTR();
9453 }
9454
9455 /* opcode 0xd6 ILLEGAL OPCODE */
9456
9457 /****************************************************************************
9458 REMARKS:
9459 Handles opcode 0xd7
9460 ****************************************************************************/
9461 static void x86emuOp_xlat(u8 X86EMU_UNUSED(op1))
9462 {
9463     u16 addr;
9464
9465     START_OF_INSTR();
9466     DECODE_PRINTF("XLAT\n");
9467     TRACE_AND_STEP();
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();
9471     END_OF_INSTR();
9472 }
9473
9474 /* instuctions  D8 .. DF are in i87_ops.c */
9475
9476 /****************************************************************************
9477 REMARKS:
9478 Handles opcode 0xe0
9479 ****************************************************************************/
9480 static void x86emuOp_loopne(u8 X86EMU_UNUSED(op1))
9481 {
9482     s16 ip;
9483
9484     START_OF_INSTR();
9485     DECODE_PRINTF("LOOPNE\t");
9486     ip = (s8) fetch_byte_imm();
9487     ip += (s16) M.x86.R_IP;
9488     DECODE_PRINTF2("%04x\n", ip);
9489     TRACE_AND_STEP();
9490     M.x86.R_CX -= 1;
9491     if (M.x86.R_CX != 0 && !ACCESS_FLAG(F_ZF))      /* CX != 0 and !ZF */
9492         M.x86.R_IP = ip;
9493     DECODE_CLEAR_SEGOVR();
9494     END_OF_INSTR();
9495 }
9496
9497 /****************************************************************************
9498 REMARKS:
9499 Handles opcode 0xe1
9500 ****************************************************************************/
9501 static void x86emuOp_loope(u8 X86EMU_UNUSED(op1))
9502 {
9503     s16 ip;
9504
9505     START_OF_INSTR();
9506     DECODE_PRINTF("LOOPE\t");
9507     ip = (s8) fetch_byte_imm();
9508     ip += (s16) M.x86.R_IP;
9509     DECODE_PRINTF2("%04x\n", ip);
9510     TRACE_AND_STEP();
9511     M.x86.R_CX -= 1;
9512     if (M.x86.R_CX != 0 && ACCESS_FLAG(F_ZF))       /* CX != 0 and ZF */
9513         M.x86.R_IP = ip;
9514     DECODE_CLEAR_SEGOVR();
9515     END_OF_INSTR();
9516 }
9517
9518 /****************************************************************************
9519 REMARKS:
9520 Handles opcode 0xe2
9521 ****************************************************************************/
9522 static void x86emuOp_loop(u8 X86EMU_UNUSED(op1))
9523 {
9524     s16 ip;
9525
9526     START_OF_INSTR();
9527     DECODE_PRINTF("LOOP\t");
9528     ip = (s8) fetch_byte_imm();
9529     ip += (s16) M.x86.R_IP;
9530     DECODE_PRINTF2("%04x\n", ip);
9531     TRACE_AND_STEP();
9532     M.x86.R_CX -= 1;
9533     if (M.x86.R_CX != 0)
9534         M.x86.R_IP = ip;
9535     DECODE_CLEAR_SEGOVR();
9536     END_OF_INSTR();
9537 }
9538
9539 /****************************************************************************
9540 REMARKS:
9541 Handles opcode 0xe3
9542 ****************************************************************************/
9543 static void x86emuOp_jcxz(u8 X86EMU_UNUSED(op1))
9544 {
9545     u16 target;
9546     s8  offset;
9547
9548     /* jump to byte offset if overflow flag is set */
9549     START_OF_INSTR();
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);
9554     TRACE_AND_STEP();
9555     if (M.x86.R_CX == 0)
9556         M.x86.R_IP = target;
9557     DECODE_CLEAR_SEGOVR();
9558     END_OF_INSTR();
9559 }
9560
9561 /****************************************************************************
9562 REMARKS:
9563 Handles opcode 0xe4
9564 ****************************************************************************/
9565 static void x86emuOp_in_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
9566 {
9567     u8 port;
9568
9569     START_OF_INSTR();
9570     DECODE_PRINTF("IN\t");
9571         port = (u8) fetch_byte_imm();
9572     DECODE_PRINTF2("%x,AL\n", port);
9573     TRACE_AND_STEP();
9574     M.x86.R_AL = (*sys_inb)(port);
9575     DECODE_CLEAR_SEGOVR();
9576     END_OF_INSTR();
9577 }
9578
9579 /****************************************************************************
9580 REMARKS:
9581 Handles opcode 0xe5
9582 ****************************************************************************/
9583 static void x86emuOp_in_word_AX_IMM(u8 X86EMU_UNUSED(op1))
9584 {
9585     u8 port;
9586
9587     START_OF_INSTR();
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);
9592     } else {
9593         DECODE_PRINTF2("AX,%x\n", port);
9594     }
9595     TRACE_AND_STEP();
9596     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
9597         M.x86.R_EAX = (*sys_inl)(port);
9598     } else {
9599         M.x86.R_AX = (*sys_inw)(port);
9600     }
9601     DECODE_CLEAR_SEGOVR();
9602     END_OF_INSTR();
9603 }
9604
9605 /****************************************************************************
9606 REMARKS:
9607 Handles opcode 0xe6
9608 ****************************************************************************/
9609 static void x86emuOp_out_byte_IMM_AL(u8 X86EMU_UNUSED(op1))
9610 {
9611     u8 port;
9612
9613     START_OF_INSTR();
9614     DECODE_PRINTF("OUT\t");
9615         port = (u8) fetch_byte_imm();
9616     DECODE_PRINTF2("%x,AL\n", port);
9617     TRACE_AND_STEP();
9618     (*sys_outb)(port, M.x86.R_AL);
9619     DECODE_CLEAR_SEGOVR();
9620     END_OF_INSTR();
9621 }
9622
9623 /****************************************************************************
9624 REMARKS:
9625 Handles opcode 0xe7
9626 ****************************************************************************/
9627 static void x86emuOp_out_word_IMM_AX(u8 X86EMU_UNUSED(op1))
9628 {
9629     u8 port;
9630
9631     START_OF_INSTR();
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);
9636     } else {
9637         DECODE_PRINTF2("%x,AX\n", port);
9638     }
9639     TRACE_AND_STEP();
9640     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
9641         (*sys_outl)(port, M.x86.R_EAX);
9642     } else {
9643         (*sys_outw)(port, M.x86.R_AX);
9644     }
9645     DECODE_CLEAR_SEGOVR();
9646     END_OF_INSTR();
9647 }
9648
9649 /****************************************************************************
9650 REMARKS:
9651 Handles opcode 0xe8
9652 ****************************************************************************/
9653 static void x86emuOp_call_near_IMM(u8 X86EMU_UNUSED(op1))
9654 {
9655     s16 ip;
9656
9657     START_OF_INSTR();
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, "");
9663     TRACE_AND_STEP();
9664     push_word(M.x86.R_IP);
9665     M.x86.R_IP = ip;
9666     DECODE_CLEAR_SEGOVR();
9667     END_OF_INSTR();
9668 }
9669
9670 /****************************************************************************
9671 REMARKS:
9672 Handles opcode 0xe9
9673 ****************************************************************************/
9674 static void x86emuOp_jump_near_IMM(u8 X86EMU_UNUSED(op1))
9675 {
9676     int ip;
9677
9678     START_OF_INSTR();
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);
9683     TRACE_AND_STEP();
9684     M.x86.R_IP = (u16)ip;
9685     DECODE_CLEAR_SEGOVR();
9686     END_OF_INSTR();
9687 }
9688
9689 /****************************************************************************
9690 REMARKS:
9691 Handles opcode 0xea
9692 ****************************************************************************/
9693 static void x86emuOp_jump_far_IMM(u8 X86EMU_UNUSED(op1))
9694 {
9695     u16 cs, ip;
9696
9697     START_OF_INSTR();
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);
9703     TRACE_AND_STEP();
9704     M.x86.R_IP = ip;
9705     M.x86.R_CS = cs;
9706     DECODE_CLEAR_SEGOVR();
9707     END_OF_INSTR();
9708 }
9709
9710 /****************************************************************************
9711 REMARKS:
9712 Handles opcode 0xeb
9713 ****************************************************************************/
9714 static void x86emuOp_jump_byte_IMM(u8 X86EMU_UNUSED(op1))
9715 {
9716     u16 target;
9717     s8 offset;
9718
9719     START_OF_INSTR();
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);
9724     TRACE_AND_STEP();
9725     M.x86.R_IP = target;
9726     DECODE_CLEAR_SEGOVR();
9727     END_OF_INSTR();
9728 }
9729
9730 /****************************************************************************
9731 REMARKS:
9732 Handles opcode 0xec
9733 ****************************************************************************/
9734 static void x86emuOp_in_byte_AL_DX(u8 X86EMU_UNUSED(op1))
9735 {
9736     START_OF_INSTR();
9737     DECODE_PRINTF("IN\tAL,DX\n");
9738     TRACE_AND_STEP();
9739     M.x86.R_AL = (*sys_inb)(M.x86.R_DX);
9740     DECODE_CLEAR_SEGOVR();
9741     END_OF_INSTR();
9742 }
9743
9744 /****************************************************************************
9745 REMARKS:
9746 Handles opcode 0xed
9747 ****************************************************************************/
9748 static void x86emuOp_in_word_AX_DX(u8 X86EMU_UNUSED(op1))
9749 {
9750     START_OF_INSTR();
9751     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
9752         DECODE_PRINTF("IN\tEAX,DX\n");
9753     } else {
9754         DECODE_PRINTF("IN\tAX,DX\n");
9755     }
9756     TRACE_AND_STEP();
9757     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
9758         M.x86.R_EAX = (*sys_inl)(M.x86.R_DX);
9759     } else {
9760         M.x86.R_AX = (*sys_inw)(M.x86.R_DX);
9761     }
9762     DECODE_CLEAR_SEGOVR();
9763     END_OF_INSTR();
9764 }
9765
9766 /****************************************************************************
9767 REMARKS:
9768 Handles opcode 0xee
9769 ****************************************************************************/
9770 static void x86emuOp_out_byte_DX_AL(u8 X86EMU_UNUSED(op1))
9771 {
9772     START_OF_INSTR();
9773     DECODE_PRINTF("OUT\tDX,AL\n");
9774     TRACE_AND_STEP();
9775     (*sys_outb)(M.x86.R_DX, M.x86.R_AL);
9776     DECODE_CLEAR_SEGOVR();
9777     END_OF_INSTR();
9778 }
9779
9780 /****************************************************************************
9781 REMARKS:
9782 Handles opcode 0xef
9783 ****************************************************************************/
9784 static void x86emuOp_out_word_DX_AX(u8 X86EMU_UNUSED(op1))
9785 {
9786     START_OF_INSTR();
9787     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
9788         DECODE_PRINTF("OUT\tDX,EAX\n");
9789     } else {
9790         DECODE_PRINTF("OUT\tDX,AX\n");
9791     }
9792     TRACE_AND_STEP();
9793     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
9794         (*sys_outl)(M.x86.R_DX, M.x86.R_EAX);
9795     } else {
9796         (*sys_outw)(M.x86.R_DX, M.x86.R_AX);
9797     }
9798     DECODE_CLEAR_SEGOVR();
9799     END_OF_INSTR();
9800 }
9801
9802 /****************************************************************************
9803 REMARKS:
9804 Handles opcode 0xf0
9805 ****************************************************************************/
9806 static void x86emuOp_lock(u8 X86EMU_UNUSED(op1))
9807 {
9808     START_OF_INSTR();
9809     DECODE_PRINTF("LOCK:\n");
9810     TRACE_AND_STEP();
9811     DECODE_CLEAR_SEGOVR();
9812     END_OF_INSTR();
9813 }
9814
9815 /*opcode 0xf1 ILLEGAL OPERATION */
9816
9817 /****************************************************************************
9818 REMARKS:
9819 Handles opcode 0xf2
9820 ****************************************************************************/
9821 static void x86emuOp_repne(u8 X86EMU_UNUSED(op1))
9822 {
9823     START_OF_INSTR();
9824     DECODE_PRINTF("REPNE\n");
9825     TRACE_AND_STEP();
9826     M.x86.mode |= SYSMODE_PREFIX_REPNE;
9827     DECODE_CLEAR_SEGOVR();
9828     END_OF_INSTR();
9829 }
9830
9831 /****************************************************************************
9832 REMARKS:
9833 Handles opcode 0xf3
9834 ****************************************************************************/
9835 static void x86emuOp_repe(u8 X86EMU_UNUSED(op1))
9836 {
9837     START_OF_INSTR();
9838     DECODE_PRINTF("REPE\n");
9839     TRACE_AND_STEP();
9840     M.x86.mode |= SYSMODE_PREFIX_REPE;
9841     DECODE_CLEAR_SEGOVR();
9842     END_OF_INSTR();
9843 }
9844
9845 /****************************************************************************
9846 REMARKS:
9847 Handles opcode 0xf4
9848 ****************************************************************************/
9849 static void x86emuOp_halt(u8 X86EMU_UNUSED(op1))
9850 {
9851     START_OF_INSTR();
9852     DECODE_PRINTF("HALT\n");
9853     TRACE_AND_STEP();
9854     HALT_SYS();
9855     DECODE_CLEAR_SEGOVR();
9856     END_OF_INSTR();
9857 }
9858
9859 /****************************************************************************
9860 REMARKS:
9861 Handles opcode 0xf5
9862 ****************************************************************************/
9863 static void x86emuOp_cmc(u8 X86EMU_UNUSED(op1))
9864 {
9865     /* complement the carry flag. */
9866     START_OF_INSTR();
9867     DECODE_PRINTF("CMC\n");
9868     TRACE_AND_STEP();
9869     TOGGLE_FLAG(F_CF);
9870     DECODE_CLEAR_SEGOVR();
9871     END_OF_INSTR();
9872 }
9873
9874 /****************************************************************************
9875 REMARKS:
9876 Handles opcode 0xf6
9877 ****************************************************************************/
9878 static void x86emuOp_opcF6_byte_RM(u8 X86EMU_UNUSED(op1))
9879 {
9880     int mod, rl, rh;
9881     u8 *destreg;
9882     uint destoffset;
9883     u8 destval, srcval;
9884
9885     /* long, drawn out code follows.  Double switch for a total
9886        of 32 cases.  */
9887     START_OF_INSTR();
9888     FETCH_DECODE_MODRM(mod, rh, rl);
9889     switch (mod) {
9890     case 0:                     /* mod=00 */
9891         switch (rh) {
9892         case 0:         /* test byte imm */
9893             DECODE_PRINTF("TEST\tBYTE PTR ");
9894             destoffset = decode_rm00_address(rl);
9895             DECODE_PRINTF(",");
9896             srcval = fetch_byte_imm();
9897             DECODE_PRINTF2("%02x\n", srcval);
9898             destval = fetch_data_byte(destoffset);
9899             TRACE_AND_STEP();
9900             test_byte(destval, srcval);
9901             break;
9902         case 1:
9903             DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F6\n");
9904             HALT_SYS();
9905             break;
9906         case 2:
9907             DECODE_PRINTF("NOT\tBYTE PTR ");
9908             destoffset = decode_rm00_address(rl);
9909             DECODE_PRINTF("\n");
9910             destval = fetch_data_byte(destoffset);
9911             TRACE_AND_STEP();
9912             destval = not_byte(destval);
9913             store_data_byte(destoffset, destval);
9914             break;
9915         case 3:
9916             DECODE_PRINTF("NEG\tBYTE PTR ");
9917             destoffset = decode_rm00_address(rl);
9918             DECODE_PRINTF("\n");
9919             destval = fetch_data_byte(destoffset);
9920             TRACE_AND_STEP();
9921             destval = neg_byte(destval);
9922             store_data_byte(destoffset, destval);
9923             break;
9924         case 4:
9925             DECODE_PRINTF("MUL\tBYTE PTR ");
9926             destoffset = decode_rm00_address(rl);
9927             DECODE_PRINTF("\n");
9928             destval = fetch_data_byte(destoffset);
9929             TRACE_AND_STEP();
9930             mul_byte(destval);
9931             break;
9932         case 5:
9933             DECODE_PRINTF("IMUL\tBYTE PTR ");
9934             destoffset = decode_rm00_address(rl);
9935             DECODE_PRINTF("\n");
9936             destval = fetch_data_byte(destoffset);
9937             TRACE_AND_STEP();
9938             imul_byte(destval);
9939             break;
9940         case 6:
9941             DECODE_PRINTF("DIV\tBYTE PTR ");
9942             destoffset = decode_rm00_address(rl);
9943             DECODE_PRINTF("\n");
9944             destval = fetch_data_byte(destoffset);
9945             TRACE_AND_STEP();
9946             div_byte(destval);
9947             break;
9948         case 7:
9949             DECODE_PRINTF("IDIV\tBYTE PTR ");
9950             destoffset = decode_rm00_address(rl);
9951             DECODE_PRINTF("\n");
9952             destval = fetch_data_byte(destoffset);
9953             TRACE_AND_STEP();
9954             idiv_byte(destval);
9955             break;
9956         }
9957         break;                  /* end mod==00 */
9958     case 1:                     /* mod=01 */
9959         switch (rh) {
9960         case 0:         /* test byte imm */
9961             DECODE_PRINTF("TEST\tBYTE PTR ");
9962             destoffset = decode_rm01_address(rl);
9963             DECODE_PRINTF(",");
9964             srcval = fetch_byte_imm();
9965             DECODE_PRINTF2("%02x\n", srcval);
9966             destval = fetch_data_byte(destoffset);
9967             TRACE_AND_STEP();
9968             test_byte(destval, srcval);
9969             break;
9970         case 1:
9971             DECODE_PRINTF("ILLEGAL OP MOD=01 RH=01 OP=F6\n");
9972             HALT_SYS();
9973             break;
9974         case 2:
9975             DECODE_PRINTF("NOT\tBYTE PTR ");
9976             destoffset = decode_rm01_address(rl);
9977             DECODE_PRINTF("\n");
9978             destval = fetch_data_byte(destoffset);
9979             TRACE_AND_STEP();
9980             destval = not_byte(destval);
9981             store_data_byte(destoffset, destval);
9982             break;
9983         case 3:
9984             DECODE_PRINTF("NEG\tBYTE PTR ");
9985             destoffset = decode_rm01_address(rl);
9986             DECODE_PRINTF("\n");
9987             destval = fetch_data_byte(destoffset);
9988             TRACE_AND_STEP();
9989             destval = neg_byte(destval);
9990             store_data_byte(destoffset, destval);
9991             break;
9992         case 4:
9993             DECODE_PRINTF("MUL\tBYTE PTR ");
9994             destoffset = decode_rm01_address(rl);
9995             DECODE_PRINTF("\n");
9996             destval = fetch_data_byte(destoffset);
9997             TRACE_AND_STEP();
9998             mul_byte(destval);
9999             break;
10000         case 5:
10001             DECODE_PRINTF("IMUL\tBYTE PTR ");
10002             destoffset = decode_rm01_address(rl);
10003             DECODE_PRINTF("\n");
10004             destval = fetch_data_byte(destoffset);
10005             TRACE_AND_STEP();
10006             imul_byte(destval);
10007             break;
10008         case 6:
10009             DECODE_PRINTF("DIV\tBYTE PTR ");
10010             destoffset = decode_rm01_address(rl);
10011             DECODE_PRINTF("\n");
10012             destval = fetch_data_byte(destoffset);
10013             TRACE_AND_STEP();
10014             div_byte(destval);
10015             break;
10016         case 7:
10017             DECODE_PRINTF("IDIV\tBYTE PTR ");
10018             destoffset = decode_rm01_address(rl);
10019             DECODE_PRINTF("\n");
10020             destval = fetch_data_byte(destoffset);
10021             TRACE_AND_STEP();
10022             idiv_byte(destval);
10023             break;
10024         }
10025         break;                  /* end mod==01 */
10026     case 2:                     /* mod=10 */
10027         switch (rh) {
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);
10035             TRACE_AND_STEP();
10036             test_byte(destval, srcval);
10037             break;
10038         case 1:
10039             DECODE_PRINTF("ILLEGAL OP MOD=10 RH=01 OP=F6\n");
10040             HALT_SYS();
10041             break;
10042         case 2:
10043             DECODE_PRINTF("NOT\tBYTE PTR ");
10044             destoffset = decode_rm10_address(rl);
10045             DECODE_PRINTF("\n");
10046             destval = fetch_data_byte(destoffset);
10047             TRACE_AND_STEP();
10048             destval = not_byte(destval);
10049             store_data_byte(destoffset, destval);
10050             break;
10051         case 3:
10052             DECODE_PRINTF("NEG\tBYTE PTR ");
10053             destoffset = decode_rm10_address(rl);
10054             DECODE_PRINTF("\n");
10055             destval = fetch_data_byte(destoffset);
10056             TRACE_AND_STEP();
10057             destval = neg_byte(destval);
10058             store_data_byte(destoffset, destval);
10059             break;
10060         case 4:
10061             DECODE_PRINTF("MUL\tBYTE PTR ");
10062             destoffset = decode_rm10_address(rl);
10063             DECODE_PRINTF("\n");
10064             destval = fetch_data_byte(destoffset);
10065             TRACE_AND_STEP();
10066             mul_byte(destval);
10067             break;
10068         case 5:
10069             DECODE_PRINTF("IMUL\tBYTE PTR ");
10070             destoffset = decode_rm10_address(rl);
10071             DECODE_PRINTF("\n");
10072             destval = fetch_data_byte(destoffset);
10073             TRACE_AND_STEP();
10074             imul_byte(destval);
10075             break;
10076         case 6:
10077             DECODE_PRINTF("DIV\tBYTE PTR ");
10078             destoffset = decode_rm10_address(rl);
10079             DECODE_PRINTF("\n");
10080             destval = fetch_data_byte(destoffset);
10081             TRACE_AND_STEP();
10082             div_byte(destval);
10083             break;
10084         case 7:
10085             DECODE_PRINTF("IDIV\tBYTE PTR ");
10086             destoffset = decode_rm10_address(rl);
10087             DECODE_PRINTF("\n");
10088             destval = fetch_data_byte(destoffset);
10089             TRACE_AND_STEP();
10090             idiv_byte(destval);
10091             break;
10092         }
10093         break;                  /* end mod==10 */
10094     case 3:                     /* mod=11 */
10095         switch (rh) {
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);
10102             TRACE_AND_STEP();
10103             test_byte(*destreg, srcval);
10104             break;
10105         case 1:
10106             DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F6\n");
10107             HALT_SYS();
10108             break;
10109         case 2:
10110             DECODE_PRINTF("NOT\t");
10111             destreg = DECODE_RM_BYTE_REGISTER(rl);
10112             DECODE_PRINTF("\n");
10113             TRACE_AND_STEP();
10114             *destreg = not_byte(*destreg);
10115             break;
10116         case 3:
10117             DECODE_PRINTF("NEG\t");
10118             destreg = DECODE_RM_BYTE_REGISTER(rl);
10119             DECODE_PRINTF("\n");
10120             TRACE_AND_STEP();
10121             *destreg = neg_byte(*destreg);
10122             break;
10123         case 4:
10124             DECODE_PRINTF("MUL\t");
10125             destreg = DECODE_RM_BYTE_REGISTER(rl);
10126             DECODE_PRINTF("\n");
10127             TRACE_AND_STEP();
10128             mul_byte(*destreg);      /*!!!  */
10129             break;
10130         case 5:
10131             DECODE_PRINTF("IMUL\t");
10132             destreg = DECODE_RM_BYTE_REGISTER(rl);
10133             DECODE_PRINTF("\n");
10134             TRACE_AND_STEP();
10135             imul_byte(*destreg);
10136             break;
10137         case 6:
10138             DECODE_PRINTF("DIV\t");
10139             destreg = DECODE_RM_BYTE_REGISTER(rl);
10140             DECODE_PRINTF("\n");
10141             TRACE_AND_STEP();
10142             div_byte(*destreg);
10143             break;
10144         case 7:
10145             DECODE_PRINTF("IDIV\t");
10146             destreg = DECODE_RM_BYTE_REGISTER(rl);
10147             DECODE_PRINTF("\n");
10148             TRACE_AND_STEP();
10149             idiv_byte(*destreg);
10150             break;
10151         }
10152         break;                  /* end mod==11 */
10153     }
10154     DECODE_CLEAR_SEGOVR();
10155     END_OF_INSTR();
10156 }
10157
10158 /****************************************************************************
10159 REMARKS:
10160 Handles opcode 0xf7
10161 ****************************************************************************/
10162 static void x86emuOp_opcF7_word_RM(u8 X86EMU_UNUSED(op1))
10163 {
10164     int mod, rl, rh;
10165     uint destoffset;
10166
10167     /* long, drawn out code follows.  Double switch for a total
10168        of 32 cases.  */
10169     START_OF_INSTR();
10170     FETCH_DECODE_MODRM(mod, rh, rl);
10171     switch (mod) {
10172     case 0:                     /* mod=00 */
10173         switch (rh) {
10174         case 0:         /* test word imm */
10175             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10176                 u32 destval,srcval;
10177
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);
10184                 TRACE_AND_STEP();
10185                 test_long(destval, srcval);
10186             } else {
10187                 u16 destval,srcval;
10188
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);
10195                 TRACE_AND_STEP();
10196                 test_word(destval, srcval);
10197             }
10198             break;
10199         case 1:
10200             DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F7\n");
10201             HALT_SYS();
10202             break;
10203         case 2:
10204             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10205                 u32 destval;
10206
10207                 DECODE_PRINTF("NOT\tDWORD PTR ");
10208                 destoffset = decode_rm00_address(rl);
10209                 DECODE_PRINTF("\n");
10210                 destval = fetch_data_long(destoffset);
10211                 TRACE_AND_STEP();
10212                 destval = not_long(destval);
10213                 store_data_long(destoffset, destval);
10214             } else {
10215                 u16 destval;
10216
10217                 DECODE_PRINTF("NOT\tWORD PTR ");
10218                 destoffset = decode_rm00_address(rl);
10219                 DECODE_PRINTF("\n");
10220                 destval = fetch_data_word(destoffset);
10221                 TRACE_AND_STEP();
10222                 destval = not_word(destval);
10223                 store_data_word(destoffset, destval);
10224             }
10225             break;
10226         case 3:
10227             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10228                 u32 destval;
10229
10230                 DECODE_PRINTF("NEG\tDWORD PTR ");
10231                 destoffset = decode_rm00_address(rl);
10232                 DECODE_PRINTF("\n");
10233                 destval = fetch_data_long(destoffset);
10234                 TRACE_AND_STEP();
10235                 destval = neg_long(destval);
10236                 store_data_long(destoffset, destval);
10237             } else {
10238                 u16 destval;
10239
10240                 DECODE_PRINTF("NEG\tWORD PTR ");
10241                 destoffset = decode_rm00_address(rl);
10242                 DECODE_PRINTF("\n");
10243                 destval = fetch_data_word(destoffset);
10244                 TRACE_AND_STEP();
10245                 destval = neg_word(destval);
10246                 store_data_word(destoffset, destval);
10247             }
10248             break;
10249         case 4:
10250             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10251                 u32 destval;
10252
10253                 DECODE_PRINTF("MUL\tDWORD PTR ");
10254                 destoffset = decode_rm00_address(rl);
10255                 DECODE_PRINTF("\n");
10256                 destval = fetch_data_long(destoffset);
10257                 TRACE_AND_STEP();
10258                 mul_long(destval);
10259             } else {
10260                 u16 destval;
10261
10262                 DECODE_PRINTF("MUL\tWORD PTR ");
10263                 destoffset = decode_rm00_address(rl);
10264                 DECODE_PRINTF("\n");
10265                 destval = fetch_data_word(destoffset);
10266                 TRACE_AND_STEP();
10267                 mul_word(destval);
10268             }
10269             break;
10270         case 5:
10271             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10272                 u32 destval;
10273
10274                 DECODE_PRINTF("IMUL\tDWORD PTR ");
10275                 destoffset = decode_rm00_address(rl);
10276                 DECODE_PRINTF("\n");
10277                 destval = fetch_data_long(destoffset);
10278                 TRACE_AND_STEP();
10279                 imul_long(destval);
10280             } else {
10281                 u16 destval;
10282
10283                 DECODE_PRINTF("IMUL\tWORD PTR ");
10284                 destoffset = decode_rm00_address(rl);
10285                 DECODE_PRINTF("\n");
10286                 destval = fetch_data_word(destoffset);
10287                 TRACE_AND_STEP();
10288                 imul_word(destval);
10289             }
10290             break;
10291         case 6:
10292             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10293                 u32 destval;
10294
10295                 DECODE_PRINTF("DIV\tDWORD PTR ");
10296                 destoffset = decode_rm00_address(rl);
10297                 DECODE_PRINTF("\n");
10298                 destval = fetch_data_long(destoffset);
10299                 TRACE_AND_STEP();
10300                 div_long(destval);
10301             } else {
10302                 u16 destval;
10303
10304                 DECODE_PRINTF("DIV\tWORD PTR ");
10305                 destoffset = decode_rm00_address(rl);
10306                 DECODE_PRINTF("\n");
10307                 destval = fetch_data_word(destoffset);
10308                 TRACE_AND_STEP();
10309                 div_word(destval);
10310             }
10311             break;
10312         case 7:
10313             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10314                 u32 destval;
10315
10316                 DECODE_PRINTF("IDIV\tDWORD PTR ");
10317                 destoffset = decode_rm00_address(rl);
10318                 DECODE_PRINTF("\n");
10319                 destval = fetch_data_long(destoffset);
10320                 TRACE_AND_STEP();
10321                 idiv_long(destval);
10322             } else {
10323                 u16 destval;
10324
10325                 DECODE_PRINTF("IDIV\tWORD PTR ");
10326                 destoffset = decode_rm00_address(rl);
10327                 DECODE_PRINTF("\n");
10328                 destval = fetch_data_word(destoffset);
10329                 TRACE_AND_STEP();
10330                 idiv_word(destval);
10331             }
10332             break;
10333         }
10334         break;                  /* end mod==00 */
10335     case 1:                     /* mod=01 */
10336         switch (rh) {
10337         case 0:         /* test word imm */
10338             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10339                 u32 destval,srcval;
10340
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);
10347                 TRACE_AND_STEP();
10348                 test_long(destval, srcval);
10349             } else {
10350                 u16 destval,srcval;
10351
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);
10358                 TRACE_AND_STEP();
10359                 test_word(destval, srcval);
10360             }
10361             break;
10362         case 1:
10363             DECODE_PRINTF("ILLEGAL OP MOD=01 RH=01 OP=F6\n");
10364             HALT_SYS();
10365             break;
10366         case 2:
10367             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10368                 u32 destval;
10369
10370                 DECODE_PRINTF("NOT\tDWORD PTR ");
10371                 destoffset = decode_rm01_address(rl);
10372                 DECODE_PRINTF("\n");
10373                 destval = fetch_data_long(destoffset);
10374                 TRACE_AND_STEP();
10375                 destval = not_long(destval);
10376                 store_data_long(destoffset, destval);
10377             } else {
10378                 u16 destval;
10379
10380                 DECODE_PRINTF("NOT\tWORD PTR ");
10381                 destoffset = decode_rm01_address(rl);
10382                 DECODE_PRINTF("\n");
10383                 destval = fetch_data_word(destoffset);
10384                 TRACE_AND_STEP();
10385                 destval = not_word(destval);
10386                 store_data_word(destoffset, destval);
10387             }
10388             break;
10389         case 3:
10390             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10391                 u32 destval;
10392
10393                 DECODE_PRINTF("NEG\tDWORD PTR ");
10394                 destoffset = decode_rm01_address(rl);
10395                 DECODE_PRINTF("\n");
10396                 destval = fetch_data_long(destoffset);
10397                 TRACE_AND_STEP();
10398                 destval = neg_long(destval);
10399                 store_data_long(destoffset, destval);
10400             } else {
10401                 u16 destval;
10402
10403                 DECODE_PRINTF("NEG\tWORD PTR ");
10404                 destoffset = decode_rm01_address(rl);
10405                 DECODE_PRINTF("\n");
10406                 destval = fetch_data_word(destoffset);
10407                 TRACE_AND_STEP();
10408                 destval = neg_word(destval);
10409                 store_data_word(destoffset, destval);
10410             }
10411             break;
10412         case 4:
10413             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10414                 u32 destval;
10415
10416                 DECODE_PRINTF("MUL\tDWORD PTR ");
10417                 destoffset = decode_rm01_address(rl);
10418                 DECODE_PRINTF("\n");
10419                 destval = fetch_data_long(destoffset);
10420                 TRACE_AND_STEP();
10421                 mul_long(destval);
10422             } else {
10423                 u16 destval;
10424
10425                 DECODE_PRINTF("MUL\tWORD PTR ");
10426                 destoffset = decode_rm01_address(rl);
10427                 DECODE_PRINTF("\n");
10428                 destval = fetch_data_word(destoffset);
10429                 TRACE_AND_STEP();
10430                 mul_word(destval);
10431             }
10432             break;
10433         case 5:
10434             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10435                 u32 destval;
10436
10437                 DECODE_PRINTF("IMUL\tDWORD PTR ");
10438                 destoffset = decode_rm01_address(rl);
10439                 DECODE_PRINTF("\n");
10440                 destval = fetch_data_long(destoffset);
10441                 TRACE_AND_STEP();
10442                 imul_long(destval);
10443             } else {
10444                 u16 destval;
10445
10446                 DECODE_PRINTF("IMUL\tWORD PTR ");
10447                 destoffset = decode_rm01_address(rl);
10448                 DECODE_PRINTF("\n");
10449                 destval = fetch_data_word(destoffset);
10450                 TRACE_AND_STEP();
10451                 imul_word(destval);
10452             }
10453             break;
10454         case 6:
10455             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10456                 u32 destval;
10457
10458                 DECODE_PRINTF("DIV\tDWORD PTR ");
10459                 destoffset = decode_rm01_address(rl);
10460                 DECODE_PRINTF("\n");
10461                 destval = fetch_data_long(destoffset);
10462                 TRACE_AND_STEP();
10463                 div_long(destval);
10464             } else {
10465                 u16 destval;
10466
10467                 DECODE_PRINTF("DIV\tWORD PTR ");
10468                 destoffset = decode_rm01_address(rl);
10469                 DECODE_PRINTF("\n");
10470                 destval = fetch_data_word(destoffset);
10471                 TRACE_AND_STEP();
10472                 div_word(destval);
10473             }
10474             break;
10475         case 7:
10476             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10477                 u32 destval;
10478
10479                 DECODE_PRINTF("IDIV\tDWORD PTR ");
10480                 destoffset = decode_rm01_address(rl);
10481                 DECODE_PRINTF("\n");
10482                 destval = fetch_data_long(destoffset);
10483                 TRACE_AND_STEP();
10484                 idiv_long(destval);
10485             } else {
10486                 u16 destval;
10487
10488                 DECODE_PRINTF("IDIV\tWORD PTR ");
10489                 destoffset = decode_rm01_address(rl);
10490                 DECODE_PRINTF("\n");
10491                 destval = fetch_data_word(destoffset);
10492                 TRACE_AND_STEP();
10493                 idiv_word(destval);
10494             }
10495             break;
10496         }
10497         break;                  /* end mod==01 */
10498     case 2:                     /* mod=10 */
10499         switch (rh) {
10500         case 0:         /* test word imm */
10501             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10502                 u32 destval,srcval;
10503
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);
10510                 TRACE_AND_STEP();
10511                 test_long(destval, srcval);
10512             } else {
10513                 u16 destval,srcval;
10514
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);
10521                 TRACE_AND_STEP();
10522                 test_word(destval, srcval);
10523             }
10524             break;
10525         case 1:
10526             DECODE_PRINTF("ILLEGAL OP MOD=10 RH=01 OP=F6\n");
10527             HALT_SYS();
10528             break;
10529         case 2:
10530             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10531                 u32 destval;
10532
10533                 DECODE_PRINTF("NOT\tDWORD PTR ");
10534                 destoffset = decode_rm10_address(rl);
10535                 DECODE_PRINTF("\n");
10536                 destval = fetch_data_long(destoffset);
10537                 TRACE_AND_STEP();
10538                 destval = not_long(destval);
10539                 store_data_long(destoffset, destval);
10540             } else {
10541                 u16 destval;
10542
10543                 DECODE_PRINTF("NOT\tWORD PTR ");
10544                 destoffset = decode_rm10_address(rl);
10545                 DECODE_PRINTF("\n");
10546                 destval = fetch_data_word(destoffset);
10547                 TRACE_AND_STEP();
10548                 destval = not_word(destval);
10549                 store_data_word(destoffset, destval);
10550             }
10551             break;
10552         case 3:
10553             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10554                 u32 destval;
10555
10556                 DECODE_PRINTF("NEG\tDWORD PTR ");
10557                 destoffset = decode_rm10_address(rl);
10558                 DECODE_PRINTF("\n");
10559                 destval = fetch_data_long(destoffset);
10560                 TRACE_AND_STEP();
10561                 destval = neg_long(destval);
10562                 store_data_long(destoffset, destval);
10563             } else {
10564                 u16 destval;
10565
10566                 DECODE_PRINTF("NEG\tWORD PTR ");
10567                 destoffset = decode_rm10_address(rl);
10568                 DECODE_PRINTF("\n");
10569                 destval = fetch_data_word(destoffset);
10570                 TRACE_AND_STEP();
10571                 destval = neg_word(destval);
10572                 store_data_word(destoffset, destval);
10573             }
10574             break;
10575         case 4:
10576             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10577                 u32 destval;
10578
10579                 DECODE_PRINTF("MUL\tDWORD PTR ");
10580                 destoffset = decode_rm10_address(rl);
10581                 DECODE_PRINTF("\n");
10582                 destval = fetch_data_long(destoffset);
10583                 TRACE_AND_STEP();
10584                 mul_long(destval);
10585             } else {
10586                 u16 destval;
10587
10588                 DECODE_PRINTF("MUL\tWORD PTR ");
10589                 destoffset = decode_rm10_address(rl);
10590                 DECODE_PRINTF("\n");
10591                 destval = fetch_data_word(destoffset);
10592                 TRACE_AND_STEP();
10593                 mul_word(destval);
10594             }
10595             break;
10596         case 5:
10597             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10598                 u32 destval;
10599
10600                 DECODE_PRINTF("IMUL\tDWORD PTR ");
10601                 destoffset = decode_rm10_address(rl);
10602                 DECODE_PRINTF("\n");
10603                 destval = fetch_data_long(destoffset);
10604                 TRACE_AND_STEP();
10605                 imul_long(destval);
10606             } else {
10607                 u16 destval;
10608
10609                 DECODE_PRINTF("IMUL\tWORD PTR ");
10610                 destoffset = decode_rm10_address(rl);
10611                 DECODE_PRINTF("\n");
10612                 destval = fetch_data_word(destoffset);
10613                 TRACE_AND_STEP();
10614                 imul_word(destval);
10615             }
10616             break;
10617         case 6:
10618             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10619                 u32 destval;
10620
10621                 DECODE_PRINTF("DIV\tDWORD PTR ");
10622                 destoffset = decode_rm10_address(rl);
10623                 DECODE_PRINTF("\n");
10624                 destval = fetch_data_long(destoffset);
10625                 TRACE_AND_STEP();
10626                 div_long(destval);
10627             } else {
10628                 u16 destval;
10629
10630                 DECODE_PRINTF("DIV\tWORD PTR ");
10631                 destoffset = decode_rm10_address(rl);
10632                 DECODE_PRINTF("\n");
10633                 destval = fetch_data_word(destoffset);
10634                 TRACE_AND_STEP();
10635                 div_word(destval);
10636             }
10637             break;
10638         case 7:
10639             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10640                 u32 destval;
10641
10642                 DECODE_PRINTF("IDIV\tDWORD PTR ");
10643                 destoffset = decode_rm10_address(rl);
10644                 DECODE_PRINTF("\n");
10645                 destval = fetch_data_long(destoffset);
10646                 TRACE_AND_STEP();
10647                 idiv_long(destval);
10648             } else {
10649                 u16 destval;
10650
10651                 DECODE_PRINTF("IDIV\tWORD PTR ");
10652                 destoffset = decode_rm10_address(rl);
10653                 DECODE_PRINTF("\n");
10654                 destval = fetch_data_word(destoffset);
10655                 TRACE_AND_STEP();
10656                 idiv_word(destval);
10657             }
10658             break;
10659         }
10660         break;                  /* end mod==10 */
10661     case 3:                     /* mod=11 */
10662         switch (rh) {
10663         case 0:         /* test word imm */
10664             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10665                 u32 *destreg;
10666                 u32 srcval;
10667
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);
10673                 TRACE_AND_STEP();
10674                 test_long(*destreg, srcval);
10675             } else {
10676                 u16 *destreg;
10677                 u16 srcval;
10678
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);
10684                 TRACE_AND_STEP();
10685                 test_word(*destreg, srcval);
10686             }
10687             break;
10688         case 1:
10689             DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F6\n");
10690             HALT_SYS();
10691             break;
10692         case 2:
10693             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10694                 u32 *destreg;
10695
10696                 DECODE_PRINTF("NOT\t");
10697                 destreg = DECODE_RM_LONG_REGISTER(rl);
10698                 DECODE_PRINTF("\n");
10699                 TRACE_AND_STEP();
10700                 *destreg = not_long(*destreg);
10701             } else {
10702                 u16 *destreg;
10703
10704                 DECODE_PRINTF("NOT\t");
10705                 destreg = DECODE_RM_WORD_REGISTER(rl);
10706                 DECODE_PRINTF("\n");
10707                 TRACE_AND_STEP();
10708                 *destreg = not_word(*destreg);
10709             }
10710             break;
10711         case 3:
10712             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10713                 u32 *destreg;
10714
10715                 DECODE_PRINTF("NEG\t");
10716                 destreg = DECODE_RM_LONG_REGISTER(rl);
10717                 DECODE_PRINTF("\n");
10718                 TRACE_AND_STEP();
10719                 *destreg = neg_long(*destreg);
10720             } else {
10721                 u16 *destreg;
10722
10723                 DECODE_PRINTF("NEG\t");
10724                 destreg = DECODE_RM_WORD_REGISTER(rl);
10725                 DECODE_PRINTF("\n");
10726                 TRACE_AND_STEP();
10727                 *destreg = neg_word(*destreg);
10728             }
10729             break;
10730         case 4:
10731             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10732                 u32 *destreg;
10733
10734                 DECODE_PRINTF("MUL\t");
10735                 destreg = DECODE_RM_LONG_REGISTER(rl);
10736                 DECODE_PRINTF("\n");
10737                 TRACE_AND_STEP();
10738                 mul_long(*destreg);      /*!!!  */
10739             } else {
10740                 u16 *destreg;
10741
10742                 DECODE_PRINTF("MUL\t");
10743                 destreg = DECODE_RM_WORD_REGISTER(rl);
10744                 DECODE_PRINTF("\n");
10745                 TRACE_AND_STEP();
10746                 mul_word(*destreg);      /*!!!  */
10747             }
10748             break;
10749         case 5:
10750             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10751                 u32 *destreg;
10752
10753                 DECODE_PRINTF("IMUL\t");
10754                 destreg = DECODE_RM_LONG_REGISTER(rl);
10755                 DECODE_PRINTF("\n");
10756                 TRACE_AND_STEP();
10757                 imul_long(*destreg);
10758             } else {
10759                 u16 *destreg;
10760
10761                 DECODE_PRINTF("IMUL\t");
10762                 destreg = DECODE_RM_WORD_REGISTER(rl);
10763                 DECODE_PRINTF("\n");
10764                 TRACE_AND_STEP();
10765                 imul_word(*destreg);
10766             }
10767             break;
10768         case 6:
10769             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10770                 u32 *destreg;
10771
10772                 DECODE_PRINTF("DIV\t");
10773                 destreg = DECODE_RM_LONG_REGISTER(rl);
10774                 DECODE_PRINTF("\n");
10775                 TRACE_AND_STEP();
10776                 div_long(*destreg);
10777             } else {
10778                 u16 *destreg;
10779
10780                 DECODE_PRINTF("DIV\t");
10781                 destreg = DECODE_RM_WORD_REGISTER(rl);
10782                 DECODE_PRINTF("\n");
10783                 TRACE_AND_STEP();
10784                 div_word(*destreg);
10785             }
10786             break;
10787         case 7:
10788             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
10789                 u32 *destreg;
10790
10791                 DECODE_PRINTF("IDIV\t");
10792                 destreg = DECODE_RM_LONG_REGISTER(rl);
10793                 DECODE_PRINTF("\n");
10794                 TRACE_AND_STEP();
10795                 idiv_long(*destreg);
10796             } else {
10797                 u16 *destreg;
10798
10799                 DECODE_PRINTF("IDIV\t");
10800                 destreg = DECODE_RM_WORD_REGISTER(rl);
10801                 DECODE_PRINTF("\n");
10802                 TRACE_AND_STEP();
10803                 idiv_word(*destreg);
10804             }
10805             break;
10806         }
10807         break;                  /* end mod==11 */
10808     }
10809     DECODE_CLEAR_SEGOVR();
10810     END_OF_INSTR();
10811 }
10812
10813 /****************************************************************************
10814 REMARKS:
10815 Handles opcode 0xf8
10816 ****************************************************************************/
10817 static void x86emuOp_clc(u8 X86EMU_UNUSED(op1))
10818 {
10819     /* clear the carry flag. */
10820     START_OF_INSTR();
10821     DECODE_PRINTF("CLC\n");
10822     TRACE_AND_STEP();
10823     CLEAR_FLAG(F_CF);
10824     DECODE_CLEAR_SEGOVR();
10825     END_OF_INSTR();
10826 }
10827
10828 /****************************************************************************
10829 REMARKS:
10830 Handles opcode 0xf9
10831 ****************************************************************************/
10832 static void x86emuOp_stc(u8 X86EMU_UNUSED(op1))
10833 {
10834     /* set the carry flag. */
10835     START_OF_INSTR();
10836     DECODE_PRINTF("STC\n");
10837     TRACE_AND_STEP();
10838     SET_FLAG(F_CF);
10839     DECODE_CLEAR_SEGOVR();
10840     END_OF_INSTR();
10841 }
10842
10843 /****************************************************************************
10844 REMARKS:
10845 Handles opcode 0xfa
10846 ****************************************************************************/
10847 static void x86emuOp_cli(u8 X86EMU_UNUSED(op1))
10848 {
10849     /* clear interrupts. */
10850     START_OF_INSTR();
10851     DECODE_PRINTF("CLI\n");
10852     TRACE_AND_STEP();
10853     CLEAR_FLAG(F_IF);
10854     DECODE_CLEAR_SEGOVR();
10855     END_OF_INSTR();
10856 }
10857
10858 /****************************************************************************
10859 REMARKS:
10860 Handles opcode 0xfb
10861 ****************************************************************************/
10862 static void x86emuOp_sti(u8 X86EMU_UNUSED(op1))
10863 {
10864     /* enable  interrupts. */
10865     START_OF_INSTR();
10866     DECODE_PRINTF("STI\n");
10867     TRACE_AND_STEP();
10868     SET_FLAG(F_IF);
10869     DECODE_CLEAR_SEGOVR();
10870     END_OF_INSTR();
10871 }
10872
10873 /****************************************************************************
10874 REMARKS:
10875 Handles opcode 0xfc
10876 ****************************************************************************/
10877 static void x86emuOp_cld(u8 X86EMU_UNUSED(op1))
10878 {
10879     /* clear interrupts. */
10880     START_OF_INSTR();
10881     DECODE_PRINTF("CLD\n");
10882     TRACE_AND_STEP();
10883     CLEAR_FLAG(F_DF);
10884     DECODE_CLEAR_SEGOVR();
10885     END_OF_INSTR();
10886 }
10887
10888 /****************************************************************************
10889 REMARKS:
10890 Handles opcode 0xfd
10891 ****************************************************************************/
10892 static void x86emuOp_std(u8 X86EMU_UNUSED(op1))
10893 {
10894     /* clear interrupts. */
10895     START_OF_INSTR();
10896     DECODE_PRINTF("STD\n");
10897     TRACE_AND_STEP();
10898     SET_FLAG(F_DF);
10899     DECODE_CLEAR_SEGOVR();
10900     END_OF_INSTR();
10901 }
10902
10903 /****************************************************************************
10904 REMARKS:
10905 Handles opcode 0xfe
10906 ****************************************************************************/
10907 static void x86emuOp_opcFE_byte_RM(u8 X86EMU_UNUSED(op1))
10908 {
10909     int mod, rh, rl;
10910     u8 destval;
10911     uint destoffset;
10912     u8 *destreg;
10913
10914     /* Yet another special case instruction. */
10915     START_OF_INSTR();
10916     FETCH_DECODE_MODRM(mod, rh, rl);
10917 #ifdef DEBUG
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. */
10923
10924         switch (rh) {
10925         case 0:
10926             DECODE_PRINTF("INC\t");
10927             break;
10928         case 1:
10929             DECODE_PRINTF("DEC\t");
10930             break;
10931         case 2:
10932         case 3:
10933         case 4:
10934         case 5:
10935         case 6:
10936         case 7:
10937             DECODE_PRINTF2("ILLEGAL OP MAJOR OP 0xFE MINOR OP %x \n", mod);
10938             HALT_SYS();
10939             break;
10940         }
10941     }
10942 #endif
10943     switch (mod) {
10944     case 0:
10945         DECODE_PRINTF("BYTE PTR ");
10946         destoffset = decode_rm00_address(rl);
10947         DECODE_PRINTF("\n");
10948         switch (rh) {
10949         case 0:         /* inc word ptr ... */
10950             destval = fetch_data_byte(destoffset);
10951             TRACE_AND_STEP();
10952             destval = inc_byte(destval);
10953             store_data_byte(destoffset, destval);
10954             break;
10955         case 1:         /* dec word ptr ... */
10956             destval = fetch_data_byte(destoffset);
10957             TRACE_AND_STEP();
10958             destval = dec_byte(destval);
10959             store_data_byte(destoffset, destval);
10960             break;
10961         }
10962         break;
10963     case 1:
10964         DECODE_PRINTF("BYTE PTR ");
10965         destoffset = decode_rm01_address(rl);
10966         DECODE_PRINTF("\n");
10967         switch (rh) {
10968         case 0:
10969             destval = fetch_data_byte(destoffset);
10970             TRACE_AND_STEP();
10971             destval = inc_byte(destval);
10972             store_data_byte(destoffset, destval);
10973             break;
10974         case 1:
10975             destval = fetch_data_byte(destoffset);
10976             TRACE_AND_STEP();
10977             destval = dec_byte(destval);
10978             store_data_byte(destoffset, destval);
10979             break;
10980         }
10981         break;
10982     case 2:
10983         DECODE_PRINTF("BYTE PTR ");
10984         destoffset = decode_rm10_address(rl);
10985         DECODE_PRINTF("\n");
10986         switch (rh) {
10987         case 0:
10988             destval = fetch_data_byte(destoffset);
10989             TRACE_AND_STEP();
10990             destval = inc_byte(destval);
10991             store_data_byte(destoffset, destval);
10992             break;
10993         case 1:
10994             destval = fetch_data_byte(destoffset);
10995             TRACE_AND_STEP();
10996             destval = dec_byte(destval);
10997             store_data_byte(destoffset, destval);
10998             break;
10999         }
11000         break;
11001     case 3:
11002         destreg = DECODE_RM_BYTE_REGISTER(rl);
11003         DECODE_PRINTF("\n");
11004         switch (rh) {
11005         case 0:
11006             TRACE_AND_STEP();
11007             *destreg = inc_byte(*destreg);
11008             break;
11009         case 1:
11010             TRACE_AND_STEP();
11011             *destreg = dec_byte(*destreg);
11012             break;
11013         }
11014         break;
11015     }
11016     DECODE_CLEAR_SEGOVR();
11017     END_OF_INSTR();
11018 }
11019
11020 /****************************************************************************
11021 REMARKS:
11022 Handles opcode 0xff
11023 ****************************************************************************/
11024 static void x86emuOp_opcFF_word_RM(u8 X86EMU_UNUSED(op1))
11025 {
11026     int mod, rh, rl;
11027     uint destoffset = 0;
11028         u16 *destreg;
11029         u16 destval,destval2;
11030
11031     /* Yet another special case instruction. */
11032     START_OF_INSTR();
11033     FETCH_DECODE_MODRM(mod, rh, rl);
11034 #ifdef DEBUG
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. */
11040
11041         switch (rh) {
11042         case 0:
11043             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
11044                 DECODE_PRINTF("INC\tDWORD PTR ");
11045             } else {
11046                 DECODE_PRINTF("INC\tWORD PTR ");
11047             }
11048             break;
11049         case 1:
11050             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
11051                 DECODE_PRINTF("DEC\tDWORD PTR ");
11052             } else {
11053                 DECODE_PRINTF("DEC\tWORD PTR ");
11054             }
11055             break;
11056         case 2:
11057             DECODE_PRINTF("CALL\t");
11058             break;
11059         case 3:
11060             DECODE_PRINTF("CALL\tFAR ");
11061             break;
11062         case 4:
11063             DECODE_PRINTF("JMP\t");
11064             break;
11065         case 5:
11066             DECODE_PRINTF("JMP\tFAR ");
11067             break;
11068         case 6:
11069             DECODE_PRINTF("PUSH\t");
11070             break;
11071         case 7:
11072             DECODE_PRINTF("ILLEGAL DECODING OF OPCODE FF\t");
11073             HALT_SYS();
11074             break;
11075         }
11076     }
11077 #endif
11078     switch (mod) {
11079     case 0:
11080         destoffset = decode_rm00_address(rl);
11081         DECODE_PRINTF("\n");
11082         switch (rh) {
11083         case 0:         /* inc word ptr ... */
11084             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
11085                 u32 destval;
11086
11087                 destval = fetch_data_long(destoffset);
11088                 TRACE_AND_STEP();
11089                 destval = inc_long(destval);
11090                 store_data_long(destoffset, destval);
11091             } else {
11092                 u16 destval;
11093
11094                 destval = fetch_data_word(destoffset);
11095                 TRACE_AND_STEP();
11096                 destval = inc_word(destval);
11097                 store_data_word(destoffset, destval);
11098             }
11099             break;
11100         case 1:         /* dec word ptr ... */
11101             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
11102                 u32 destval;
11103
11104                 destval = fetch_data_long(destoffset);
11105                 TRACE_AND_STEP();
11106                 destval = dec_long(destval);
11107                 store_data_long(destoffset, destval);
11108             } else {
11109                 u16 destval;
11110
11111                 destval = fetch_data_word(destoffset);
11112                 TRACE_AND_STEP();
11113                 destval = dec_word(destval);
11114                 store_data_word(destoffset, destval);
11115             }
11116             break;
11117         case 2:         /* call word ptr ... */
11118             destval = fetch_data_word(destoffset);
11119             TRACE_AND_STEP();
11120             push_word(M.x86.R_IP);
11121             M.x86.R_IP = destval;
11122             break;
11123         case 3:         /* call far ptr ... */
11124             destval = fetch_data_word(destoffset);
11125             destval2 = fetch_data_word(destoffset + 2);
11126             TRACE_AND_STEP();
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;
11131             break;
11132         case 4:         /* jmp word ptr ... */
11133             destval = fetch_data_word(destoffset);
11134             TRACE_AND_STEP();
11135             M.x86.R_IP = destval;
11136             break;
11137         case 5:         /* jmp far ptr ... */
11138             destval = fetch_data_word(destoffset);
11139             destval2 = fetch_data_word(destoffset + 2);
11140             TRACE_AND_STEP();
11141             M.x86.R_IP = destval;
11142             M.x86.R_CS = destval2;
11143             break;
11144         case 6:         /*  push word ptr ... */
11145             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
11146                 u32 destval;
11147
11148                 destval = fetch_data_long(destoffset);
11149                 TRACE_AND_STEP();
11150                 push_long(destval);
11151             } else {
11152                 u16 destval;
11153
11154                 destval = fetch_data_word(destoffset);
11155                 TRACE_AND_STEP();
11156                 push_word(destval);
11157             }
11158             break;
11159         }
11160         break;
11161     case 1:
11162         destoffset = decode_rm01_address(rl);
11163         DECODE_PRINTF("\n");
11164         switch (rh) {
11165         case 0:
11166             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
11167                 u32 destval;
11168
11169                 destval = fetch_data_long(destoffset);
11170                 TRACE_AND_STEP();
11171                 destval = inc_long(destval);
11172                 store_data_long(destoffset, destval);
11173             } else {
11174                 u16 destval;
11175
11176                 destval = fetch_data_word(destoffset);
11177                 TRACE_AND_STEP();
11178                 destval = inc_word(destval);
11179                 store_data_word(destoffset, destval);
11180             }
11181             break;
11182         case 1:
11183             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
11184                 u32 destval;
11185
11186                 destval = fetch_data_long(destoffset);
11187                 TRACE_AND_STEP();
11188                 destval = dec_long(destval);
11189                 store_data_long(destoffset, destval);
11190             } else {
11191                 u16 destval;
11192
11193                 destval = fetch_data_word(destoffset);
11194                 TRACE_AND_STEP();
11195                 destval = dec_word(destval);
11196                 store_data_word(destoffset, destval);
11197             }
11198             break;
11199         case 2:         /* call word ptr ... */
11200             destval = fetch_data_word(destoffset);
11201             TRACE_AND_STEP();
11202             push_word(M.x86.R_IP);
11203             M.x86.R_IP = destval;
11204             break;
11205         case 3:         /* call far ptr ... */
11206             destval = fetch_data_word(destoffset);
11207             destval2 = fetch_data_word(destoffset + 2);
11208             TRACE_AND_STEP();
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;
11213             break;
11214         case 4:         /* jmp word ptr ... */
11215             destval = fetch_data_word(destoffset);
11216             TRACE_AND_STEP();
11217             M.x86.R_IP = destval;
11218             break;
11219         case 5:         /* jmp far ptr ... */
11220             destval = fetch_data_word(destoffset);
11221             destval2 = fetch_data_word(destoffset + 2);
11222             TRACE_AND_STEP();
11223             M.x86.R_IP = destval;
11224             M.x86.R_CS = destval2;
11225             break;
11226         case 6:         /*  push word ptr ... */
11227             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
11228                 u32 destval;
11229
11230                 destval = fetch_data_long(destoffset);
11231                 TRACE_AND_STEP();
11232                 push_long(destval);
11233             } else {
11234                 u16 destval;
11235
11236                 destval = fetch_data_word(destoffset);
11237                 TRACE_AND_STEP();
11238                 push_word(destval);
11239             }
11240             break;
11241         }
11242         break;
11243     case 2:
11244         destoffset = decode_rm10_address(rl);
11245         DECODE_PRINTF("\n");
11246         switch (rh) {
11247         case 0:
11248             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
11249                 u32 destval;
11250
11251                 destval = fetch_data_long(destoffset);
11252                 TRACE_AND_STEP();
11253                 destval = inc_long(destval);
11254                 store_data_long(destoffset, destval);
11255             } else {
11256                 u16 destval;
11257
11258                 destval = fetch_data_word(destoffset);
11259                 TRACE_AND_STEP();
11260                 destval = inc_word(destval);
11261                 store_data_word(destoffset, destval);
11262             }
11263             break;
11264         case 1:
11265             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
11266                 u32 destval;
11267
11268                 destval = fetch_data_long(destoffset);
11269                 TRACE_AND_STEP();
11270                 destval = dec_long(destval);
11271                 store_data_long(destoffset, destval);
11272             } else {
11273                 u16 destval;
11274
11275                 destval = fetch_data_word(destoffset);
11276                 TRACE_AND_STEP();
11277                 destval = dec_word(destval);
11278                 store_data_word(destoffset, destval);
11279             }
11280             break;
11281         case 2:         /* call word ptr ... */
11282             destval = fetch_data_word(destoffset);
11283             TRACE_AND_STEP();
11284             push_word(M.x86.R_IP);
11285             M.x86.R_IP = destval;
11286             break;
11287         case 3:         /* call far ptr ... */
11288             destval = fetch_data_word(destoffset);
11289             destval2 = fetch_data_word(destoffset + 2);
11290             TRACE_AND_STEP();
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;
11295             break;
11296         case 4:         /* jmp word ptr ... */
11297             destval = fetch_data_word(destoffset);
11298             TRACE_AND_STEP();
11299             M.x86.R_IP = destval;
11300             break;
11301         case 5:         /* jmp far ptr ... */
11302             destval = fetch_data_word(destoffset);
11303             destval2 = fetch_data_word(destoffset + 2);
11304             TRACE_AND_STEP();
11305             M.x86.R_IP = destval;
11306             M.x86.R_CS = destval2;
11307             break;
11308         case 6:         /*  push word ptr ... */
11309             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
11310                 u32 destval;
11311
11312                 destval = fetch_data_long(destoffset);
11313                 TRACE_AND_STEP();
11314                 push_long(destval);
11315             } else {
11316                 u16 destval;
11317
11318                 destval = fetch_data_word(destoffset);
11319                 TRACE_AND_STEP();
11320                 push_word(destval);
11321             }
11322             break;
11323         }
11324         break;
11325     case 3:
11326         switch (rh) {
11327         case 0:
11328             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
11329                 u32 *destreg;
11330
11331                 destreg = DECODE_RM_LONG_REGISTER(rl);
11332                 DECODE_PRINTF("\n");
11333                 TRACE_AND_STEP();
11334                 *destreg = inc_long(*destreg);
11335             } else {
11336                 u16 *destreg;
11337
11338                 destreg = DECODE_RM_WORD_REGISTER(rl);
11339                 DECODE_PRINTF("\n");
11340                 TRACE_AND_STEP();
11341                 *destreg = inc_word(*destreg);
11342             }
11343             break;
11344         case 1:
11345             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
11346                 u32 *destreg;
11347
11348                 destreg = DECODE_RM_LONG_REGISTER(rl);
11349                 DECODE_PRINTF("\n");
11350                 TRACE_AND_STEP();
11351                 *destreg = dec_long(*destreg);
11352             } else {
11353                 u16 *destreg;
11354
11355                 destreg = DECODE_RM_WORD_REGISTER(rl);
11356                 DECODE_PRINTF("\n");
11357                 TRACE_AND_STEP();
11358                 *destreg = dec_word(*destreg);
11359             }
11360             break;
11361         case 2:         /* call word ptr ... */
11362             destreg = DECODE_RM_WORD_REGISTER(rl);
11363             DECODE_PRINTF("\n");
11364             TRACE_AND_STEP();
11365             push_word(M.x86.R_IP);
11366             M.x86.R_IP = *destreg;
11367             break;
11368         case 3:         /* jmp far ptr ... */
11369             DECODE_PRINTF("OPERATION UNDEFINED 0XFF \n");
11370             TRACE_AND_STEP();
11371             HALT_SYS();
11372             break;
11373
11374         case 4:         /* jmp  ... */
11375             destreg = DECODE_RM_WORD_REGISTER(rl);
11376             DECODE_PRINTF("\n");
11377             TRACE_AND_STEP();
11378             M.x86.R_IP = (u16) (*destreg);
11379             break;
11380         case 5:         /* jmp far ptr ... */
11381             DECODE_PRINTF("OPERATION UNDEFINED 0XFF \n");
11382             TRACE_AND_STEP();
11383             HALT_SYS();
11384             break;
11385         case 6:
11386             if (M.x86.mode & SYSMODE_PREFIX_DATA) {
11387                 u32 *destreg;
11388
11389                 destreg = DECODE_RM_LONG_REGISTER(rl);
11390                 DECODE_PRINTF("\n");
11391                 TRACE_AND_STEP();
11392                 push_long(*destreg);
11393             } else {
11394                 u16 *destreg;
11395
11396                 destreg = DECODE_RM_WORD_REGISTER(rl);
11397                 DECODE_PRINTF("\n");
11398                 TRACE_AND_STEP();
11399                 push_word(*destreg);
11400             }
11401             break;
11402         }
11403         break;
11404     }
11405     DECODE_CLEAR_SEGOVR();
11406     END_OF_INSTR();
11407 }
11408
11409 /***************************************************************************
11410  * Single byte operation code table:
11411  **************************************************************************/
11412 void (*x86emu_optab[256])(u8) =
11413 {
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,
11422
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,
11431
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,
11440
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,
11449
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,
11458
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,
11467
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,
11476
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,
11485
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,
11494
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,
11503
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,
11512
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,
11521
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,
11530
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,
11539
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,
11548
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,
11557
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,
11566
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,
11575
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,
11584
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,
11593
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,
11610
11611
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,
11620
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,
11629
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,
11646
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,
11663
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,
11672
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,
11681
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,
11690
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,
11699 };