REMARKS:
Handles illegal opcodes.
****************************************************************************/
-static void x86emuOp_illegal_op(
- u8 op1)
+static void
+x86emuOp_illegal_op(u8 op1)
{
START_OF_INSTR();
if (M.x86.R_SP != 0) {
- DECODE_PRINTF("ILLEGAL X86 OPCODE\n");
- TRACE_REGS();
- DB( printk("%04x:%04x: %02X ILLEGAL X86 OPCODE!\n",
- M.x86.R_CS, M.x86.R_IP-1,op1));
- HALT_SYS();
- }
+ DECODE_PRINTF("ILLEGAL X86 OPCODE\n");
+ TRACE_REGS();
+ DB(printk("%04x:%04x: %02X ILLEGAL X86 OPCODE!\n",
+ M.x86.R_CS, M.x86.R_IP - 1, op1));
+ HALT_SYS();
+ }
else {
/* If we get here, it means the stack pointer is back to zero
* so we are just returning from an emulator service call
* call.
*/
X86EMU_halt_sys();
- }
+ }
END_OF_INSTR();
}
REMARKS:
Handles opcode 0x00
****************************************************************************/
-static void x86emuOp_add_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_add_byte_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
destval = add_byte(destval, *srcreg);
store_data_byte(destoffset, destval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rl);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rh);
REMARKS:
Handles opcode 0x01
****************************************************************************/
-static void x86emuOp_add_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_add_word_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
TRACE_AND_STEP();
destval = add_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
TRACE_AND_STEP();
destval = add_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
TRACE_AND_STEP();
destval = add_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
store_data_word(destoffset, destval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rl);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = add_long(*destreg, *srcreg);
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rl);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x02
****************************************************************************/
-static void x86emuOp_add_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_add_byte_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
TRACE_AND_STEP();
*destreg = add_byte(*destreg, srcval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rh);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rl);
REMARKS:
Handles opcode 0x03
****************************************************************************/
-static void x86emuOp_add_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_add_word_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint srcoffset;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = add_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = add_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = add_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
*destreg = add_word(*destreg, srcval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rh);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = add_long(*destreg, *srcreg);
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rh);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x04
****************************************************************************/
-static void x86emuOp_add_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_add_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
{
u8 srcval;
REMARKS:
Handles opcode 0x05
****************************************************************************/
-static void x86emuOp_add_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_add_word_AX_IMM(u8 X86EMU_UNUSED(op1))
{
u32 srcval;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("ADD\tEAX,");
srcval = fetch_long_imm();
- } else {
+ }
+ else {
DECODE_PRINTF("ADD\tAX,");
srcval = fetch_word_imm();
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EAX = add_long(M.x86.R_EAX, srcval);
- } else {
- M.x86.R_AX = add_word(M.x86.R_AX, (u16)srcval);
+ }
+ else {
+ M.x86.R_AX = add_word(M.x86.R_AX, (u16) srcval);
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x06
****************************************************************************/
-static void x86emuOp_push_ES(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_push_ES(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("PUSH\tES\n");
REMARKS:
Handles opcode 0x07
****************************************************************************/
-static void x86emuOp_pop_ES(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_pop_ES(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("POP\tES\n");
REMARKS:
Handles opcode 0x08
****************************************************************************/
-static void x86emuOp_or_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_or_byte_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
destval = or_byte(destval, *srcreg);
store_data_byte(destoffset, destval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rl);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rh);
REMARKS:
Handles opcode 0x09
****************************************************************************/
-static void x86emuOp_or_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_or_word_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
TRACE_AND_STEP();
destval = or_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
TRACE_AND_STEP();
destval = or_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
TRACE_AND_STEP();
destval = or_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
store_data_word(destoffset, destval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rl);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = or_long(*destreg, *srcreg);
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rl);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x0a
****************************************************************************/
-static void x86emuOp_or_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_or_byte_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
TRACE_AND_STEP();
*destreg = or_byte(*destreg, srcval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rh);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rl);
REMARKS:
Handles opcode 0x0b
****************************************************************************/
-static void x86emuOp_or_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_or_word_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint srcoffset;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = or_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = or_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = or_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
*destreg = or_word(*destreg, srcval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rh);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = or_long(*destreg, *srcreg);
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rh);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x0c
****************************************************************************/
-static void x86emuOp_or_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_or_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
{
u8 srcval;
REMARKS:
Handles opcode 0x0d
****************************************************************************/
-static void x86emuOp_or_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_or_word_AX_IMM(u8 X86EMU_UNUSED(op1))
{
u32 srcval;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("OR\tEAX,");
srcval = fetch_long_imm();
- } else {
+ }
+ else {
DECODE_PRINTF("OR\tAX,");
srcval = fetch_word_imm();
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EAX = or_long(M.x86.R_EAX, srcval);
- } else {
- M.x86.R_AX = or_word(M.x86.R_AX, (u16)srcval);
+ }
+ else {
+ M.x86.R_AX = or_word(M.x86.R_AX, (u16) srcval);
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x0e
****************************************************************************/
-static void x86emuOp_push_CS(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_push_CS(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("PUSH\tCS\n");
REMARKS:
Handles opcode 0x0f. Escape for two-byte opcode (286 or better)
****************************************************************************/
-static void x86emuOp_two_byte(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_two_byte(u8 X86EMU_UNUSED(op1))
{
- u8 op2 = (*sys_rdb)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP++));
+ u8 op2 = (*sys_rdb) (((u32) M.x86.R_CS << 4) + (M.x86.R_IP++));
+
INC_DECODED_INST_LEN(1);
- (*x86emu_optab2[op2])(op2);
+ (*x86emu_optab2[op2]) (op2);
}
/****************************************************************************
REMARKS:
Handles opcode 0x10
****************************************************************************/
-static void x86emuOp_adc_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_adc_byte_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
destval = adc_byte(destval, *srcreg);
store_data_byte(destoffset, destval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rl);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rh);
REMARKS:
Handles opcode 0x11
****************************************************************************/
-static void x86emuOp_adc_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_adc_word_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
TRACE_AND_STEP();
destval = adc_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
TRACE_AND_STEP();
destval = adc_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
TRACE_AND_STEP();
destval = adc_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
store_data_word(destoffset, destval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rl);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = adc_long(*destreg, *srcreg);
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rl);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x12
****************************************************************************/
-static void x86emuOp_adc_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_adc_byte_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
TRACE_AND_STEP();
*destreg = adc_byte(*destreg, srcval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rh);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rl);
REMARKS:
Handles opcode 0x13
****************************************************************************/
-static void x86emuOp_adc_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_adc_word_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint srcoffset;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = adc_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = adc_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = adc_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
*destreg = adc_word(*destreg, srcval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rh);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = adc_long(*destreg, *srcreg);
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rh);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x14
****************************************************************************/
-static void x86emuOp_adc_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_adc_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
{
u8 srcval;
REMARKS:
Handles opcode 0x15
****************************************************************************/
-static void x86emuOp_adc_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_adc_word_AX_IMM(u8 X86EMU_UNUSED(op1))
{
u32 srcval;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("ADC\tEAX,");
srcval = fetch_long_imm();
- } else {
+ }
+ else {
DECODE_PRINTF("ADC\tAX,");
srcval = fetch_word_imm();
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EAX = adc_long(M.x86.R_EAX, srcval);
- } else {
- M.x86.R_AX = adc_word(M.x86.R_AX, (u16)srcval);
+ }
+ else {
+ M.x86.R_AX = adc_word(M.x86.R_AX, (u16) srcval);
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x16
****************************************************************************/
-static void x86emuOp_push_SS(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_push_SS(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("PUSH\tSS\n");
REMARKS:
Handles opcode 0x17
****************************************************************************/
-static void x86emuOp_pop_SS(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_pop_SS(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("POP\tSS\n");
REMARKS:
Handles opcode 0x18
****************************************************************************/
-static void x86emuOp_sbb_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_sbb_byte_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
destval = sbb_byte(destval, *srcreg);
store_data_byte(destoffset, destval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rl);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rh);
REMARKS:
Handles opcode 0x19
****************************************************************************/
-static void x86emuOp_sbb_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_sbb_word_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
TRACE_AND_STEP();
destval = sbb_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
TRACE_AND_STEP();
destval = sbb_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
TRACE_AND_STEP();
destval = sbb_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
store_data_word(destoffset, destval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rl);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = sbb_long(*destreg, *srcreg);
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rl);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x1a
****************************************************************************/
-static void x86emuOp_sbb_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_sbb_byte_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
TRACE_AND_STEP();
*destreg = sbb_byte(*destreg, srcval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rh);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rl);
REMARKS:
Handles opcode 0x1b
****************************************************************************/
-static void x86emuOp_sbb_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_sbb_word_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint srcoffset;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = sbb_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = sbb_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = sbb_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
*destreg = sbb_word(*destreg, srcval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rh);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = sbb_long(*destreg, *srcreg);
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rh);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x1c
****************************************************************************/
-static void x86emuOp_sbb_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_sbb_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
{
u8 srcval;
REMARKS:
Handles opcode 0x1d
****************************************************************************/
-static void x86emuOp_sbb_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_sbb_word_AX_IMM(u8 X86EMU_UNUSED(op1))
{
u32 srcval;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("SBB\tEAX,");
srcval = fetch_long_imm();
- } else {
+ }
+ else {
DECODE_PRINTF("SBB\tAX,");
srcval = fetch_word_imm();
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EAX = sbb_long(M.x86.R_EAX, srcval);
- } else {
- M.x86.R_AX = sbb_word(M.x86.R_AX, (u16)srcval);
+ }
+ else {
+ M.x86.R_AX = sbb_word(M.x86.R_AX, (u16) srcval);
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x1e
****************************************************************************/
-static void x86emuOp_push_DS(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_push_DS(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("PUSH\tDS\n");
REMARKS:
Handles opcode 0x1f
****************************************************************************/
-static void x86emuOp_pop_DS(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_pop_DS(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("POP\tDS\n");
REMARKS:
Handles opcode 0x20
****************************************************************************/
-static void x86emuOp_and_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_and_byte_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
store_data_byte(destoffset, destval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rl);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rh);
REMARKS:
Handles opcode 0x21
****************************************************************************/
-static void x86emuOp_and_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_and_word_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
TRACE_AND_STEP();
destval = and_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
TRACE_AND_STEP();
destval = and_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
TRACE_AND_STEP();
destval = and_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
store_data_word(destoffset, destval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rl);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = and_long(*destreg, *srcreg);
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rl);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x22
****************************************************************************/
-static void x86emuOp_and_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_and_byte_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
TRACE_AND_STEP();
*destreg = and_byte(*destreg, srcval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rh);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rl);
REMARKS:
Handles opcode 0x23
****************************************************************************/
-static void x86emuOp_and_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_and_word_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint srcoffset;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = and_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
TRACE_AND_STEP();
*destreg = and_long(*destreg, srcval);
break;
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = and_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
*destreg = and_word(*destreg, srcval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rh);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = and_long(*destreg, *srcreg);
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rh);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x24
****************************************************************************/
-static void x86emuOp_and_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_and_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
{
u8 srcval;
REMARKS:
Handles opcode 0x25
****************************************************************************/
-static void x86emuOp_and_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_and_word_AX_IMM(u8 X86EMU_UNUSED(op1))
{
u32 srcval;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("AND\tEAX,");
srcval = fetch_long_imm();
- } else {
+ }
+ else {
DECODE_PRINTF("AND\tAX,");
srcval = fetch_word_imm();
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EAX = and_long(M.x86.R_EAX, srcval);
- } else {
- M.x86.R_AX = and_word(M.x86.R_AX, (u16)srcval);
+ }
+ else {
+ M.x86.R_AX = and_word(M.x86.R_AX, (u16) srcval);
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x26
****************************************************************************/
-static void x86emuOp_segovr_ES(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_segovr_ES(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("ES:\n");
REMARKS:
Handles opcode 0x27
****************************************************************************/
-static void x86emuOp_daa(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_daa(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("DAA\n");
REMARKS:
Handles opcode 0x28
****************************************************************************/
-static void x86emuOp_sub_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_sub_byte_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
destval = sub_byte(destval, *srcreg);
store_data_byte(destoffset, destval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rl);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rh);
REMARKS:
Handles opcode 0x29
****************************************************************************/
-static void x86emuOp_sub_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_sub_word_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
TRACE_AND_STEP();
destval = sub_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
TRACE_AND_STEP();
destval = sub_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
TRACE_AND_STEP();
destval = sub_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
store_data_word(destoffset, destval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rl);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = sub_long(*destreg, *srcreg);
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rl);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x2a
****************************************************************************/
-static void x86emuOp_sub_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_sub_byte_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
TRACE_AND_STEP();
*destreg = sub_byte(*destreg, srcval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rh);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rl);
REMARKS:
Handles opcode 0x2b
****************************************************************************/
-static void x86emuOp_sub_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_sub_word_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint srcoffset;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = sub_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = sub_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = sub_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
*destreg = sub_word(*destreg, srcval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rh);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = sub_long(*destreg, *srcreg);
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rh);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x2c
****************************************************************************/
-static void x86emuOp_sub_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_sub_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
{
u8 srcval;
REMARKS:
Handles opcode 0x2d
****************************************************************************/
-static void x86emuOp_sub_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_sub_word_AX_IMM(u8 X86EMU_UNUSED(op1))
{
u32 srcval;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("SUB\tEAX,");
srcval = fetch_long_imm();
- } else {
+ }
+ else {
DECODE_PRINTF("SUB\tAX,");
srcval = fetch_word_imm();
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EAX = sub_long(M.x86.R_EAX, srcval);
- } else {
- M.x86.R_AX = sub_word(M.x86.R_AX, (u16)srcval);
+ }
+ else {
+ M.x86.R_AX = sub_word(M.x86.R_AX, (u16) srcval);
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x2e
****************************************************************************/
-static void x86emuOp_segovr_CS(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_segovr_CS(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("CS:\n");
REMARKS:
Handles opcode 0x2f
****************************************************************************/
-static void x86emuOp_das(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_das(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("DAS\n");
REMARKS:
Handles opcode 0x30
****************************************************************************/
-static void x86emuOp_xor_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_xor_byte_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
destval = xor_byte(destval, *srcreg);
store_data_byte(destoffset, destval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rl);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rh);
REMARKS:
Handles opcode 0x31
****************************************************************************/
-static void x86emuOp_xor_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_xor_word_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
TRACE_AND_STEP();
destval = xor_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
TRACE_AND_STEP();
destval = xor_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
TRACE_AND_STEP();
destval = xor_long(destval, *srcreg);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
store_data_word(destoffset, destval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rl);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = xor_long(*destreg, *srcreg);
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rl);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x32
****************************************************************************/
-static void x86emuOp_xor_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_xor_byte_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
TRACE_AND_STEP();
*destreg = xor_byte(*destreg, srcval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rh);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rl);
REMARKS:
Handles opcode 0x33
****************************************************************************/
-static void x86emuOp_xor_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_xor_word_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint srcoffset;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = xor_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = xor_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = xor_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
*destreg = xor_word(*destreg, srcval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rh);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = xor_long(*destreg, *srcreg);
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rh);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x34
****************************************************************************/
-static void x86emuOp_xor_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_xor_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
{
u8 srcval;
REMARKS:
Handles opcode 0x35
****************************************************************************/
-static void x86emuOp_xor_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_xor_word_AX_IMM(u8 X86EMU_UNUSED(op1))
{
u32 srcval;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("XOR\tEAX,");
srcval = fetch_long_imm();
- } else {
+ }
+ else {
DECODE_PRINTF("XOR\tAX,");
srcval = fetch_word_imm();
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EAX = xor_long(M.x86.R_EAX, srcval);
- } else {
- M.x86.R_AX = xor_word(M.x86.R_AX, (u16)srcval);
+ }
+ else {
+ M.x86.R_AX = xor_word(M.x86.R_AX, (u16) srcval);
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x36
****************************************************************************/
-static void x86emuOp_segovr_SS(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_segovr_SS(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("SS:\n");
REMARKS:
Handles opcode 0x37
****************************************************************************/
-static void x86emuOp_aaa(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_aaa(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("AAA\n");
REMARKS:
Handles opcode 0x38
****************************************************************************/
-static void x86emuOp_cmp_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_cmp_byte_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
TRACE_AND_STEP();
cmp_byte(destval, *srcreg);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rl);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rh);
REMARKS:
Handles opcode 0x39
****************************************************************************/
-static void x86emuOp_cmp_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_cmp_word_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
cmp_long(destval, *srcreg);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
cmp_long(destval, *srcreg);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
cmp_long(destval, *srcreg);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
cmp_word(destval, *srcreg);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rl);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
cmp_long(*destreg, *srcreg);
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rl);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x3a
****************************************************************************/
-static void x86emuOp_cmp_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_cmp_byte_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
TRACE_AND_STEP();
cmp_byte(*destreg, srcval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rh);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rl);
REMARKS:
Handles opcode 0x3b
****************************************************************************/
-static void x86emuOp_cmp_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_cmp_word_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint srcoffset;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
cmp_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
cmp_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
cmp_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
cmp_word(*destreg, srcval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rh);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
cmp_long(*destreg, *srcreg);
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rh);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x3c
****************************************************************************/
-static void x86emuOp_cmp_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_cmp_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
{
u8 srcval;
REMARKS:
Handles opcode 0x3d
****************************************************************************/
-static void x86emuOp_cmp_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_cmp_word_AX_IMM(u8 X86EMU_UNUSED(op1))
{
u32 srcval;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("CMP\tEAX,");
srcval = fetch_long_imm();
- } else {
+ }
+ else {
DECODE_PRINTF("CMP\tAX,");
srcval = fetch_word_imm();
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
cmp_long(M.x86.R_EAX, srcval);
- } else {
- cmp_word(M.x86.R_AX, (u16)srcval);
+ }
+ else {
+ cmp_word(M.x86.R_AX, (u16) srcval);
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x3e
****************************************************************************/
-static void x86emuOp_segovr_DS(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_segovr_DS(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("DS:\n");
REMARKS:
Handles opcode 0x3f
****************************************************************************/
-static void x86emuOp_aas(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_aas(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("AAS\n");
REMARKS:
Handles opcode 0x40
****************************************************************************/
-static void x86emuOp_inc_AX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_inc_AX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("INC\tEAX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("INC\tAX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EAX = inc_long(M.x86.R_EAX);
- } else {
+ }
+ else {
M.x86.R_AX = inc_word(M.x86.R_AX);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x41
****************************************************************************/
-static void x86emuOp_inc_CX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_inc_CX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("INC\tECX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("INC\tCX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_ECX = inc_long(M.x86.R_ECX);
- } else {
+ }
+ else {
M.x86.R_CX = inc_word(M.x86.R_CX);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x42
****************************************************************************/
-static void x86emuOp_inc_DX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_inc_DX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("INC\tEDX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("INC\tDX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EDX = inc_long(M.x86.R_EDX);
- } else {
+ }
+ else {
M.x86.R_DX = inc_word(M.x86.R_DX);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x43
****************************************************************************/
-static void x86emuOp_inc_BX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_inc_BX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("INC\tEBX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("INC\tBX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EBX = inc_long(M.x86.R_EBX);
- } else {
+ }
+ else {
M.x86.R_BX = inc_word(M.x86.R_BX);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x44
****************************************************************************/
-static void x86emuOp_inc_SP(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_inc_SP(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("INC\tESP\n");
- } else {
+ }
+ else {
DECODE_PRINTF("INC\tSP\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_ESP = inc_long(M.x86.R_ESP);
- } else {
+ }
+ else {
M.x86.R_SP = inc_word(M.x86.R_SP);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x45
****************************************************************************/
-static void x86emuOp_inc_BP(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_inc_BP(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("INC\tEBP\n");
- } else {
+ }
+ else {
DECODE_PRINTF("INC\tBP\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EBP = inc_long(M.x86.R_EBP);
- } else {
+ }
+ else {
M.x86.R_BP = inc_word(M.x86.R_BP);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x46
****************************************************************************/
-static void x86emuOp_inc_SI(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_inc_SI(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("INC\tESI\n");
- } else {
+ }
+ else {
DECODE_PRINTF("INC\tSI\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_ESI = inc_long(M.x86.R_ESI);
- } else {
+ }
+ else {
M.x86.R_SI = inc_word(M.x86.R_SI);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x47
****************************************************************************/
-static void x86emuOp_inc_DI(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_inc_DI(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("INC\tEDI\n");
- } else {
+ }
+ else {
DECODE_PRINTF("INC\tDI\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EDI = inc_long(M.x86.R_EDI);
- } else {
+ }
+ else {
M.x86.R_DI = inc_word(M.x86.R_DI);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x48
****************************************************************************/
-static void x86emuOp_dec_AX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_dec_AX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("DEC\tEAX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("DEC\tAX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EAX = dec_long(M.x86.R_EAX);
- } else {
+ }
+ else {
M.x86.R_AX = dec_word(M.x86.R_AX);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x49
****************************************************************************/
-static void x86emuOp_dec_CX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_dec_CX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("DEC\tECX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("DEC\tCX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_ECX = dec_long(M.x86.R_ECX);
- } else {
+ }
+ else {
M.x86.R_CX = dec_word(M.x86.R_CX);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x4a
****************************************************************************/
-static void x86emuOp_dec_DX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_dec_DX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("DEC\tEDX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("DEC\tDX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EDX = dec_long(M.x86.R_EDX);
- } else {
+ }
+ else {
M.x86.R_DX = dec_word(M.x86.R_DX);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x4b
****************************************************************************/
-static void x86emuOp_dec_BX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_dec_BX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("DEC\tEBX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("DEC\tBX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EBX = dec_long(M.x86.R_EBX);
- } else {
+ }
+ else {
M.x86.R_BX = dec_word(M.x86.R_BX);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x4c
****************************************************************************/
-static void x86emuOp_dec_SP(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_dec_SP(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("DEC\tESP\n");
- } else {
+ }
+ else {
DECODE_PRINTF("DEC\tSP\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_ESP = dec_long(M.x86.R_ESP);
- } else {
+ }
+ else {
M.x86.R_SP = dec_word(M.x86.R_SP);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x4d
****************************************************************************/
-static void x86emuOp_dec_BP(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_dec_BP(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("DEC\tEBP\n");
- } else {
+ }
+ else {
DECODE_PRINTF("DEC\tBP\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EBP = dec_long(M.x86.R_EBP);
- } else {
+ }
+ else {
M.x86.R_BP = dec_word(M.x86.R_BP);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x4e
****************************************************************************/
-static void x86emuOp_dec_SI(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_dec_SI(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("DEC\tESI\n");
- } else {
+ }
+ else {
DECODE_PRINTF("DEC\tSI\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_ESI = dec_long(M.x86.R_ESI);
- } else {
+ }
+ else {
M.x86.R_SI = dec_word(M.x86.R_SI);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x4f
****************************************************************************/
-static void x86emuOp_dec_DI(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_dec_DI(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("DEC\tEDI\n");
- } else {
+ }
+ else {
DECODE_PRINTF("DEC\tDI\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EDI = dec_long(M.x86.R_EDI);
- } else {
+ }
+ else {
M.x86.R_DI = dec_word(M.x86.R_DI);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x50
****************************************************************************/
-static void x86emuOp_push_AX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_push_AX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("PUSH\tEAX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("PUSH\tAX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
push_long(M.x86.R_EAX);
- } else {
+ }
+ else {
push_word(M.x86.R_AX);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x51
****************************************************************************/
-static void x86emuOp_push_CX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_push_CX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("PUSH\tECX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("PUSH\tCX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
push_long(M.x86.R_ECX);
- } else {
+ }
+ else {
push_word(M.x86.R_CX);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x52
****************************************************************************/
-static void x86emuOp_push_DX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_push_DX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("PUSH\tEDX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("PUSH\tDX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
push_long(M.x86.R_EDX);
- } else {
+ }
+ else {
push_word(M.x86.R_DX);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x53
****************************************************************************/
-static void x86emuOp_push_BX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_push_BX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("PUSH\tEBX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("PUSH\tBX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
push_long(M.x86.R_EBX);
- } else {
+ }
+ else {
push_word(M.x86.R_BX);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x54
****************************************************************************/
-static void x86emuOp_push_SP(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_push_SP(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("PUSH\tESP\n");
- } else {
+ }
+ else {
DECODE_PRINTF("PUSH\tSP\n");
}
TRACE_AND_STEP();
- /* Always push (E)SP, since we are emulating an i386 and above
- * processor. This is necessary as some BIOS'es use this to check
- * what type of processor is in the system.
- */
- if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- push_long(M.x86.R_ESP);
- } else {
- push_word((u16)(M.x86.R_SP));
+ /* Always push (E)SP, since we are emulating an i386 and above
+ * processor. This is necessary as some BIOS'es use this to check
+ * what type of processor is in the system.
+ */
+ if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+ push_long(M.x86.R_ESP);
+ }
+ else {
+ push_word((u16) (M.x86.R_SP));
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x55
****************************************************************************/
-static void x86emuOp_push_BP(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_push_BP(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("PUSH\tEBP\n");
- } else {
+ }
+ else {
DECODE_PRINTF("PUSH\tBP\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
push_long(M.x86.R_EBP);
- } else {
+ }
+ else {
push_word(M.x86.R_BP);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x56
****************************************************************************/
-static void x86emuOp_push_SI(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_push_SI(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("PUSH\tESI\n");
- } else {
+ }
+ else {
DECODE_PRINTF("PUSH\tSI\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
push_long(M.x86.R_ESI);
- } else {
+ }
+ else {
push_word(M.x86.R_SI);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x57
****************************************************************************/
-static void x86emuOp_push_DI(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_push_DI(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("PUSH\tEDI\n");
- } else {
+ }
+ else {
DECODE_PRINTF("PUSH\tDI\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
push_long(M.x86.R_EDI);
- } else {
+ }
+ else {
push_word(M.x86.R_DI);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x58
****************************************************************************/
-static void x86emuOp_pop_AX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_pop_AX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("POP\tEAX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("POP\tAX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EAX = pop_long();
- } else {
+ }
+ else {
M.x86.R_AX = pop_word();
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x59
****************************************************************************/
-static void x86emuOp_pop_CX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_pop_CX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("POP\tECX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("POP\tCX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_ECX = pop_long();
- } else {
+ }
+ else {
M.x86.R_CX = pop_word();
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x5a
****************************************************************************/
-static void x86emuOp_pop_DX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_pop_DX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("POP\tEDX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("POP\tDX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EDX = pop_long();
- } else {
+ }
+ else {
M.x86.R_DX = pop_word();
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x5b
****************************************************************************/
-static void x86emuOp_pop_BX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_pop_BX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("POP\tEBX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("POP\tBX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EBX = pop_long();
- } else {
+ }
+ else {
M.x86.R_BX = pop_word();
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x5c
****************************************************************************/
-static void x86emuOp_pop_SP(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_pop_SP(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("POP\tESP\n");
- } else {
+ }
+ else {
DECODE_PRINTF("POP\tSP\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_ESP = pop_long();
- } else {
+ }
+ else {
M.x86.R_SP = pop_word();
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x5d
****************************************************************************/
-static void x86emuOp_pop_BP(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_pop_BP(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("POP\tEBP\n");
- } else {
+ }
+ else {
DECODE_PRINTF("POP\tBP\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EBP = pop_long();
- } else {
+ }
+ else {
M.x86.R_BP = pop_word();
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x5e
****************************************************************************/
-static void x86emuOp_pop_SI(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_pop_SI(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("POP\tESI\n");
- } else {
+ }
+ else {
DECODE_PRINTF("POP\tSI\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_ESI = pop_long();
- } else {
+ }
+ else {
M.x86.R_SI = pop_word();
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x5f
****************************************************************************/
-static void x86emuOp_pop_DI(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_pop_DI(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("POP\tEDI\n");
- } else {
+ }
+ else {
DECODE_PRINTF("POP\tDI\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EDI = pop_long();
- } else {
+ }
+ else {
M.x86.R_DI = pop_word();
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x60
****************************************************************************/
-static void x86emuOp_push_all(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_push_all(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("PUSHAD\n");
- } else {
+ }
+ else {
DECODE_PRINTF("PUSHA\n");
}
TRACE_AND_STEP();
push_long(M.x86.R_EBP);
push_long(M.x86.R_ESI);
push_long(M.x86.R_EDI);
- } else {
+ }
+ else {
u16 old_sp = M.x86.R_SP;
push_word(M.x86.R_AX);
REMARKS:
Handles opcode 0x61
****************************************************************************/
-static void x86emuOp_pop_all(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_pop_all(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("POPAD\n");
- } else {
+ }
+ else {
DECODE_PRINTF("POPA\n");
}
TRACE_AND_STEP();
M.x86.R_EDI = pop_long();
M.x86.R_ESI = pop_long();
M.x86.R_EBP = pop_long();
- M.x86.R_ESP += 4; /* skip ESP */
+ M.x86.R_ESP += 4; /* skip ESP */
M.x86.R_EBX = pop_long();
M.x86.R_EDX = pop_long();
M.x86.R_ECX = pop_long();
M.x86.R_EAX = pop_long();
- } else {
+ }
+ else {
M.x86.R_DI = pop_word();
M.x86.R_SI = pop_word();
M.x86.R_BP = pop_word();
- M.x86.R_SP += 2; /* skip SP */
+ M.x86.R_SP += 2; /* skip SP */
M.x86.R_BX = pop_word();
M.x86.R_DX = pop_word();
M.x86.R_CX = pop_word();
REMARKS:
Handles opcode 0x64
****************************************************************************/
-static void x86emuOp_segovr_FS(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_segovr_FS(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("FS:\n");
REMARKS:
Handles opcode 0x65
****************************************************************************/
-static void x86emuOp_segovr_GS(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_segovr_GS(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("GS:\n");
REMARKS:
Handles opcode 0x66 - prefix for 32-bit register
****************************************************************************/
-static void x86emuOp_prefix_data(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_prefix_data(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("DATA:\n");
REMARKS:
Handles opcode 0x67 - prefix for 32-bit address
****************************************************************************/
-static void x86emuOp_prefix_addr(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_prefix_addr(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("ADDR:\n");
REMARKS:
Handles opcode 0x68
****************************************************************************/
-static void x86emuOp_push_word_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_push_word_IMM(u8 X86EMU_UNUSED(op1))
{
u32 imm;
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
imm = fetch_long_imm();
- } else {
+ }
+ else {
imm = fetch_word_imm();
}
DECODE_PRINTF2("PUSH\t%x\n", imm);
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
push_long(imm);
- } else {
- push_word((u16)imm);
+ }
+ else {
+ push_word((u16) imm);
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x69
****************************************************************************/
-static void x86emuOp_imul_word_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_imul_word_IMM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint srcoffset;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 *destreg;
u32 srcval;
- u32 res_lo,res_hi;
+ u32 res_lo, res_hi;
s32 imm;
destreg = DECODE_RM_LONG_REGISTER(rh);
srcoffset = decode_rm00_address(rl);
srcval = fetch_data_long(srcoffset);
imm = fetch_long_imm();
- DECODE_PRINTF2(",%d\n", (s32)imm);
+ DECODE_PRINTF2(",%d\n", (s32) imm);
TRACE_AND_STEP();
- imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
+ imul_long_direct(&res_lo, &res_hi, (s32) srcval, (s32) imm);
if (res_hi != 0) {
SET_FLAG(F_CF);
SET_FLAG(F_OF);
- } else {
+ }
+ else {
CLEAR_FLAG(F_CF);
CLEAR_FLAG(F_OF);
}
- *destreg = (u32)res_lo;
- } else {
+ *destreg = (u32) res_lo;
+ }
+ else {
u16 *destreg;
u16 srcval;
u32 res;
srcoffset = decode_rm00_address(rl);
srcval = fetch_data_word(srcoffset);
imm = fetch_word_imm();
- DECODE_PRINTF2(",%d\n", (s32)imm);
+ DECODE_PRINTF2(",%d\n", (s32) imm);
TRACE_AND_STEP();
- res = (s16)srcval * (s16)imm;
+ res = (s16) srcval *(s16) imm;
+
if (res > 0xFFFF) {
SET_FLAG(F_CF);
SET_FLAG(F_OF);
- } else {
+ }
+ else {
CLEAR_FLAG(F_CF);
CLEAR_FLAG(F_OF);
}
- *destreg = (u16)res;
+ *destreg = (u16) res;
}
break;
case 1:
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 *destreg;
u32 srcval;
- u32 res_lo,res_hi;
+ u32 res_lo, res_hi;
s32 imm;
destreg = DECODE_RM_LONG_REGISTER(rh);
srcoffset = decode_rm01_address(rl);
srcval = fetch_data_long(srcoffset);
imm = fetch_long_imm();
- DECODE_PRINTF2(",%d\n", (s32)imm);
+ DECODE_PRINTF2(",%d\n", (s32) imm);
TRACE_AND_STEP();
- imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
+ imul_long_direct(&res_lo, &res_hi, (s32) srcval, (s32) imm);
if (res_hi != 0) {
SET_FLAG(F_CF);
SET_FLAG(F_OF);
- } else {
+ }
+ else {
CLEAR_FLAG(F_CF);
CLEAR_FLAG(F_OF);
}
- *destreg = (u32)res_lo;
- } else {
+ *destreg = (u32) res_lo;
+ }
+ else {
u16 *destreg;
u16 srcval;
u32 res;
srcoffset = decode_rm01_address(rl);
srcval = fetch_data_word(srcoffset);
imm = fetch_word_imm();
- DECODE_PRINTF2(",%d\n", (s32)imm);
+ DECODE_PRINTF2(",%d\n", (s32) imm);
TRACE_AND_STEP();
- res = (s16)srcval * (s16)imm;
+ res = (s16) srcval *(s16) imm;
+
if (res > 0xFFFF) {
SET_FLAG(F_CF);
SET_FLAG(F_OF);
- } else {
+ }
+ else {
CLEAR_FLAG(F_CF);
CLEAR_FLAG(F_OF);
}
- *destreg = (u16)res;
+ *destreg = (u16) res;
}
break;
case 2:
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 *destreg;
u32 srcval;
- u32 res_lo,res_hi;
+ u32 res_lo, res_hi;
s32 imm;
destreg = DECODE_RM_LONG_REGISTER(rh);
srcoffset = decode_rm10_address(rl);
srcval = fetch_data_long(srcoffset);
imm = fetch_long_imm();
- DECODE_PRINTF2(",%d\n", (s32)imm);
+ DECODE_PRINTF2(",%d\n", (s32) imm);
TRACE_AND_STEP();
- imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
+ imul_long_direct(&res_lo, &res_hi, (s32) srcval, (s32) imm);
if (res_hi != 0) {
SET_FLAG(F_CF);
SET_FLAG(F_OF);
- } else {
+ }
+ else {
CLEAR_FLAG(F_CF);
CLEAR_FLAG(F_OF);
}
- *destreg = (u32)res_lo;
- } else {
+ *destreg = (u32) res_lo;
+ }
+ else {
u16 *destreg;
u16 srcval;
u32 res;
srcoffset = decode_rm10_address(rl);
srcval = fetch_data_word(srcoffset);
imm = fetch_word_imm();
- DECODE_PRINTF2(",%d\n", (s32)imm);
+ DECODE_PRINTF2(",%d\n", (s32) imm);
TRACE_AND_STEP();
- res = (s16)srcval * (s16)imm;
+ res = (s16) srcval *(s16) imm;
+
if (res > 0xFFFF) {
SET_FLAG(F_CF);
SET_FLAG(F_OF);
- } else {
+ }
+ else {
CLEAR_FLAG(F_CF);
CLEAR_FLAG(F_OF);
}
- *destreg = (u16)res;
+ *destreg = (u16) res;
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
- u32 res_lo,res_hi;
+ u32 *destreg, *srcreg;
+ u32 res_lo, res_hi;
s32 imm;
destreg = DECODE_RM_LONG_REGISTER(rh);
DECODE_PRINTF(",");
srcreg = DECODE_RM_LONG_REGISTER(rl);
imm = fetch_long_imm();
- DECODE_PRINTF2(",%d\n", (s32)imm);
+ DECODE_PRINTF2(",%d\n", (s32) imm);
TRACE_AND_STEP();
- imul_long_direct(&res_lo,&res_hi,(s32)*srcreg,(s32)imm);
+ imul_long_direct(&res_lo, &res_hi, (s32) * srcreg, (s32) imm);
if (res_hi != 0) {
SET_FLAG(F_CF);
SET_FLAG(F_OF);
- } else {
+ }
+ else {
CLEAR_FLAG(F_CF);
CLEAR_FLAG(F_OF);
}
- *destreg = (u32)res_lo;
- } else {
- u16 *destreg,*srcreg;
+ *destreg = (u32) res_lo;
+ }
+ else {
+ u16 *destreg, *srcreg;
u32 res;
s16 imm;
DECODE_PRINTF(",");
srcreg = DECODE_RM_WORD_REGISTER(rl);
imm = fetch_word_imm();
- DECODE_PRINTF2(",%d\n", (s32)imm);
- res = (s16)*srcreg * (s16)imm;
+ DECODE_PRINTF2(",%d\n", (s32) imm);
+ res = (s16) * srcreg * (s16) imm;
if (res > 0xFFFF) {
SET_FLAG(F_CF);
SET_FLAG(F_OF);
- } else {
+ }
+ else {
CLEAR_FLAG(F_CF);
CLEAR_FLAG(F_OF);
}
- *destreg = (u16)res;
+ *destreg = (u16) res;
}
break;
}
REMARKS:
Handles opcode 0x6a
****************************************************************************/
-static void x86emuOp_push_byte_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_push_byte_IMM(u8 X86EMU_UNUSED(op1))
{
s16 imm;
START_OF_INSTR();
- imm = (s8)fetch_byte_imm();
+ imm = (s8) fetch_byte_imm();
DECODE_PRINTF2("PUSH\t%d\n", imm);
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- push_long((s32)imm);
- } else {
- push_word(imm);
+ push_long((s32) imm);
+ }
+ else {
+ push_word(imm);
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x6b
****************************************************************************/
-static void x86emuOp_imul_byte_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_imul_byte_IMM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint srcoffset;
- s8 imm;
+ s8 imm;
START_OF_INSTR();
DECODE_PRINTF("IMUL\t");
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 *destreg;
u32 srcval;
- u32 res_lo,res_hi;
+ u32 res_lo, res_hi;
destreg = DECODE_RM_LONG_REGISTER(rh);
DECODE_PRINTF(",");
srcoffset = decode_rm00_address(rl);
srcval = fetch_data_long(srcoffset);
imm = fetch_byte_imm();
- DECODE_PRINTF2(",%d\n", (s32)imm);
+ DECODE_PRINTF2(",%d\n", (s32) imm);
TRACE_AND_STEP();
- imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
+ imul_long_direct(&res_lo, &res_hi, (s32) srcval, (s32) imm);
if (res_hi != 0) {
SET_FLAG(F_CF);
SET_FLAG(F_OF);
- } else {
+ }
+ else {
CLEAR_FLAG(F_CF);
CLEAR_FLAG(F_OF);
}
- *destreg = (u32)res_lo;
- } else {
+ *destreg = (u32) res_lo;
+ }
+ else {
u16 *destreg;
u16 srcval;
u32 res;
srcoffset = decode_rm00_address(rl);
srcval = fetch_data_word(srcoffset);
imm = fetch_byte_imm();
- DECODE_PRINTF2(",%d\n", (s32)imm);
+ DECODE_PRINTF2(",%d\n", (s32) imm);
TRACE_AND_STEP();
- res = (s16)srcval * (s16)imm;
+ res = (s16) srcval *(s16) imm;
+
if (res > 0xFFFF) {
SET_FLAG(F_CF);
SET_FLAG(F_OF);
- } else {
+ }
+ else {
CLEAR_FLAG(F_CF);
CLEAR_FLAG(F_OF);
}
- *destreg = (u16)res;
+ *destreg = (u16) res;
}
break;
case 1:
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 *destreg;
u32 srcval;
- u32 res_lo,res_hi;
+ u32 res_lo, res_hi;
destreg = DECODE_RM_LONG_REGISTER(rh);
DECODE_PRINTF(",");
srcoffset = decode_rm01_address(rl);
srcval = fetch_data_long(srcoffset);
imm = fetch_byte_imm();
- DECODE_PRINTF2(",%d\n", (s32)imm);
+ DECODE_PRINTF2(",%d\n", (s32) imm);
TRACE_AND_STEP();
- imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
+ imul_long_direct(&res_lo, &res_hi, (s32) srcval, (s32) imm);
if (res_hi != 0) {
SET_FLAG(F_CF);
SET_FLAG(F_OF);
- } else {
+ }
+ else {
CLEAR_FLAG(F_CF);
CLEAR_FLAG(F_OF);
}
- *destreg = (u32)res_lo;
- } else {
+ *destreg = (u32) res_lo;
+ }
+ else {
u16 *destreg;
u16 srcval;
u32 res;
srcoffset = decode_rm01_address(rl);
srcval = fetch_data_word(srcoffset);
imm = fetch_byte_imm();
- DECODE_PRINTF2(",%d\n", (s32)imm);
+ DECODE_PRINTF2(",%d\n", (s32) imm);
TRACE_AND_STEP();
- res = (s16)srcval * (s16)imm;
+ res = (s16) srcval *(s16) imm;
+
if (res > 0xFFFF) {
SET_FLAG(F_CF);
SET_FLAG(F_OF);
- } else {
+ }
+ else {
CLEAR_FLAG(F_CF);
CLEAR_FLAG(F_OF);
}
- *destreg = (u16)res;
+ *destreg = (u16) res;
}
break;
case 2:
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 *destreg;
u32 srcval;
- u32 res_lo,res_hi;
+ u32 res_lo, res_hi;
destreg = DECODE_RM_LONG_REGISTER(rh);
DECODE_PRINTF(",");
srcoffset = decode_rm10_address(rl);
srcval = fetch_data_long(srcoffset);
imm = fetch_byte_imm();
- DECODE_PRINTF2(",%d\n", (s32)imm);
+ DECODE_PRINTF2(",%d\n", (s32) imm);
TRACE_AND_STEP();
- imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
+ imul_long_direct(&res_lo, &res_hi, (s32) srcval, (s32) imm);
if (res_hi != 0) {
SET_FLAG(F_CF);
SET_FLAG(F_OF);
- } else {
+ }
+ else {
CLEAR_FLAG(F_CF);
CLEAR_FLAG(F_OF);
}
- *destreg = (u32)res_lo;
- } else {
+ *destreg = (u32) res_lo;
+ }
+ else {
u16 *destreg;
u16 srcval;
u32 res;
srcoffset = decode_rm10_address(rl);
srcval = fetch_data_word(srcoffset);
imm = fetch_byte_imm();
- DECODE_PRINTF2(",%d\n", (s32)imm);
+ DECODE_PRINTF2(",%d\n", (s32) imm);
TRACE_AND_STEP();
- res = (s16)srcval * (s16)imm;
+ res = (s16) srcval *(s16) imm;
+
if (res > 0xFFFF) {
SET_FLAG(F_CF);
SET_FLAG(F_OF);
- } else {
+ }
+ else {
CLEAR_FLAG(F_CF);
CLEAR_FLAG(F_OF);
}
- *destreg = (u16)res;
+ *destreg = (u16) res;
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
- u32 res_lo,res_hi;
+ u32 *destreg, *srcreg;
+ u32 res_lo, res_hi;
destreg = DECODE_RM_LONG_REGISTER(rh);
DECODE_PRINTF(",");
srcreg = DECODE_RM_LONG_REGISTER(rl);
imm = fetch_byte_imm();
- DECODE_PRINTF2(",%d\n", (s32)imm);
+ DECODE_PRINTF2(",%d\n", (s32) imm);
TRACE_AND_STEP();
- imul_long_direct(&res_lo,&res_hi,(s32)*srcreg,(s32)imm);
+ imul_long_direct(&res_lo, &res_hi, (s32) * srcreg, (s32) imm);
if (res_hi != 0) {
SET_FLAG(F_CF);
SET_FLAG(F_OF);
- } else {
+ }
+ else {
CLEAR_FLAG(F_CF);
CLEAR_FLAG(F_OF);
}
- *destreg = (u32)res_lo;
- } else {
- u16 *destreg,*srcreg;
+ *destreg = (u32) res_lo;
+ }
+ else {
+ u16 *destreg, *srcreg;
u32 res;
destreg = DECODE_RM_WORD_REGISTER(rh);
DECODE_PRINTF(",");
srcreg = DECODE_RM_WORD_REGISTER(rl);
imm = fetch_byte_imm();
- DECODE_PRINTF2(",%d\n", (s32)imm);
- res = (s16)*srcreg * (s16)imm;
+ DECODE_PRINTF2(",%d\n", (s32) imm);
+ res = (s16) * srcreg * (s16) imm;
if (res > 0xFFFF) {
SET_FLAG(F_CF);
SET_FLAG(F_OF);
- } else {
+ }
+ else {
CLEAR_FLAG(F_CF);
CLEAR_FLAG(F_OF);
}
- *destreg = (u16)res;
+ *destreg = (u16) res;
}
break;
}
REMARKS:
Handles opcode 0x6c
****************************************************************************/
-static void x86emuOp_ins_byte(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_ins_byte(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("INSB\n");
REMARKS:
Handles opcode 0x6d
****************************************************************************/
-static void x86emuOp_ins_word(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_ins_word(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("INSD\n");
ins(4);
- } else {
+ }
+ else {
DECODE_PRINTF("INSW\n");
ins(2);
}
REMARKS:
Handles opcode 0x6e
****************************************************************************/
-static void x86emuOp_outs_byte(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_outs_byte(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("OUTSB\n");
REMARKS:
Handles opcode 0x6f
****************************************************************************/
-static void x86emuOp_outs_word(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_outs_word(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("OUTSD\n");
outs(4);
- } else {
+ }
+ else {
DECODE_PRINTF("OUTSW\n");
outs(2);
}
REMARKS:
Handles opcode 0x70
****************************************************************************/
-static void x86emuOp_jump_near_O(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_near_O(u8 X86EMU_UNUSED(op1))
{
s8 offset;
u16 target;
/* jump to byte offset if overflow flag is set */
START_OF_INSTR();
DECODE_PRINTF("JO\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + (s16)offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + (s16) offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
if (ACCESS_FLAG(F_OF))
REMARKS:
Handles opcode 0x71
****************************************************************************/
-static void x86emuOp_jump_near_NO(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_near_NO(u8 X86EMU_UNUSED(op1))
{
s8 offset;
u16 target;
/* jump to byte offset if overflow is not set */
START_OF_INSTR();
DECODE_PRINTF("JNO\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + (s16)offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + (s16) offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
if (!ACCESS_FLAG(F_OF))
REMARKS:
Handles opcode 0x72
****************************************************************************/
-static void x86emuOp_jump_near_B(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_near_B(u8 X86EMU_UNUSED(op1))
{
s8 offset;
u16 target;
/* jump to byte offset if carry flag is set. */
START_OF_INSTR();
DECODE_PRINTF("JB\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + (s16)offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + (s16) offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
if (ACCESS_FLAG(F_CF))
REMARKS:
Handles opcode 0x73
****************************************************************************/
-static void x86emuOp_jump_near_NB(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_near_NB(u8 X86EMU_UNUSED(op1))
{
s8 offset;
u16 target;
/* jump to byte offset if carry flag is clear. */
START_OF_INSTR();
DECODE_PRINTF("JNB\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + (s16)offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + (s16) offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
if (!ACCESS_FLAG(F_CF))
REMARKS:
Handles opcode 0x74
****************************************************************************/
-static void x86emuOp_jump_near_Z(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_near_Z(u8 X86EMU_UNUSED(op1))
{
s8 offset;
u16 target;
/* jump to byte offset if zero flag is set. */
START_OF_INSTR();
DECODE_PRINTF("JZ\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + (s16)offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + (s16) offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
if (ACCESS_FLAG(F_ZF))
REMARKS:
Handles opcode 0x75
****************************************************************************/
-static void x86emuOp_jump_near_NZ(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_near_NZ(u8 X86EMU_UNUSED(op1))
{
s8 offset;
u16 target;
/* jump to byte offset if zero flag is clear. */
START_OF_INSTR();
DECODE_PRINTF("JNZ\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + (s16)offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + (s16) offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
if (!ACCESS_FLAG(F_ZF))
REMARKS:
Handles opcode 0x76
****************************************************************************/
-static void x86emuOp_jump_near_BE(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_near_BE(u8 X86EMU_UNUSED(op1))
{
s8 offset;
u16 target;
flag is set. */
START_OF_INSTR();
DECODE_PRINTF("JBE\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + (s16)offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + (s16) offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
if (ACCESS_FLAG(F_CF) || ACCESS_FLAG(F_ZF))
REMARKS:
Handles opcode 0x77
****************************************************************************/
-static void x86emuOp_jump_near_NBE(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_near_NBE(u8 X86EMU_UNUSED(op1))
{
s8 offset;
u16 target;
flag is clear */
START_OF_INSTR();
DECODE_PRINTF("JNBE\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + (s16)offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + (s16) offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
if (!(ACCESS_FLAG(F_CF) || ACCESS_FLAG(F_ZF)))
REMARKS:
Handles opcode 0x78
****************************************************************************/
-static void x86emuOp_jump_near_S(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_near_S(u8 X86EMU_UNUSED(op1))
{
s8 offset;
u16 target;
/* jump to byte offset if sign flag is set */
START_OF_INSTR();
DECODE_PRINTF("JS\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + (s16)offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + (s16) offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
if (ACCESS_FLAG(F_SF))
REMARKS:
Handles opcode 0x79
****************************************************************************/
-static void x86emuOp_jump_near_NS(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_near_NS(u8 X86EMU_UNUSED(op1))
{
s8 offset;
u16 target;
/* jump to byte offset if sign flag is clear */
START_OF_INSTR();
DECODE_PRINTF("JNS\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + (s16)offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + (s16) offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
if (!ACCESS_FLAG(F_SF))
REMARKS:
Handles opcode 0x7a
****************************************************************************/
-static void x86emuOp_jump_near_P(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_near_P(u8 X86EMU_UNUSED(op1))
{
s8 offset;
u16 target;
/* jump to byte offset if parity flag is set (even parity) */
START_OF_INSTR();
DECODE_PRINTF("JP\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + (s16)offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + (s16) offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
if (ACCESS_FLAG(F_PF))
REMARKS:
Handles opcode 0x7b
****************************************************************************/
-static void x86emuOp_jump_near_NP(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_near_NP(u8 X86EMU_UNUSED(op1))
{
s8 offset;
u16 target;
/* jump to byte offset if parity flag is clear (odd parity) */
START_OF_INSTR();
DECODE_PRINTF("JNP\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + (s16)offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + (s16) offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
if (!ACCESS_FLAG(F_PF))
REMARKS:
Handles opcode 0x7c
****************************************************************************/
-static void x86emuOp_jump_near_L(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_near_L(u8 X86EMU_UNUSED(op1))
{
s8 offset;
u16 target;
/* jump to byte offset if sign flag not equal to overflow flag. */
START_OF_INSTR();
DECODE_PRINTF("JL\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + (s16)offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + (s16) offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
sf = ACCESS_FLAG(F_SF) != 0;
REMARKS:
Handles opcode 0x7d
****************************************************************************/
-static void x86emuOp_jump_near_NL(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_near_NL(u8 X86EMU_UNUSED(op1))
{
s8 offset;
u16 target;
/* jump to byte offset if sign flag not equal to overflow flag. */
START_OF_INSTR();
DECODE_PRINTF("JNL\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + (s16)offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + (s16) offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
sf = ACCESS_FLAG(F_SF) != 0;
REMARKS:
Handles opcode 0x7e
****************************************************************************/
-static void x86emuOp_jump_near_LE(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_near_LE(u8 X86EMU_UNUSED(op1))
{
s8 offset;
u16 target;
or the zero flag is set */
START_OF_INSTR();
DECODE_PRINTF("JLE\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + (s16)offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + (s16) offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
sf = ACCESS_FLAG(F_SF) != 0;
REMARKS:
Handles opcode 0x7f
****************************************************************************/
-static void x86emuOp_jump_near_NLE(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_near_NLE(u8 X86EMU_UNUSED(op1))
{
s8 offset;
u16 target;
and the zero flag is clear */
START_OF_INSTR();
DECODE_PRINTF("JNLE\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + (s16)offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + (s16) offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
sf = ACCESS_FLAG(F_SF) != 0;
END_OF_INSTR();
}
-static u8 (*opc80_byte_operation[])(u8 d, u8 s) =
-{
- add_byte, /* 00 */
- or_byte, /* 01 */
- adc_byte, /* 02 */
- sbb_byte, /* 03 */
- and_byte, /* 04 */
- sub_byte, /* 05 */
- xor_byte, /* 06 */
- cmp_byte, /* 07 */
+static u8(*opc80_byte_operation[]) (u8 d, u8 s) = {
+ add_byte, /* 00 */
+ or_byte, /* 01 */
+ adc_byte, /* 02 */
+ sbb_byte, /* 03 */
+ and_byte, /* 04 */
+ sub_byte, /* 05 */
+ xor_byte, /* 06 */
+ cmp_byte, /* 07 */
};
/****************************************************************************
REMARKS:
Handles opcode 0x80
****************************************************************************/
-static void x86emuOp_opc80_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_opc80_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg;
if (rh != 7)
store_data_byte(destoffset, destval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rl);
DECODE_PRINTF(",");
imm = fetch_byte_imm();
END_OF_INSTR();
}
-static u16 (*opc81_word_operation[])(u16 d, u16 s) =
-{
- add_word, /*00 */
- or_word, /*01 */
- adc_word, /*02 */
- sbb_word, /*03 */
- and_word, /*04 */
- sub_word, /*05 */
- xor_word, /*06 */
- cmp_word, /*07 */
+static u16(*opc81_word_operation[]) (u16 d, u16 s) = {
+ add_word, /*00 */
+ or_word, /*01 */
+ adc_word, /*02 */
+ sbb_word, /*03 */
+ and_word, /*04 */
+ sub_word, /*05 */
+ xor_word, /*06 */
+ cmp_word, /*07 */
};
-static u32 (*opc81_long_operation[])(u32 d, u32 s) =
-{
- add_long, /*00 */
- or_long, /*01 */
- adc_long, /*02 */
- sbb_long, /*03 */
- and_long, /*04 */
- sub_long, /*05 */
- xor_long, /*06 */
- cmp_long, /*07 */
+static u32(*opc81_long_operation[]) (u32 d, u32 s) = {
+ add_long, /*00 */
+ or_long, /*01 */
+ adc_long, /*02 */
+ sbb_long, /*03 */
+ and_long, /*04 */
+ sub_long, /*05 */
+ xor_long, /*06 */
+ cmp_long, /*07 */
};
/****************************************************************************
REMARKS:
Handles opcode 0x81
****************************************************************************/
-static void x86emuOp_opc81_word_RM_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_opc81_word_RM_IMM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
switch (mod) {
case 0:
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 destval,imm;
+ u32 destval, imm;
DECODE_PRINTF("DWORD PTR ");
destoffset = decode_rm00_address(rl);
destval = (*opc81_long_operation[rh]) (destval, imm);
if (rh != 7)
store_data_long(destoffset, destval);
- } else {
- u16 destval,imm;
+ }
+ else {
+ u16 destval, imm;
DECODE_PRINTF("WORD PTR ");
destoffset = decode_rm00_address(rl);
break;
case 1:
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 destval,imm;
+ u32 destval, imm;
DECODE_PRINTF("DWORD PTR ");
destoffset = decode_rm01_address(rl);
destval = (*opc81_long_operation[rh]) (destval, imm);
if (rh != 7)
store_data_long(destoffset, destval);
- } else {
- u16 destval,imm;
+ }
+ else {
+ u16 destval, imm;
DECODE_PRINTF("WORD PTR ");
destoffset = decode_rm01_address(rl);
break;
case 2:
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 destval,imm;
+ u32 destval, imm;
DECODE_PRINTF("DWORD PTR ");
destoffset = decode_rm10_address(rl);
destval = (*opc81_long_operation[rh]) (destval, imm);
if (rh != 7)
store_data_long(destoffset, destval);
- } else {
- u16 destval,imm;
+ }
+ else {
+ u16 destval, imm;
DECODE_PRINTF("WORD PTR ");
destoffset = decode_rm10_address(rl);
store_data_word(destoffset, destval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 *destreg;
- u32 destval,imm;
+ u32 destval, imm;
destreg = DECODE_RM_LONG_REGISTER(rl);
DECODE_PRINTF(",");
destval = (*opc81_long_operation[rh]) (*destreg, imm);
if (rh != 7)
*destreg = destval;
- } else {
+ }
+ else {
u16 *destreg;
- u16 destval,imm;
+ u16 destval, imm;
destreg = DECODE_RM_WORD_REGISTER(rl);
DECODE_PRINTF(",");
END_OF_INSTR();
}
-static u8 (*opc82_byte_operation[])(u8 s, u8 d) =
-{
- add_byte, /*00 */
- or_byte, /*01 *//*YYY UNUSED ???? */
- adc_byte, /*02 */
- sbb_byte, /*03 */
- and_byte, /*04 *//*YYY UNUSED ???? */
- sub_byte, /*05 */
- xor_byte, /*06 *//*YYY UNUSED ???? */
- cmp_byte, /*07 */
+static u8(*opc82_byte_operation[]) (u8 s, u8 d) = {
+ add_byte, /*00 */
+ or_byte, /*01 *//*YYY UNUSED ???? */
+ adc_byte, /*02 */
+ sbb_byte, /*03 */
+ and_byte, /*04 *//*YYY UNUSED ???? */
+ sub_byte, /*05 */
+ xor_byte, /*06 *//*YYY UNUSED ???? */
+ cmp_byte, /*07 */
};
/****************************************************************************
REMARKS:
Handles opcode 0x82
****************************************************************************/
-static void x86emuOp_opc82_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_opc82_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg;
if (rh != 7)
store_data_byte(destoffset, destval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rl);
imm = fetch_byte_imm();
DECODE_PRINTF2(",%x\n", imm);
END_OF_INSTR();
}
-static u16 (*opc83_word_operation[])(u16 s, u16 d) =
-{
- add_word, /*00 */
- or_word, /*01 *//*YYY UNUSED ???? */
- adc_word, /*02 */
- sbb_word, /*03 */
- and_word, /*04 *//*YYY UNUSED ???? */
- sub_word, /*05 */
- xor_word, /*06 *//*YYY UNUSED ???? */
- cmp_word, /*07 */
+static u16(*opc83_word_operation[]) (u16 s, u16 d) = {
+ add_word, /*00 */
+ or_word, /*01 *//*YYY UNUSED ???? */
+ adc_word, /*02 */
+ sbb_word, /*03 */
+ and_word, /*04 *//*YYY UNUSED ???? */
+ sub_word, /*05 */
+ xor_word, /*06 *//*YYY UNUSED ???? */
+ cmp_word, /*07 */
};
-static u32 (*opc83_long_operation[])(u32 s, u32 d) =
-{
- add_long, /*00 */
- or_long, /*01 *//*YYY UNUSED ???? */
- adc_long, /*02 */
- sbb_long, /*03 */
- and_long, /*04 *//*YYY UNUSED ???? */
- sub_long, /*05 */
- xor_long, /*06 *//*YYY UNUSED ???? */
- cmp_long, /*07 */
+static u32(*opc83_long_operation[]) (u32 s, u32 d) = {
+ add_long, /*00 */
+ or_long, /*01 *//*YYY UNUSED ???? */
+ adc_long, /*02 */
+ sbb_long, /*03 */
+ and_long, /*04 *//*YYY UNUSED ???? */
+ sub_long, /*05 */
+ xor_long, /*06 *//*YYY UNUSED ???? */
+ cmp_long, /*07 */
};
/****************************************************************************
REMARKS:
Handles opcode 0x83
****************************************************************************/
-static void x86emuOp_opc83_word_RM_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_opc83_word_RM_IMM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
general, so that it is important to leave the strings
in the same format, even though the result is that the
above test is done twice. */
- switch (rh) {
+ switch (rh) {
case 0:
DECODE_PRINTF("ADD\t");
break;
switch (mod) {
case 0:
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 destval,imm;
+ u32 destval, imm;
DECODE_PRINTF("DWORD PTR ");
destoffset = decode_rm00_address(rl);
destval = (*opc83_long_operation[rh]) (destval, imm);
if (rh != 7)
store_data_long(destoffset, destval);
- } else {
- u16 destval,imm;
+ }
+ else {
+ u16 destval, imm;
DECODE_PRINTF("WORD PTR ");
destoffset = decode_rm00_address(rl);
break;
case 1:
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 destval,imm;
+ u32 destval, imm;
DECODE_PRINTF("DWORD PTR ");
destoffset = decode_rm01_address(rl);
destval = (*opc83_long_operation[rh]) (destval, imm);
if (rh != 7)
store_data_long(destoffset, destval);
- } else {
- u16 destval,imm;
+ }
+ else {
+ u16 destval, imm;
DECODE_PRINTF("WORD PTR ");
destoffset = decode_rm01_address(rl);
break;
case 2:
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 destval,imm;
+ u32 destval, imm;
DECODE_PRINTF("DWORD PTR ");
destoffset = decode_rm10_address(rl);
destval = (*opc83_long_operation[rh]) (destval, imm);
if (rh != 7)
store_data_long(destoffset, destval);
- } else {
- u16 destval,imm;
+ }
+ else {
+ u16 destval, imm;
DECODE_PRINTF("WORD PTR ");
destoffset = decode_rm10_address(rl);
store_data_word(destoffset, destval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 *destreg;
- u32 destval,imm;
+ u32 destval, imm;
destreg = DECODE_RM_LONG_REGISTER(rl);
imm = (s8) fetch_byte_imm();
destval = (*opc83_long_operation[rh]) (*destreg, imm);
if (rh != 7)
*destreg = destval;
- } else {
+ }
+ else {
u16 *destreg;
- u16 destval,imm;
+ u16 destval, imm;
destreg = DECODE_RM_WORD_REGISTER(rl);
imm = (s8) fetch_byte_imm();
REMARKS:
Handles opcode 0x84
****************************************************************************/
-static void x86emuOp_test_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_test_byte_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
TRACE_AND_STEP();
test_byte(destval, *srcreg);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rl);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rh);
REMARKS:
Handles opcode 0x85
****************************************************************************/
-static void x86emuOp_test_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_test_word_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
test_long(destval, *srcreg);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
test_long(destval, *srcreg);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
test_long(destval, *srcreg);
- } else {
+ }
+ else {
u16 destval;
u16 *srcreg;
test_word(destval, *srcreg);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rl);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
test_long(*destreg, *srcreg);
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rl);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x86
****************************************************************************/
-static void x86emuOp_xchg_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_xchg_byte_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
destval = tmp;
store_data_byte(destoffset, destval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rl);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rh);
REMARKS:
Handles opcode 0x87
****************************************************************************/
-static void x86emuOp_xchg_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_xchg_word_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
case 0:
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 *srcreg;
- u32 destval,tmp;
+ u32 destval, tmp;
destoffset = decode_rm00_address(rl);
DECODE_PRINTF(",");
*srcreg = destval;
destval = tmp;
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 *srcreg;
- u16 destval,tmp;
+ u16 destval, tmp;
destoffset = decode_rm00_address(rl);
DECODE_PRINTF(",");
case 1:
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 *srcreg;
- u32 destval,tmp;
+ u32 destval, tmp;
destoffset = decode_rm01_address(rl);
DECODE_PRINTF(",");
*srcreg = destval;
destval = tmp;
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 *srcreg;
- u16 destval,tmp;
+ u16 destval, tmp;
destoffset = decode_rm01_address(rl);
DECODE_PRINTF(",");
case 2:
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 *srcreg;
- u32 destval,tmp;
+ u32 destval, tmp;
destoffset = decode_rm10_address(rl);
DECODE_PRINTF(",");
*srcreg = destval;
destval = tmp;
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 *srcreg;
- u16 destval,tmp;
+ u16 destval, tmp;
destoffset = decode_rm10_address(rl);
DECODE_PRINTF(",");
store_data_word(destoffset, destval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
u32 tmp;
destreg = DECODE_RM_LONG_REGISTER(rl);
tmp = *srcreg;
*srcreg = *destreg;
*destreg = tmp;
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
u16 tmp;
destreg = DECODE_RM_WORD_REGISTER(rl);
REMARKS:
Handles opcode 0x88
****************************************************************************/
-static void x86emuOp_mov_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_byte_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
TRACE_AND_STEP();
store_data_byte(destoffset, *srcreg);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rl);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rh);
REMARKS:
Handles opcode 0x89
****************************************************************************/
-static void x86emuOp_mov_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_word_RM_R(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u32 destoffset;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
store_data_long(destoffset, *srcreg);
- } else {
+ }
+ else {
u16 *srcreg;
destoffset = decode_rm00_address(rl);
DECODE_PRINTF("\n");
TRACE_AND_STEP();
store_data_long(destoffset, *srcreg);
- } else {
+ }
+ else {
u16 *srcreg;
destoffset = decode_rm01_address(rl);
DECODE_PRINTF("\n");
TRACE_AND_STEP();
store_data_long(destoffset, *srcreg);
- } else {
+ }
+ else {
u16 *srcreg;
destoffset = decode_rm10_address(rl);
store_data_word(destoffset, *srcreg);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg,*srcreg;
+ u32 *destreg, *srcreg;
destreg = DECODE_RM_LONG_REGISTER(rl);
DECODE_PRINTF(",");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = *srcreg;
- } else {
- u16 *destreg,*srcreg;
+ }
+ else {
+ u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rl);
DECODE_PRINTF(",");
REMARKS:
Handles opcode 0x8a
****************************************************************************/
-static void x86emuOp_mov_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_byte_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg, *srcreg;
TRACE_AND_STEP();
*destreg = srcval;
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rh);
DECODE_PRINTF(",");
srcreg = DECODE_RM_BYTE_REGISTER(rl);
REMARKS:
Handles opcode 0x8b
****************************************************************************/
-static void x86emuOp_mov_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_word_R_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint srcoffset;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = srcval;
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = srcval;
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = srcval;
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
*destreg = srcval;
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 *destreg, *srcreg;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = *srcreg;
- } else {
+ }
+ else {
u16 *destreg, *srcreg;
destreg = DECODE_RM_WORD_REGISTER(rh);
REMARKS:
Handles opcode 0x8c
****************************************************************************/
-static void x86emuOp_mov_word_RM_SR(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_word_RM_SR(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u16 *destreg, *srcreg;
destval = *srcreg;
store_data_word(destoffset, destval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_WORD_REGISTER(rl);
DECODE_PRINTF(",");
srcreg = decode_rm_seg_register(rh);
REMARKS:
Handles opcode 0x8d
****************************************************************************/
-static void x86emuOp_lea_word_R_M(u8 X86EMU_UNUSED(op1))
+static 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);
switch (mod) {
case 0:
- srcreg = DECODE_RM_WORD_REGISTER(rh);
- DECODE_PRINTF(",");
- destoffset = decode_rm00_address(rl);
- DECODE_PRINTF("\n");
- TRACE_AND_STEP();
- *srcreg = (u16)destoffset;
+ if (M.x86.mode & SYSMODE_PREFIX_ADDR) {
+ u32 *srcreg = DECODE_RM_LONG_REGISTER(rh);
+
+ DECODE_PRINTF(",");
+ destoffset = decode_rm00_address(rl);
+ DECODE_PRINTF("\n");
+ TRACE_AND_STEP();
+ *srcreg = (u32) destoffset;
+ }
+ else {
+ u16 *srcreg = DECODE_RM_WORD_REGISTER(rh);
+
+ DECODE_PRINTF(",");
+ destoffset = decode_rm00_address(rl);
+ DECODE_PRINTF("\n");
+ TRACE_AND_STEP();
+ *srcreg = (u16) destoffset;
+ }
break;
case 1:
- srcreg = DECODE_RM_WORD_REGISTER(rh);
- DECODE_PRINTF(",");
- destoffset = decode_rm01_address(rl);
- DECODE_PRINTF("\n");
- TRACE_AND_STEP();
- *srcreg = (u16)destoffset;
+ if (M.x86.mode & SYSMODE_PREFIX_ADDR) {
+ u32 *srcreg = DECODE_RM_LONG_REGISTER(rh);
+
+ DECODE_PRINTF(",");
+ destoffset = decode_rm01_address(rl);
+ DECODE_PRINTF("\n");
+ TRACE_AND_STEP();
+ *srcreg = (u32) destoffset;
+ }
+ else {
+ u16 *srcreg = DECODE_RM_WORD_REGISTER(rh);
+
+ DECODE_PRINTF(",");
+ destoffset = decode_rm01_address(rl);
+ DECODE_PRINTF("\n");
+ TRACE_AND_STEP();
+ *srcreg = (u16) destoffset;
+ }
break;
case 2:
- srcreg = DECODE_RM_WORD_REGISTER(rh);
- DECODE_PRINTF(",");
- destoffset = decode_rm10_address(rl);
- DECODE_PRINTF("\n");
- TRACE_AND_STEP();
- *srcreg = (u16)destoffset;
+ if (M.x86.mode & SYSMODE_PREFIX_ADDR) {
+ u32 *srcreg = DECODE_RM_LONG_REGISTER(rh);
+
+ DECODE_PRINTF(",");
+ destoffset = decode_rm10_address(rl);
+ DECODE_PRINTF("\n");
+ TRACE_AND_STEP();
+ *srcreg = (u32) destoffset;
+ }
+ else {
+ u16 *srcreg = DECODE_RM_WORD_REGISTER(rh);
+
+ DECODE_PRINTF(",");
+ destoffset = decode_rm10_address(rl);
+ DECODE_PRINTF("\n");
+ TRACE_AND_STEP();
+ *srcreg = (u16) destoffset;
+ }
break;
- case 3: /* register to register */
+ case 3: /* register to register */
/* undefined. Do nothing. */
break;
}
REMARKS:
Handles opcode 0x8e
****************************************************************************/
-static void x86emuOp_mov_word_SR_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_word_SR_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u16 *destreg, *srcreg;
TRACE_AND_STEP();
*destreg = srcval;
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = decode_rm_seg_register(rh);
DECODE_PRINTF(",");
srcreg = DECODE_RM_WORD_REGISTER(rl);
REMARKS:
Handles opcode 0x8f
****************************************************************************/
-static void x86emuOp_pop_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_pop_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
TRACE_AND_STEP();
destval = pop_long();
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
destoffset = decode_rm00_address(rl);
TRACE_AND_STEP();
destval = pop_long();
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
destoffset = decode_rm01_address(rl);
TRACE_AND_STEP();
destval = pop_long();
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
destoffset = decode_rm10_address(rl);
store_data_word(destoffset, destval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 *destreg;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = pop_long();
- } else {
+ }
+ else {
u16 *destreg;
destreg = DECODE_RM_WORD_REGISTER(rl);
REMARKS:
Handles opcode 0x90
****************************************************************************/
-static void x86emuOp_nop(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_nop(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("NOP\n");
REMARKS:
Handles opcode 0x91
****************************************************************************/
-static void x86emuOp_xchg_word_AX_CX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_xchg_word_AX_CX(u8 X86EMU_UNUSED(op1))
{
u32 tmp;
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("XCHG\tEAX,ECX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("XCHG\tAX,CX\n");
}
TRACE_AND_STEP();
tmp = M.x86.R_EAX;
M.x86.R_EAX = M.x86.R_ECX;
M.x86.R_ECX = tmp;
- } else {
+ }
+ else {
tmp = M.x86.R_AX;
M.x86.R_AX = M.x86.R_CX;
- M.x86.R_CX = (u16)tmp;
+ M.x86.R_CX = (u16) tmp;
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x92
****************************************************************************/
-static void x86emuOp_xchg_word_AX_DX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_xchg_word_AX_DX(u8 X86EMU_UNUSED(op1))
{
u32 tmp;
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("XCHG\tEAX,EDX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("XCHG\tAX,DX\n");
}
TRACE_AND_STEP();
tmp = M.x86.R_EAX;
M.x86.R_EAX = M.x86.R_EDX;
M.x86.R_EDX = tmp;
- } else {
+ }
+ else {
tmp = M.x86.R_AX;
M.x86.R_AX = M.x86.R_DX;
- M.x86.R_DX = (u16)tmp;
+ M.x86.R_DX = (u16) tmp;
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x93
****************************************************************************/
-static void x86emuOp_xchg_word_AX_BX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_xchg_word_AX_BX(u8 X86EMU_UNUSED(op1))
{
u32 tmp;
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("XCHG\tEAX,EBX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("XCHG\tAX,BX\n");
}
TRACE_AND_STEP();
tmp = M.x86.R_EAX;
M.x86.R_EAX = M.x86.R_EBX;
M.x86.R_EBX = tmp;
- } else {
+ }
+ else {
tmp = M.x86.R_AX;
M.x86.R_AX = M.x86.R_BX;
- M.x86.R_BX = (u16)tmp;
+ M.x86.R_BX = (u16) tmp;
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x94
****************************************************************************/
-static void x86emuOp_xchg_word_AX_SP(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_xchg_word_AX_SP(u8 X86EMU_UNUSED(op1))
{
u32 tmp;
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("XCHG\tEAX,ESP\n");
- } else {
+ }
+ else {
DECODE_PRINTF("XCHG\tAX,SP\n");
}
TRACE_AND_STEP();
tmp = M.x86.R_EAX;
M.x86.R_EAX = M.x86.R_ESP;
M.x86.R_ESP = tmp;
- } else {
+ }
+ else {
tmp = M.x86.R_AX;
M.x86.R_AX = M.x86.R_SP;
- M.x86.R_SP = (u16)tmp;
+ M.x86.R_SP = (u16) tmp;
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x95
****************************************************************************/
-static void x86emuOp_xchg_word_AX_BP(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_xchg_word_AX_BP(u8 X86EMU_UNUSED(op1))
{
u32 tmp;
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("XCHG\tEAX,EBP\n");
- } else {
+ }
+ else {
DECODE_PRINTF("XCHG\tAX,BP\n");
}
TRACE_AND_STEP();
tmp = M.x86.R_EAX;
M.x86.R_EAX = M.x86.R_EBP;
M.x86.R_EBP = tmp;
- } else {
+ }
+ else {
tmp = M.x86.R_AX;
M.x86.R_AX = M.x86.R_BP;
- M.x86.R_BP = (u16)tmp;
+ M.x86.R_BP = (u16) tmp;
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x96
****************************************************************************/
-static void x86emuOp_xchg_word_AX_SI(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_xchg_word_AX_SI(u8 X86EMU_UNUSED(op1))
{
u32 tmp;
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("XCHG\tEAX,ESI\n");
- } else {
+ }
+ else {
DECODE_PRINTF("XCHG\tAX,SI\n");
}
TRACE_AND_STEP();
tmp = M.x86.R_EAX;
M.x86.R_EAX = M.x86.R_ESI;
M.x86.R_ESI = tmp;
- } else {
+ }
+ else {
tmp = M.x86.R_AX;
M.x86.R_AX = M.x86.R_SI;
- M.x86.R_SI = (u16)tmp;
+ M.x86.R_SI = (u16) tmp;
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x97
****************************************************************************/
-static void x86emuOp_xchg_word_AX_DI(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_xchg_word_AX_DI(u8 X86EMU_UNUSED(op1))
{
u32 tmp;
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("XCHG\tEAX,EDI\n");
- } else {
+ }
+ else {
DECODE_PRINTF("XCHG\tAX,DI\n");
}
TRACE_AND_STEP();
tmp = M.x86.R_EAX;
M.x86.R_EAX = M.x86.R_EDI;
M.x86.R_EDI = tmp;
- } else {
+ }
+ else {
tmp = M.x86.R_AX;
M.x86.R_AX = M.x86.R_DI;
- M.x86.R_DI = (u16)tmp;
+ M.x86.R_DI = (u16) tmp;
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x98
****************************************************************************/
-static void x86emuOp_cbw(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_cbw(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("CWDE\n");
- } else {
+ }
+ 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 {
+ }
+ else {
M.x86.R_EAX &= 0x0000ffff;
}
- } else {
+ }
+ else {
if (M.x86.R_AL & 0x80) {
M.x86.R_AH = 0xff;
- } else {
+ }
+ else {
M.x86.R_AH = 0x0;
}
}
REMARKS:
Handles opcode 0x99
****************************************************************************/
-static void x86emuOp_cwd(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_cwd(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("CDQ\n");
- } else {
+ }
+ else {
DECODE_PRINTF("CWD\n");
}
DECODE_PRINTF("CWD\n");
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
if (M.x86.R_EAX & 0x80000000) {
M.x86.R_EDX = 0xffffffff;
- } else {
+ }
+ else {
M.x86.R_EDX = 0x0;
}
- } else {
+ }
+ else {
if (M.x86.R_AX & 0x8000) {
M.x86.R_DX = 0xffff;
- } else {
+ }
+ else {
M.x86.R_DX = 0x0;
}
}
REMARKS:
Handles opcode 0x9a
****************************************************************************/
-static void x86emuOp_call_far_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_call_far_IMM(u8 X86EMU_UNUSED(op1))
{
- u16 farseg, faroff;
+ u32 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 ");
+ DECODE_PRINTF("CALL\t");
+ if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+ faroff = fetch_long_imm();
+ farseg = fetch_word_imm();
+ }
+ else {
+ 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
*
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;
+ if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+ push_long(M.x86.R_EIP);
+ }
+ else {
+ push_word(M.x86.R_IP);
+ }
+ M.x86.R_EIP = faroff & 0xffff;
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
}
REMARKS:
Handles opcode 0x9b
****************************************************************************/
-static void x86emuOp_wait(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_wait(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("WAIT");
REMARKS:
Handles opcode 0x9c
****************************************************************************/
-static void x86emuOp_pushf_word(u8 X86EMU_UNUSED(op1))
+static 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 {
+ }
+ else {
DECODE_PRINTF("PUSHF\n");
}
TRACE_AND_STEP();
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);
+ }
+ else {
+ push_word((u16) flags);
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0x9d
****************************************************************************/
-static void x86emuOp_popf_word(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_popf_word(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("POPFD\n");
- } else {
+ }
+ else {
DECODE_PRINTF("POPF\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EFLG = pop_long();
- } else {
+ }
+ else {
M.x86.R_FLG = pop_word();
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0x9e
****************************************************************************/
-static void x86emuOp_sahf(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_sahf(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("SAHF\n");
REMARKS:
Handles opcode 0x9f
****************************************************************************/
-static void x86emuOp_lahf(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_lahf(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("LAHF\n");
TRACE_AND_STEP();
- M.x86.R_AH = (u8)(M.x86.R_FLG & 0xff);
+ M.x86.R_AH = (u8) (M.x86.R_FLG & 0xff);
/*undocumented TC++ behavior??? Nope. It's documented, but
you have too look real hard to notice it. */
M.x86.R_AH |= 0x2;
REMARKS:
Handles opcode 0xa0
****************************************************************************/
-static void x86emuOp_mov_AL_M_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_AL_M_IMM(u8 X86EMU_UNUSED(op1))
{
u16 offset;
REMARKS:
Handles opcode 0xa1
****************************************************************************/
-static void x86emuOp_mov_AX_M_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_AX_M_IMM(u8 X86EMU_UNUSED(op1))
{
u16 offset;
offset = fetch_word_imm();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF2("MOV\tEAX,[%04x]\n", offset);
- } else {
+ }
+ else {
DECODE_PRINTF2("MOV\tAX,[%04x]\n", offset);
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EAX = fetch_data_long(offset);
- } else {
+ }
+ else {
M.x86.R_AX = fetch_data_word(offset);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0xa2
****************************************************************************/
-static void x86emuOp_mov_M_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_M_AL_IMM(u8 X86EMU_UNUSED(op1))
{
u16 offset;
REMARKS:
Handles opcode 0xa3
****************************************************************************/
-static void x86emuOp_mov_M_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_M_AX_IMM(u8 X86EMU_UNUSED(op1))
{
u16 offset;
offset = fetch_word_imm();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF2("MOV\t[%04x],EAX\n", offset);
- } else {
+ }
+ else {
DECODE_PRINTF2("MOV\t[%04x],AX\n", offset);
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
store_data_long(offset, M.x86.R_EAX);
- } else {
+ }
+ else {
store_data_word(offset, M.x86.R_AX);
}
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0xa4
****************************************************************************/
-static void x86emuOp_movs_byte(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_movs_byte(u8 X86EMU_UNUSED(op1))
{
- u8 val;
+ u8 val;
u32 count;
int inc;
START_OF_INSTR();
DECODE_PRINTF("MOVS\tBYTE\n");
- if (ACCESS_FLAG(F_DF)) /* down */
+ if (ACCESS_FLAG(F_DF)) /* down */
inc = -1;
else
inc = 1;
REMARKS:
Handles opcode 0xa5
****************************************************************************/
-static void x86emuOp_movs_word(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_movs_word(u8 X86EMU_UNUSED(op1))
{
u32 val;
int inc;
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("MOVS\tDWORD\n");
- if (ACCESS_FLAG(F_DF)) /* down */
+ if (ACCESS_FLAG(F_DF)) /* down */
inc = -4;
else
inc = 4;
- } else {
+ }
+ else {
DECODE_PRINTF("MOVS\tWORD\n");
- if (ACCESS_FLAG(F_DF)) /* down */
+ if (ACCESS_FLAG(F_DF)) /* down */
inc = -2;
else
inc = 2;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
val = fetch_data_long(M.x86.R_SI);
store_data_long_abs(M.x86.R_ES, M.x86.R_DI, val);
- } else {
+ }
+ else {
val = fetch_data_word(M.x86.R_SI);
- store_data_word_abs(M.x86.R_ES, M.x86.R_DI, (u16)val);
+ store_data_word_abs(M.x86.R_ES, M.x86.R_DI, (u16) val);
}
M.x86.R_SI += inc;
M.x86.R_DI += inc;
REMARKS:
Handles opcode 0xa6
****************************************************************************/
-static void x86emuOp_cmps_byte(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_cmps_byte(u8 X86EMU_UNUSED(op1))
{
s8 val1, val2;
int inc;
START_OF_INSTR();
DECODE_PRINTF("CMPS\tBYTE\n");
TRACE_AND_STEP();
- if (ACCESS_FLAG(F_DF)) /* down */
+ if (ACCESS_FLAG(F_DF)) /* down */
inc = -1;
else
inc = 1;
while (M.x86.R_CX != 0) {
val1 = fetch_data_byte(M.x86.R_SI);
val2 = fetch_data_byte_abs(M.x86.R_ES, M.x86.R_DI);
- cmp_byte(val1, val2);
+ cmp_byte(val1, val2);
M.x86.R_CX -= 1;
M.x86.R_SI += inc;
M.x86.R_DI += inc;
break;
}
M.x86.mode &= ~SYSMODE_PREFIX_REPE;
- } else if (M.x86.mode & SYSMODE_PREFIX_REPNE) {
+ }
+ else if (M.x86.mode & SYSMODE_PREFIX_REPNE) {
/* REPNE */
/* move them until CX is ZERO. */
while (M.x86.R_CX != 0) {
break; /* zero flag set means equal */
}
M.x86.mode &= ~SYSMODE_PREFIX_REPNE;
- } else {
+ }
+ else {
val1 = fetch_data_byte(M.x86.R_SI);
val2 = fetch_data_byte_abs(M.x86.R_ES, M.x86.R_DI);
cmp_byte(val1, val2);
REMARKS:
Handles opcode 0xa7
****************************************************************************/
-static void x86emuOp_cmps_word(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_cmps_word(u8 X86EMU_UNUSED(op1))
{
- u32 val1,val2;
+ u32 val1, val2;
int inc;
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("CMPS\tDWORD\n");
- if (ACCESS_FLAG(F_DF)) /* down */
+ if (ACCESS_FLAG(F_DF)) /* down */
inc = -4;
else
inc = 4;
- } else {
+ }
+ else {
DECODE_PRINTF("CMPS\tWORD\n");
- if (ACCESS_FLAG(F_DF)) /* down */
+ if (ACCESS_FLAG(F_DF)) /* down */
inc = -2;
else
inc = 2;
val1 = fetch_data_long(M.x86.R_SI);
val2 = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
cmp_long(val1, val2);
- } else {
+ }
+ else {
val1 = fetch_data_word(M.x86.R_SI);
val2 = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
- cmp_word((u16)val1, (u16)val2);
+ cmp_word((u16) val1, (u16) val2);
}
M.x86.R_CX -= 1;
M.x86.R_SI += inc;
break;
}
M.x86.mode &= ~SYSMODE_PREFIX_REPE;
- } else if (M.x86.mode & SYSMODE_PREFIX_REPNE) {
+ }
+ else if (M.x86.mode & SYSMODE_PREFIX_REPNE) {
/* REPNE */
/* move them until CX is ZERO. */
while (M.x86.R_CX != 0) {
val1 = fetch_data_long(M.x86.R_SI);
val2 = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
cmp_long(val1, val2);
- } else {
+ }
+ else {
val1 = fetch_data_word(M.x86.R_SI);
val2 = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
- cmp_word((u16)val1, (u16)val2);
+ cmp_word((u16) val1, (u16) val2);
}
M.x86.R_CX -= 1;
M.x86.R_SI += inc;
break; /* zero flag set means equal */
}
M.x86.mode &= ~SYSMODE_PREFIX_REPNE;
- } else {
+ }
+ else {
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
val1 = fetch_data_long(M.x86.R_SI);
val2 = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
cmp_long(val1, val2);
- } else {
+ }
+ else {
val1 = fetch_data_word(M.x86.R_SI);
val2 = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
- cmp_word((u16)val1, (u16)val2);
+ cmp_word((u16) val1, (u16) val2);
}
M.x86.R_SI += inc;
M.x86.R_DI += inc;
REMARKS:
Handles opcode 0xa8
****************************************************************************/
-static void x86emuOp_test_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_test_AL_IMM(u8 X86EMU_UNUSED(op1))
{
int imm;
imm = fetch_byte_imm();
DECODE_PRINTF2("%04x\n", imm);
TRACE_AND_STEP();
- test_byte(M.x86.R_AL, (u8)imm);
+ test_byte(M.x86.R_AL, (u8) imm);
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
}
REMARKS:
Handles opcode 0xa9
****************************************************************************/
-static void x86emuOp_test_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_test_AX_IMM(u8 X86EMU_UNUSED(op1))
{
u32 srcval;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("TEST\tEAX,");
srcval = fetch_long_imm();
- } else {
+ }
+ else {
DECODE_PRINTF("TEST\tAX,");
srcval = fetch_word_imm();
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
test_long(M.x86.R_EAX, srcval);
- } else {
- test_word(M.x86.R_AX, (u16)srcval);
+ }
+ else {
+ test_word(M.x86.R_AX, (u16) srcval);
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0xaa
****************************************************************************/
-static void x86emuOp_stos_byte(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_stos_byte(u8 X86EMU_UNUSED(op1))
{
int inc;
START_OF_INSTR();
DECODE_PRINTF("STOS\tBYTE\n");
- if (ACCESS_FLAG(F_DF)) /* down */
+ if (ACCESS_FLAG(F_DF)) /* down */
inc = -1;
else
inc = 1;
M.x86.R_DI += inc;
}
M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
- } else {
+ }
+ else {
store_data_byte_abs(M.x86.R_ES, M.x86.R_DI, M.x86.R_AL);
M.x86.R_DI += inc;
}
REMARKS:
Handles opcode 0xab
****************************************************************************/
-static void x86emuOp_stos_word(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_stos_word(u8 X86EMU_UNUSED(op1))
{
int inc;
u32 count;
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("STOS\tDWORD\n");
- if (ACCESS_FLAG(F_DF)) /* down */
+ if (ACCESS_FLAG(F_DF)) /* down */
inc = -4;
else
inc = 4;
- } else {
+ }
+ else {
DECODE_PRINTF("STOS\tWORD\n");
- if (ACCESS_FLAG(F_DF)) /* down */
+ if (ACCESS_FLAG(F_DF)) /* down */
inc = -2;
else
inc = 2;
while (count--) {
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
store_data_long_abs(M.x86.R_ES, M.x86.R_DI, M.x86.R_EAX);
- } else {
+ }
+ else {
store_data_word_abs(M.x86.R_ES, M.x86.R_DI, M.x86.R_AX);
}
M.x86.R_DI += inc;
REMARKS:
Handles opcode 0xac
****************************************************************************/
-static void x86emuOp_lods_byte(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_lods_byte(u8 X86EMU_UNUSED(op1))
{
int inc;
START_OF_INSTR();
DECODE_PRINTF("LODS\tBYTE\n");
TRACE_AND_STEP();
- if (ACCESS_FLAG(F_DF)) /* down */
+ if (ACCESS_FLAG(F_DF)) /* down */
inc = -1;
else
inc = 1;
M.x86.R_SI += inc;
}
M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
- } else {
+ }
+ else {
M.x86.R_AL = fetch_data_byte(M.x86.R_SI);
M.x86.R_SI += inc;
}
REMARKS:
Handles opcode 0xad
****************************************************************************/
-static void x86emuOp_lods_word(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_lods_word(u8 X86EMU_UNUSED(op1))
{
int inc;
u32 count;
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("LODS\tDWORD\n");
- if (ACCESS_FLAG(F_DF)) /* down */
+ if (ACCESS_FLAG(F_DF)) /* down */
inc = -4;
else
inc = 4;
- } else {
+ }
+ else {
DECODE_PRINTF("LODS\tWORD\n");
- if (ACCESS_FLAG(F_DF)) /* down */
+ if (ACCESS_FLAG(F_DF)) /* down */
inc = -2;
else
inc = 2;
while (count--) {
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EAX = fetch_data_long(M.x86.R_SI);
- } else {
+ }
+ else {
M.x86.R_AX = fetch_data_word(M.x86.R_SI);
}
M.x86.R_SI += inc;
REMARKS:
Handles opcode 0xae
****************************************************************************/
-static void x86emuOp_scas_byte(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_scas_byte(u8 X86EMU_UNUSED(op1))
{
s8 val2;
int inc;
START_OF_INSTR();
DECODE_PRINTF("SCAS\tBYTE\n");
TRACE_AND_STEP();
- if (ACCESS_FLAG(F_DF)) /* down */
+ if (ACCESS_FLAG(F_DF)) /* down */
inc = -1;
else
inc = 1;
break;
}
M.x86.mode &= ~SYSMODE_PREFIX_REPE;
- } else if (M.x86.mode & SYSMODE_PREFIX_REPNE) {
+ }
+ else if (M.x86.mode & SYSMODE_PREFIX_REPNE) {
/* REPNE */
/* move them until CX is ZERO. */
while (M.x86.R_CX != 0) {
break; /* zero flag set means equal */
}
M.x86.mode &= ~SYSMODE_PREFIX_REPNE;
- } else {
+ }
+ else {
val2 = fetch_data_byte_abs(M.x86.R_ES, M.x86.R_DI);
cmp_byte(M.x86.R_AL, val2);
M.x86.R_DI += inc;
REMARKS:
Handles opcode 0xaf
****************************************************************************/
-static void x86emuOp_scas_word(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_scas_word(u8 X86EMU_UNUSED(op1))
{
int inc;
u32 val;
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("SCAS\tDWORD\n");
- if (ACCESS_FLAG(F_DF)) /* down */
+ if (ACCESS_FLAG(F_DF)) /* down */
inc = -4;
else
inc = 4;
- } else {
+ }
+ else {
DECODE_PRINTF("SCAS\tWORD\n");
- if (ACCESS_FLAG(F_DF)) /* down */
+ if (ACCESS_FLAG(F_DF)) /* down */
inc = -2;
else
inc = 2;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
val = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
cmp_long(M.x86.R_EAX, val);
- } else {
+ }
+ else {
val = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
- cmp_word(M.x86.R_AX, (u16)val);
+ cmp_word(M.x86.R_AX, (u16) val);
}
M.x86.R_CX -= 1;
M.x86.R_DI += inc;
break;
}
M.x86.mode &= ~SYSMODE_PREFIX_REPE;
- } else if (M.x86.mode & SYSMODE_PREFIX_REPNE) {
+ }
+ else if (M.x86.mode & SYSMODE_PREFIX_REPNE) {
/* REPNE */
/* move them until CX is ZERO. */
while (M.x86.R_CX != 0) {
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
val = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
cmp_long(M.x86.R_EAX, val);
- } else {
+ }
+ else {
val = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
- cmp_word(M.x86.R_AX, (u16)val);
+ cmp_word(M.x86.R_AX, (u16) val);
}
M.x86.R_CX -= 1;
M.x86.R_DI += inc;
break; /* zero flag set means equal */
}
M.x86.mode &= ~SYSMODE_PREFIX_REPNE;
- } else {
+ }
+ else {
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
val = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
cmp_long(M.x86.R_EAX, val);
- } else {
+ }
+ else {
val = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
- cmp_word(M.x86.R_AX, (u16)val);
+ cmp_word(M.x86.R_AX, (u16) val);
}
M.x86.R_DI += inc;
}
REMARKS:
Handles opcode 0xb0
****************************************************************************/
-static void x86emuOp_mov_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
{
u8 imm;
REMARKS:
Handles opcode 0xb1
****************************************************************************/
-static void x86emuOp_mov_byte_CL_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_byte_CL_IMM(u8 X86EMU_UNUSED(op1))
{
u8 imm;
REMARKS:
Handles opcode 0xb2
****************************************************************************/
-static void x86emuOp_mov_byte_DL_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_byte_DL_IMM(u8 X86EMU_UNUSED(op1))
{
u8 imm;
REMARKS:
Handles opcode 0xb3
****************************************************************************/
-static void x86emuOp_mov_byte_BL_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_byte_BL_IMM(u8 X86EMU_UNUSED(op1))
{
u8 imm;
REMARKS:
Handles opcode 0xb4
****************************************************************************/
-static void x86emuOp_mov_byte_AH_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_byte_AH_IMM(u8 X86EMU_UNUSED(op1))
{
u8 imm;
REMARKS:
Handles opcode 0xb5
****************************************************************************/
-static void x86emuOp_mov_byte_CH_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_byte_CH_IMM(u8 X86EMU_UNUSED(op1))
{
u8 imm;
REMARKS:
Handles opcode 0xb6
****************************************************************************/
-static void x86emuOp_mov_byte_DH_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_byte_DH_IMM(u8 X86EMU_UNUSED(op1))
{
u8 imm;
REMARKS:
Handles opcode 0xb7
****************************************************************************/
-static void x86emuOp_mov_byte_BH_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_byte_BH_IMM(u8 X86EMU_UNUSED(op1))
{
u8 imm;
REMARKS:
Handles opcode 0xb8
****************************************************************************/
-static void x86emuOp_mov_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_word_AX_IMM(u8 X86EMU_UNUSED(op1))
{
u32 srcval;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("MOV\tEAX,");
srcval = fetch_long_imm();
- } else {
+ }
+ else {
DECODE_PRINTF("MOV\tAX,");
srcval = fetch_word_imm();
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EAX = srcval;
- } else {
- M.x86.R_AX = (u16)srcval;
+ }
+ else {
+ M.x86.R_AX = (u16) srcval;
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0xb9
****************************************************************************/
-static void x86emuOp_mov_word_CX_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_word_CX_IMM(u8 X86EMU_UNUSED(op1))
{
u32 srcval;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("MOV\tECX,");
srcval = fetch_long_imm();
- } else {
+ }
+ else {
DECODE_PRINTF("MOV\tCX,");
srcval = fetch_word_imm();
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_ECX = srcval;
- } else {
- M.x86.R_CX = (u16)srcval;
+ }
+ else {
+ M.x86.R_CX = (u16) srcval;
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0xba
****************************************************************************/
-static void x86emuOp_mov_word_DX_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_word_DX_IMM(u8 X86EMU_UNUSED(op1))
{
u32 srcval;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("MOV\tEDX,");
srcval = fetch_long_imm();
- } else {
+ }
+ else {
DECODE_PRINTF("MOV\tDX,");
srcval = fetch_word_imm();
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EDX = srcval;
- } else {
- M.x86.R_DX = (u16)srcval;
+ }
+ else {
+ M.x86.R_DX = (u16) srcval;
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0xbb
****************************************************************************/
-static void x86emuOp_mov_word_BX_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_word_BX_IMM(u8 X86EMU_UNUSED(op1))
{
u32 srcval;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("MOV\tEBX,");
srcval = fetch_long_imm();
- } else {
+ }
+ else {
DECODE_PRINTF("MOV\tBX,");
srcval = fetch_word_imm();
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EBX = srcval;
- } else {
- M.x86.R_BX = (u16)srcval;
+ }
+ else {
+ M.x86.R_BX = (u16) srcval;
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0xbc
****************************************************************************/
-static void x86emuOp_mov_word_SP_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_word_SP_IMM(u8 X86EMU_UNUSED(op1))
{
u32 srcval;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("MOV\tESP,");
srcval = fetch_long_imm();
- } else {
+ }
+ else {
DECODE_PRINTF("MOV\tSP,");
srcval = fetch_word_imm();
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_ESP = srcval;
- } else {
- M.x86.R_SP = (u16)srcval;
+ }
+ else {
+ M.x86.R_SP = (u16) srcval;
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0xbd
****************************************************************************/
-static void x86emuOp_mov_word_BP_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_word_BP_IMM(u8 X86EMU_UNUSED(op1))
{
u32 srcval;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("MOV\tEBP,");
srcval = fetch_long_imm();
- } else {
+ }
+ else {
DECODE_PRINTF("MOV\tBP,");
srcval = fetch_word_imm();
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EBP = srcval;
- } else {
- M.x86.R_BP = (u16)srcval;
+ }
+ else {
+ M.x86.R_BP = (u16) srcval;
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0xbe
****************************************************************************/
-static void x86emuOp_mov_word_SI_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_word_SI_IMM(u8 X86EMU_UNUSED(op1))
{
u32 srcval;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("MOV\tESI,");
srcval = fetch_long_imm();
- } else {
+ }
+ else {
DECODE_PRINTF("MOV\tSI,");
srcval = fetch_word_imm();
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_ESI = srcval;
- } else {
- M.x86.R_SI = (u16)srcval;
+ }
+ else {
+ M.x86.R_SI = (u16) srcval;
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0xbf
****************************************************************************/
-static void x86emuOp_mov_word_DI_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_word_DI_IMM(u8 X86EMU_UNUSED(op1))
{
u32 srcval;
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("MOV\tEDI,");
srcval = fetch_long_imm();
- } else {
+ }
+ else {
DECODE_PRINTF("MOV\tDI,");
srcval = fetch_word_imm();
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
M.x86.R_EDI = srcval;
- } else {
- M.x86.R_DI = (u16)srcval;
+ }
+ else {
+ M.x86.R_DI = (u16) srcval;
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
}
/* used by opcodes c0, d0, and d2. */
-static u8(*opcD0_byte_operation[])(u8 d, u8 s) =
-{
- rol_byte,
- ror_byte,
- rcl_byte,
- rcr_byte,
- shl_byte,
- shr_byte,
- shl_byte, /* sal_byte === shl_byte by definition */
- sar_byte,
-};
+static u8(*opcD0_byte_operation[]) (u8 d, u8 s) = {
+ rol_byte, ror_byte, rcl_byte, rcr_byte, shl_byte, shr_byte, shl_byte, /* sal_byte === shl_byte by definition */
+sar_byte,};
/****************************************************************************
REMARKS:
Handles opcode 0xc0
****************************************************************************/
-static void x86emuOp_opcC0_byte_RM_MEM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_opcC0_byte_RM_MEM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg;
destval = (*opcD0_byte_operation[rh]) (destval, amt);
store_data_byte(destoffset, destval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rl);
amt = fetch_byte_imm();
DECODE_PRINTF2(",%x\n", amt);
}
/* used by opcodes c1, d1, and d3. */
-static u16(*opcD1_word_operation[])(u16 s, u8 d) =
-{
- rol_word,
- ror_word,
- rcl_word,
- rcr_word,
- shl_word,
- shr_word,
- shl_word, /* sal_byte === shl_byte by definition */
- sar_word,
-};
+static u16(*opcD1_word_operation[]) (u16 s, u8 d) = {
+ rol_word, ror_word, rcl_word, rcr_word, shl_word, shr_word, shl_word, /* sal_byte === shl_byte by definition */
+sar_word,};
/* used by opcodes c1, d1, and d3. */
-static u32 (*opcD1_long_operation[])(u32 s, u8 d) =
-{
- rol_long,
- ror_long,
- rcl_long,
- rcr_long,
- shl_long,
- shr_long,
- shl_long, /* sal_byte === shl_byte by definition */
- sar_long,
-};
+static u32(*opcD1_long_operation[]) (u32 s, u8 d) = {
+ rol_long, ror_long, rcl_long, rcr_long, shl_long, shr_long, shl_long, /* sal_byte === shl_byte by definition */
+sar_long,};
/****************************************************************************
REMARKS:
Handles opcode 0xc1
****************************************************************************/
-static void x86emuOp_opcC1_word_RM_MEM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_opcC1_word_RM_MEM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
TRACE_AND_STEP();
destval = (*opcD1_long_operation[rh]) (destval, amt);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("WORD PTR ");
TRACE_AND_STEP();
destval = (*opcD1_long_operation[rh]) (destval, amt);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("WORD PTR ");
TRACE_AND_STEP();
destval = (*opcD1_long_operation[rh]) (destval, amt);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("WORD PTR ");
store_data_word(destoffset, destval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 *destreg;
DECODE_PRINTF2(",%x\n", amt);
TRACE_AND_STEP();
*destreg = (*opcD1_long_operation[rh]) (*destreg, amt);
- } else {
+ }
+ else {
u16 *destreg;
destreg = DECODE_RM_WORD_REGISTER(rl);
REMARKS:
Handles opcode 0xc2
****************************************************************************/
-static void x86emuOp_ret_near_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_ret_near_IMM(u8 X86EMU_UNUSED(op1))
{
u16 imm;
DECODE_PRINTF("RET\t");
imm = fetch_word_imm();
DECODE_PRINTF2("%x\n", imm);
- RETURN_TRACE("RET",M.x86.saved_cs,M.x86.saved_ip);
- TRACE_AND_STEP();
+ RETURN_TRACE("RET", M.x86.saved_cs, M.x86.saved_ip);
+ TRACE_AND_STEP();
M.x86.R_IP = pop_word();
M.x86.R_SP += imm;
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0xc3
****************************************************************************/
-static void x86emuOp_ret_near(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_ret_near(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("RET\n");
- RETURN_TRACE("RET",M.x86.saved_cs,M.x86.saved_ip);
- TRACE_AND_STEP();
+ RETURN_TRACE("RET", M.x86.saved_cs, M.x86.saved_ip);
+ TRACE_AND_STEP();
M.x86.R_IP = pop_word();
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0xc4
****************************************************************************/
-static void x86emuOp_les_R_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_les_R_IMM(u8 X86EMU_UNUSED(op1))
{
int mod, rh, rl;
u16 *dstreg;
*dstreg = fetch_data_word(srcoffset);
M.x86.R_ES = fetch_data_word(srcoffset + 2);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
/* UNDEFINED! */
TRACE_AND_STEP();
}
REMARKS:
Handles opcode 0xc5
****************************************************************************/
-static void x86emuOp_lds_R_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_lds_R_IMM(u8 X86EMU_UNUSED(op1))
{
int mod, rh, rl;
u16 *dstreg;
*dstreg = fetch_data_word(srcoffset);
M.x86.R_DS = fetch_data_word(srcoffset + 2);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
/* UNDEFINED! */
TRACE_AND_STEP();
}
REMARKS:
Handles opcode 0xc6
****************************************************************************/
-static void x86emuOp_mov_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg;
TRACE_AND_STEP();
store_data_byte(destoffset, imm);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rl);
imm = fetch_byte_imm();
DECODE_PRINTF2(",%2x\n", imm);
REMARKS:
Handles opcode 0xc7
****************************************************************************/
-static void x86emuOp_mov_word_RM_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_mov_word_RM_IMM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
DECODE_PRINTF2(",%x\n", imm);
TRACE_AND_STEP();
store_data_long(destoffset, imm);
- } else {
+ }
+ else {
u16 imm;
DECODE_PRINTF("WORD PTR ");
DECODE_PRINTF2(",%x\n", imm);
TRACE_AND_STEP();
store_data_long(destoffset, imm);
- } else {
+ }
+ else {
u16 imm;
DECODE_PRINTF("WORD PTR ");
DECODE_PRINTF2(",%x\n", imm);
TRACE_AND_STEP();
store_data_long(destoffset, imm);
- } else {
+ }
+ else {
u16 imm;
DECODE_PRINTF("WORD PTR ");
store_data_word(destoffset, imm);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 *destreg;
- u32 imm;
+ u32 *destreg;
+ u32 imm;
destreg = DECODE_RM_LONG_REGISTER(rl);
imm = fetch_long_imm();
DECODE_PRINTF2(",%x\n", imm);
TRACE_AND_STEP();
*destreg = imm;
- } else {
- u16 *destreg;
- u16 imm;
+ }
+ else {
+ u16 *destreg;
+ u16 imm;
destreg = DECODE_RM_WORD_REGISTER(rl);
imm = fetch_word_imm();
REMARKS:
Handles opcode 0xc8
****************************************************************************/
-static void x86emuOp_enter(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_enter(u8 X86EMU_UNUSED(op1))
{
- u16 local,frame_pointer;
- u8 nesting;
+ u16 local, frame_pointer;
+ u8 nesting;
int i;
START_OF_INSTR();
for (i = 1; i < nesting; i++) {
M.x86.R_BP -= 2;
push_word(fetch_data_word_abs(M.x86.R_SS, M.x86.R_BP));
- }
- push_word(frame_pointer);
}
+ push_word(frame_pointer);
+ }
M.x86.R_BP = frame_pointer;
- M.x86.R_SP = (u16)(M.x86.R_SP - local);
+ M.x86.R_SP = (u16) (M.x86.R_SP - local);
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
}
REMARKS:
Handles opcode 0xc9
****************************************************************************/
-static void x86emuOp_leave(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_leave(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("LEAVE\n");
REMARKS:
Handles opcode 0xca
****************************************************************************/
-static void x86emuOp_ret_far_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_ret_far_IMM(u8 X86EMU_UNUSED(op1))
{
u16 imm;
DECODE_PRINTF("RETF\t");
imm = fetch_word_imm();
DECODE_PRINTF2("%x\n", imm);
- RETURN_TRACE("RETF",M.x86.saved_cs,M.x86.saved_ip);
- TRACE_AND_STEP();
+ RETURN_TRACE("RETF", M.x86.saved_cs, M.x86.saved_ip);
+ TRACE_AND_STEP();
M.x86.R_IP = pop_word();
M.x86.R_CS = pop_word();
M.x86.R_SP += imm;
REMARKS:
Handles opcode 0xcb
****************************************************************************/
-static void x86emuOp_ret_far(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_ret_far(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("RETF\n");
- RETURN_TRACE("RETF",M.x86.saved_cs,M.x86.saved_ip);
- TRACE_AND_STEP();
+ RETURN_TRACE("RETF", M.x86.saved_cs, M.x86.saved_ip);
+ TRACE_AND_STEP();
M.x86.R_IP = pop_word();
M.x86.R_CS = pop_word();
DECODE_CLEAR_SEGOVR();
REMARKS:
Handles opcode 0xcc
****************************************************************************/
-static void x86emuOp_int3(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_int3(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("INT 3\n");
TRACE_AND_STEP();
if (_X86EMU_intrTab[3]) {
- (*_X86EMU_intrTab[3])(3);
- } else {
- push_word((u16)M.x86.R_FLG);
+ (*_X86EMU_intrTab[3]) (3);
+ }
+ else {
+ push_word((u16) M.x86.R_FLG);
CLEAR_FLAG(F_IF);
CLEAR_FLAG(F_TF);
push_word(M.x86.R_CS);
REMARKS:
Handles opcode 0xcd
****************************************************************************/
-static void x86emuOp_int_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_int_IMM(u8 X86EMU_UNUSED(op1))
{
u8 intnum;
DECODE_PRINTF2("%x\n", intnum);
TRACE_AND_STEP();
if (_X86EMU_intrTab[intnum]) {
- (*_X86EMU_intrTab[intnum])(intnum);
- } else {
- push_word((u16)M.x86.R_FLG);
+ (*_X86EMU_intrTab[intnum]) (intnum);
+ }
+ else {
+ push_word((u16) M.x86.R_FLG);
CLEAR_FLAG(F_IF);
CLEAR_FLAG(F_TF);
push_word(M.x86.R_CS);
REMARKS:
Handles opcode 0xce
****************************************************************************/
-static void x86emuOp_into(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_into(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("INTO\n");
TRACE_AND_STEP();
if (ACCESS_FLAG(F_OF)) {
- if (_X86EMU_intrTab[4]) {
- (*_X86EMU_intrTab[4])(4);
- } else {
- push_word((u16)M.x86.R_FLG);
+ if (_X86EMU_intrTab[4]) {
+ (*_X86EMU_intrTab[4]) (4);
+ }
+ else {
+ push_word((u16) M.x86.R_FLG);
CLEAR_FLAG(F_IF);
CLEAR_FLAG(F_TF);
push_word(M.x86.R_CS);
REMARKS:
Handles opcode 0xcf
****************************************************************************/
-static void x86emuOp_iret(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_iret(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("IRET\n");
REMARKS:
Handles opcode 0xd0
****************************************************************************/
-static void x86emuOp_opcD0_byte_RM_1(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_opcD0_byte_RM_1(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg;
destval = (*opcD0_byte_operation[rh]) (destval, 1);
store_data_byte(destoffset, destval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rl);
DECODE_PRINTF(",1\n");
TRACE_AND_STEP();
REMARKS:
Handles opcode 0xd1
****************************************************************************/
-static void x86emuOp_opcD1_word_RM_1(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_opcD1_word_RM_1(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
TRACE_AND_STEP();
destval = (*opcD1_long_operation[rh]) (destval, 1);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("WORD PTR ");
TRACE_AND_STEP();
destval = (*opcD1_long_operation[rh]) (destval, 1);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("WORD PTR ");
TRACE_AND_STEP();
destval = (*opcD1_long_operation[rh]) (destval, 1);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("BYTE PTR ");
store_data_word(destoffset, destval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 destval;
- u32 *destreg;
+ u32 destval;
+ u32 *destreg;
destreg = DECODE_RM_LONG_REGISTER(rl);
DECODE_PRINTF(",1\n");
TRACE_AND_STEP();
destval = (*opcD1_long_operation[rh]) (*destreg, 1);
*destreg = destval;
- } else {
- u16 destval;
- u16 *destreg;
+ }
+ else {
+ u16 destval;
+ u16 *destreg;
destreg = DECODE_RM_WORD_REGISTER(rl);
DECODE_PRINTF(",1\n");
REMARKS:
Handles opcode 0xd2
****************************************************************************/
-static void x86emuOp_opcD2_byte_RM_CL(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_opcD2_byte_RM_CL(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg;
destval = (*opcD0_byte_operation[rh]) (destval, amt);
store_data_byte(destoffset, destval);
break;
- case 3: /* register to register */
+ case 3: /* register to register */
destreg = DECODE_RM_BYTE_REGISTER(rl);
DECODE_PRINTF(",CL\n");
TRACE_AND_STEP();
REMARKS:
Handles opcode 0xd3
****************************************************************************/
-static void x86emuOp_opcD3_word_RM_CL(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_opcD3_word_RM_CL(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
TRACE_AND_STEP();
destval = (*opcD1_long_operation[rh]) (destval, amt);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("WORD PTR ");
TRACE_AND_STEP();
destval = (*opcD1_long_operation[rh]) (destval, amt);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("WORD PTR ");
TRACE_AND_STEP();
destval = (*opcD1_long_operation[rh]) (destval, amt);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("WORD PTR ");
store_data_word(destoffset, destval);
}
break;
- case 3: /* register to register */
+ case 3: /* register to register */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 *destreg;
DECODE_PRINTF(",CL\n");
TRACE_AND_STEP();
*destreg = (*opcD1_long_operation[rh]) (*destreg, amt);
- } else {
+ }
+ else {
u16 *destreg;
destreg = DECODE_RM_WORD_REGISTER(rl);
REMARKS:
Handles opcode 0xd4
****************************************************************************/
-static void x86emuOp_aam(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_aam(u8 X86EMU_UNUSED(op1))
{
u8 a;
START_OF_INSTR();
DECODE_PRINTF("AAM\n");
- a = fetch_byte_imm(); /* this is a stupid encoding. */
+ a = fetch_byte_imm(); /* this is a stupid encoding. */
if (a != 10) {
- /* fix: add base decoding
- aam_word(u8 val, int base a) */
+ /* fix: add base decoding
+ aam_word(u8 val, int base a) */
DECODE_PRINTF("ERROR DECODING AAM\n");
TRACE_REGS();
HALT_SYS();
REMARKS:
Handles opcode 0xd5
****************************************************************************/
-static void x86emuOp_aad(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_aad(u8 X86EMU_UNUSED(op1))
{
u8 a;
DECODE_PRINTF("AAD\n");
a = fetch_byte_imm();
if (a != 10) {
- /* fix: add base decoding
- aad_word(u16 val, int base a) */
+ /* fix: add base decoding
+ aad_word(u16 val, int base a) */
DECODE_PRINTF("ERROR DECODING AAM\n");
TRACE_REGS();
HALT_SYS();
REMARKS:
Handles opcode 0xd7
****************************************************************************/
-static void x86emuOp_xlat(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_xlat(u8 X86EMU_UNUSED(op1))
{
u16 addr;
START_OF_INSTR();
DECODE_PRINTF("XLAT\n");
TRACE_AND_STEP();
- addr = (u16)(M.x86.R_BX + (u8)M.x86.R_AL);
+ addr = (u16) (M.x86.R_BX + (u8) M.x86.R_AL);
M.x86.R_AL = fetch_data_byte(addr);
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0xe0
****************************************************************************/
-static void x86emuOp_loopne(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_loopne(u8 X86EMU_UNUSED(op1))
{
s16 ip;
DECODE_PRINTF2("%04x\n", ip);
TRACE_AND_STEP();
M.x86.R_CX -= 1;
- if (M.x86.R_CX != 0 && !ACCESS_FLAG(F_ZF)) /* CX != 0 and !ZF */
+ if (M.x86.R_CX != 0 && !ACCESS_FLAG(F_ZF)) /* CX != 0 and !ZF */
M.x86.R_IP = ip;
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0xe1
****************************************************************************/
-static void x86emuOp_loope(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_loope(u8 X86EMU_UNUSED(op1))
{
s16 ip;
DECODE_PRINTF2("%04x\n", ip);
TRACE_AND_STEP();
M.x86.R_CX -= 1;
- if (M.x86.R_CX != 0 && ACCESS_FLAG(F_ZF)) /* CX != 0 and ZF */
+ if (M.x86.R_CX != 0 && ACCESS_FLAG(F_ZF)) /* CX != 0 and ZF */
M.x86.R_IP = ip;
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0xe2
****************************************************************************/
-static void x86emuOp_loop(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_loop(u8 X86EMU_UNUSED(op1))
{
s16 ip;
REMARKS:
Handles opcode 0xe3
****************************************************************************/
-static void x86emuOp_jcxz(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jcxz(u8 X86EMU_UNUSED(op1))
{
u16 target;
- s8 offset;
+ s8 offset;
/* jump to byte offset if overflow flag is set */
START_OF_INSTR();
DECODE_PRINTF("JCXZ\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
if (M.x86.R_CX == 0)
REMARKS:
Handles opcode 0xe4
****************************************************************************/
-static void x86emuOp_in_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_in_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
{
u8 port;
START_OF_INSTR();
DECODE_PRINTF("IN\t");
- port = (u8) fetch_byte_imm();
+ port = (u8) fetch_byte_imm();
DECODE_PRINTF2("%x,AL\n", port);
TRACE_AND_STEP();
- M.x86.R_AL = (*sys_inb)(port);
+ M.x86.R_AL = (*sys_inb) (port);
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
}
REMARKS:
Handles opcode 0xe5
****************************************************************************/
-static void x86emuOp_in_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_in_word_AX_IMM(u8 X86EMU_UNUSED(op1))
{
u8 port;
START_OF_INSTR();
DECODE_PRINTF("IN\t");
- port = (u8) fetch_byte_imm();
+ port = (u8) fetch_byte_imm();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF2("EAX,%x\n", port);
- } else {
+ }
+ else {
DECODE_PRINTF2("AX,%x\n", port);
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- M.x86.R_EAX = (*sys_inl)(port);
- } else {
- M.x86.R_AX = (*sys_inw)(port);
+ M.x86.R_EAX = (*sys_inl) (port);
+ }
+ else {
+ M.x86.R_AX = (*sys_inw) (port);
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0xe6
****************************************************************************/
-static void x86emuOp_out_byte_IMM_AL(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_out_byte_IMM_AL(u8 X86EMU_UNUSED(op1))
{
u8 port;
START_OF_INSTR();
DECODE_PRINTF("OUT\t");
- port = (u8) fetch_byte_imm();
+ port = (u8) fetch_byte_imm();
DECODE_PRINTF2("%x,AL\n", port);
TRACE_AND_STEP();
- (*sys_outb)(port, M.x86.R_AL);
+ (*sys_outb) (port, M.x86.R_AL);
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
}
REMARKS:
Handles opcode 0xe7
****************************************************************************/
-static void x86emuOp_out_word_IMM_AX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_out_word_IMM_AX(u8 X86EMU_UNUSED(op1))
{
u8 port;
START_OF_INSTR();
DECODE_PRINTF("OUT\t");
- port = (u8) fetch_byte_imm();
+ port = (u8) fetch_byte_imm();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF2("%x,EAX\n", port);
- } else {
+ }
+ else {
DECODE_PRINTF2("%x,AX\n", port);
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- (*sys_outl)(port, M.x86.R_EAX);
- } else {
- (*sys_outw)(port, M.x86.R_AX);
+ (*sys_outl) (port, M.x86.R_EAX);
+ }
+ else {
+ (*sys_outw) (port, M.x86.R_AX);
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0xe8
****************************************************************************/
-static void x86emuOp_call_near_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_call_near_IMM(u8 X86EMU_UNUSED(op1))
{
- s16 ip;
+ s16 ip16;
+ s32 ip32;
START_OF_INSTR();
- DECODE_PRINTF("CALL\t");
- ip = (s16) fetch_word_imm();
- ip += (s16) M.x86.R_IP; /* CHECK SIGN */
- DECODE_PRINTF2("%04x\n", (u16)ip);
- CALL_TRACE(M.x86.saved_cs, M.x86.saved_ip, M.x86.R_CS, ip, "");
+ DECODE_PRINTF("CALL\t");
+ if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+ ip32 = (s32) fetch_long_imm();
+ ip32 += (s16) M.x86.R_IP; /* CHECK SIGN */
+ DECODE_PRINTF2("%04x\n", (u16) ip32);
+ CALL_TRACE(M.x86.saved_cs, M.x86.saved_ip, M.x86.R_CS, ip32, "");
+ }
+ else {
+ ip16 = (s16) fetch_word_imm();
+ ip16 += (s16) M.x86.R_IP; /* CHECK SIGN */
+ DECODE_PRINTF2("%04x\n", (u16) ip16);
+ CALL_TRACE(M.x86.saved_cs, M.x86.saved_ip, M.x86.R_CS, ip16, "");
+ }
TRACE_AND_STEP();
- push_word(M.x86.R_IP);
- M.x86.R_IP = ip;
+ if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+ push_long(M.x86.R_EIP);
+ M.x86.R_EIP = ip32 & 0xffff;
+ }
+ else {
+ push_word(M.x86.R_IP);
+ M.x86.R_EIP = ip16;
+ }
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
}
REMARKS:
Handles opcode 0xe9
****************************************************************************/
-static void x86emuOp_jump_near_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_near_IMM(u8 X86EMU_UNUSED(op1))
{
- int ip;
+ u32 ip;
START_OF_INSTR();
DECODE_PRINTF("JMP\t");
- ip = (s16)fetch_word_imm();
- ip += (s16)M.x86.R_IP;
- DECODE_PRINTF2("%04x\n", (u16)ip);
- TRACE_AND_STEP();
- M.x86.R_IP = (u16)ip;
+ if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+ ip = (u32) fetch_long_imm();
+ ip += (u32) M.x86.R_EIP;
+ DECODE_PRINTF2("%08x\n", (u32) ip);
+ TRACE_AND_STEP();
+ M.x86.R_EIP = (u32) ip;
+ }
+ else {
+ ip = (s16) fetch_word_imm();
+ ip += (s16) M.x86.R_IP;
+ DECODE_PRINTF2("%04x\n", (u16) ip);
+ TRACE_AND_STEP();
+ M.x86.R_IP = (u16) ip;
+ }
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
}
REMARKS:
Handles opcode 0xea
****************************************************************************/
-static void x86emuOp_jump_far_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_far_IMM(u8 X86EMU_UNUSED(op1))
{
- u16 cs, ip;
+ u16 cs;
+ u32 ip;
START_OF_INSTR();
DECODE_PRINTF("JMP\tFAR ");
- ip = fetch_word_imm();
+ if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+ ip = fetch_long_imm();
+ }
+ else {
+ ip = fetch_word_imm();
+ }
cs = fetch_word_imm();
DECODE_PRINTF2("%04x:", cs);
DECODE_PRINTF2("%04x\n", ip);
TRACE_AND_STEP();
- M.x86.R_IP = ip;
+ M.x86.R_EIP = ip & 0xffff;
M.x86.R_CS = cs;
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0xeb
****************************************************************************/
-static void x86emuOp_jump_byte_IMM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_jump_byte_IMM(u8 X86EMU_UNUSED(op1))
{
u16 target;
s8 offset;
START_OF_INSTR();
DECODE_PRINTF("JMP\t");
- offset = (s8)fetch_byte_imm();
- target = (u16)(M.x86.R_IP + offset);
+ offset = (s8) fetch_byte_imm();
+ target = (u16) (M.x86.R_IP + offset);
DECODE_PRINTF2("%x\n", target);
TRACE_AND_STEP();
M.x86.R_IP = target;
REMARKS:
Handles opcode 0xec
****************************************************************************/
-static void x86emuOp_in_byte_AL_DX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_in_byte_AL_DX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("IN\tAL,DX\n");
TRACE_AND_STEP();
- M.x86.R_AL = (*sys_inb)(M.x86.R_DX);
+ M.x86.R_AL = (*sys_inb) (M.x86.R_DX);
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
}
REMARKS:
Handles opcode 0xed
****************************************************************************/
-static void x86emuOp_in_word_AX_DX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_in_word_AX_DX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("IN\tEAX,DX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("IN\tAX,DX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- M.x86.R_EAX = (*sys_inl)(M.x86.R_DX);
- } else {
- M.x86.R_AX = (*sys_inw)(M.x86.R_DX);
+ M.x86.R_EAX = (*sys_inl) (M.x86.R_DX);
+ }
+ else {
+ M.x86.R_AX = (*sys_inw) (M.x86.R_DX);
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0xee
****************************************************************************/
-static void x86emuOp_out_byte_DX_AL(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_out_byte_DX_AL(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("OUT\tDX,AL\n");
TRACE_AND_STEP();
- (*sys_outb)(M.x86.R_DX, M.x86.R_AL);
+ (*sys_outb) (M.x86.R_DX, M.x86.R_AL);
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
}
REMARKS:
Handles opcode 0xef
****************************************************************************/
-static void x86emuOp_out_word_DX_AX(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_out_word_DX_AX(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("OUT\tDX,EAX\n");
- } else {
+ }
+ else {
DECODE_PRINTF("OUT\tDX,AX\n");
}
TRACE_AND_STEP();
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- (*sys_outl)(M.x86.R_DX, M.x86.R_EAX);
- } else {
- (*sys_outw)(M.x86.R_DX, M.x86.R_AX);
+ (*sys_outl) (M.x86.R_DX, M.x86.R_EAX);
+ }
+ else {
+ (*sys_outw) (M.x86.R_DX, M.x86.R_AX);
}
DECODE_CLEAR_SEGOVR();
END_OF_INSTR();
REMARKS:
Handles opcode 0xf0
****************************************************************************/
-static void x86emuOp_lock(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_lock(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("LOCK:\n");
REMARKS:
Handles opcode 0xf2
****************************************************************************/
-static void x86emuOp_repne(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_repne(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("REPNE\n");
REMARKS:
Handles opcode 0xf3
****************************************************************************/
-static void x86emuOp_repe(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_repe(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("REPE\n");
REMARKS:
Handles opcode 0xf4
****************************************************************************/
-static void x86emuOp_halt(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_halt(u8 X86EMU_UNUSED(op1))
{
START_OF_INSTR();
DECODE_PRINTF("HALT\n");
REMARKS:
Handles opcode 0xf5
****************************************************************************/
-static void x86emuOp_cmc(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_cmc(u8 X86EMU_UNUSED(op1))
{
/* complement the carry flag. */
START_OF_INSTR();
REMARKS:
Handles opcode 0xf6
****************************************************************************/
-static void x86emuOp_opcF6_byte_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_opcF6_byte_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
u8 *destreg;
START_OF_INSTR();
FETCH_DECODE_MODRM(mod, rh, rl);
switch (mod) {
- case 0: /* mod=00 */
+ case 0: /* mod=00 */
switch (rh) {
- case 0: /* test byte imm */
+ case 0: /* test byte imm */
DECODE_PRINTF("TEST\tBYTE PTR ");
destoffset = decode_rm00_address(rl);
DECODE_PRINTF(",");
break;
}
break; /* end mod==00 */
- case 1: /* mod=01 */
+ case 1: /* mod=01 */
switch (rh) {
- case 0: /* test byte imm */
+ case 0: /* test byte imm */
DECODE_PRINTF("TEST\tBYTE PTR ");
destoffset = decode_rm01_address(rl);
DECODE_PRINTF(",");
break;
}
break; /* end mod==01 */
- case 2: /* mod=10 */
+ case 2: /* mod=10 */
switch (rh) {
- case 0: /* test byte imm */
+ case 0: /* test byte imm */
DECODE_PRINTF("TEST\tBYTE PTR ");
destoffset = decode_rm10_address(rl);
DECODE_PRINTF(",");
break;
}
break; /* end mod==10 */
- case 3: /* mod=11 */
+ case 3: /* mod=11 */
switch (rh) {
- case 0: /* test byte imm */
+ case 0: /* test byte imm */
DECODE_PRINTF("TEST\t");
destreg = DECODE_RM_BYTE_REGISTER(rl);
DECODE_PRINTF(",");
destreg = DECODE_RM_BYTE_REGISTER(rl);
DECODE_PRINTF("\n");
TRACE_AND_STEP();
- mul_byte(*destreg); /*!!! */
+ mul_byte(*destreg); /*!!! */
break;
case 5:
DECODE_PRINTF("IMUL\t");
REMARKS:
Handles opcode 0xf7
****************************************************************************/
-static void x86emuOp_opcF7_word_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_opcF7_word_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rl, rh;
uint destoffset;
START_OF_INSTR();
FETCH_DECODE_MODRM(mod, rh, rl);
switch (mod) {
- case 0: /* mod=00 */
+ case 0: /* mod=00 */
switch (rh) {
- case 0: /* test word imm */
+ case 0: /* test word imm */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 destval,srcval;
+ u32 destval, srcval;
DECODE_PRINTF("TEST\tDWORD PTR ");
destoffset = decode_rm00_address(rl);
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
test_long(destval, srcval);
- } else {
- u16 destval,srcval;
+ }
+ else {
+ u16 destval, srcval;
DECODE_PRINTF("TEST\tWORD PTR ");
destoffset = decode_rm00_address(rl);
TRACE_AND_STEP();
destval = not_long(destval);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("NOT\tWORD PTR ");
TRACE_AND_STEP();
destval = neg_long(destval);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("NEG\tWORD PTR ");
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
mul_long(destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("MUL\tWORD PTR ");
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
imul_long(destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("IMUL\tWORD PTR ");
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
div_long(destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("DIV\tWORD PTR ");
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
idiv_long(destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("IDIV\tWORD PTR ");
break;
}
break; /* end mod==00 */
- case 1: /* mod=01 */
+ case 1: /* mod=01 */
switch (rh) {
- case 0: /* test word imm */
+ case 0: /* test word imm */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 destval,srcval;
+ u32 destval, srcval;
DECODE_PRINTF("TEST\tDWORD PTR ");
destoffset = decode_rm01_address(rl);
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
test_long(destval, srcval);
- } else {
- u16 destval,srcval;
+ }
+ else {
+ u16 destval, srcval;
DECODE_PRINTF("TEST\tWORD PTR ");
destoffset = decode_rm01_address(rl);
TRACE_AND_STEP();
destval = not_long(destval);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("NOT\tWORD PTR ");
TRACE_AND_STEP();
destval = neg_long(destval);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("NEG\tWORD PTR ");
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
mul_long(destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("MUL\tWORD PTR ");
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
imul_long(destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("IMUL\tWORD PTR ");
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
div_long(destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("DIV\tWORD PTR ");
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
idiv_long(destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("IDIV\tWORD PTR ");
break;
}
break; /* end mod==01 */
- case 2: /* mod=10 */
+ case 2: /* mod=10 */
switch (rh) {
- case 0: /* test word imm */
+ case 0: /* test word imm */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
- u32 destval,srcval;
+ u32 destval, srcval;
DECODE_PRINTF("TEST\tDWORD PTR ");
destoffset = decode_rm10_address(rl);
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
test_long(destval, srcval);
- } else {
- u16 destval,srcval;
+ }
+ else {
+ u16 destval, srcval;
DECODE_PRINTF("TEST\tWORD PTR ");
destoffset = decode_rm10_address(rl);
TRACE_AND_STEP();
destval = not_long(destval);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("NOT\tWORD PTR ");
TRACE_AND_STEP();
destval = neg_long(destval);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("NEG\tWORD PTR ");
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
mul_long(destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("MUL\tWORD PTR ");
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
imul_long(destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("IMUL\tWORD PTR ");
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
div_long(destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("DIV\tWORD PTR ");
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
idiv_long(destval);
- } else {
+ }
+ else {
u16 destval;
DECODE_PRINTF("IDIV\tWORD PTR ");
break;
}
break; /* end mod==10 */
- case 3: /* mod=11 */
+ case 3: /* mod=11 */
switch (rh) {
- case 0: /* test word imm */
+ case 0: /* test word imm */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 *destreg;
u32 srcval;
DECODE_PRINTF2("%x\n", srcval);
TRACE_AND_STEP();
test_long(*destreg, srcval);
- } else {
+ }
+ else {
u16 *destreg;
u16 srcval;
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = not_long(*destreg);
- } else {
+ }
+ else {
u16 *destreg;
DECODE_PRINTF("NOT\t");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = neg_long(*destreg);
- } else {
+ }
+ else {
u16 *destreg;
DECODE_PRINTF("NEG\t");
destreg = DECODE_RM_LONG_REGISTER(rl);
DECODE_PRINTF("\n");
TRACE_AND_STEP();
- mul_long(*destreg); /*!!! */
- } else {
+ mul_long(*destreg); /*!!! */
+ }
+ else {
u16 *destreg;
DECODE_PRINTF("MUL\t");
destreg = DECODE_RM_WORD_REGISTER(rl);
DECODE_PRINTF("\n");
TRACE_AND_STEP();
- mul_word(*destreg); /*!!! */
+ mul_word(*destreg); /*!!! */
}
break;
case 5:
DECODE_PRINTF("\n");
TRACE_AND_STEP();
imul_long(*destreg);
- } else {
+ }
+ else {
u16 *destreg;
DECODE_PRINTF("IMUL\t");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
div_long(*destreg);
- } else {
+ }
+ else {
u16 *destreg;
DECODE_PRINTF("DIV\t");
DECODE_PRINTF("\n");
TRACE_AND_STEP();
idiv_long(*destreg);
- } else {
+ }
+ else {
u16 *destreg;
DECODE_PRINTF("IDIV\t");
REMARKS:
Handles opcode 0xf8
****************************************************************************/
-static void x86emuOp_clc(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_clc(u8 X86EMU_UNUSED(op1))
{
/* clear the carry flag. */
START_OF_INSTR();
REMARKS:
Handles opcode 0xf9
****************************************************************************/
-static void x86emuOp_stc(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_stc(u8 X86EMU_UNUSED(op1))
{
/* set the carry flag. */
START_OF_INSTR();
REMARKS:
Handles opcode 0xfa
****************************************************************************/
-static void x86emuOp_cli(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_cli(u8 X86EMU_UNUSED(op1))
{
/* clear interrupts. */
START_OF_INSTR();
REMARKS:
Handles opcode 0xfb
****************************************************************************/
-static void x86emuOp_sti(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_sti(u8 X86EMU_UNUSED(op1))
{
/* enable interrupts. */
START_OF_INSTR();
REMARKS:
Handles opcode 0xfc
****************************************************************************/
-static void x86emuOp_cld(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_cld(u8 X86EMU_UNUSED(op1))
{
/* clear interrupts. */
START_OF_INSTR();
REMARKS:
Handles opcode 0xfd
****************************************************************************/
-static void x86emuOp_std(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_std(u8 X86EMU_UNUSED(op1))
{
/* clear interrupts. */
START_OF_INSTR();
REMARKS:
Handles opcode 0xfe
****************************************************************************/
-static void x86emuOp_opcFE_byte_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_opcFE_byte_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rh, rl;
u8 destval;
destoffset = decode_rm00_address(rl);
DECODE_PRINTF("\n");
switch (rh) {
- case 0: /* inc word ptr ... */
+ case 0: /* inc word ptr ... */
destval = fetch_data_byte(destoffset);
TRACE_AND_STEP();
destval = inc_byte(destval);
store_data_byte(destoffset, destval);
break;
- case 1: /* dec word ptr ... */
+ case 1: /* dec word ptr ... */
destval = fetch_data_byte(destoffset);
TRACE_AND_STEP();
destval = dec_byte(destval);
REMARKS:
Handles opcode 0xff
****************************************************************************/
-static void x86emuOp_opcFF_word_RM(u8 X86EMU_UNUSED(op1))
+static void
+x86emuOp_opcFF_word_RM(u8 X86EMU_UNUSED(op1))
{
int mod, rh, rl;
uint destoffset = 0;
- u16 *destreg;
- u16 destval,destval2;
+ u16 *destreg;
+ u16 destval, destval2;
/* Yet another special case instruction. */
START_OF_INSTR();
case 0:
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("INC\tDWORD PTR ");
- } else {
+ }
+ else {
DECODE_PRINTF("INC\tWORD PTR ");
}
break;
case 1:
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
DECODE_PRINTF("DEC\tDWORD PTR ");
- } else {
+ }
+ else {
DECODE_PRINTF("DEC\tWORD PTR ");
}
break;
destoffset = decode_rm00_address(rl);
DECODE_PRINTF("\n");
switch (rh) {
- case 0: /* inc word ptr ... */
+ case 0: /* inc word ptr ... */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 destval;
TRACE_AND_STEP();
destval = inc_long(destval);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
destval = fetch_data_word(destoffset);
store_data_word(destoffset, destval);
}
break;
- case 1: /* dec word ptr ... */
+ case 1: /* dec word ptr ... */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 destval;
TRACE_AND_STEP();
destval = dec_long(destval);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
destval = fetch_data_word(destoffset);
store_data_word(destoffset, destval);
}
break;
- case 2: /* call word ptr ... */
+ case 2: /* call word ptr ... */
destval = fetch_data_word(destoffset);
TRACE_AND_STEP();
push_word(M.x86.R_IP);
M.x86.R_IP = destval;
break;
- case 3: /* call far ptr ... */
+ case 3: /* call far ptr ... */
destval = fetch_data_word(destoffset);
destval2 = fetch_data_word(destoffset + 2);
TRACE_AND_STEP();
push_word(M.x86.R_IP);
M.x86.R_IP = destval;
break;
- case 4: /* jmp word ptr ... */
+ case 4: /* jmp word ptr ... */
destval = fetch_data_word(destoffset);
TRACE_AND_STEP();
M.x86.R_IP = destval;
break;
- case 5: /* jmp far ptr ... */
+ case 5: /* jmp far ptr ... */
destval = fetch_data_word(destoffset);
destval2 = fetch_data_word(destoffset + 2);
TRACE_AND_STEP();
M.x86.R_IP = destval;
M.x86.R_CS = destval2;
break;
- case 6: /* push word ptr ... */
+ case 6: /* push word ptr ... */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 destval;
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
push_long(destval);
- } else {
+ }
+ else {
u16 destval;
destval = fetch_data_word(destoffset);
TRACE_AND_STEP();
destval = inc_long(destval);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
destval = fetch_data_word(destoffset);
TRACE_AND_STEP();
destval = dec_long(destval);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
destval = fetch_data_word(destoffset);
store_data_word(destoffset, destval);
}
break;
- case 2: /* call word ptr ... */
+ case 2: /* call word ptr ... */
destval = fetch_data_word(destoffset);
TRACE_AND_STEP();
push_word(M.x86.R_IP);
M.x86.R_IP = destval;
break;
- case 3: /* call far ptr ... */
+ case 3: /* call far ptr ... */
destval = fetch_data_word(destoffset);
destval2 = fetch_data_word(destoffset + 2);
TRACE_AND_STEP();
push_word(M.x86.R_IP);
M.x86.R_IP = destval;
break;
- case 4: /* jmp word ptr ... */
+ case 4: /* jmp word ptr ... */
destval = fetch_data_word(destoffset);
TRACE_AND_STEP();
M.x86.R_IP = destval;
break;
- case 5: /* jmp far ptr ... */
+ case 5: /* jmp far ptr ... */
destval = fetch_data_word(destoffset);
destval2 = fetch_data_word(destoffset + 2);
TRACE_AND_STEP();
M.x86.R_IP = destval;
M.x86.R_CS = destval2;
break;
- case 6: /* push word ptr ... */
+ case 6: /* push word ptr ... */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 destval;
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
push_long(destval);
- } else {
+ }
+ else {
u16 destval;
destval = fetch_data_word(destoffset);
TRACE_AND_STEP();
destval = inc_long(destval);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
destval = fetch_data_word(destoffset);
TRACE_AND_STEP();
destval = dec_long(destval);
store_data_long(destoffset, destval);
- } else {
+ }
+ else {
u16 destval;
destval = fetch_data_word(destoffset);
store_data_word(destoffset, destval);
}
break;
- case 2: /* call word ptr ... */
+ case 2: /* call word ptr ... */
destval = fetch_data_word(destoffset);
TRACE_AND_STEP();
push_word(M.x86.R_IP);
M.x86.R_IP = destval;
break;
- case 3: /* call far ptr ... */
+ case 3: /* call far ptr ... */
destval = fetch_data_word(destoffset);
destval2 = fetch_data_word(destoffset + 2);
TRACE_AND_STEP();
push_word(M.x86.R_IP);
M.x86.R_IP = destval;
break;
- case 4: /* jmp word ptr ... */
+ case 4: /* jmp word ptr ... */
destval = fetch_data_word(destoffset);
TRACE_AND_STEP();
M.x86.R_IP = destval;
break;
- case 5: /* jmp far ptr ... */
+ case 5: /* jmp far ptr ... */
destval = fetch_data_word(destoffset);
destval2 = fetch_data_word(destoffset + 2);
TRACE_AND_STEP();
M.x86.R_IP = destval;
M.x86.R_CS = destval2;
break;
- case 6: /* push word ptr ... */
+ case 6: /* push word ptr ... */
if (M.x86.mode & SYSMODE_PREFIX_DATA) {
u32 destval;
destval = fetch_data_long(destoffset);
TRACE_AND_STEP();
push_long(destval);
- } else {
+ }
+ else {
u16 destval;
destval = fetch_data_word(destoffset);
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = inc_long(*destreg);
- } else {
+ }
+ else {
u16 *destreg;
destreg = DECODE_RM_WORD_REGISTER(rl);
DECODE_PRINTF("\n");
TRACE_AND_STEP();
*destreg = dec_long(*destreg);
- } else {
+ }
+ else {
u16 *destreg;
destreg = DECODE_RM_WORD_REGISTER(rl);
*destreg = dec_word(*destreg);
}
break;
- case 2: /* call word ptr ... */
+ case 2: /* call word ptr ... */
destreg = DECODE_RM_WORD_REGISTER(rl);
DECODE_PRINTF("\n");
TRACE_AND_STEP();
push_word(M.x86.R_IP);
M.x86.R_IP = *destreg;
break;
- case 3: /* jmp far ptr ... */
+ case 3: /* jmp far ptr ... */
DECODE_PRINTF("OPERATION UNDEFINED 0XFF \n");
TRACE_AND_STEP();
HALT_SYS();
break;
- case 4: /* jmp ... */
+ case 4: /* jmp ... */
destreg = DECODE_RM_WORD_REGISTER(rl);
DECODE_PRINTF("\n");
TRACE_AND_STEP();
M.x86.R_IP = (u16) (*destreg);
break;
- case 5: /* jmp far ptr ... */
+ case 5: /* jmp far ptr ... */
DECODE_PRINTF("OPERATION UNDEFINED 0XFF \n");
TRACE_AND_STEP();
HALT_SYS();
DECODE_PRINTF("\n");
TRACE_AND_STEP();
push_long(*destreg);
- } else {
+ }
+ else {
u16 *destreg;
destreg = DECODE_RM_WORD_REGISTER(rl);
/***************************************************************************
* Single byte operation code table:
**************************************************************************/
-void (*x86emu_optab[256])(u8) =
-{
+void (*x86emu_optab[256]) (u8) = {
/* 0x00 */ x86emuOp_add_byte_RM_R,
/* 0x01 */ x86emuOp_add_word_RM_R,
/* 0x02 */ x86emuOp_add_byte_R_RM,
/* 0x05 */ x86emuOp_add_word_AX_IMM,
/* 0x06 */ x86emuOp_push_ES,
/* 0x07 */ x86emuOp_pop_ES,
-
/* 0x08 */ x86emuOp_or_byte_RM_R,
/* 0x09 */ x86emuOp_or_word_RM_R,
/* 0x0a */ x86emuOp_or_byte_R_RM,
/* 0x0d */ x86emuOp_or_word_AX_IMM,
/* 0x0e */ x86emuOp_push_CS,
/* 0x0f */ x86emuOp_two_byte,
-
/* 0x10 */ x86emuOp_adc_byte_RM_R,
/* 0x11 */ x86emuOp_adc_word_RM_R,
/* 0x12 */ x86emuOp_adc_byte_R_RM,
/* 0x15 */ x86emuOp_adc_word_AX_IMM,
/* 0x16 */ x86emuOp_push_SS,
/* 0x17 */ x86emuOp_pop_SS,
-
/* 0x18 */ x86emuOp_sbb_byte_RM_R,
/* 0x19 */ x86emuOp_sbb_word_RM_R,
/* 0x1a */ x86emuOp_sbb_byte_R_RM,
/* 0x1d */ x86emuOp_sbb_word_AX_IMM,
/* 0x1e */ x86emuOp_push_DS,
/* 0x1f */ x86emuOp_pop_DS,
-
/* 0x20 */ x86emuOp_and_byte_RM_R,
/* 0x21 */ x86emuOp_and_word_RM_R,
/* 0x22 */ x86emuOp_and_byte_R_RM,
/* 0x25 */ x86emuOp_and_word_AX_IMM,
/* 0x26 */ x86emuOp_segovr_ES,
/* 0x27 */ x86emuOp_daa,
-
/* 0x28 */ x86emuOp_sub_byte_RM_R,
/* 0x29 */ x86emuOp_sub_word_RM_R,
/* 0x2a */ x86emuOp_sub_byte_R_RM,
/* 0x2d */ x86emuOp_sub_word_AX_IMM,
/* 0x2e */ x86emuOp_segovr_CS,
/* 0x2f */ x86emuOp_das,
-
/* 0x30 */ x86emuOp_xor_byte_RM_R,
/* 0x31 */ x86emuOp_xor_word_RM_R,
/* 0x32 */ x86emuOp_xor_byte_R_RM,
/* 0x35 */ x86emuOp_xor_word_AX_IMM,
/* 0x36 */ x86emuOp_segovr_SS,
/* 0x37 */ x86emuOp_aaa,
-
/* 0x38 */ x86emuOp_cmp_byte_RM_R,
/* 0x39 */ x86emuOp_cmp_word_RM_R,
/* 0x3a */ x86emuOp_cmp_byte_R_RM,
/* 0x3d */ x86emuOp_cmp_word_AX_IMM,
/* 0x3e */ x86emuOp_segovr_DS,
/* 0x3f */ x86emuOp_aas,
-
/* 0x40 */ x86emuOp_inc_AX,
/* 0x41 */ x86emuOp_inc_CX,
/* 0x42 */ x86emuOp_inc_DX,
/* 0x45 */ x86emuOp_inc_BP,
/* 0x46 */ x86emuOp_inc_SI,
/* 0x47 */ x86emuOp_inc_DI,
-
/* 0x48 */ x86emuOp_dec_AX,
/* 0x49 */ x86emuOp_dec_CX,
/* 0x4a */ x86emuOp_dec_DX,
/* 0x4d */ x86emuOp_dec_BP,
/* 0x4e */ x86emuOp_dec_SI,
/* 0x4f */ x86emuOp_dec_DI,
-
/* 0x50 */ x86emuOp_push_AX,
/* 0x51 */ x86emuOp_push_CX,
/* 0x52 */ x86emuOp_push_DX,
/* 0x55 */ x86emuOp_push_BP,
/* 0x56 */ x86emuOp_push_SI,
/* 0x57 */ x86emuOp_push_DI,
-
/* 0x58 */ x86emuOp_pop_AX,
/* 0x59 */ x86emuOp_pop_CX,
/* 0x5a */ x86emuOp_pop_DX,
/* 0x5d */ x86emuOp_pop_BP,
/* 0x5e */ x86emuOp_pop_SI,
/* 0x5f */ x86emuOp_pop_DI,
-
/* 0x60 */ x86emuOp_push_all,
/* 0x61 */ x86emuOp_pop_all,
-/* 0x62 */ x86emuOp_illegal_op, /* bound */
-/* 0x63 */ x86emuOp_illegal_op, /* arpl */
+ /* 0x62 */ x86emuOp_illegal_op,
+ /* bound */
+ /* 0x63 */ x86emuOp_illegal_op,
+ /* arpl */
/* 0x64 */ x86emuOp_segovr_FS,
/* 0x65 */ x86emuOp_segovr_GS,
/* 0x66 */ x86emuOp_prefix_data,
/* 0x67 */ x86emuOp_prefix_addr,
-
/* 0x68 */ x86emuOp_push_word_IMM,
/* 0x69 */ x86emuOp_imul_word_IMM,
/* 0x6a */ x86emuOp_push_byte_IMM,
/* 0x6d */ x86emuOp_ins_word,
/* 0x6e */ x86emuOp_outs_byte,
/* 0x6f */ x86emuOp_outs_word,
-
/* 0x70 */ x86emuOp_jump_near_O,
/* 0x71 */ x86emuOp_jump_near_NO,
/* 0x72 */ x86emuOp_jump_near_B,
/* 0x75 */ x86emuOp_jump_near_NZ,
/* 0x76 */ x86emuOp_jump_near_BE,
/* 0x77 */ x86emuOp_jump_near_NBE,
-
/* 0x78 */ x86emuOp_jump_near_S,
/* 0x79 */ x86emuOp_jump_near_NS,
/* 0x7a */ x86emuOp_jump_near_P,
/* 0x7d */ x86emuOp_jump_near_NL,
/* 0x7e */ x86emuOp_jump_near_LE,
/* 0x7f */ x86emuOp_jump_near_NLE,
-
/* 0x80 */ x86emuOp_opc80_byte_RM_IMM,
/* 0x81 */ x86emuOp_opc81_word_RM_IMM,
/* 0x82 */ x86emuOp_opc82_byte_RM_IMM,
/* 0x85 */ x86emuOp_test_word_RM_R,
/* 0x86 */ x86emuOp_xchg_byte_RM_R,
/* 0x87 */ x86emuOp_xchg_word_RM_R,
-
/* 0x88 */ x86emuOp_mov_byte_RM_R,
/* 0x89 */ x86emuOp_mov_word_RM_R,
/* 0x8a */ x86emuOp_mov_byte_R_RM,
/* 0x8d */ x86emuOp_lea_word_R_M,
/* 0x8e */ x86emuOp_mov_word_SR_RM,
/* 0x8f */ x86emuOp_pop_RM,
-
/* 0x90 */ x86emuOp_nop,
/* 0x91 */ x86emuOp_xchg_word_AX_CX,
/* 0x92 */ x86emuOp_xchg_word_AX_DX,
/* 0x95 */ x86emuOp_xchg_word_AX_BP,
/* 0x96 */ x86emuOp_xchg_word_AX_SI,
/* 0x97 */ x86emuOp_xchg_word_AX_DI,
-
/* 0x98 */ x86emuOp_cbw,
/* 0x99 */ x86emuOp_cwd,
/* 0x9a */ x86emuOp_call_far_IMM,
/* 0x9d */ x86emuOp_popf_word,
/* 0x9e */ x86emuOp_sahf,
/* 0x9f */ x86emuOp_lahf,
-
/* 0xa0 */ x86emuOp_mov_AL_M_IMM,
/* 0xa1 */ x86emuOp_mov_AX_M_IMM,
/* 0xa2 */ x86emuOp_mov_M_AL_IMM,
/* 0xad */ x86emuOp_lods_word,
/* 0xac */ x86emuOp_scas_byte,
/* 0xad */ x86emuOp_scas_word,
-
-
/* 0xb0 */ x86emuOp_mov_byte_AL_IMM,
/* 0xb1 */ x86emuOp_mov_byte_CL_IMM,
/* 0xb2 */ x86emuOp_mov_byte_DL_IMM,
/* 0xb5 */ x86emuOp_mov_byte_CH_IMM,
/* 0xb6 */ x86emuOp_mov_byte_DH_IMM,
/* 0xb7 */ x86emuOp_mov_byte_BH_IMM,
-
/* 0xb8 */ x86emuOp_mov_word_AX_IMM,
/* 0xb9 */ x86emuOp_mov_word_CX_IMM,
/* 0xba */ x86emuOp_mov_word_DX_IMM,
/* 0xbd */ x86emuOp_mov_word_BP_IMM,
/* 0xbe */ x86emuOp_mov_word_SI_IMM,
/* 0xbf */ x86emuOp_mov_word_DI_IMM,
-
/* 0xc0 */ x86emuOp_opcC0_byte_RM_MEM,
/* 0xc1 */ x86emuOp_opcC1_word_RM_MEM,
/* 0xc2 */ x86emuOp_ret_near_IMM,
/* 0xcd */ x86emuOp_int_IMM,
/* 0xce */ x86emuOp_into,
/* 0xcf */ x86emuOp_iret,
-
/* 0xd0 */ x86emuOp_opcD0_byte_RM_1,
/* 0xd1 */ x86emuOp_opcD1_word_RM_1,
/* 0xd2 */ x86emuOp_opcD2_byte_RM_CL,
/* 0xd3 */ x86emuOp_opcD3_word_RM_CL,
/* 0xd4 */ x86emuOp_aam,
/* 0xd5 */ x86emuOp_aad,
-/* 0xd6 */ x86emuOp_illegal_op, /* Undocumented SETALC instruction */
+ /* 0xd6 */ x86emuOp_illegal_op,
+ /* Undocumented SETALC instruction */
/* 0xd7 */ x86emuOp_xlat,
/* 0xd8 */ x86emuOp_esc_coprocess_d8,
/* 0xd9 */ x86emuOp_esc_coprocess_d9,
/* 0xdd */ x86emuOp_esc_coprocess_dd,
/* 0xde */ x86emuOp_esc_coprocess_de,
/* 0xdf */ x86emuOp_esc_coprocess_df,
-
/* 0xe0 */ x86emuOp_loopne,
/* 0xe1 */ x86emuOp_loope,
/* 0xe2 */ x86emuOp_loop,
/* 0xe5 */ x86emuOp_in_word_AX_IMM,
/* 0xe6 */ x86emuOp_out_byte_IMM_AL,
/* 0xe7 */ x86emuOp_out_word_IMM_AX,
-
/* 0xe8 */ x86emuOp_call_near_IMM,
/* 0xe9 */ x86emuOp_jump_near_IMM,
/* 0xea */ x86emuOp_jump_far_IMM,
/* 0xed */ x86emuOp_in_word_AX_DX,
/* 0xee */ x86emuOp_out_byte_DX_AL,
/* 0xef */ x86emuOp_out_word_DX_AX,
-
/* 0xf0 */ x86emuOp_lock,
/* 0xf1 */ x86emuOp_illegal_op,
/* 0xf2 */ x86emuOp_repne,
/* 0xf5 */ x86emuOp_cmc,
/* 0xf6 */ x86emuOp_opcF6_byte_RM,
/* 0xf7 */ x86emuOp_opcF7_word_RM,
-
/* 0xf8 */ x86emuOp_clc,
/* 0xf9 */ x86emuOp_stc,
/* 0xfa */ x86emuOp_cli,
projects / l4.git / blobdiff