}/****************************************************************************REMARKS:Handles opcode 0x8a****************************************************************************/void x86emuOp_mov_byte_R_RM(u8 X86EMU_UNUSED(op1)){    int mod, rl, rh;    u8 *destreg, *srcreg;    uint srcoffset;    u8 srcval;    START_OF_INSTR();    DECODE_PRINTF("MOV\t");    FETCH_DECODE_MODRM(mod, rh, rl);    if (mod < 3) {	destreg = DECODE_RM_BYTE_REGISTER(rh);	DECODE_PRINTF(",");	srcoffset = decode_rmXX_address(mod, rl);	srcval = fetch_data_byte(srcoffset);	DECODE_PRINTF("\n");	TRACE_AND_STEP();	*destreg = srcval;    } else {			 /* register to register */	destreg = DECODE_RM_BYTE_REGISTER(rh);	DECODE_PRINTF(",");	srcreg = DECODE_RM_BYTE_REGISTER(rl);	DECODE_PRINTF("\n");	TRACE_AND_STEP();	*destreg = *srcreg;    }    DECODE_CLEAR_SEGOVR();    END_OF_INSTR();}/****************************************************************************REMARKS:Handles opcode 0x8b****************************************************************************/void x86emuOp_mov_word_R_RM(u8 X86EMU_UNUSED(op1)){    int mod, rl, rh;    uint srcoffset;    START_OF_INSTR();    DECODE_PRINTF("MOV\t");    FETCH_DECODE_MODRM(mod, rh, rl);    if (mod < 3) {	if (M.x86.mode & SYSMODE_PREFIX_DATA) {	    u32 *destreg;	    u32 srcval;	    destreg = DECODE_RM_LONG_REGISTER(rh);	    DECODE_PRINTF(",");	    srcoffset = decode_rmXX_address(mod, rl);	    srcval = fetch_data_long(srcoffset);	    DECODE_PRINTF("\n");	    TRACE_AND_STEP();	    *destreg = srcval;	} else {	    u16 *destreg;	    u16 srcval;	    destreg = DECODE_RM_WORD_REGISTER(rh);	    DECODE_PRINTF(",");	    srcoffset = decode_rmXX_address(mod, rl);	    srcval = fetch_data_word(srcoffset);	    DECODE_PRINTF("\n");	    TRACE_AND_STEP();	    *destreg = srcval;	}    } else {			 /* register to register */	if (M.x86.mode & SYSMODE_PREFIX_DATA) {	    u32 *destreg, *srcreg;	    destreg = DECODE_RM_LONG_REGISTER(rh);	    DECODE_PRINTF(",");	    srcreg = DECODE_RM_LONG_REGISTER(rl);	    DECODE_PRINTF("\n");	    TRACE_AND_STEP();	    *destreg = *srcreg;	} else {	    u16 *destreg, *srcreg;	    destreg = DECODE_RM_WORD_REGISTER(rh);	    DECODE_PRINTF(",");	    srcreg = DECODE_RM_WORD_REGISTER(rl);	    DECODE_PRINTF("\n");	    TRACE_AND_STEP();	    *destreg = *srcreg;	}    }    DECODE_CLEAR_SEGOVR();    END_OF_INSTR();}/****************************************************************************REMARKS:Handles opcode 0x8c****************************************************************************/void x86emuOp_mov_word_RM_SR(u8 X86EMU_UNUSED(op1)){    int mod, rl, rh;    u16 *destreg, *srcreg;    uint destoffset;    u16 destval;    START_OF_INSTR();    DECODE_PRINTF("MOV\t");    FETCH_DECODE_MODRM(mod, rh, rl);    if (mod < 3) {	destoffset = decode_rmXX_address(mod, rl);	DECODE_PRINTF(",");	srcreg = decode_rm_seg_register(rh);	DECODE_PRINTF("\n");	TRACE_AND_STEP();	destval = *srcreg;	store_data_word(destoffset, destval);    } else {			 /* register to register */	destreg = DECODE_RM_WORD_REGISTER(rl);	DECODE_PRINTF(",");	srcreg = decode_rm_seg_register(rh);	DECODE_PRINTF("\n");	TRACE_AND_STEP();	*destreg = *srcreg;    }    DECODE_CLEAR_SEGOVR();    END_OF_INSTR();}/****************************************************************************REMARKS:Handles opcode 0x8d****************************************************************************/void x86emuOp_lea_word_R_M(u8 X86EMU_UNUSED(op1)){    int mod, rl, rh;    u16 *srcreg;    uint destoffset;/* * TODO: Need to handle address size prefix! * * lea	eax,[eax+ebx*2] ?? */    START_OF_INSTR();    DECODE_PRINTF("LEA\t");    FETCH_DECODE_MODRM(mod, rh, rl);    if (mod < 3) {	srcreg = DECODE_RM_WORD_REGISTER(rh);	DECODE_PRINTF(",");	destoffset = decode_rmXX_address(mod, rl);	DECODE_PRINTF("\n");	TRACE_AND_STEP();	*srcreg = (u16)destoffset;	}    /* } else { undefined.  Do nothing. } */    DECODE_CLEAR_SEGOVR();    END_OF_INSTR();}/****************************************************************************REMARKS:Handles opcode 0x8e****************************************************************************/void x86emuOp_mov_word_SR_RM(u8 X86EMU_UNUSED(op1)){    int mod, rl, rh;    u16 *destreg, *srcreg;    uint srcoffset;    u16 srcval;    START_OF_INSTR();    DECODE_PRINTF("MOV\t");    FETCH_DECODE_MODRM(mod, rh, rl);    if (mod < 3) {	destreg = decode_rm_seg_register(rh);	DECODE_PRINTF(",");	srcoffset = decode_rmXX_address(mod, rl);	srcval = fetch_data_word(srcoffset);	DECODE_PRINTF("\n");	TRACE_AND_STEP();	*destreg = srcval;    } else {			 /* register to register */	destreg = decode_rm_seg_register(rh);	DECODE_PRINTF(",");	srcreg = DECODE_RM_WORD_REGISTER(rl);	DECODE_PRINTF("\n");	TRACE_AND_STEP();	*destreg = *srcreg;    }    /*     * Clean up, and reset all the R_xSP pointers to the correct     * locations.  This is about 3x too much overhead (doing all the     * segreg ptrs when only one is needed, but this instruction     * *cannot* be that common, and this isn't too much work anyway.     */    DECODE_CLEAR_SEGOVR();    END_OF_INSTR();}/****************************************************************************REMARKS:Handles opcode 0x8f****************************************************************************/void x86emuOp_pop_RM(u8 X86EMU_UNUSED(op1)){    int mod, rl, rh;    uint destoffset;    START_OF_INSTR();    DECODE_PRINTF("POP\t");    FETCH_DECODE_MODRM(mod, rh, rl);    if (rh != 0) {	DECODE_PRINTF("ILLEGAL DECODE OF OPCODE 8F\n");	HALT_SYS();    }    if (mod < 3) {	destoffset = decode_rmXX_address(mod, rl);	if (M.x86.mode & SYSMODE_PREFIX_DATA) {	    u32 destval;	    DECODE_PRINTF("\n");	    TRACE_AND_STEP();	    destval = pop_long();	    store_data_long(destoffset, destval);	} else {	    u16 destval;	    DECODE_PRINTF("\n");	    TRACE_AND_STEP();	    destval = pop_word();	    store_data_word(destoffset, destval);	}    } else {			/* register to register */	if (M.x86.mode & SYSMODE_PREFIX_DATA) {	    u32 *destreg;	    destreg = DECODE_RM_LONG_REGISTER(rl);	    DECODE_PRINTF("\n");	    TRACE_AND_STEP();	    *destreg = pop_long();	} else {	    u16 *destreg;	    destreg = DECODE_RM_WORD_REGISTER(rl);	    DECODE_PRINTF("\n");	    TRACE_AND_STEP();	    *destreg = pop_word();	}    }    DECODE_CLEAR_SEGOVR();    END_OF_INSTR();}/****************************************************************************REMARKS:Handles opcode 0x90****************************************************************************/void x86emuOp_nop(u8 X86EMU_UNUSED(op1)){    START_OF_INSTR();    DECODE_PRINTF("NOP\n");    TRACE_AND_STEP();    DECODE_CLEAR_SEGOVR();    END_OF_INSTR();}/****************************************************************************REMARKS:Handles opcode 0x91-0x97****************************************************************************/void x86emuOp_xchg_word_AX_register(u8 X86EMU_UNUSED(op1)){    u32 tmp;    op1 &= 0x7;    START_OF_INSTR();    if (M.x86.mode & SYSMODE_PREFIX_DATA) {	u32 *reg32;	DECODE_PRINTF("XCHG\tEAX,");	reg32 = DECODE_RM_LONG_REGISTER(op1);	DECODE_PRINTF("\n");	TRACE_AND_STEP();	tmp = M.x86.R_EAX;	M.x86.R_EAX = *reg32;	*reg32 = tmp;    } else {	u16 *reg16;	DECODE_PRINTF("XCHG\tAX,");	reg16 = DECODE_RM_WORD_REGISTER(op1);	DECODE_PRINTF("\n");	TRACE_AND_STEP();	tmp = M.x86.R_AX;	M.x86.R_EAX = *reg16;	*reg16 = (u16)tmp;    }    DECODE_CLEAR_SEGOVR();    END_OF_INSTR();}/****************************************************************************REMARKS:Handles opcode 0x98****************************************************************************/void x86emuOp_cbw(u8 X86EMU_UNUSED(op1)){    START_OF_INSTR();    if (M.x86.mode & SYSMODE_PREFIX_DATA) {	DECODE_PRINTF("CWDE\n");    } else {	DECODE_PRINTF("CBW\n");    }    TRACE_AND_STEP();    if (M.x86.mode & SYSMODE_PREFIX_DATA) {	if (M.x86.R_AX & 0x8000) {	    M.x86.R_EAX |= 0xffff0000;	} else {	    M.x86.R_EAX &= 0x0000ffff;	}    } else {	if (M.x86.R_AL & 0x80) {	    M.x86.R_AH = 0xff;	} else {	    M.x86.R_AH = 0x0;	}    }    DECODE_CLEAR_SEGOVR();    END_OF_INSTR();}/****************************************************************************REMARKS:Handles opcode 0x99****************************************************************************/void x86emuOp_cwd(u8 X86EMU_UNUSED(op1)){    START_OF_INSTR();    if (M.x86.mode & SYSMODE_PREFIX_DATA) {	DECODE_PRINTF("CDQ\n");    } else {	DECODE_PRINTF("CWD\n");    }    DECODE_PRINTF("CWD\n");    TRACE_AND_STEP();    if (M.x86.mode & SYSMODE_PREFIX_DATA) {	if (M.x86.R_EAX & 0x80000000) {	    M.x86.R_EDX = 0xffffffff;	} else {	    M.x86.R_EDX = 0x0;	}    } else {	if (M.x86.R_AX & 0x8000) {	    M.x86.R_DX = 0xffff;	} else {	    M.x86.R_DX = 0x0;	}    }    DECODE_CLEAR_SEGOVR();    END_OF_INSTR();}/****************************************************************************REMARKS:Handles opcode 0x9a****************************************************************************/void x86emuOp_call_far_IMM(u8 X86EMU_UNUSED(op1)){    u16 farseg, faroff;    START_OF_INSTR();	DECODE_PRINTF("CALL\t");	faroff = fetch_word_imm();	farseg = fetch_word_imm();	DECODE_PRINTF2("%04x:", farseg);	DECODE_PRINTF2("%04x\n", faroff);	CALL_TRACE(M.x86.saved_cs, M.x86.saved_ip, farseg, faroff, "FAR ");    /* XXX     *     * Hooked interrupt vectors calling into our "BIOS" will cause     * problems unless all intersegment stuff is checked for BIOS     * access.	Check needed here.  For moment, let it alone.     */    TRACE_AND_STEP();    push_word(M.x86.R_CS);    M.x86.R_CS = farseg;    push_word(M.x86.R_IP);    M.x86.R_IP = faroff;    DECODE_CLEAR_SEGOVR();    END_OF_INSTR();}/****************************************************************************REMARKS:Handles opcode 0x9b****************************************************************************/void x86emuOp_wait(u8 X86EMU_UNUSED(op1)){    START_OF_INSTR();    DECODE_PRINTF("WAIT");    TRACE_AND_STEP();    /* NADA.  */    DECODE_CLEAR_SEGOVR();    END_OF_INSTR();}/****************************************************************************REMARKS:Handles opcode 0x9c****************************************************************************/void x86emuOp_pushf_word(u8 X86EMU_UNUSED(op1)){    u32 flags;    START_OF_INSTR();    if (M.x86.mode & SYSMODE_PREFIX_DATA) {	DECODE_PRINTF("PUSHFD\n");    } else {	DECODE_PRINTF("PUSHF\n");    }    TRACE_AND_STEP();    /* clear out *all* bits not representing flags, and turn on real bits */    flags = (M.x86.R_EFLG & F_MSK) | F_ALWAYS_ON;    if (M.x86.mode & SYSMODE_PREFIX_DATA) {	push_long(flags);    } else {	push_word((u16)flags);    }    DECODE_CLEAR_SEGOVR();    END_OF_INSTR();}/****************************************************************************REMARKS:Handles opcode 0x9d****************************************************************************/void x86emuOp_popf_word(u8 X86EMU_UNUSED(op1)){    START_OF_INSTR();    if (M.x86.mode & SYSMODE_PREFIX_DATA) {	DECODE_PRINTF("POPFD\n");    } else {	DECODE_PRINTF("POPF\n");    }    TRACE_AND_STEP();    if (M.x86.mode & SYSMODE_PREFIX_DATA) {	M.x86.R_EFLG = pop_long();    } else {	M.x86.R_FLG = pop_word();    }    DECODE_CLEAR_SEGOVR();    END_OF_INSTR();}/****************************************************************************REMARKS:Handles opcode 0x9e****************************************************************************/void x86emuOp_sahf(u8 X86EMU_UNUSED(op1)){    START_OF_INSTR();    DECODE_PRINTF("SAHF\n");    TRACE_AND_STEP();    /* clear the lower bits of the flag register */    M.x86.R_FLG &= 0xffffff00;    /* or in the AH register into the flags register */    M.x86.R_FLG |= M.x86.R_AH;    DECODE_CLEAR_SEGOVR();    END_OF_INSTR();}/****************************************************************************REMARKS:Handles opcode 0x9f****************************************************************************/void x86emuOp_lahf(u8 X86EMU_UNUSED(op1)){    START_OF_INSTR();