[VM][I386] Merge Upstream 2018-11-23.
[VM][I386] Debugger: Fix get_debug_regs_info().
[VM][I386][FMR50] Fix INT xxh with pseudo-bios.
+11/23/2018
+
+[VM/I386] improve i386_limit_check to consider data size
+[VM/SCSI_DEV] improve REQ timing just after ACK is raised
+
+[PC6001/*] apply patch for timing issues (thanks Mr.Akikawa)
+[PC8801/PC88] support to change palette for each scan line
+[PC9801] support PC-9801-86 sound board for PC-9801RA and PC-98RL
+[PC9801/FMSOUND] fix process_state
+
+
10/14/2018
[COMMON/FILEIO] improve functions to load/save state file for big-endian
uint16_vec8_t tmpd;
uint16_vec8_t* vt = (uint16_vec8_t*)__builtin_assume_aligned(&(tbl->plane_table[0]), sizeof(uint16_vec8_t));
- __DECL_ALIGNED(16) uint8_t d[16];
tmpd = vt[src];
__DECL_VECTORIZED_LOOP
for(int i = 0; i < 8; i++) {
#endif
#ifdef USE_SOUND_TYPE
menuSoundDevice->setTitle(QApplication::translate("MainWindow", "Sound Card", 0));
+#if defined(SUPPORT_PC98_OPNA)
+ actionSoundDevice[0]->setText(QApplication::translate("MainWindow", "PC-9801-86 (BIOS Enabled)", 0));
+ actionSoundDevice[1]->setText(QApplication::translate("MainWindow", "PC-9801-86 (BIOS Disabled)", 0));
+#else
actionSoundDevice[0]->setText(QApplication::translate("MainWindow", "PC-9801-26 (BIOS Enabled)", 0));
actionSoundDevice[1]->setText(QApplication::translate("MainWindow", "PC-9801-26 (BIOS Disabled)", 0));
+#endif
actionSoundDevice[2]->setText(QApplication::translate("MainWindow", "PC-9801-14 (BIOS Enabled)", 0));
actionSoundDevice[3]->setText(QApplication::translate("MainWindow", "PC-9801-14 (BIOS Disabled)", 0));
actionSoundDevice[4]->setText(QApplication::translate("MainWindow", "None", 0));
+#if defined(SUPPORT_PC98_OPNA)
+ actionSoundDevice[0]->setToolTip(QApplication::translate("MainWindow", "PC-9801-86 sound board has connected.\nThis uses YAMAHA YM-2608 OPNA synthesizer chip.\nOn board BIOS is enabled.", 0));
+ actionSoundDevice[1]->setToolTip(QApplication::translate("MainWindow", "PC-9801-86 sound board has connected.\nThis uses YAMAHA YM-2608 OPNA synthesizer chip.\nOn board BIOS is disabled.", 0));
+#else
actionSoundDevice[0]->setToolTip(QApplication::translate("MainWindow", "PC-9801-26 sound board has connected.\nThis uses YAMAHA YM-2203 OPN synthesizer chip.\nOn board BIOS is enabled.", 0));
actionSoundDevice[1]->setToolTip(QApplication::translate("MainWindow", "PC-9801-26 sound board has connected.\nThis uses YAMAHA YM-2203 OPN synthesizer chip.\nOn board BIOS is disabled.", 0));
+#endif
actionSoundDevice[2]->setToolTip(QApplication::translate("MainWindow", "PC-9801-14 sound board has connected.\nThis uses TI TMS3631-RI104 synthesizer chip.\nOn board BIOS is enabled.", 0));
actionSoundDevice[3]->setToolTip(QApplication::translate("MainWindow", "PC-9801-14 sound board has connected.\nThis uses TI TMS3631-RI104 synthesizer chip.\nOn board BIOS is disabled.", 0));
actionSoundDevice[4]->setToolTip(QApplication::translate("MainWindow", "None sound devices has connected.", 0));
// Dialog
//
-IDD_VOLUME DIALOG DISCARDABLE 0, 0, 250, 180
+IDD_VOLUME DIALOG DISCARDABLE 0, 0, 250, 240
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "Volume"
FONT 9, "MS PGothic"
LTEXT "Sound Device #5",IDC_VOLUME_CAPTION4,6,126,60,8
CONTROL "",IDC_VOLUME_PARAM_L4,"msctls_trackbar32",TBS_AUTOTICKS | WS_TABSTOP,70,126,175,12
CONTROL "",IDC_VOLUME_PARAM_R4,"msctls_trackbar32",TBS_AUTOTICKS | WS_TABSTOP,70,141,175,12
- DEFPUSHBUTTON "OK",IDOK,70,160,50,14
- DEFPUSHBUTTON "Reset",IDC_VOLUME_RESET,130,160,50,14
+ LTEXT "Sound Device #6",IDC_VOLUME_CAPTION5,6,156,60,8
+ CONTROL "",IDC_VOLUME_PARAM_L5,"msctls_trackbar32",TBS_AUTOTICKS | WS_TABSTOP,70,156,175,12
+ CONTROL "",IDC_VOLUME_PARAM_R5,"msctls_trackbar32",TBS_AUTOTICKS | WS_TABSTOP,70,171,175,12
+ LTEXT "Sound Device #7",IDC_VOLUME_CAPTION6,6,186,60,8
+ CONTROL "",IDC_VOLUME_PARAM_L6,"msctls_trackbar32",TBS_AUTOTICKS | WS_TABSTOP,70,186,175,12
+ CONTROL "",IDC_VOLUME_PARAM_R6,"msctls_trackbar32",TBS_AUTOTICKS | WS_TABSTOP,70,201,175,12
+ DEFPUSHBUTTON "OK",IDOK,70,220,50,14
+ DEFPUSHBUTTON "Reset",IDC_VOLUME_RESET,130,220,50,14
END
IDD_JOYSTICK DIALOG DISCARDABLE 0, 0, 175, 120
// Dialog
//
-IDD_VOLUME DIALOG DISCARDABLE 0, 0, 250, 180
+IDD_VOLUME DIALOG DISCARDABLE 0, 0, 250, 240
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "Volume"
FONT 9, "MS PGothic"
LTEXT "Sound Device #5",IDC_VOLUME_CAPTION4,6,126,60,8
CONTROL "",IDC_VOLUME_PARAM_L4,"msctls_trackbar32",TBS_AUTOTICKS | WS_TABSTOP,70,126,175,12
CONTROL "",IDC_VOLUME_PARAM_R4,"msctls_trackbar32",TBS_AUTOTICKS | WS_TABSTOP,70,141,175,12
- DEFPUSHBUTTON "OK",IDOK,70,160,50,14
- DEFPUSHBUTTON "Reset",IDC_VOLUME_RESET,130,160,50,14
+ LTEXT "Sound Device #6",IDC_VOLUME_CAPTION5,6,156,60,8
+ CONTROL "",IDC_VOLUME_PARAM_L5,"msctls_trackbar32",TBS_AUTOTICKS | WS_TABSTOP,70,156,175,12
+ CONTROL "",IDC_VOLUME_PARAM_R5,"msctls_trackbar32",TBS_AUTOTICKS | WS_TABSTOP,70,171,175,12
+ LTEXT "Sound Device #7",IDC_VOLUME_CAPTION6,6,186,60,8
+ CONTROL "",IDC_VOLUME_PARAM_L6,"msctls_trackbar32",TBS_AUTOTICKS | WS_TABSTOP,70,186,175,12
+ CONTROL "",IDC_VOLUME_PARAM_R6,"msctls_trackbar32",TBS_AUTOTICKS | WS_TABSTOP,70,201,175,12
+ DEFPUSHBUTTON "OK",IDOK,70,220,50,14
+ DEFPUSHBUTTON "Reset",IDC_VOLUME_RESET,130,220,50,14
END
IDD_JOYSTICK DIALOG DISCARDABLE 0, 0, 175, 120
message("* vm/common_vm")
-SET(THIS_LIB_VERSION 2.4.0)
+SET(THIS_LIB_VERSION 2.4.1)
#include(cotire)
set(s_vm_common_vm_srcs
i386_state *cpustate = cpucore->get_cpu_state();
//#if defined(USE_DEBUGGER)
my_stprintf_s(buffer, buffer_len,
- _T("AX=%04X BX=%04X CX=%04X DX=%04X SP=%04X BP=%04X SI=%04X DI=%04X\nDS=%04X ES=%04X SS=%04X CS=%04X IP=%04X FLAG=[%c%c%c%c%c%c%c%c%c]\nClocks = %llu (%llu) Since Scanline = %d/%d (%d/%d)"),
- cpustate->sreg[DS].selector, cpustate->sreg[ES].selector, cpustate->sreg[SS].selector, cpustate->sreg[CS].selector, cpustate->eip,
- cpustate->OF ? _T('O') : _T('-'), cpustate->DF ? _T('D') : _T('-'), cpustate->IF ? _T('I') : _T('-'), cpustate->TF ? _T('T') : _T('-'),
- cpustate->SF ? _T('S') : _T('-'), cpustate->ZF ? _T('Z') : _T('-'), cpustate->AF ? _T('A') : _T('-'), cpustate->PF ? _T('P') : _T('-'),
- cpustate->CF ? _T('C') : _T('-'),
+ _T("Privilege Level=[%02x] MODE=%s V86=%s STACK_32BIT=%08x\nEAX=%08X EBX=%08X ECX=%08X EDX=%08X \nESP=%08X EBP=%08X ESI=%08X EDI=%08X\nDS=%04X ES=%04X SS=%04X CS=%04X EIP=%08X\nFLAG=[%c%c%c%c%c%c%c%c%c]\nClocks = %llu (%llu) Since Scanline = %d/%d (%d/%d)"),
+ cpustate->CPL, (PROTECTED_MODE == 0) ? _T("REAL") : _T("PROTECTED"), (V8086_MODE) ? _T("YES") : _T("NO"),
+ STACK_32BIT,
+ REG32(EAX), REG32(EBX), REG32(ECX), REG32(EDX), REG32(ESP), REG32(EBP), REG32(ESI), REG32(EDI),
+ cpustate->sreg[DS].selector, cpustate->sreg[ES].selector, cpustate->sreg[SS].selector, cpustate->sreg[CS].selector, cpustate->eip,
+ cpustate->OF ? _T('O') : _T('-'), cpustate->DF ? _T('D') : _T('-'), cpustate->IF ? _T('I') : _T('-'), cpustate->TF ? _T('T') : _T('-'),
+ cpustate->SF ? _T('S') : _T('-'), cpustate->ZF ? _T('Z') : _T('-'), cpustate->AF ? _T('A') : _T('-'), cpustate->PF ? _T('P') : _T('-'), cpustate->CF ? _T('C') : _T('-'),
cpustate->total_cycles, cpustate->total_cycles - cpustate->prev_total_cycles,
- get_passed_clock_since_vline(), get_cur_vline_clocks(), get_cur_vline(), get_lines_per_frame());
+ get_passed_clock_since_vline(), get_cur_vline_clocks(), get_cur_vline(), get_lines_per_frame());
cpustate->prev_total_cycles = cpustate->total_cycles;
//#endif
}
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
#pragma once
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
#pragma once
#ifndef __I386INTF_H__
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Phil Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
/*
Intel 386 emulator
return ea;
}
-UINT32 I386_OPS_BASE::GetEA(UINT8 modrm, int rwn)
+UINT32 I386_OPS_BASE::GetEA(UINT8 modrm, int rwn, UINT32 size)
{
UINT8 segment;
UINT32 ea;
modrm_to_EA(modrm, &ea, &segment );
- return i386_translate(segment, ea, rwn );
+ return i386_translate(segment, ea, rwn, size );
}
/* Check segment register for validity when changing privilege level after an RETF */
}
}
-int I386_OPS_BASE::i386_limit_check( int seg, UINT32 offset)
+int I386_OPS_BASE::i386_limit_check( int seg, UINT32 offset, UINT32 size)
{
if(PROTECTED_MODE && !V8086_MODE)
{
if((cpustate->sreg[seg].flags & 0x0018) == 0x0010 && cpustate->sreg[seg].flags & 0x0004) // if expand-down data segment
{
// compare if greater then 0xffffffff when we're passed the access size
- if((offset <= cpustate->sreg[seg].limit) || ((cpustate->sreg[seg].d)?0:(offset > 0xffff)))
+ if((offset <= cpustate->sreg[seg].limit) || ((cpustate->sreg[seg].d)?0:((offset + size - 1) > 0xffff)))
{
logerror("Limit check at 0x%08x failed. Segment %04x, limit %08x, offset %08x (expand-down)\n",cpustate->pc,cpustate->sreg[seg].selector,cpustate->sreg[seg].limit,offset);
return 1;
}
else
{
- if(offset > cpustate->sreg[seg].limit)
+ if((offset + size - 1) > cpustate->sreg[seg].limit)
{
logerror("Limit check at 0x%08x failed. Segment %04x, limit %08x, offset %08x\n",cpustate->pc,cpustate->sreg[seg].selector,cpustate->sreg[seg].limit,offset);
return 1;
if (operand32 != 0) // if 32-bit
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) - 8 : (REG16(SP) - 8) & 0xffff);
- if(i386_limit_check(SS, offset))
+ if(i386_limit_check(SS, offset, 8))
{
logerror("CALL (%08x): Stack has no room for return address.\n",cpustate->pc);
FAULT(FAULT_SS,0) // #SS(0)
else
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) - 4 : (REG16(SP) - 4) & 0xffff);
- if(i386_limit_check(SS, offset))
+ if(i386_limit_check(SS, offset, 4))
{
logerror("CALL (%08x): Stack has no room for return address.\n",cpustate->pc);
FAULT(FAULT_SS,0) // #SS(0)
if (operand32 != 0) // if 32-bit
{
UINT32 stkoff = (STACK_32BIT ? REG32(ESP) - 8 : (REG16(SP) - 8) & 0xffff);
- if(i386_limit_check(SS, stkoff))
+ if(i386_limit_check(SS, stkoff, 8))
{
logerror("CALL: Stack has no room for return address.\n");
FAULT(FAULT_SS,0) // #SS(0)
else
{
UINT32 stkoff = (STACK_32BIT ? REG32(ESP) - 4 : (REG16(SP) - 4) & 0xffff);
- if(i386_limit_check(SS, stkoff))
+ if(i386_limit_check(SS, stkoff, 4))
{
logerror("CALL: Stack has no room for return address.\n");
FAULT(FAULT_SS,0) // #SS(0)
I386_SREG desc;
UINT8 CPL, RPL, DPL;
- UINT32 ea = i386_translate(SS, (STACK_32BIT)?REG32(ESP):REG16(SP), 0);
+ UINT32 ea = i386_translate(SS, (STACK_32BIT)?REG32(ESP):REG16(SP), 0, (operand32!=0) ? 8 : 4);
if(operand32 == 0)
{
if(operand32 == 0)
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+count+3) != 0)
+ if(i386_limit_check(SS, offset, count + 4) != 0)
{
logerror("RETF (%08x): SP is past stack segment limit.\n",cpustate->pc);
FAULT(FAULT_SS,0)
else
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+count+7) != 0)
+ if(i386_limit_check(SS, offset, count + 8) != 0)
{
logerror("RETF: ESP is past stack segment limit.\n");
FAULT(FAULT_SS,0)
if(operand32 == 0)
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+count+7) != 0)
+ if(i386_limit_check(SS, offset, count + 8) != 0)
{
logerror("RETF (%08x): SP is past stack segment limit.\n",cpustate->pc);
FAULT(FAULT_SS,0)
else
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+count+15) != 0)
+ if(i386_limit_check(SS, offset, count + 16) != 0)
{
logerror("RETF: ESP is past stack segment limit.\n");
FAULT(FAULT_SS,0)
UINT8 IOPL = cpustate->IOP1 | (cpustate->IOP2 << 1);
CPL = cpustate->CPL;
- UINT32 ea = i386_translate(SS, (STACK_32BIT)?REG32(ESP):REG16(SP), 0);
+ UINT32 ea = i386_translate(SS, (STACK_32BIT)?REG32(ESP):REG16(SP), 0, (operand32 != 0) ? 12 : 6);
if(operand32 == 0)
{
newEIP = READ16(ea) & 0xffff;
if(operand32 == 0)
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+3) != 0)
+ if(i386_limit_check(SS, offset, 4) != 0)
{
logerror("IRET: Data on stack is past SS limit.\n");
FAULT(FAULT_SS,0)
else
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+7) != 0)
+ if(i386_limit_check(SS, offset, 8) != 0)
{
logerror("IRET: Data on stack is past SS limit.\n");
FAULT(FAULT_SS,0)
if(operand32 == 0)
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+5) != 0)
+ if(i386_limit_check(SS, offset, 6) != 0)
{
logerror("IRET (%08x): Data on stack is past SS limit.\n",cpustate->pc);
FAULT(FAULT_SS,0)
else
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+11) != 0)
+ if(i386_limit_check(SS, offset, 12) != 0)
{
logerror("IRET (%08x): Data on stack is past SS limit.\n",cpustate->pc);
FAULT(FAULT_SS,0)
if(operand32 == 0)
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+9) != 0)
+ if(i386_limit_check(SS, offset, 10) != 0)
{
logerror("IRET: SP is past SS limit.\n");
FAULT(FAULT_SS,0)
else
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+19) != 0)
+ if(i386_limit_check(SS, offset, 20) != 0)
{
logerror("IRET: ESP is past SS limit.\n");
FAULT(FAULT_SS,0)
process_state_GPR(&cpustate->reg, state_fio);
- for(int i = 0; i < array_length(cpustate->sreg); i++) {
+ for(int i = 0; i < (int)array_length(cpustate->sreg); i++) {
process_state_SREG(&cpustate->sreg[i], state_fio);
}
state_fio->StateValue(cpustate->eip);
virtual void i386_trap_with_error(int irq, int irq_gate, int trap_level, UINT32 error);
void i386_set_irq_line(int irqline, int state);
void i386_set_a20_line(int state);
- int i386_limit_check( int seg, UINT32 offset);
+ int i386_limit_check( int seg, UINT32 offset, UINT32 size);
void i386_vtlb_free(void);
void i386_free_state(void);
void modrm_to_EA(UINT8 mod_rm, UINT32* out_ea, UINT8* out_segment);
UINT32 GetNonTranslatedEA(UINT8 modrm,UINT8 *seg);
- UINT32 GetEA(UINT8 modrm, int rwn);
+ UINT32 GetEA(UINT8 modrm, int rwn, UINT32 size);
//
void i386_check_sreg_validity(int reg);
void I386OP_D(address_size)(); // Opcode 0x67
void I386OP_D(nop)(); // Opcode 0x90
void I386OP_D(int3)(); // Opcode 0xcc
- void I386OP_D(int)(); // Opcode 0xcd
+ virtual void I386OP_D(_int)(); // Opcode 0xcd
void I386OP_D(into)(); // Opcode 0xce
void I386OP_D(escape)(); // Opcodes 0xd8 - 0xdf
void I386OP_D(hlt)(); // Opcode 0xf4
//
INLINE vtlb_entry get_permissions(UINT32 pte, int wp);
INLINE int translate_address(int pl, int type, UINT32 *address, UINT32 *error);
- INLINE UINT32 i386_translate(int segment, UINT32 ip, int rwn);
+ INLINE UINT32 i386_translate(int segment, UINT32 ip, int rwn, UINT32 size);
INLINE UINT8 FETCH();
INLINE UINT16 FETCH16();
}
-INLINE UINT32 I386_OPS_BASE::i386_translate(int segment, UINT32 ip, int rwn)
+INLINE UINT32 I386_OPS_BASE::i386_translate(int segment, UINT32 ip, int rwn, UINT32 size)
{
// TODO: segment limit access size, execution permission, handle exception thrown from exception handler
if(PROTECTED_MODE && !V8086_MODE && (rwn != -1))
{
if(!(cpustate->sreg[segment].valid))
FAULT_THROW((segment==SS)?FAULT_SS:FAULT_GP, 0);
- if(i386_limit_check(segment, ip))
+ if(i386_limit_check(segment, ip, size))
FAULT_THROW((segment==SS)?FAULT_SS:FAULT_GP, 0);
if((rwn == 0) && ((cpustate->sreg[segment].flags & 8) && !(cpustate->sreg[segment].flags & 2)))
FAULT_THROW(FAULT_GP, 0);
INLINE void I386_OPS_BASE::CHANGE_PC(UINT32 pc)
{
- cpustate->pc = i386_translate(CS, pc, -1 );
+ cpustate->pc = i386_translate(CS, pc, -1, 1 );
}
INLINE void I386_OPS_BASE::NEAR_BRANCH(INT32 offs)
if(!translate_address(cpustate->CPL,TRANSLATE_WRITE,&address,&error))
PF_THROW(error);
- ea &= cpustate->a20_mask;
+ address &= cpustate->a20_mask;
cpustate->program->write_data32(address, value);
}
}
if(!translate_address(cpustate->CPL,TRANSLATE_WRITE,&address,&error))
PF_THROW(error);
- ea &= cpustate->a20_mask;
+ address &= cpustate->a20_mask;
cpustate->program->write_data32(address+0, value & 0xffffffff);
cpustate->program->write_data32(address+4, (value >> 32) & 0xffffffff);
}
UINT32 ea, new_esp;
if( STACK_32BIT ) {
new_esp = REG32(ESP) - 2;
- ea = i386_translate( SS, new_esp, 1);
+ ea = i386_translate( SS, new_esp, 1, 2);
WRITE16( ea, value );
REG32(ESP) = new_esp;
} else {
new_esp = (REG16(SP) - 2) & 0xffff;
- ea = i386_translate( SS, new_esp, 1);
+ ea = i386_translate( SS, new_esp, 1, 2);
WRITE16( ea, value );
REG16(SP) = new_esp;
}
UINT32 ea, new_esp;
if( STACK_32BIT ) {
new_esp = REG32(ESP) - 4;
- ea = i386_translate( SS, new_esp, 1);
+ ea = i386_translate( SS, new_esp, 1, 4);
WRITE32( ea, value );
REG32(ESP) = new_esp;
} else {
new_esp = (REG16(SP) - 4) & 0xffff;
- ea = i386_translate( SS, new_esp, 1);
+ ea = i386_translate( SS, new_esp, 1, 4);
WRITE32( ea, value );
REG16(SP) = new_esp;
}
UINT32 ea, new_esp;
if( STACK_32BIT ) {
new_esp = REG32(ESP) - 4;
- ea = i386_translate(SS, new_esp, 1);
- ((cpustate->cpu_version & 0xf00) == 0x300) ? WRITE16(ea, value) : WRITE32(ea, value ); // 486 also?
+ if( (cpustate->cpu_version & 0xf00) == 0x300 ) {
+ ea = i386_translate(SS, new_esp, 1, 2);
+ WRITE16(ea, value); // 486 also?
+ } else {
+ ea = i386_translate(SS, new_esp, 1, 4);
+ WRITE32(ea, value ); // 486 also?
+ }
REG32(ESP) = new_esp;
} else {
new_esp = (REG16(SP) - 4) & 0xffff;
- ea = i386_translate(SS, new_esp, 1);
- ((cpustate->cpu_version & 0xf00) == 0x300) ? WRITE16(ea, value) : WRITE32(ea, value );
+ if( (cpustate->cpu_version & 0xf00) == 0x300 ) {
+ ea = i386_translate(SS, new_esp, 1, 2);
+ WRITE16(ea, value);
+ } else {
+ ea = i386_translate(SS, new_esp, 1, 4);
+ WRITE32(ea, value );
+ }
REG16(SP) = new_esp;
}
}
UINT32 ea, new_esp;
if( STACK_32BIT ) {
new_esp = REG32(ESP) + 1;
- ea = i386_translate( SS, new_esp - 1, 0);
+ ea = i386_translate( SS, new_esp - 1, 0, 1);
value = READ8( ea );
REG32(ESP) = new_esp;
} else {
new_esp = REG16(SP) + 1;
- ea = i386_translate( SS, (new_esp - 1) & 0xffff, 0);
+ ea = i386_translate( SS, (new_esp - 1) & 0xffff, 0, 1);
value = READ8( ea );
REG16(SP) = new_esp;
}
UINT32 ea, new_esp;
if( STACK_32BIT ) {
new_esp = REG32(ESP) + 2;
- ea = i386_translate( SS, new_esp - 2, 0);
+ ea = i386_translate( SS, new_esp - 2, 0, 2);
value = READ16( ea );
REG32(ESP) = new_esp;
} else {
new_esp = REG16(SP) + 2;
- ea = i386_translate( SS, (new_esp - 2) & 0xffff, 0);
+ ea = i386_translate( SS, (new_esp - 2) & 0xffff, 0, 2);
value = READ16( ea );
REG16(SP) = new_esp;
}
UINT32 ea, new_esp;
if( STACK_32BIT ) {
new_esp = REG32(ESP) + 4;
- ea = i386_translate( SS, new_esp - 4, 0);
+ ea = i386_translate( SS, new_esp - 4, 0, 4);
value = READ32( ea );
REG32(ESP) = new_esp;
} else {
new_esp = REG16(SP) + 4;
- ea = i386_translate( SS, (new_esp - 4) & 0xffff, 0);
+ ea = i386_translate( SS, (new_esp - 4) & 0xffff, 0, 4);
value = READ32( ea );
REG16(SP) = new_esp;
}
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Phil Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
#ifndef __LIB_I386_OPS_TABLE_H__
#define __LIB_I386_OPS_TABLE_H__
{ 0xCA, OP_I386, &I386_OPS_BASE::i386_retf_i16, &I386_OPS_BASE::i386_retf_i32, false},
{ 0xCB, OP_I386, &I386_OPS_BASE::i386_retf16, &I386_OPS_BASE::i386_retf32, false},
{ 0xCC, OP_I386, &I386_OPS_BASE::i386_int3, &I386_OPS_BASE::i386_int3, false},
- { 0xCD, OP_I386, &I386_OPS_BASE::i386_int, &I386_OPS_BASE::i386_int, false},
+ { 0xCD, OP_I386, &I386_OPS_BASE::i386__int, &I386_OPS_BASE::i386__int, false},
{ 0xCE, OP_I386, &I386_OPS_BASE::i386_into, &I386_OPS_BASE::i386_into, false},
{ 0xCF, OP_I386, &I386_OPS_BASE::i386_iret16, &I386_OPS_BASE::i386_iret32, false},
{ 0xD0, OP_I386, &I386_OPS_BASE::i386_groupD0_8, &I386_OPS_BASE::i386_groupD0_8, false},
int cpu_execute_i386(int cycles);
void i386_trap(int irq, int irq_gate, int trap_level);
void i386_trap_with_error(int irq, int irq_gate, int trap_level, UINT32 error);
- void i386_call_abs16(); // Opcode 0x9a
- void i386_call_rel16(); // Opcode 0xe8
- void i386_groupFF_16(); // Opcode 0xff
+ void i386__int(); // Opcode 0xcd
+ void i386_call_abs16(); // Opcode 0x9a
+ void i386_call_rel16(); // Opcode 0xe8
+ void i386_groupFF_16(); // Opcode 0xff
void i386_decode_opcode();
//void build_opcode_table(UINT32 features);
i386_state *i386_common_init(int tlbsize);
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
#include "./i386_opdef.h"
#define FAULT(fault,error) {cpustate->ext = 1; i386_trap_with_error(fault,0,0,error); return;}
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
src = LOAD_REG16(modrm);
dst = READ16(ea);
dst = ADC16( dst, src, cpustate->CF);
STORE_REG16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = READ16(ea);
dst = LOAD_REG16(modrm);
dst = ADC16( dst, src, cpustate->CF);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
src = LOAD_REG16(modrm);
dst = READ16(ea);
dst = ADD16(dst, src);
STORE_REG16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = READ16(ea);
dst = LOAD_REG16(modrm);
dst = ADD16(dst, src);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
src = LOAD_REG16(modrm);
dst = READ16(ea);
dst = AND16(dst, src);
STORE_REG16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = READ16(ea);
dst = LOAD_REG16(modrm);
dst = AND16(dst, src);
if( modrm >= 0xc0 ) {
src = LOAD_RM16(modrm);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = READ16(ea);
}
if( modrm >= 0xc0 ) {
src = LOAD_RM16(modrm);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = READ16(ea);
}
UINT32 ea = GetNonTranslatedEA(modrm,&segment);
UINT16 bit = LOAD_REG16(modrm);
ea += 2*(bit/16);
- ea = i386_translate(segment,(cpustate->address_size)?ea:(ea&0xffff),0);
+ ea = i386_translate(segment,(cpustate->address_size)?ea:(ea&0xffff), 0, 2);
bit %= 16;
UINT16 dst = READ16(ea);
UINT32 ea = GetNonTranslatedEA(modrm,&segment);
UINT16 bit = LOAD_REG16(modrm);
ea += 2*(bit/16);
- ea = i386_translate(segment,(cpustate->address_size)?ea:(ea&0xffff),1);
+ ea = i386_translate(segment,(cpustate->address_size)?ea:(ea&0xffff),1, 2);
bit %= 16;
UINT16 dst = READ16(ea);
UINT32 ea = GetNonTranslatedEA(modrm,&segment);
UINT16 bit = LOAD_REG16(modrm);
ea += 2*(bit/16);
- ea = i386_translate(segment,(cpustate->address_size)?ea:(ea&0xffff),1);
+ ea = i386_translate(segment,(cpustate->address_size)?ea:(ea&0xffff),1, 2);
bit %= 16;
UINT16 dst = READ16(ea);
UINT32 ea = GetNonTranslatedEA(modrm,&segment);
UINT16 bit = LOAD_REG16(modrm);
ea += 2*(bit/16);
- ea = i386_translate(segment,(cpustate->address_size)?ea:(ea&0xffff),1);
+ ea = i386_translate(segment,(cpustate->address_size)?ea:(ea&0xffff),1, 2);
bit %= 16;
UINT16 dst = READ16(ea);
SUB16(dst, src);
CYCLES(CYCLES_CMP_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = LOAD_REG16(modrm);
dst = READ16(ea);
SUB16(dst, src);
SUB16(dst, src);
CYCLES(CYCLES_CMP_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = READ16(ea);
dst = LOAD_REG16(modrm);
SUB16(dst, src);
UINT32 eas, ead;
UINT16 src, dst;
if( cpustate->segment_prefix ) {
- eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 2 );
} else {
- eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 2 );
}
- ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0 );
+ ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0, 2 );
src = READ16(eas);
dst = READ16(ead);
SUB16(src,dst);
src = (INT32)(INT16)LOAD_RM16(modrm);
CYCLES(CYCLES_IMUL16_REG_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = (INT32)(INT16)READ16(ea);
CYCLES(CYCLES_IMUL16_REG_MEM); /* TODO: Correct multiply timing */
}
dst = (INT32)(INT16)LOAD_RM16(modrm);
CYCLES(CYCLES_IMUL16_REG_IMM_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
dst = (INT32)(INT16)READ16(ea);
CYCLES(CYCLES_IMUL16_MEM_IMM_REG); /* TODO: Correct multiply timing */
}
dst = (INT32)(INT16)LOAD_RM16(modrm);
CYCLES(CYCLES_IMUL16_REG_IMM_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
dst = (INT32)(INT16)READ16(ea);
CYCLES(CYCLES_IMUL16_MEM_IMM_REG); /* TODO: Correct multiply timing */
}
{
UINT32 eas;
if( cpustate->segment_prefix ) {
- eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 2 );
} else {
- eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 2 );
}
REG16(AX) = READ16(eas);
BUMP_SI(2);
STORE_RM16(modrm, src);
CYCLES(CYCLES_MOV_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
+#if 0
// NEC PC-9801RA's ITF routine intentionally raise general protection fault :-(
int segment = DS;
if( cpustate->segment_prefix ) {
segment = cpustate->segment_override;
}
- if( i386_limit_check(segment, (ea + 1) & 0xffff) == 0 ) {
+ if( i386_limit_check(segment, (ea + 1) & 0xffff, 2) == 0 ) {
src = READ16(ea);
STORE_REG16(modrm, src);
} else {
FAULT(FAULT_GP, 0)
}
CYCLES(CYCLES_MOV_MEM_REG);
+#else
+ src = LOAD_REG16(modrm);
+ WRITE16(ea, src);
+ CYCLES(CYCLES_MOV_REG_MEM);
+#endif
}
}
STORE_REG16(modrm, src);
CYCLES(CYCLES_MOV_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = READ16(ea);
STORE_REG16(modrm, src);
CYCLES(CYCLES_MOV_MEM_REG);
STORE_RM16(modrm, value);
CYCLES(CYCLES_MOV_IMM_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
UINT16 value = FETCH16();
WRITE16(ea, value);
CYCLES(CYCLES_MOV_IMM_MEM);
}
/* TODO: Not sure if this is correct... */
if( cpustate->segment_prefix ) {
- ea = i386_translate( cpustate->segment_override, offset, 0 );
+ ea = i386_translate( cpustate->segment_override, offset, 0, 2);
} else {
- ea = i386_translate( DS, offset, 0 );
+ ea = i386_translate( DS, offset, 0, 2 );
}
REG16(AX) = READ16(ea);
CYCLES(CYCLES_MOV_MEM_ACC);
}
/* TODO: Not sure if this is correct... */
if( cpustate->segment_prefix ) {
- ea = i386_translate( cpustate->segment_override, offset, 1 );
+ ea = i386_translate( cpustate->segment_override, offset, 1, 2);
} else {
- ea = i386_translate( DS, offset, 1 );
+ ea = i386_translate( DS, offset, 1, 2);
}
WRITE16( ea, REG16(AX) );
CYCLES(CYCLES_MOV_ACC_MEM);
UINT32 eas, ead;
UINT16 v;
if( cpustate->segment_prefix ) {
- eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 2);
} else {
- eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 2);
}
- ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1 );
+ ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1, 2 );
v = READ16(eas);
WRITE16(ead, v);
BUMP_SI(2);
STORE_REG16(modrm, src);
CYCLES(CYCLES_MOVSX_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 1);
INT16 src = (INT8)READ8(ea);
STORE_REG16(modrm, src);
CYCLES(CYCLES_MOVSX_MEM_REG);
STORE_REG16(modrm, src);
CYCLES(CYCLES_MOVZX_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 1);
UINT16 src = (UINT8)READ8(ea);
STORE_REG16(modrm, src);
CYCLES(CYCLES_MOVZX_MEM_REG);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
src = LOAD_REG16(modrm);
dst = READ16(ea);
dst = OR16(dst, src);
STORE_REG16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = READ16(ea);
dst = LOAD_REG16(modrm);
dst = OR16(dst, src);
void I386_OPS_BASE::I386OP(pop_ax)() // Opcode 0x58
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+1) == 0)
+ if(i386_limit_check(SS,offset+1, 2) == 0)
REG16(AX) = POP16();
else
FAULT(FAULT_SS,0)
void I386_OPS_BASE::I386OP(pop_cx)() // Opcode 0x59
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+1) == 0)
+ if(i386_limit_check(SS,offset+1, 2) == 0)
REG16(CX) = POP16();
else
FAULT(FAULT_SS,0)
void I386_OPS_BASE::I386OP(pop_dx)() // Opcode 0x5a
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+1) == 0)
+ if(i386_limit_check(SS,offset+1, 2) == 0)
REG16(DX) = POP16();
else
FAULT(FAULT_SS,0)
void I386_OPS_BASE::I386OP(pop_bx)() // Opcode 0x5b
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+1) == 0)
+ if(i386_limit_check(SS,offset+1, 2) == 0)
REG16(BX) = POP16();
else
FAULT(FAULT_SS,0)
void I386_OPS_BASE::I386OP(pop_sp)() // Opcode 0x5c
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+1) == 0)
+ if(i386_limit_check(SS,offset+1, 2) == 0)
REG16(SP) = POP16();
else
FAULT(FAULT_SS,0)
void I386_OPS_BASE::I386OP(pop_bp)() // Opcode 0x5d
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+1) == 0)
+ if(i386_limit_check(SS,offset+1, 2) == 0)
REG16(BP) = POP16();
else
FAULT(FAULT_SS,0)
void I386_OPS_BASE::I386OP(pop_si)() // Opcode 0x5e
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+1) == 0)
+ if(i386_limit_check(SS,offset+1, 2) == 0)
REG16(SI) = POP16();
else
FAULT(FAULT_SS,0)
void I386_OPS_BASE::I386OP(pop_di)() // Opcode 0x5f
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+1) == 0)
+ if(i386_limit_check(SS,offset+1, 2) == 0)
REG16(DI) = POP16();
else
FAULT(FAULT_SS,0)
UINT32 ea, offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
UINT16 value;
bool fault;
- if(i386_limit_check(SS,offset+1) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
{
- ea = i386_translate( SS, offset, 0);
+ ea = i386_translate( SS, offset, 0, 2);
value = READ16( ea);
i386_sreg_load(value, segment, &fault);
if(fault) return false;
UINT16 value;
UINT32 ea, offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+1) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
{
UINT32 temp_sp = REG32(ESP);
value = POP16();
if( modrm >= 0xc0 ) {
STORE_RM16(modrm, value);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
try
{
WRITE16(ea, value);
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+15) == 0)
+ if(i386_limit_check(SS,offset ,16) == 0)
{
REG16(DI) = POP16();
REG16(SI) = POP16();
mask &= ~0x00003000; // IOPL cannot be changed while in V8086 mode
}
- if(i386_limit_check(SS,offset+1) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
{
value = POP16();
set_flags((current & ~mask) | (value & mask)); // mask out reserved bits
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
PUSH16( REG16(AX) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
PUSH16( REG16(CX) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
PUSH16( REG16(DX) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
PUSH16( REG16(BX) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
PUSH16( REG16(SP) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
PUSH16( REG16(BP) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
PUSH16( REG16(SI) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
PUSH16( REG16(DI) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
PUSH16( cpustate->sreg[CS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
PUSH16( cpustate->sreg[DS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
PUSH16( cpustate->sreg[ES].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
PUSH16( cpustate->sreg[FS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
PUSH16( cpustate->sreg[GS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
PUSH16( cpustate->sreg[SS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
PUSH16(value);
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 16;
else
offset = (REG16(SP) - 16) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 16) == 0)
{
PUSH16( REG16(AX) );
PUSH16( REG16(CX) );
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 2) == 0)
PUSH16( get_flags() & 0xffff );
else
FAULT(FAULT_SS,0)
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
src = LOAD_REG16(modrm);
dst = READ16(ea);
dst = SBB16( dst, src, cpustate->CF);
STORE_REG16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = READ16(ea);
dst = LOAD_REG16(modrm);
dst = SBB16( dst, src, cpustate->CF);
{
UINT32 eas;
UINT16 src, dst;
- eas = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0 );
+ eas = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0, 2);
src = READ16(eas);
dst = REG16(AX);
SUB16(dst, src);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_SHLD_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
UINT16 dst = READ16(ea);
UINT16 upper = LOAD_REG16(modrm);
UINT8 shift = FETCH();
STORE_RM16(modrm, dst);
CYCLES(CYCLES_SHLD_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
UINT16 dst = READ16(ea);
UINT16 upper = LOAD_REG16(modrm);
UINT8 shift = REG8(CL);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_SHRD_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
UINT16 dst = READ16(ea);
UINT16 upper = LOAD_REG16(modrm);
UINT8 shift = FETCH();
STORE_RM16(modrm, dst);
CYCLES(CYCLES_SHRD_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
UINT16 dst = READ16(ea);
UINT16 upper = LOAD_REG16(modrm);
UINT8 shift = REG8(CL);
void I386_OPS_BASE::I386OP(stosw)() // Opcode 0xab
{
UINT32 ead;
- ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1 );
+ ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1, 2);
WRITE16(ead, REG16(AX));
BUMP_DI(2);
CYCLES(CYCLES_STOS);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
src = LOAD_REG16(modrm);
dst = READ16(ea);
dst = SUB16(dst, src);
STORE_REG16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = READ16(ea);
dst = LOAD_REG16(modrm);
dst = SUB16(dst, src);
cpustate->OF = 0;
CYCLES(CYCLES_TEST_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = LOAD_REG16(modrm);
dst = READ16(ea);
dst = src & dst;
STORE_RM16(modrm, dst);
CYCLES(CYCLES_XCHG_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
UINT16 src = READ16(ea);
UINT16 dst = LOAD_REG16(modrm);
STORE_REG16(modrm, src);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
src = LOAD_REG16(modrm);
dst = READ16(ea);
dst = XOR16(dst, src);
STORE_REG16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = READ16(ea);
dst = LOAD_REG16(modrm);
dst = XOR16(dst, src);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
dst = READ16(ea);
src = FETCH16();
dst = ADD16(dst, src);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
dst = READ16(ea);
src = FETCH16();
dst = OR16(dst, src);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
dst = READ16(ea);
src = FETCH16();
dst = ADC16( dst, src, cpustate->CF);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
dst = READ16(ea);
src = FETCH16();
dst = SBB16( dst, src, cpustate->CF);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
dst = READ16(ea);
src = FETCH16();
dst = AND16(dst, src);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
dst = READ16(ea);
src = FETCH16();
dst = SUB16(dst, src);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
dst = READ16(ea);
src = FETCH16();
dst = XOR16(dst, src);
SUB16(dst, src);
CYCLES(CYCLES_CMP_REG_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0, 2);
dst = READ16(ea);
src = FETCH16();
SUB16(dst, src);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
dst = READ16(ea);
src = (UINT16)(INT16)(INT8)FETCH();
dst = ADD16(dst, src);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
dst = READ16(ea);
src = (UINT16)(INT16)(INT8)FETCH();
dst = OR16(dst, src);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
dst = READ16(ea);
src = (UINT16)(INT16)(INT8)FETCH();
dst = ADC16( dst, src, cpustate->CF);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
dst = READ16(ea);
src = ((UINT16)(INT16)(INT8)FETCH());
dst = SBB16( dst, src, cpustate->CF);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
dst = READ16(ea);
src = (UINT16)(INT16)(INT8)FETCH();
dst = AND16(dst, src);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
dst = READ16(ea);
src = (UINT16)(INT16)(INT8)FETCH();
dst = SUB16(dst, src);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
dst = READ16(ea);
src = (UINT16)(INT16)(INT8)FETCH();
dst = XOR16(dst, src);
SUB16(dst, src);
CYCLES(CYCLES_CMP_REG_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0, 2);
dst = READ16(ea);
src = (UINT16)(INT16)(INT8)FETCH();
SUB16(dst, src);
dst = i386_shift_rotate16( modrm, dst, shift);
STORE_RM16(modrm, dst);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
dst = READ16(ea);
shift = FETCH() & 0x1f;
dst = i386_shift_rotate16( modrm, dst, shift);
dst = i386_shift_rotate16( modrm, dst, 1);
STORE_RM16(modrm, dst);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
dst = READ16(ea);
dst = i386_shift_rotate16( modrm, dst, 1);
WRITE16(ea, dst);
dst = i386_shift_rotate16( modrm, dst, REG8(CL));
STORE_RM16(modrm, dst);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
dst = READ16(ea);
dst = i386_shift_rotate16( modrm, dst, REG8(CL));
WRITE16(ea, dst);
SetSZPF16(dst);
CYCLES(CYCLES_TEST_IMM_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
UINT16 dst = READ16(ea);
UINT16 src = FETCH16();
dst &= src;
STORE_RM16(modrm, dst);
CYCLES(CYCLES_NOT_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
UINT16 dst = READ16(ea);
dst = ~dst;
WRITE16(ea, dst);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_NEG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
UINT16 dst = READ16(ea);
dst = SUB16( 0, dst );
WRITE16(ea, dst);
src = LOAD_RM16(modrm);
CYCLES(CYCLES_MUL16_ACC_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = READ16(ea);
CYCLES(CYCLES_MUL16_ACC_MEM); /* TODO: Correct multiply timing */
}
src = (INT32)(INT16)LOAD_RM16(modrm);
CYCLES(CYCLES_IMUL16_ACC_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = (INT32)(INT16)READ16(ea);
CYCLES(CYCLES_IMUL16_ACC_MEM); /* TODO: Correct multiply timing */
}
src = LOAD_RM16(modrm);
CYCLES(CYCLES_DIV16_ACC_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = READ16(ea);
CYCLES(CYCLES_DIV16_ACC_MEM);
}
src = LOAD_RM16(modrm);
CYCLES(CYCLES_IDIV16_ACC_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
src = READ16(ea);
CYCLES(CYCLES_IDIV16_ACC_MEM);
}
STORE_RM16(modrm, dst);
CYCLES(CYCLES_INC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
UINT16 dst = READ16(ea);
dst = INC16(dst);
WRITE16(ea, dst);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_DEC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
UINT16 dst = READ16(ea);
dst = DEC16(dst);
WRITE16(ea, dst);
address = LOAD_RM16(modrm);
CYCLES(CYCLES_CALL_REG); /* TODO: Timing = 7 + m */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
address = READ16(ea);
CYCLES(CYCLES_CALL_MEM); /* TODO: Timing = 10 + m */
}
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
address = READ16(ea + 0);
selector = READ16(ea + 2);
CYCLES(CYCLES_CALL_MEM_INTERSEG); /* TODO: Timing = 10 + m */
address = LOAD_RM16(modrm);
CYCLES(CYCLES_JMP_REG); /* TODO: Timing = 7 + m */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
address = READ16(ea);
CYCLES(CYCLES_JMP_MEM); /* TODO: Timing = 10 + m */
}
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
address = READ16(ea + 0);
selector = READ16(ea + 2);
CYCLES(CYCLES_JMP_MEM_INTERSEG); /* TODO: Timing = 10 + m */
if( modrm >= 0xc0 ) {
value = LOAD_RM16(modrm);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
value = READ16(ea);
}
PUSH16(value);
STORE_RM16(modrm, cpustate->ldtr.segment);
CYCLES(CYCLES_SLDT_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
WRITE16( ea, cpustate->ldtr.segment);
CYCLES(CYCLES_SLDT_MEM);
}
STORE_RM16(modrm, cpustate->task.segment);
CYCLES(CYCLES_STR_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
WRITE16( ea, cpustate->task.segment);
CYCLES(CYCLES_STR_MEM);
}
cpustate->ldtr.segment = address;
CYCLES(CYCLES_LLDT_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0, 2);
cpustate->ldtr.segment = READ16(ea);
CYCLES(CYCLES_LLDT_MEM);
}
cpustate->task.segment = address;
CYCLES(CYCLES_LTR_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0, 2);
cpustate->task.segment = READ16(ea);
CYCLES(CYCLES_LTR_MEM);
}
address = LOAD_RM16(modrm);
CYCLES(CYCLES_VERR_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0, 2);
address = READ16(ea);
CYCLES(CYCLES_VERR_MEM);
}
address = LOAD_RM16(modrm);
CYCLES(CYCLES_VERW_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0, 2);
address = READ16(ea);
CYCLES(CYCLES_VERW_MEM);
}
{
if( modrm >= 0xc0 ) {
address = LOAD_RM16(modrm);
- ea = i386_translate( CS, address, 1 );
+ ea = i386_translate( CS, address, 1, 6 );
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 6);
}
WRITE16(ea, cpustate->gdtr.limit);
WRITE32(ea + 2, cpustate->gdtr.base);
if (modrm >= 0xc0)
{
address = LOAD_RM16(modrm);
- ea = i386_translate( CS, address, 1 );
+ ea = i386_translate( CS, address, 1, 6 );
}
else
{
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 6);
}
WRITE16(ea, cpustate->idtr.limit);
WRITE32(ea + 2, cpustate->idtr.base);
FAULT(FAULT_GP,0)
if( modrm >= 0xc0 ) {
address = LOAD_RM16(modrm);
- ea = i386_translate( CS, address, 0 );
+ ea = i386_translate( CS, address, 0, 6 );
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0, 6);
}
cpustate->gdtr.limit = READ16(ea);
cpustate->gdtr.base = READ32(ea + 2) & 0xffffff;
FAULT(FAULT_GP,0)
if( modrm >= 0xc0 ) {
address = LOAD_RM16(modrm);
- ea = i386_translate( CS, address, 0 );
+ ea = i386_translate( CS, address, 0, 6 );
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0, 6);
}
cpustate->idtr.limit = READ16(ea);
cpustate->idtr.base = READ32(ea + 2) & 0xffffff;
STORE_RM16(modrm, cpustate->cr[0]);
CYCLES(CYCLES_SMSW_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 2);
WRITE16(ea, cpustate->cr[0]);
CYCLES(CYCLES_SMSW_MEM);
}
b = LOAD_RM16(modrm);
CYCLES(CYCLES_LMSW_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0, 2);
CYCLES(CYCLES_LMSW_MEM);
b = READ16(ea);
}
CYCLES(CYCLES_BT_IMM_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
UINT16 dst = READ16(ea);
UINT8 bit = FETCH();
STORE_RM16(modrm, dst);
CYCLES(CYCLES_BTS_IMM_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
UINT16 dst = READ16(ea);
UINT8 bit = FETCH();
STORE_RM16(modrm, dst);
CYCLES(CYCLES_BTR_IMM_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
UINT16 dst = READ16(ea);
UINT8 bit = FETCH();
STORE_RM16(modrm, dst);
CYCLES(CYCLES_BTC_IMM_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
UINT16 dst = READ16(ea);
UINT8 bit = FETCH();
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
seg.selector = READ16(ea);
CYCLES(CYCLES_LAR_MEM);
}
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
seg.selector = READ16(ea);
}
if(seg.selector == 0)
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
low = READ16(ea + 0);
high = READ16(ea + 2);
}
i386_trap(6, 0, 0);
return false;
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
STORE_REG16(modrm, READ16(ea + 0));
selector = READ16(ea + 2);
i386_sreg_load(selector,s,NULL);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_INC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
UINT16 dst = READ16(ea);
dst = INC16(dst);
WRITE16(ea, dst);
STORE_RM16(modrm, dst);
CYCLES(CYCLES_DEC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 2);
UINT16 dst = READ16(ea);
dst = DEC16(dst);
WRITE16(ea, dst);
address = LOAD_RM16(modrm);
CYCLES(CYCLES_CALL_REG); /* TODO: Timing = 7 + m */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
address = READ16(ea);
CYCLES(CYCLES_CALL_MEM); /* TODO: Timing = 10 + m */
}
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
address = READ16(ea + 0);
selector = READ16(ea + 2);
CYCLES(CYCLES_CALL_MEM_INTERSEG); /* TODO: Timing = 10 + m */
address = LOAD_RM16(modrm);
CYCLES(CYCLES_JMP_REG); /* TODO: Timing = 7 + m */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
address = READ16(ea);
CYCLES(CYCLES_JMP_MEM); /* TODO: Timing = 10 + m */
}
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
address = READ16(ea + 0);
selector = READ16(ea + 2);
CYCLES(CYCLES_JMP_MEM_INTERSEG); /* TODO: Timing = 10 + m */
if( modrm >= 0xc0 ) {
value = LOAD_RM16(modrm);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
value = READ16(ea);
}
PUSH16(value);
break;
}
}
+
+void I386_OPS::i386__int() // Opcode 0xcd
+{
+ int interrupt = FETCH();
+ CYCLES(CYCLES_INT);
+
+#ifdef I386_PSEUDO_BIOS
+ BIOS_INT(interrupt)
+#endif
+ cpustate->ext = 0; // not an external interrupt
+ i386_trap(interrupt, 1, 0);
+ cpustate->ext = 1;
+}
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
#include "./i386_opdef.h"
#include "./i386ops.h"
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 4);
src = LOAD_REG32(modrm);
dst = READ32(ea);
dst = ADC32( dst, src, cpustate->CF);
STORE_REG32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
src = READ32(ea);
dst = LOAD_REG32(modrm);
dst = ADC32( dst, src, cpustate->CF);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 4);
src = LOAD_REG32(modrm);
dst = READ32(ea);
dst = ADD32(dst, src);
STORE_REG32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
src = READ32(ea);
dst = LOAD_REG32(modrm);
dst = ADD32(dst, src);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 4);
src = LOAD_REG32(modrm);
dst = READ32(ea);
dst = AND32(dst, src);
STORE_REG32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
src = READ32(ea);
dst = LOAD_REG32(modrm);
dst = AND32(dst, src);
if( modrm >= 0xc0 ) {
src = LOAD_RM32(modrm);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
src = READ32(ea);
}
if( modrm >= 0xc0 ) {
src = LOAD_RM32(modrm);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
src = READ32(ea);
}
UINT32 ea = GetNonTranslatedEA(modrm,&segment);
UINT32 bit = LOAD_REG32(modrm);
ea += 4*(bit/32);
- ea = i386_translate(segment,(cpustate->address_size)?ea:(ea&0xffff),0);
+ ea = i386_translate(segment,(cpustate->address_size)?ea:(ea&0xffff),0,4);
bit %= 32;
UINT32 dst = READ32(ea);
UINT32 ea = GetNonTranslatedEA(modrm,&segment);
UINT32 bit = LOAD_REG32(modrm);
ea += 4*(bit/32);
- ea = i386_translate(segment,(cpustate->address_size)?ea:(ea&0xffff),1);
+ ea = i386_translate(segment,(cpustate->address_size)?ea:(ea&0xffff),1,4);
bit %= 32;
UINT32 dst = READ32(ea);
UINT32 ea = GetNonTranslatedEA(modrm,&segment);
UINT32 bit = LOAD_REG32(modrm);
ea += 4*(bit/32);
- ea = i386_translate(segment,(cpustate->address_size)?ea:(ea&0xffff),1);
+ ea = i386_translate(segment,(cpustate->address_size)?ea:(ea&0xffff),1,4);
bit %= 32;
UINT32 dst = READ32(ea);
UINT32 ea = GetNonTranslatedEA(modrm,&segment);
UINT32 bit = LOAD_REG32(modrm);
ea += 4*(bit/32);
- ea = i386_translate(segment,(cpustate->address_size)?ea:(ea&0xffff),1);
+ ea = i386_translate(segment,(cpustate->address_size)?ea:(ea&0xffff),1,4);
bit %= 32;
UINT32 dst = READ32(ea);
SUB32(dst, src);
CYCLES(CYCLES_CMP_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
src = LOAD_REG32(modrm);
dst = READ32(ea);
SUB32(dst, src);
SUB32(dst, src);
CYCLES(CYCLES_CMP_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
src = READ32(ea);
dst = LOAD_REG32(modrm);
SUB32(dst, src);
{
UINT32 eas, ead, src, dst;
if( cpustate->segment_prefix ) {
- eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0,4 );
} else {
- eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0,4 );
}
- ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0 );
+ ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0,4 );
src = READ32(eas);
dst = READ32(ead);
SUB32(src,dst);
src = (INT64)(INT32)LOAD_RM32(modrm);
CYCLES(CYCLES_IMUL32_REG_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
src = (INT64)(INT32)READ32(ea);
CYCLES(CYCLES_IMUL32_REG_REG); /* TODO: Correct multiply timing */
}
dst = (INT64)(INT32)LOAD_RM32(modrm);
CYCLES(CYCLES_IMUL32_REG_IMM_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
dst = (INT64)(INT32)READ32(ea);
CYCLES(CYCLES_IMUL32_MEM_IMM_REG); /* TODO: Correct multiply timing */
}
dst = (INT64)(INT32)LOAD_RM32(modrm);
CYCLES(CYCLES_IMUL32_REG_IMM_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
dst = (INT64)(INT32)READ32(ea);
CYCLES(CYCLES_IMUL32_MEM_IMM_REG); /* TODO: Correct multiply timing */
}
{
UINT32 eas;
if( cpustate->segment_prefix ) {
- eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0,4 );
} else {
- eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0,4 );
}
REG32(EAX) = READ32(eas);
BUMP_SI(4);
STORE_RM32(modrm, src);
CYCLES(CYCLES_MOV_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 4);
src = LOAD_REG32(modrm);
WRITE32(ea, src);
CYCLES(CYCLES_MOV_REG_MEM);
STORE_REG32(modrm, src);
CYCLES(CYCLES_MOV_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
src = READ32(ea);
STORE_REG32(modrm, src);
CYCLES(CYCLES_MOV_MEM_REG);
STORE_RM32(modrm, value);
CYCLES(CYCLES_MOV_IMM_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 4);
UINT32 value = FETCH32();
WRITE32(ea, value);
CYCLES(CYCLES_MOV_IMM_MEM);
offset = FETCH16();
}
if( cpustate->segment_prefix ) {
- ea = i386_translate( cpustate->segment_override, offset, 0 );
+ ea = i386_translate( cpustate->segment_override, offset, 0,4 );
} else {
- ea = i386_translate( DS, offset, 0 );
+ ea = i386_translate( DS, offset, 0,4 );
}
REG32(EAX) = READ32(ea);
CYCLES(CYCLES_MOV_MEM_ACC);
offset = FETCH16();
}
if( cpustate->segment_prefix ) {
- ea = i386_translate( cpustate->segment_override, offset, 1 );
+ ea = i386_translate( cpustate->segment_override, offset, 1, 4 );
} else {
- ea = i386_translate( DS, offset, 1 );
+ ea = i386_translate( DS, offset, 1, 4 );
}
WRITE32( ea, REG32(EAX) );
CYCLES(CYCLES_MOV_ACC_MEM);
{
UINT32 eas, ead, v;
if( cpustate->segment_prefix ) {
- eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 4 );
} else {
- eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 4 );
}
- ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1 );
+ ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1, 4 );
v = READ32(eas);
WRITE32(ead, v);
BUMP_SI(4);
STORE_REG32(modrm, src);
CYCLES(CYCLES_MOVSX_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 1);
INT32 src = (INT8)READ8(ea);
STORE_REG32(modrm, src);
CYCLES(CYCLES_MOVSX_MEM_REG);
STORE_REG32(modrm, src);
CYCLES(CYCLES_MOVSX_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
INT32 src = (INT16)READ16(ea);
STORE_REG32(modrm, src);
CYCLES(CYCLES_MOVSX_MEM_REG);
STORE_REG32(modrm, src);
CYCLES(CYCLES_MOVZX_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 1);
UINT32 src = (UINT8)READ8(ea);
STORE_REG32(modrm, src);
CYCLES(CYCLES_MOVZX_MEM_REG);
STORE_REG32(modrm, src);
CYCLES(CYCLES_MOVZX_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 2);
UINT32 src = (UINT16)READ16(ea);
STORE_REG32(modrm, src);
CYCLES(CYCLES_MOVZX_MEM_REG);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 4);
src = LOAD_REG32(modrm);
dst = READ32(ea);
dst = OR32(dst, src);
STORE_REG32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
src = READ32(ea);
dst = LOAD_REG32(modrm);
dst = OR32(dst, src);
void I386_OPS_BASE::I386OP(pop_eax)() // Opcode 0x58
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+3) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
REG32(EAX) = POP32();
else
FAULT(FAULT_SS,0)
void I386_OPS_BASE::I386OP(pop_ecx)() // Opcode 0x59
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+3) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
REG32(ECX) = POP32();
else
FAULT(FAULT_SS,0)
void I386_OPS_BASE::I386OP(pop_edx)() // Opcode 0x5a
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+3) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
REG32(EDX) = POP32();
else
FAULT(FAULT_SS,0)
void I386_OPS_BASE::I386OP(pop_ebx)() // Opcode 0x5b
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+3) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
REG32(EBX) = POP32();
else
FAULT(FAULT_SS,0)
void I386_OPS_BASE::I386OP(pop_esp)() // Opcode 0x5c
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+3) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
REG32(ESP) = POP32();
else
FAULT(FAULT_SS,0)
void I386_OPS_BASE::I386OP(pop_ebp)() // Opcode 0x5d
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+3) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
REG32(EBP) = POP32();
else
FAULT(FAULT_SS,0)
void I386_OPS_BASE::I386OP(pop_esi)() // Opcode 0x5e
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+3) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
REG32(ESI) = POP32();
else
FAULT(FAULT_SS,0)
void I386_OPS_BASE::I386OP(pop_edi)() // Opcode 0x5f
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+3) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
REG32(EDI) = POP32();
else
FAULT(FAULT_SS,0)
UINT32 ea, offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
UINT32 value;
bool fault;
- if(i386_limit_check(SS,offset+3) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
{
- ea = i386_translate( SS, offset, 0);
+ ea = i386_translate( SS, offset, 0, 4);
value = READ32( ea);
i386_sreg_load(value, segment, &fault);
if(fault) return false;
UINT8 modrm = FETCH();
UINT32 value;
UINT32 ea, offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+3) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
{
// be careful here, if the write references the esp register
// it expects the post-pop value but esp must be wound back
if( modrm >= 0xc0 ) {
STORE_RM32(modrm, value);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1, 4);
try
{
WRITE32(ea, value);
void I386_OPS_BASE::I386OP(popad)() // Opcode 0x61
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(SS,offset+31) == 0)
+ if(i386_limit_check(SS,offset, 32) == 0)
{
REG32(EDI) = POP32();
REG32(ESI) = POP32();
mask &= ~0x00003000; // IOPL cannot be changed while in V8086 mode
}
- if(i386_limit_check(SS,offset+3) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
{
value = POP32();
value &= ~0x00010000; // RF will always return zero
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
PUSH32( REG32(EAX) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
PUSH32( REG32(ECX) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
PUSH32( REG32(EDX) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
PUSH32( REG32(EBX) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
PUSH32( REG32(ESP) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
PUSH32( REG32(EBP) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
PUSH32( REG32(ESI) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
PUSH32( REG32(EDI) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
PUSH32SEG( cpustate->sreg[CS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
PUSH32SEG( cpustate->sreg[DS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
PUSH32SEG( cpustate->sreg[ES].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
PUSH32SEG( cpustate->sreg[FS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
PUSH32SEG( cpustate->sreg[GS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
PUSH32( cpustate->sreg[SS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
PUSH32(value);
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 32;
else
offset = (REG16(SP) - 32) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 32) == 0)
{
PUSH32( REG32(EAX) );
PUSH32( REG32(ECX) );
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(SS,offset) == 0)
+ if(i386_limit_check(SS,offset, 4) == 0)
PUSH32( get_flags() & 0x00fcffff );
else
FAULT(FAULT_SS,0)
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 4);
src = LOAD_REG32(modrm);
dst = READ32(ea);
dst = SBB32( dst, src, cpustate->CF);
STORE_REG32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0, 4);
src = READ32(ea);
dst = LOAD_REG32(modrm);
dst = SBB32( dst, src, cpustate->CF);
void I386_OPS_BASE::I386OP(scasd)() // Opcode 0xaf
{
UINT32 eas, src, dst;
- eas = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0 );
+ eas = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0, 4 );
src = READ32(eas);
dst = REG32(EAX);
SUB32(dst, src);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_SHLD_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1, 4);
UINT32 dst = READ32(ea);
UINT32 upper = LOAD_REG32(modrm);
UINT8 shift = FETCH();
STORE_RM32(modrm, dst);
CYCLES(CYCLES_SHLD_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,4);
UINT32 dst = READ32(ea);
UINT32 upper = LOAD_REG32(modrm);
UINT8 shift = REG8(CL);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_SHRD_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,4);
UINT32 dst = READ32(ea);
UINT32 upper = LOAD_REG32(modrm);
UINT8 shift = FETCH();
STORE_RM32(modrm, dst);
CYCLES(CYCLES_SHRD_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,4);
UINT32 dst = READ32(ea);
UINT32 upper = LOAD_REG32(modrm);
UINT8 shift = REG8(CL);
void I386_OPS_BASE::I386OP(stosd)() // Opcode 0xab
{
- UINT32 eas = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1 );
+ UINT32 eas = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1, 4 );
WRITE32(eas, REG32(EAX));
BUMP_DI(4);
CYCLES(CYCLES_STOS);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,4);
src = LOAD_REG32(modrm);
dst = READ32(ea);
dst = SUB32(dst, src);
STORE_REG32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,4);
src = READ32(ea);
dst = LOAD_REG32(modrm);
dst = SUB32(dst, src);
cpustate->OF = 0;
CYCLES(CYCLES_TEST_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,4);
src = LOAD_REG32(modrm);
dst = READ32(ea);
dst = src & dst;
STORE_RM32(modrm, dst);
CYCLES(CYCLES_XCHG_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,4);
UINT32 src = READ32(ea);
UINT32 dst = LOAD_REG32(modrm);
WRITE32(ea, dst);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,4);
src = LOAD_REG32(modrm);
dst = READ32(ea);
dst = XOR32(dst, src);
STORE_REG32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,4);
src = READ32(ea);
dst = LOAD_REG32(modrm);
dst = XOR32(dst, src);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,4);
dst = READ32(ea);
src = FETCH32();
dst = ADD32(dst, src);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,4);
dst = READ32(ea);
src = FETCH32();
dst = OR32(dst, src);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,4);
dst = READ32(ea);
src = FETCH32();
dst = ADC32( dst, src, cpustate->CF);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,4);
dst = READ32(ea);
src = FETCH32();
dst = SBB32( dst, src, cpustate->CF);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,4);
dst = READ32(ea);
src = FETCH32();
dst = AND32(dst, src);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,4);
dst = READ32(ea);
src = FETCH32();
dst = SUB32(dst, src);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,4);
dst = READ32(ea);
src = FETCH32();
dst = XOR32(dst, src);
SUB32(dst, src);
CYCLES(CYCLES_CMP_REG_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0,4);
dst = READ32(ea);
src = FETCH32();
SUB32(dst, src);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,4);
dst = READ32(ea);
src = (UINT32)(INT32)(INT8)FETCH();
dst = ADD32(dst, src);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,4);
dst = READ32(ea);
src = (UINT32)(INT32)(INT8)FETCH();
dst = OR32(dst, src);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,4);
dst = READ32(ea);
src = (UINT32)(INT32)(INT8)FETCH();
dst = ADC32( dst, src, cpustate->CF);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,4);
dst = READ32(ea);
src = ((UINT32)(INT32)(INT8)FETCH());
dst = SBB32( dst, src, cpustate->CF);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,4);
dst = READ32(ea);
src = (UINT32)(INT32)(INT8)FETCH();
dst = AND32(dst, src);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,4);
dst = READ32(ea);
src = (UINT32)(INT32)(INT8)FETCH();
dst = SUB32(dst, src);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,4);
dst = READ32(ea);
src = (UINT32)(INT32)(INT8)FETCH();
dst = XOR32(dst, src);
SUB32(dst, src);
CYCLES(CYCLES_CMP_REG_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0,4);
dst = READ32(ea);
src = (UINT32)(INT32)(INT8)FETCH();
SUB32(dst, src);
dst = i386_shift_rotate32( modrm, dst, shift);
STORE_RM32(modrm, dst);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,4);
dst = READ32(ea);
shift = FETCH() & 0x1f;
dst = i386_shift_rotate32( modrm, dst, shift);
dst = i386_shift_rotate32( modrm, dst, 1);
STORE_RM32(modrm, dst);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,4);
dst = READ32(ea);
dst = i386_shift_rotate32( modrm, dst, 1);
WRITE32(ea, dst);
dst = i386_shift_rotate32( modrm, dst, REG8(CL));
STORE_RM32(modrm, dst);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,4);
dst = READ32(ea);
dst = i386_shift_rotate32( modrm, dst, REG8(CL));
WRITE32(ea, dst);
SetSZPF32(dst);
CYCLES(CYCLES_TEST_IMM_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,4);
UINT32 dst = READ32(ea);
UINT32 src = FETCH32();
dst &= src;
STORE_RM32(modrm, dst);
CYCLES(CYCLES_NOT_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,4);
UINT32 dst = READ32(ea);
dst = ~dst;
WRITE32(ea, dst);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_NEG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,4);
UINT32 dst = READ32(ea);
dst = SUB32( 0, dst );
WRITE32(ea, dst);
src = LOAD_RM32(modrm);
CYCLES(CYCLES_MUL32_ACC_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,4);
src = READ32(ea);
CYCLES(CYCLES_MUL32_ACC_MEM); /* TODO: Correct multiply timing */
}
src = (INT64)(INT32)LOAD_RM32(modrm);
CYCLES(CYCLES_IMUL32_ACC_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,4);
src = (INT64)(INT32)READ32(ea);
CYCLES(CYCLES_IMUL32_ACC_MEM); /* TODO: Correct multiply timing */
}
src = LOAD_RM32(modrm);
CYCLES(CYCLES_DIV32_ACC_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,4);
src = READ32(ea);
CYCLES(CYCLES_DIV32_ACC_MEM);
}
src = LOAD_RM32(modrm);
CYCLES(CYCLES_IDIV32_ACC_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,4);
src = READ32(ea);
CYCLES(CYCLES_IDIV32_ACC_MEM);
}
STORE_RM32(modrm, dst);
CYCLES(CYCLES_INC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,4);
UINT32 dst = READ32(ea);
dst = INC32(dst);
WRITE32(ea, dst);
STORE_RM32(modrm, dst);
CYCLES(CYCLES_DEC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,4);
UINT32 dst = READ32(ea);
dst = DEC32(dst);
WRITE32(ea, dst);
address = LOAD_RM32(modrm);
CYCLES(CYCLES_CALL_REG); /* TODO: Timing = 7 + m */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,4);
address = READ32(ea);
CYCLES(CYCLES_CALL_MEM); /* TODO: Timing = 10 + m */
}
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,6);
address = READ32(ea + 0);
selector = READ16(ea + 4);
CYCLES(CYCLES_CALL_MEM_INTERSEG); /* TODO: Timing = 10 + m */
address = LOAD_RM32(modrm);
CYCLES(CYCLES_JMP_REG); /* TODO: Timing = 7 + m */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,4);
address = READ32(ea);
CYCLES(CYCLES_JMP_MEM); /* TODO: Timing = 10 + m */
}
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,6);
address = READ32(ea + 0);
selector = READ16(ea + 4);
CYCLES(CYCLES_JMP_MEM_INTERSEG); /* TODO: Timing = 10 + m */
if( modrm >= 0xc0 ) {
value = LOAD_RM32(modrm);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,4);
value = READ32(ea);
}
PUSH32(value);
STORE_RM32(modrm, cpustate->ldtr.segment);
CYCLES(CYCLES_SLDT_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,2);
WRITE16( ea, cpustate->ldtr.segment);
CYCLES(CYCLES_SLDT_MEM);
}
STORE_RM32(modrm, cpustate->task.segment);
CYCLES(CYCLES_STR_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,2);
WRITE16( ea, cpustate->task.segment);
CYCLES(CYCLES_STR_MEM);
}
cpustate->ldtr.segment = address;
CYCLES(CYCLES_LLDT_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0,4);
cpustate->ldtr.segment = READ32(ea);
CYCLES(CYCLES_LLDT_MEM);
}
cpustate->task.segment = address;
CYCLES(CYCLES_LTR_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0,4);
cpustate->task.segment = READ32(ea);
CYCLES(CYCLES_LTR_MEM);
}
address = LOAD_RM32(modrm);
CYCLES(CYCLES_VERR_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0,4);
address = READ32(ea);
CYCLES(CYCLES_VERR_MEM);
}
address = LOAD_RM16(modrm);
CYCLES(CYCLES_VERW_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0,2);
address = READ16(ea);
CYCLES(CYCLES_VERW_MEM);
}
{
if( modrm >= 0xc0 ) {
address = LOAD_RM32(modrm);
- ea = i386_translate( CS, address, 1 );
+ ea = i386_translate( CS, address, 1, 6 );
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,6);
}
WRITE16(ea, cpustate->gdtr.limit);
WRITE32(ea + 2, cpustate->gdtr.base);
if (modrm >= 0xc0)
{
address = LOAD_RM32(modrm);
- ea = i386_translate( CS, address, 1 );
+ ea = i386_translate( CS, address, 1, 6 );
}
else
{
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,6);
}
WRITE16(ea, cpustate->idtr.limit);
WRITE32(ea + 2, cpustate->idtr.base);
FAULT(FAULT_GP,0)
if( modrm >= 0xc0 ) {
address = LOAD_RM32(modrm);
- ea = i386_translate( CS, address, 0 );
+ ea = i386_translate( CS, address, 0, 6 );
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0,6);
}
cpustate->gdtr.limit = READ16(ea);
cpustate->gdtr.base = READ32(ea + 2);
FAULT(FAULT_GP,0)
if( modrm >= 0xc0 ) {
address = LOAD_RM32(modrm);
- ea = i386_translate( CS, address, 0 );
+ ea = i386_translate( CS, address, 0, 6 );
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0,6);
}
cpustate->idtr.limit = READ16(ea);
cpustate->idtr.base = READ32(ea + 2);
CYCLES(CYCLES_SMSW_REG);
} else {
/* always 16-bit memory operand */
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,2);
WRITE16(ea, cpustate->cr[0]);
CYCLES(CYCLES_SMSW_MEM);
}
b = LOAD_RM16(modrm);
CYCLES(CYCLES_LMSW_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0,2);
CYCLES(CYCLES_LMSW_MEM);
b = READ16(ea);
}
CYCLES(CYCLES_BT_IMM_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,4);
UINT32 dst = READ32(ea);
UINT8 bit = FETCH();
STORE_RM32(modrm, dst);
CYCLES(CYCLES_BTS_IMM_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,4);
UINT32 dst = READ32(ea);
UINT8 bit = FETCH();
STORE_RM32(modrm, dst);
CYCLES(CYCLES_BTR_IMM_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,4);
UINT32 dst = READ32(ea);
UINT8 bit = FETCH();
STORE_RM32(modrm, dst);
CYCLES(CYCLES_BTC_IMM_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,4);
UINT32 dst = READ32(ea);
UINT8 bit = FETCH();
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,4);
seg.selector = READ32(ea);
CYCLES(CYCLES_LAR_MEM);
}
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,4);
seg.selector = READ32(ea);
}
if(seg.selector == 0)
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,8);
low = READ32(ea + 0);
high = READ32(ea + 4);
}
if( modrm >= 0xc0 ) {
report_invalid_modrm( "load_far_pointer32", modrm);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,6);
STORE_REG32(modrm, READ32(ea + 0));
selector = READ16(ea + 4);
i386_sreg_load(selector,s,NULL);
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
#include "./i386_opdef.h"
#define FAULT(fault,error) {cpustate->ext = 1; i386_trap_with_error(fault,0,0,error); return;}
#define FAULT_EXP(fault,error) {cpustate->ext = 1; i386_trap_with_error(fault,0,trap_level+1,error); return;}
+
+#if 1
+UINT8 I386_OPS_BASE::I386OP(shift_rotate8)( UINT8 modrm, UINT32 value, UINT8 shift)
+{
+ UINT32 src = value & 0xff;
+ UINT8 dst = value;
+
+ if( shift == 0 ) {
+ CYCLES_RM(modrm, 3, 7);
+ } else if( shift == 1 ) {
+ switch( (modrm >> 3) & 0x7 )
+ {
+ case 0: /* ROL rm8, 1 */
+ cpustate->CF = (src & 0x80) ? 1 : 0;
+ dst = (src << 1) + cpustate->CF;
+ cpustate->OF = ((src ^ dst) & 0x80) ? 1 : 0;
+ CYCLES_RM(modrm, CYCLES_ROTATE_REG, CYCLES_ROTATE_MEM);
+ break;
+ case 1: /* ROR rm8, 1 */
+ cpustate->CF = (src & 0x1) ? 1 : 0;
+ dst = (cpustate->CF << 7) | (src >> 1);
+ cpustate->OF = ((src ^ dst) & 0x80) ? 1 : 0;
+ CYCLES_RM(modrm, CYCLES_ROTATE_REG, CYCLES_ROTATE_MEM);
+ break;
+ case 2: /* RCL rm8, 1 */
+ dst = (src << 1) + cpustate->CF;
+ cpustate->CF = (src & 0x80) ? 1 : 0;
+ cpustate->OF = ((src ^ dst) & 0x80) ? 1 : 0;
+ CYCLES_RM(modrm, CYCLES_ROTATE_CARRY_REG, CYCLES_ROTATE_CARRY_MEM);
+ break;
+ case 3: /* RCR rm8, 1 */
+ dst = (cpustate->CF << 7) | (src >> 1);
+ cpustate->CF = src & 0x1;
+ cpustate->OF = ((src ^ dst) & 0x80) ? 1 : 0;
+ CYCLES_RM(modrm, CYCLES_ROTATE_CARRY_REG, CYCLES_ROTATE_CARRY_MEM);
+ break;
+ case 4: /* SHL/SAL rm8, 1 */
+ case 6:
+ dst = src << 1;
+ cpustate->CF = (src & 0x80) ? 1 : 0;
+ cpustate->OF = (((cpustate->CF << 7) ^ dst) & 0x80) ? 1 : 0;
+ SetSZPF8(dst);
+ CYCLES_RM(modrm, CYCLES_ROTATE_REG, CYCLES_ROTATE_MEM);
+ break;
+ case 5: /* SHR rm8, 1 */
+ dst = src >> 1;
+ cpustate->CF = src & 0x1;
+ cpustate->OF = (dst & 0x80) ? 1 : 0;
+ SetSZPF8(dst);
+ CYCLES_RM(modrm, CYCLES_ROTATE_REG, CYCLES_ROTATE_MEM);
+ break;
+ case 7: /* SAR rm8, 1 */
+ dst = (INT8)(src) >> 1;
+ cpustate->CF = src & 0x1;
+ cpustate->OF = 0;
+ SetSZPF8(dst);
+ CYCLES_RM(modrm, CYCLES_ROTATE_REG, CYCLES_ROTATE_MEM);
+ break;
+ }
+
+ } else {
+ switch( (modrm >> 3) & 0x7 )
+ {
+ case 0: /* ROL rm8, i8 */
+ if(!(shift & 7))
+ {
+ if(shift & 0x18)
+ {
+ cpustate->CF = src & 1;
+ cpustate->OF = (src & 1) ^ ((src >> 7) & 1);
+ }
+ break;
+ }
+ shift &= 7;
+ dst = ((src & ((UINT8)0xff >> shift)) << shift) |
+ ((src & ((UINT8)0xff << (8-shift))) >> (8-shift));
+ cpustate->CF = dst & 0x1;
+ cpustate->OF = (dst & 1) ^ (dst >> 7);
+ CYCLES_RM(modrm, CYCLES_ROTATE_REG, CYCLES_ROTATE_MEM);
+ break;
+ case 1: /* ROR rm8, i8 */
+ if(!(shift & 7))
+ {
+ if(shift & 0x18)
+ {
+ cpustate->CF = (src >> 7) & 1;
+ cpustate->OF = ((src >> 7) & 1) ^ ((src >> 6) & 1);
+ }
+ break;
+ }
+ shift &= 7;
+ dst = ((src & ((UINT8)0xff << shift)) >> shift) |
+ ((src & ((UINT8)0xff >> (8-shift))) << (8-shift));
+ cpustate->CF = (dst >> 7) & 1;
+ cpustate->OF = ((dst >> 7) ^ (dst >> 6)) & 1;
+ CYCLES_RM(modrm, CYCLES_ROTATE_REG, CYCLES_ROTATE_MEM);
+ break;
+ case 2: /* RCL rm8, i8 */
+ shift %= 9;
+ dst = ((src & ((UINT8)0xff >> shift)) << shift) |
+ ((src & ((UINT8)0xff << (9-shift))) >> (9-shift)) |
+ (cpustate->CF << (shift-1));
+ if(shift) cpustate->CF = (src >> (8-shift)) & 0x1;
+ cpustate->OF = cpustate->CF ^ ((dst >> 7) & 1);
+ CYCLES_RM(modrm, CYCLES_ROTATE_CARRY_REG, CYCLES_ROTATE_CARRY_MEM);
+ break;
+ case 3: /* RCR rm8, i8 */
+ shift %= 9;
+ dst = ((src & ((UINT8)0xff << shift)) >> shift) |
+ ((src & ((UINT8)0xff >> (8-shift))) << (9-shift)) |
+ (cpustate->CF << (8-shift));
+ if(shift) cpustate->CF = (src >> (shift-1)) & 0x1;
+ cpustate->OF = ((dst >> 7) ^ (dst >> 6)) & 1;
+ CYCLES_RM(modrm, CYCLES_ROTATE_CARRY_REG, CYCLES_ROTATE_CARRY_MEM);
+ break;
+ case 4: /* SHL/SAL rm8, i8 */
+ case 6:
+ shift &= 31;
+ dst = src << shift;
+ cpustate->CF = (shift <= 8) && ((src >> (8 - shift)) & 1);
+ SetSZPF8(dst);
+ CYCLES_RM(modrm, CYCLES_ROTATE_REG, CYCLES_ROTATE_MEM);
+ break;
+ case 5: /* SHR rm8, i8 */
+ shift &= 31;
+ dst = src >> shift;
+ cpustate->CF = (src & (1 << (shift-1))) ? 1 : 0;
+ SetSZPF8(dst);
+ CYCLES_RM(modrm, CYCLES_ROTATE_REG, CYCLES_ROTATE_MEM);
+ break;
+ case 7: /* SAR rm8, i8 */
+ shift &= 31;
+ dst = (INT8)src >> shift;
+ cpustate->CF = (src & (1 << (shift-1))) ? 1 : 0;
+ SetSZPF8(dst);
+ CYCLES_RM(modrm, CYCLES_ROTATE_REG, CYCLES_ROTATE_MEM);
+ break;
+ }
+ }
+
+ return dst;
+}
+
+
+
+void I386_OPS_BASE::I386OP(adc_rm8_r8)() // Opcode 0x10
+{
+ UINT8 src, dst;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_REG8(modrm);
+ dst = LOAD_RM8(modrm);
+ dst = ADC8( dst, src, cpustate->CF);
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ src = LOAD_REG8(modrm);
+ dst = READ8(ea);
+ dst = ADC8( dst, src, cpustate->CF);
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_ALU_REG_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(adc_r8_rm8)() // Opcode 0x12
+{
+ UINT8 src, dst;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_RM8(modrm);
+ dst = LOAD_REG8(modrm);
+ dst = ADC8( dst, src, cpustate->CF);
+ STORE_REG8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,0,1);
+ src = READ8(ea);
+ dst = LOAD_REG8(modrm);
+ dst = ADC8( dst, src, cpustate->CF);
+ STORE_REG8(modrm, dst);
+ CYCLES(CYCLES_ALU_MEM_REG);
+ }
+}
+
+void I386_OPS_BASE::I386OP(adc_al_i8)() // Opcode 0x14
+{
+ UINT8 src, dst;
+ src = FETCH();
+ dst = REG8(AL);
+ dst = ADC8( dst, src, cpustate->CF);
+ REG8(AL) = dst;
+ CYCLES(CYCLES_ALU_IMM_ACC);
+}
+
+void I386_OPS_BASE::I386OP(add_rm8_r8)() // Opcode 0x00
+{
+ UINT8 src, dst;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_REG8(modrm);
+ dst = LOAD_RM8(modrm);
+ dst = ADD8(dst, src);
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ src = LOAD_REG8(modrm);
+ dst = READ8(ea);
+ dst = ADD8(dst, src);
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_ALU_REG_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(add_r8_rm8)() // Opcode 0x02
+{
+ UINT8 src, dst;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_RM8(modrm);
+ dst = LOAD_REG8(modrm);
+ dst = ADD8(dst, src);
+ STORE_REG8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,0,1);
+ src = READ8(ea);
+ dst = LOAD_REG8(modrm);
+ dst = ADD8(dst, src);
+ STORE_REG8(modrm, dst);
+ CYCLES(CYCLES_ALU_MEM_REG);
+ }
+}
+
+void I386_OPS_BASE::I386OP(add_al_i8)() // Opcode 0x04
+{
+ UINT8 src, dst;
+ src = FETCH();
+ dst = REG8(AL);
+ dst = ADD8(dst, src);
+ REG8(AL) = dst;
+ CYCLES(CYCLES_ALU_IMM_ACC);
+}
+
+void I386_OPS_BASE::I386OP(and_rm8_r8)() // Opcode 0x20
+{
+ UINT8 src, dst;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_REG8(modrm);
+ dst = LOAD_RM8(modrm);
+ dst = AND8(dst, src);
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ src = LOAD_REG8(modrm);
+ dst = READ8(ea);
+ dst = AND8(dst, src);
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_ALU_REG_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(and_r8_rm8)() // Opcode 0x22
+{
+ UINT8 src, dst;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_RM8(modrm);
+ dst = LOAD_REG8(modrm);
+ dst = AND8(dst, src);
+ STORE_REG8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,0,1);
+ src = READ8(ea);
+ dst = LOAD_REG8(modrm);
+ dst = AND8(dst, src);
+ STORE_REG8(modrm, dst);
+ CYCLES(CYCLES_ALU_MEM_REG);
+ }
+}
+
+void I386_OPS_BASE::I386OP(and_al_i8)() // Opcode 0x24
+{
+ UINT8 src, dst;
+ src = FETCH();
+ dst = REG8(AL);
+ dst = AND8(dst, src);
+ REG8(AL) = dst;
+ CYCLES(CYCLES_ALU_IMM_ACC);
+}
+
+void I386_OPS_BASE::I386OP(clc)() // Opcode 0xf8
+{
+ cpustate->CF = 0;
+ CYCLES(CYCLES_CLC);
+}
+
+void I386_OPS_BASE::I386OP(cld)() // Opcode 0xfc
+{
+ cpustate->DF = 0;
+ CYCLES(CYCLES_CLD);
+}
+
+void I386_OPS_BASE::I386OP(cli)() // Opcode 0xfa
+{
+ if(PROTECTED_MODE)
+ {
+ UINT8 IOPL = cpustate->IOP1 | (cpustate->IOP2 << 1);
+ if(cpustate->CPL > IOPL)
+ FAULT(FAULT_GP,0);
+ }
+ cpustate->IF = 0;
+ CYCLES(CYCLES_CLI);
+}
+
+void I386_OPS_BASE::I386OP(cmc)() // Opcode 0xf5
+{
+ cpustate->CF ^= 1;
+ CYCLES(CYCLES_CMC);
+}
+
+void I386_OPS_BASE::I386OP(cmp_rm8_r8)() // Opcode 0x38
+{
+ UINT8 src, dst;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_REG8(modrm);
+ dst = LOAD_RM8(modrm);
+ SUB8(dst, src);
+ CYCLES(CYCLES_CMP_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,0,1);
+ src = LOAD_REG8(modrm);
+ dst = READ8(ea);
+ SUB8(dst, src);
+ CYCLES(CYCLES_CMP_REG_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(cmp_r8_rm8)() // Opcode 0x3a
+{
+ UINT8 src, dst;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_RM8(modrm);
+ dst = LOAD_REG8(modrm);
+ SUB8(dst, src);
+ CYCLES(CYCLES_CMP_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,0,1);
+ src = READ8(ea);
+ dst = LOAD_REG8(modrm);
+ SUB8(dst, src);
+ CYCLES(CYCLES_CMP_MEM_REG);
+ }
+}
+
+void I386_OPS_BASE::I386OP(cmp_al_i8)() // Opcode 0x3c
+{
+ UINT8 src, dst;
+ src = FETCH();
+ dst = REG8(AL);
+ SUB8(dst, src);
+ CYCLES(CYCLES_CMP_IMM_ACC);
+}
+
+void I386_OPS_BASE::I386OP(cmpsb)() // Opcode 0xa6
+{
+ UINT32 eas, ead;
+ UINT8 src, dst;
+ if( cpustate->segment_prefix ) {
+ eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
+ } else {
+ eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
+ }
+ ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0, 1 );
+ src = READ8(eas);
+ dst = READ8(ead);
+ SUB8(src, dst);
+ BUMP_SI(1);
+ BUMP_DI(1);
+ CYCLES(CYCLES_CMPS);
+}
+
+void I386_OPS_BASE::I386OP(in_al_i8)() // Opcode 0xe4
+{
+ UINT16 port = FETCH();
+ UINT8 data = READPORT8( port);
+ REG8(AL) = data;
+ CYCLES(CYCLES_IN_VAR);
+}
+
+void I386_OPS_BASE::I386OP(in_al_dx)() // Opcode 0xec
+{
+ UINT16 port = REG16(DX);
+ UINT8 data = READPORT8( port);
+ REG8(AL) = data;
+ CYCLES(CYCLES_IN);
+}
+
+void I386_OPS_BASE::I386OP(ja_rel8)() // Opcode 0x77
+{
+ INT8 disp = FETCH();
+ if( cpustate->CF == 0 && cpustate->ZF == 0 ) {
+ NEAR_BRANCH(disp);
+ CYCLES(CYCLES_JCC_DISP8); /* TODO: Timing = 7 + m */
+ } else {
+ CYCLES(CYCLES_JCC_DISP8_NOBRANCH);
+ }
+}
+
+void I386_OPS_BASE::I386OP(jbe_rel8)() // Opcode 0x76
+{
+ INT8 disp = FETCH();
+ if( cpustate->CF != 0 || cpustate->ZF != 0 ) {
+ NEAR_BRANCH(disp);
+ CYCLES(CYCLES_JCC_DISP8); /* TODO: Timing = 7 + m */
+ } else {
+ CYCLES(CYCLES_JCC_DISP8_NOBRANCH);
+ }
+}
+
+void I386_OPS_BASE::I386OP(jc_rel8)() // Opcode 0x72
+{
+ INT8 disp = FETCH();
+ if( cpustate->CF != 0 ) {
+ NEAR_BRANCH(disp);
+ CYCLES(CYCLES_JCC_DISP8); /* TODO: Timing = 7 + m */
+ } else {
+ CYCLES(CYCLES_JCC_DISP8_NOBRANCH);
+ }
+}
+
+void I386_OPS_BASE::I386OP(jg_rel8)() // Opcode 0x7f
+{
+ INT8 disp = FETCH();
+ if( cpustate->ZF == 0 && (cpustate->SF == cpustate->OF) ) {
+ NEAR_BRANCH(disp);
+ CYCLES(CYCLES_JCC_DISP8); /* TODO: Timing = 7 + m */
+ } else {
+ CYCLES(CYCLES_JCC_DISP8_NOBRANCH);
+ }
+}
+
+void I386_OPS_BASE::I386OP(jge_rel8)() // Opcode 0x7d
+{
+ INT8 disp = FETCH();
+ if(cpustate->SF == cpustate->OF) {
+ NEAR_BRANCH(disp);
+ CYCLES(CYCLES_JCC_DISP8); /* TODO: Timing = 7 + m */
+ } else {
+ CYCLES(CYCLES_JCC_DISP8_NOBRANCH);
+ }
+}
+
+void I386_OPS_BASE::I386OP(jl_rel8)() // Opcode 0x7c
+{
+ INT8 disp = FETCH();
+ if( (cpustate->SF != cpustate->OF) ) {
+ NEAR_BRANCH(disp);
+ CYCLES(CYCLES_JCC_DISP8); /* TODO: Timing = 7 + m */
+ } else {
+ CYCLES(CYCLES_JCC_DISP8_NOBRANCH);
+ }
+}
+
+void I386_OPS_BASE::I386OP(jle_rel8)() // Opcode 0x7e
+{
+ INT8 disp = FETCH();
+ if( cpustate->ZF != 0 || (cpustate->SF != cpustate->OF) ) {
+ NEAR_BRANCH(disp);
+ CYCLES(CYCLES_JCC_DISP8); /* TODO: Timing = 7 + m */
+ } else {
+ CYCLES(CYCLES_JCC_DISP8_NOBRANCH);
+ }
+}
+
+void I386_OPS_BASE::I386OP(jnc_rel8)() // Opcode 0x73
+{
+ INT8 disp = FETCH();
+ if( cpustate->CF == 0 ) {
+ NEAR_BRANCH(disp);
+ CYCLES(CYCLES_JCC_DISP8); /* TODO: Timing = 7 + m */
+ } else {
+ CYCLES(CYCLES_JCC_DISP8_NOBRANCH);
+ }
+}
+
+void I386_OPS_BASE::I386OP(jno_rel8)() // Opcode 0x71
+{
+ INT8 disp = FETCH();
+ if( cpustate->OF == 0 ) {
+ NEAR_BRANCH(disp);
+ CYCLES(CYCLES_JCC_DISP8); /* TODO: Timing = 7 + m */
+ } else {
+ CYCLES(CYCLES_JCC_DISP8_NOBRANCH);
+ }
+}
+
+void I386_OPS_BASE::I386OP(jnp_rel8)() // Opcode 0x7b
+{
+ INT8 disp = FETCH();
+ if( cpustate->PF == 0 ) {
+ NEAR_BRANCH(disp);
+ CYCLES(CYCLES_JCC_DISP8); /* TODO: Timing = 7 + m */
+ } else {
+ CYCLES(CYCLES_JCC_DISP8_NOBRANCH);
+ }
+}
+
+void I386_OPS_BASE::I386OP(jns_rel8)() // Opcode 0x79
+{
+ INT8 disp = FETCH();
+ if( cpustate->SF == 0 ) {
+ NEAR_BRANCH(disp);
+ CYCLES(CYCLES_JCC_DISP8); /* TODO: Timing = 7 + m */
+ } else {
+ CYCLES(CYCLES_JCC_DISP8_NOBRANCH);
+ }
+}
+
+void I386_OPS_BASE::I386OP(jnz_rel8)() // Opcode 0x75
+{
+ INT8 disp = FETCH();
+ if( cpustate->ZF == 0 ) {
+ NEAR_BRANCH(disp);
+ CYCLES(CYCLES_JCC_DISP8); /* TODO: Timing = 7 + m */
+ } else {
+ CYCLES(CYCLES_JCC_DISP8_NOBRANCH);
+ }
+}
+
+void I386_OPS_BASE::I386OP(jo_rel8)() // Opcode 0x70
+{
+ INT8 disp = FETCH();
+ if( cpustate->OF != 0 ) {
+ NEAR_BRANCH(disp);
+ CYCLES(CYCLES_JCC_DISP8); /* TODO: Timing = 7 + m */
+ } else {
+ CYCLES(CYCLES_JCC_DISP8_NOBRANCH);
+ }
+}
+
+void I386_OPS_BASE::I386OP(jp_rel8)() // Opcode 0x7a
+{
+ INT8 disp = FETCH();
+ if( cpustate->PF != 0 ) {
+ NEAR_BRANCH(disp);
+ CYCLES(CYCLES_JCC_DISP8); /* TODO: Timing = 7 + m */
+ } else {
+ CYCLES(CYCLES_JCC_DISP8_NOBRANCH);
+ }
+}
+
+void I386_OPS_BASE::I386OP(js_rel8)() // Opcode 0x78
+{
+ INT8 disp = FETCH();
+ if( cpustate->SF != 0 ) {
+ NEAR_BRANCH(disp);
+ CYCLES(CYCLES_JCC_DISP8); /* TODO: Timing = 7 + m */
+ } else {
+ CYCLES(CYCLES_JCC_DISP8_NOBRANCH);
+ }
+}
+
+void I386_OPS_BASE::I386OP(jz_rel8)() // Opcode 0x74
+{
+ INT8 disp = FETCH();
+ if( cpustate->ZF != 0 ) {
+ NEAR_BRANCH(disp);
+ CYCLES(CYCLES_JCC_DISP8); /* TODO: Timing = 7 + m */
+ } else {
+ CYCLES(CYCLES_JCC_DISP8_NOBRANCH);
+ }
+}
+
+void I386_OPS_BASE::I386OP(jmp_rel8)() // Opcode 0xeb
+{
+ INT8 disp = FETCH();
+ NEAR_BRANCH(disp);
+ CYCLES(CYCLES_JMP_SHORT); /* TODO: Timing = 7 + m */
+}
+
+void I386_OPS_BASE::I386OP(lahf)() // Opcode 0x9f
+{
+ REG8(AH) = get_flags() & 0xd7;
+ CYCLES(CYCLES_LAHF);
+}
+
+void I386_OPS_BASE::I386OP(lodsb)() // Opcode 0xac
+{
+ UINT32 eas;
+ if( cpustate->segment_prefix ) {
+ eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
+ } else {
+ eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
+ }
+ REG8(AL) = READ8(eas);
+ BUMP_SI(1);
+ CYCLES(CYCLES_LODS);
+}
+
+void I386_OPS_BASE::I386OP(mov_rm8_r8)() // Opcode 0x88
+{
+ UINT8 src;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_REG8(modrm);
+ STORE_RM8(modrm, src);
+ CYCLES(CYCLES_MOV_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ src = LOAD_REG8(modrm);
+ WRITE8(ea, src);
+ CYCLES(CYCLES_MOV_REG_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(mov_r8_rm8)() // Opcode 0x8a
+{
+ UINT8 src;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_RM8(modrm);
+ STORE_REG8(modrm, src);
+ CYCLES(CYCLES_MOV_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,0,1);
+ src = READ8(ea);
+ STORE_REG8(modrm, src);
+ CYCLES(CYCLES_MOV_MEM_REG);
+ }
+}
+
+void I386_OPS_BASE::I386OP(mov_rm8_i8)() // Opcode 0xc6
+{
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ UINT8 value = FETCH();
+ STORE_RM8(modrm, value);
+ CYCLES(CYCLES_MOV_IMM_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ UINT8 value = FETCH();
+ WRITE8(ea, value);
+ CYCLES(CYCLES_MOV_IMM_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(mov_r32_cr)() // Opcode 0x0f 20
+{
+ if(PROTECTED_MODE && cpustate->CPL)
+ FAULT(FAULT_GP, 0);
+ UINT8 modrm = FETCH();
+ UINT8 cr = (modrm >> 3) & 0x7;
+
+ STORE_RM32(modrm, cpustate->cr[cr]);
+ CYCLES(CYCLES_MOV_CR_REG);
+}
+
+void I386_OPS_BASE::I386OP(mov_r32_dr)() // Opcode 0x0f 21
+{
+ if(PROTECTED_MODE && cpustate->CPL)
+ FAULT(FAULT_GP, 0);
+ UINT8 modrm = FETCH();
+ UINT8 dr = (modrm >> 3) & 0x7;
+
+ STORE_RM32(modrm, cpustate->dr[dr]);
+ switch(dr)
+ {
+ case 0:
+ case 1:
+ case 2:
+ case 3:
+ CYCLES(CYCLES_MOV_REG_DR0_3);
+ break;
+ case 6:
+ case 7:
+ CYCLES(CYCLES_MOV_REG_DR6_7);
+ break;
+ }
+}
+
+void I386_OPS_BASE::I386OP(mov_cr_r32)() // Opcode 0x0f 22
+{
+ if(PROTECTED_MODE && cpustate->CPL)
+ FAULT(FAULT_GP, 0);
+ UINT8 modrm = FETCH();
+ UINT8 cr = (modrm >> 3) & 0x7;
+ UINT32 data = LOAD_RM32(modrm);
+ switch(cr)
+ {
+ case 0:
+ data &= 0xfffeffff; // wp not supported on 386
+ CYCLES(CYCLES_MOV_REG_CR0);
+ break;
+ case 2: CYCLES(CYCLES_MOV_REG_CR2); break;
+ case 3:
+ CYCLES(CYCLES_MOV_REG_CR3);
+ vtlb_flush_dynamic(cpustate->vtlb);
+ break;
+ case 4: CYCLES(1); break; // TODO
+ default:
+ logerror("i386: mov_cr_r32 CR%d!\n", cr);
+ return;
+ }
+ cpustate->cr[cr] = data;
+}
+
+void I386_OPS_BASE::I386OP(mov_dr_r32)() // Opcode 0x0f 23
+{
+ if(PROTECTED_MODE && cpustate->CPL)
+ FAULT(FAULT_GP, 0);
+ UINT8 modrm = FETCH();
+ UINT8 dr = (modrm >> 3) & 0x7;
+
+ cpustate->dr[dr] = LOAD_RM32(modrm);
+ switch(dr)
+ {
+ case 0:
+ case 1:
+ case 2:
+ case 3:
+ CYCLES(CYCLES_MOV_DR0_3_REG);
+ break;
+ case 6:
+ case 7:
+ CYCLES(CYCLES_MOV_DR6_7_REG);
+ break;
+ default:
+ logerror("i386: mov_dr_r32 DR%d!\n", dr);
+ return;
+ }
+}
+
+void I386_OPS_BASE::I386OP(mov_al_m8)() // Opcode 0xa0
+{
+ UINT32 offset, ea;
+ if( cpustate->address_size ) {
+ offset = FETCH32();
+ } else {
+ offset = FETCH16();
+ }
+ /* TODO: Not sure if this is correct... */
+ if( cpustate->segment_prefix ) {
+ ea = i386_translate( cpustate->segment_override, offset, 0, 1 );
+ } else {
+ ea = i386_translate( DS, offset, 0, 1 );
+ }
+ REG8(AL) = READ8(ea);
+ CYCLES(CYCLES_MOV_IMM_MEM);
+}
+
+void I386_OPS_BASE::I386OP(mov_m8_al)() // Opcode 0xa2
+{
+ UINT32 offset, ea;
+ if( cpustate->address_size ) {
+ offset = FETCH32();
+ } else {
+ offset = FETCH16();
+ }
+ /* TODO: Not sure if this is correct... */
+ if( cpustate->segment_prefix ) {
+ ea = i386_translate( cpustate->segment_override, offset, 1, 1 );
+ } else {
+ ea = i386_translate( DS, offset, 1, 1 );
+ }
+ WRITE8( ea, REG8(AL) );
+ CYCLES(CYCLES_MOV_MEM_ACC);
+}
+
+void I386_OPS_BASE::I386OP(mov_rm16_sreg)() // Opcode 0x8c
+{
+ UINT8 modrm = FETCH();
+ int s = (modrm >> 3) & 0x7;
+
+ if( modrm >= 0xc0 ) {
+ if(cpustate->operand_size)
+ STORE_RM32(modrm, cpustate->sreg[s].selector);
+ else
+ STORE_RM16(modrm, cpustate->sreg[s].selector);
+ CYCLES(CYCLES_MOV_SREG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,2);
+ WRITE16(ea, cpustate->sreg[s].selector);
+ CYCLES(CYCLES_MOV_SREG_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(mov_sreg_rm16)() // Opcode 0x8e
+{
+ UINT16 selector;
+ UINT8 modrm = FETCH();
+ bool fault;
+ int s = (modrm >> 3) & 0x7;
+
+ if( modrm >= 0xc0 ) {
+ selector = LOAD_RM16(modrm);
+ CYCLES(CYCLES_MOV_REG_SREG);
+ } else {
+ UINT32 ea = GetEA(modrm,0,2);
+ selector = READ16(ea);
+ CYCLES(CYCLES_MOV_MEM_SREG);
+ }
+
+ i386_sreg_load(selector,s,&fault);
+ if((s == SS) && !fault)
+ {
+ if(cpustate->IF != 0) // if external interrupts are enabled
+ {
+ cpustate->IF = 0; // reset IF for the next instruction
+ cpustate->delayed_interrupt_enable = 1;
+ }
+ }
+}
+
+void I386_OPS_BASE::I386OP(mov_al_i8)() // Opcode 0xb0
+{
+ REG8(AL) = FETCH();
+ CYCLES(CYCLES_MOV_IMM_REG);
+}
+
+void I386_OPS_BASE::I386OP(mov_cl_i8)() // Opcode 0xb1
+{
+ REG8(CL) = FETCH();
+ CYCLES(CYCLES_MOV_IMM_REG);
+}
+
+void I386_OPS_BASE::I386OP(mov_dl_i8)() // Opcode 0xb2
+{
+ REG8(DL) = FETCH();
+ CYCLES(CYCLES_MOV_IMM_REG);
+}
+
+void I386_OPS_BASE::I386OP(mov_bl_i8)() // Opcode 0xb3
+{
+ REG8(BL) = FETCH();
+ CYCLES(CYCLES_MOV_IMM_REG);
+}
+
+void I386_OPS_BASE::I386OP(mov_ah_i8)() // Opcode 0xb4
+{
+ REG8(AH) = FETCH();
+ CYCLES(CYCLES_MOV_IMM_REG);
+}
+
+void I386_OPS_BASE::I386OP(mov_ch_i8)() // Opcode 0xb5
+{
+ REG8(CH) = FETCH();
+ CYCLES(CYCLES_MOV_IMM_REG);
+}
+
+void I386_OPS_BASE::I386OP(mov_dh_i8)() // Opcode 0xb6
+{
+ REG8(DH) = FETCH();
+ CYCLES(CYCLES_MOV_IMM_REG);
+}
+
+void I386_OPS_BASE::I386OP(mov_bh_i8)() // Opcode 0xb7
+{
+ REG8(BH) = FETCH();
+ CYCLES(CYCLES_MOV_IMM_REG);
+}
+
+void I386_OPS_BASE::I386OP(movsb)() // Opcode 0xa4
+{
+ UINT32 eas, ead;
+ UINT8 v;
+ if( cpustate->segment_prefix ) {
+ eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
+ } else {
+ eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
+ }
+ ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1, 1 );
+ v = READ8(eas);
+ WRITE8(ead, v);
+ BUMP_SI(1);
+ BUMP_DI(1);
+ CYCLES(CYCLES_MOVS);
+}
+
+void I386_OPS_BASE::I386OP(or_rm8_r8)() // Opcode 0x08
+{
+ UINT8 src, dst;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_REG8(modrm);
+ dst = LOAD_RM8(modrm);
+ dst = OR8(dst, src);
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ src = LOAD_REG8(modrm);
+ dst = READ8(ea);
+ dst = OR8(dst, src);
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_ALU_REG_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(or_r8_rm8)() // Opcode 0x0a
+{
+ UINT8 src, dst;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_RM8(modrm);
+ dst = LOAD_REG8(modrm);
+ dst = OR8(dst, src);
+ STORE_REG8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,0,1);
+ src = READ8(ea);
+ dst = LOAD_REG8(modrm);
+ dst = OR8(dst, src);
+ STORE_REG8(modrm, dst);
+ CYCLES(CYCLES_ALU_MEM_REG);
+ }
+}
+
+void I386_OPS_BASE::I386OP(or_al_i8)() // Opcode 0x0c
+{
+ UINT8 src, dst;
+ src = FETCH();
+ dst = REG8(AL);
+ dst = OR8(dst, src);
+ REG8(EAX) = dst;
+ CYCLES(CYCLES_ALU_IMM_ACC);
+}
+
+void I386_OPS_BASE::I386OP(out_al_i8)() // Opcode 0xe6
+{
+ UINT16 port = FETCH();
+ UINT8 data = REG8(AL);
+ WRITEPORT8( port, data);
+ CYCLES(CYCLES_OUT_VAR);
+}
+
+void I386_OPS_BASE::I386OP(out_al_dx)() // Opcode 0xee
+{
+ UINT16 port = REG16(DX);
+ UINT8 data = REG8(AL);
+ WRITEPORT8( port, data);
+ CYCLES(CYCLES_OUT);
+}
+
+
+void I386_OPS_BASE::I386OP(arpl)() // Opcode 0x63
+{
+ UINT16 src, dst;
+ UINT8 modrm = FETCH();
+ UINT8 flag = 0;
+
+ if(PROTECTED_MODE && !V8086_MODE)
+ {
+ if( modrm >= 0xc0 ) {
+ src = LOAD_REG16(modrm);
+ dst = LOAD_RM16(modrm);
+ if( (dst&0x3) < (src&0x3) ) {
+ dst = (dst&0xfffc) | (src&0x3);
+ flag = 1;
+ STORE_RM16(modrm, dst);
+ }
+ } else {
+ UINT32 ea = GetEA( modrm,1,2);
+ src = LOAD_REG16(modrm);
+ dst = READ16( ea);
+ if( (dst&0x3) < (src&0x3) ) {
+ dst = (dst&0xfffc) | (src&0x3);
+ flag = 1;
+ WRITE16( ea, dst);
+ }
+ }
+ SetZF(flag);
+ }
+ else
+ i386_trap( 6, 0, 0); // invalid opcode in real mode or v8086 mode
+}
+
+void I386_OPS_BASE::I386OP(push_i8)() // Opcode 0x6a
+{
+ UINT8 value = FETCH();
+ PUSH8(value);
+ CYCLES(CYCLES_PUSH_IMM);
+}
+
+void I386_OPS_BASE::I386OP(ins_generic)( int size)
+{
+ UINT32 ead;
+ UINT8 vb;
+ UINT16 vw;
+ UINT32 vd;
+
+ ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1, size);
+
+ switch(size) {
+ case 1:
+ vb = READPORT8( REG16(DX));
+ WRITE8(ead, vb);
+ break;
+ case 2:
+ vw = READPORT16( REG16(DX));
+ WRITE16(ead, vw);
+ break;
+ case 4:
+ vd = READPORT32( REG16(DX));
+ WRITE32(ead, vd);
+ break;
+ }
+
+ if(cpustate->address_size)
+ REG32(EDI) += ((cpustate->DF) ? -1 : 1) * size;
+ else
+ REG16(DI) += ((cpustate->DF) ? -1 : 1) * size;
+ CYCLES(CYCLES_INS); // TODO: Confirm this value
+}
+
+void I386_OPS_BASE::I386OP(insb)() // Opcode 0x6c
+{
+ I386OP(ins_generic)( 1);
+}
+
+void I386_OPS_BASE::I386OP(insw)() // Opcode 0x6d
+{
+ I386OP(ins_generic)( 2);
+}
+
+void I386_OPS_BASE::I386OP(insd)() // Opcode 0x6d
+{
+ I386OP(ins_generic)( 4);
+}
+
+void I386_OPS_BASE::I386OP(outs_generic)( int size)
+{
+ UINT32 eas;
+ UINT8 vb;
+ UINT16 vw;
+ UINT32 vd;
+
+ if( cpustate->segment_prefix ) {
+ eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, size );
+ } else {
+ eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, size );
+ }
+
+ switch(size) {
+ case 1:
+ vb = READ8(eas);
+ WRITEPORT8( REG16(DX), vb);
+ break;
+ case 2:
+ vw = READ16(eas);
+ WRITEPORT16( REG16(DX), vw);
+ break;
+ case 4:
+ vd = READ32(eas);
+ WRITEPORT32( REG16(DX), vd);
+ break;
+ }
+
+ if(cpustate->address_size)
+ REG32(ESI) += ((cpustate->DF) ? -1 : 1) * size;
+ else
+ REG16(SI) += ((cpustate->DF) ? -1 : 1) * size;
+ CYCLES(CYCLES_OUTS); // TODO: Confirm this value
+}
+
+void I386_OPS_BASE::I386OP(outsb)() // Opcode 0x6e
+{
+ I386OP(outs_generic)( 1);
+}
+
+void I386_OPS_BASE::I386OP(outsw)() // Opcode 0x6f
+{
+ I386OP(outs_generic)( 2);
+}
+
+void I386_OPS_BASE::I386OP(outsd)() // Opcode 0x6f
+{
+ I386OP(outs_generic)( 4);
+}
+
+void I386_OPS_BASE::I386OP(repeat)( int invert_flag)
+{
+ UINT32 repeated_eip = cpustate->eip;
+ UINT32 repeated_pc = cpustate->pc;
+ UINT8 opcode; // = FETCH();
+// UINT32 eas, ead;
+ UINT32 count;
+ INT32 cycle_base = 0, cycle_adjustment = 0;
+ UINT8 prefix_flag=1;
+ UINT8 *flag = NULL;
+
+
+ do {
+ repeated_eip = cpustate->eip;
+ repeated_pc = cpustate->pc;
+ opcode = FETCH();
+ switch(opcode) {
+ case 0x0f:
+ if (invert_flag == 0)
+ I386OP(decode_three_bytef3)(); // sse f3 0f
+ else
+ I386OP(decode_three_bytef2)(); // sse f2 0f
+ return;
+ case 0x26:
+ cpustate->segment_override=ES;
+ cpustate->segment_prefix=1;
+ break;
+ case 0x2e:
+ cpustate->segment_override=CS;
+ cpustate->segment_prefix=1;
+ break;
+ case 0x36:
+ cpustate->segment_override=SS;
+ cpustate->segment_prefix=1;
+ break;
+ case 0x3e:
+ cpustate->segment_override=DS;
+ cpustate->segment_prefix=1;
+ break;
+ case 0x64:
+ cpustate->segment_override=FS;
+ cpustate->segment_prefix=1;
+ break;
+ case 0x65:
+ cpustate->segment_override=GS;
+ cpustate->segment_prefix=1;
+ break;
+ case 0x66:
+ cpustate->operand_size ^= 1;
+ cpustate->xmm_operand_size ^= 1;
+ break;
+ case 0x67:
+ cpustate->address_size ^= 1;
+ break;
+ default:
+ prefix_flag=0;
+ }
+ } while (prefix_flag);
+
+
+ if( cpustate->segment_prefix ) {
+ // FIXME: the following does not work if both address override and segment override are used
+ i386_translate( cpustate->segment_override, cpustate->sreg[cpustate->segment_prefix].d ? REG32(ESI) : REG16(SI), -1, 1 );
+ } else {
+ //eas =
+ i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), -1, 1 );
+ }
+ i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), -1, 1 );
+
+ switch(opcode)
+ {
+ case 0x6c:
+ case 0x6d:
+ /* INSB, INSW, INSD */
+ // TODO: cycle count
+ cycle_base = 8;
+ cycle_adjustment = -4;
+ flag = NULL;
+ break;
+
+ case 0x6e:
+ case 0x6f:
+ /* OUTSB, OUTSW, OUTSD */
+ // TODO: cycle count
+ cycle_base = 8;
+ cycle_adjustment = -4;
+ flag = NULL;
+ break;
+
+ case 0xa4:
+ case 0xa5:
+ /* MOVSB, MOVSW, MOVSD */
+ cycle_base = 8;
+ cycle_adjustment = -4;
+ flag = NULL;
+ break;
+
+ case 0xa6:
+ case 0xa7:
+ /* CMPSB, CMPSW, CMPSD */
+ cycle_base = 5;
+ cycle_adjustment = -1;
+ flag = &cpustate->ZF;
+ break;
+
+ case 0xac:
+ case 0xad:
+ /* LODSB, LODSW, LODSD */
+ cycle_base = 5;
+ cycle_adjustment = 1;
+ flag = NULL;
+ break;
+
+ case 0xaa:
+ case 0xab:
+ /* STOSB, STOSW, STOSD */
+ cycle_base = 5;
+ cycle_adjustment = 0;
+ flag = NULL;
+ break;
+
+ case 0xae:
+ case 0xaf:
+ /* SCASB, SCASW, SCASD */
+ cycle_base = 5;
+ cycle_adjustment = 0;
+ flag = &cpustate->ZF;
+ break;
+
+ case 0x90:
+ CYCLES(CYCLES_NOP);
+ return;
+
+ case 0xc2: // sigh
+ case 0xc3:
+ cpustate->pc--;
+ return;
+
+ default:
+ logerror("i386: Invalid REP/opcode %02X combination at %08x\n",opcode, cpustate->pc - 2);
+ cpustate->pc--;
+ break;
+ }
+
+ if( cpustate->address_size ) {
+ if( REG32(ECX) == 0 )
+ return;
+ } else {
+ if( REG16(CX) == 0 )
+ return;
+ }
+
+ /* now actually perform the repeat */
+ CYCLES_NUM(cycle_base);
+ do
+ {
+ cpustate->eip = repeated_eip;
+ cpustate->pc = repeated_pc;
+ try
+ {
+ I386OP(decode_opcode)();
+ }
+ catch (UINT64 e)
+ {
+ cpustate->eip = cpustate->prev_eip;
+ throw e;
+ }
+
+ CYCLES_NUM(cycle_adjustment);
+
+ if (cpustate->address_size)
+ count = --REG32(ECX);
+ else
+ count = --REG16(CX);
+ if (cpustate->cycles <= 0)
+ goto outofcycles;
+ }
+ while( count && (!flag || (invert_flag ? !*flag : *flag)) );
+ return;
+
+outofcycles:
+ /* if we run out of cycles to execute, and we are still in the repeat, we need
+ * to exit this instruction in such a way to go right back into it when we have
+ * time to execute cycles */
+ if(flag && (invert_flag ? *flag : !*flag))
+ return;
+ cpustate->eip = cpustate->prev_eip;
+ CHANGE_PC(cpustate->eip);
+ CYCLES_NUM(-cycle_base);
+}
+
+void I386_OPS_BASE::I386OP(rep)() // Opcode 0xf3
+{
+ I386OP(repeat)( 0);
+}
+
+void I386_OPS_BASE::I386OP(repne)() // Opcode 0xf2
+{
+ I386OP(repeat)( 1);
+}
+
+void I386_OPS_BASE::I386OP(sahf)() // Opcode 0x9e
+{
+ set_flags( (get_flags() & 0xffffff00) | (REG8(AH) & 0xd7) );
+ CYCLES(CYCLES_SAHF);
+}
+
+void I386_OPS_BASE::I386OP(sbb_rm8_r8)() // Opcode 0x18
+{
+ UINT8 src, dst;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_REG8(modrm);
+ dst = LOAD_RM8(modrm);
+ dst = SBB8( dst, src, cpustate->CF);
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ src = LOAD_REG8(modrm);
+ dst = READ8(ea);
+ dst = SBB8( dst, src, cpustate->CF);
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_ALU_REG_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(sbb_r8_rm8)() // Opcode 0x1a
+{
+ UINT8 src, dst;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_RM8(modrm);
+ dst = LOAD_REG8(modrm);
+ dst = SBB8( dst, src, cpustate->CF);
+ STORE_REG8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,0,1);
+ src = READ8(ea);
+ dst = LOAD_REG8(modrm);
+ dst = SBB8( dst, src, cpustate->CF);
+ STORE_REG8(modrm, dst);
+ CYCLES(CYCLES_ALU_MEM_REG);
+ }
+}
+
+void I386_OPS_BASE::I386OP(sbb_al_i8)() // Opcode 0x1c
+{
+ UINT8 src, dst;
+ src = FETCH();
+ dst = REG8(AL);
+ dst = SBB8( dst, src, cpustate->CF);
+ REG8(EAX) = dst;
+ CYCLES(CYCLES_ALU_IMM_ACC);
+}
+
+void I386_OPS_BASE::I386OP(scasb)() // Opcode 0xae
+{
+ UINT32 eas;
+ UINT8 src, dst;
+ eas = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0, 1 );
+ src = READ8(eas);
+ dst = REG8(AL);
+ SUB8(dst, src);
+ BUMP_DI(1);
+ CYCLES(CYCLES_SCAS);
+}
+
+void I386_OPS_BASE::I386OP(setalc)() // Opcode 0xd6 (undocumented)
+{
+ if( cpustate->CF ) {
+ REG8(AL) = 0xff;
+ } else {
+ REG8(AL) = 0;
+ }
+ CYCLES(3);
+}
+
+void I386_OPS_BASE::I386OP(seta_rm8)() // Opcode 0x0f 97
+{
+ UINT8 modrm = FETCH();
+ UINT8 value = 0;
+ if( cpustate->CF == 0 && cpustate->ZF == 0 ) {
+ value = 1;
+ }
+ if( modrm >= 0xc0 ) {
+ STORE_RM8(modrm, value);
+ CYCLES(CYCLES_SETCC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ WRITE8(ea, value);
+ CYCLES(CYCLES_SETCC_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(setbe_rm8)() // Opcode 0x0f 96
+{
+ UINT8 modrm = FETCH();
+ UINT8 value = 0;
+ if( cpustate->CF != 0 || cpustate->ZF != 0 ) {
+ value = 1;
+ }
+ if( modrm >= 0xc0 ) {
+ STORE_RM8(modrm, value);
+ CYCLES(CYCLES_SETCC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ WRITE8(ea, value);
+ CYCLES(CYCLES_SETCC_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(setc_rm8)() // Opcode 0x0f 92
+{
+ UINT8 modrm = FETCH();
+ UINT8 value = 0;
+ if( cpustate->CF != 0 ) {
+ value = 1;
+ }
+ if( modrm >= 0xc0 ) {
+ STORE_RM8(modrm, value);
+ CYCLES(CYCLES_SETCC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ WRITE8(ea, value);
+ CYCLES(CYCLES_SETCC_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(setg_rm8)() // Opcode 0x0f 9f
+{
+ UINT8 modrm = FETCH();
+ UINT8 value = 0;
+ if( cpustate->ZF == 0 && (cpustate->SF == cpustate->OF) ) {
+ value = 1;
+ }
+ if( modrm >= 0xc0 ) {
+ STORE_RM8(modrm, value);
+ CYCLES(CYCLES_SETCC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ WRITE8(ea, value);
+ CYCLES(CYCLES_SETCC_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(setge_rm8)() // Opcode 0x0f 9d
+{
+ UINT8 modrm = FETCH();
+ UINT8 value = 0;
+ if(cpustate->SF == cpustate->OF) {
+ value = 1;
+ }
+ if( modrm >= 0xc0 ) {
+ STORE_RM8(modrm, value);
+ CYCLES(CYCLES_SETCC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ WRITE8(ea, value);
+ CYCLES(CYCLES_SETCC_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(setl_rm8)() // Opcode 0x0f 9c
+{
+ UINT8 modrm = FETCH();
+ UINT8 value = 0;
+ if( cpustate->SF != cpustate->OF ) {
+ value = 1;
+ }
+ if( modrm >= 0xc0 ) {
+ STORE_RM8(modrm, value);
+ CYCLES(CYCLES_SETCC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ WRITE8(ea, value);
+ CYCLES(CYCLES_SETCC_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(setle_rm8)() // Opcode 0x0f 9e
+{
+ UINT8 modrm = FETCH();
+ UINT8 value = 0;
+ if( cpustate->ZF != 0 || (cpustate->SF != cpustate->OF) ) {
+ value = 1;
+ }
+ if( modrm >= 0xc0 ) {
+ STORE_RM8(modrm, value);
+ CYCLES(CYCLES_SETCC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ WRITE8(ea, value);
+ CYCLES(CYCLES_SETCC_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(setnc_rm8)() // Opcode 0x0f 93
+{
+ UINT8 modrm = FETCH();
+ UINT8 value = 0;
+ if( cpustate->CF == 0 ) {
+ value = 1;
+ }
+ if( modrm >= 0xc0 ) {
+ STORE_RM8(modrm, value);
+ CYCLES(CYCLES_SETCC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ WRITE8(ea, value);
+ CYCLES(CYCLES_SETCC_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(setno_rm8)() // Opcode 0x0f 91
+{
+ UINT8 modrm = FETCH();
+ UINT8 value = 0;
+ if( cpustate->OF == 0 ) {
+ value = 1;
+ }
+ if( modrm >= 0xc0 ) {
+ STORE_RM8(modrm, value);
+ CYCLES(CYCLES_SETCC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ WRITE8(ea, value);
+ CYCLES(CYCLES_SETCC_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(setnp_rm8)() // Opcode 0x0f 9b
+{
+ UINT8 modrm = FETCH();
+ UINT8 value = 0;
+ if( cpustate->PF == 0 ) {
+ value = 1;
+ }
+ if( modrm >= 0xc0 ) {
+ STORE_RM8(modrm, value);
+ CYCLES(CYCLES_SETCC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ WRITE8(ea, value);
+ CYCLES(CYCLES_SETCC_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(setns_rm8)() // Opcode 0x0f 99
+{
+ UINT8 modrm = FETCH();
+ UINT8 value = 0;
+ if( cpustate->SF == 0 ) {
+ value = 1;
+ }
+ if( modrm >= 0xc0 ) {
+ STORE_RM8(modrm, value);
+ CYCLES(CYCLES_SETCC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ WRITE8(ea, value);
+ CYCLES(CYCLES_SETCC_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(setnz_rm8)() // Opcode 0x0f 95
+{
+ UINT8 modrm = FETCH();
+ UINT8 value = 0;
+ if( cpustate->ZF == 0 ) {
+ value = 1;
+ }
+ if( modrm >= 0xc0 ) {
+ STORE_RM8(modrm, value);
+ CYCLES(CYCLES_SETCC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ WRITE8(ea, value);
+ CYCLES(CYCLES_SETCC_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(seto_rm8)() // Opcode 0x0f 90
+{
+ UINT8 modrm = FETCH();
+ UINT8 value = 0;
+ if( cpustate->OF != 0 ) {
+ value = 1;
+ }
+ if( modrm >= 0xc0 ) {
+ STORE_RM8(modrm, value);
+ CYCLES(CYCLES_SETCC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ WRITE8(ea, value);
+ CYCLES(CYCLES_SETCC_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(setp_rm8)() // Opcode 0x0f 9a
+{
+ UINT8 modrm = FETCH();
+ UINT8 value = 0;
+ if( cpustate->PF != 0 ) {
+ value = 1;
+ }
+ if( modrm >= 0xc0 ) {
+ STORE_RM8(modrm, value);
+ CYCLES(CYCLES_SETCC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ WRITE8(ea, value);
+ CYCLES(CYCLES_SETCC_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(sets_rm8)() // Opcode 0x0f 98
+{
+ UINT8 modrm = FETCH();
+ UINT8 value = 0;
+ if( cpustate->SF != 0 ) {
+ value = 1;
+ }
+ if( modrm >= 0xc0 ) {
+ STORE_RM8(modrm, value);
+ CYCLES(CYCLES_SETCC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ WRITE8(ea, value);
+ CYCLES(CYCLES_SETCC_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(setz_rm8)() // Opcode 0x0f 94
+{
+ UINT8 modrm = FETCH();
+ UINT8 value = 0;
+ if( cpustate->ZF != 0 ) {
+ value = 1;
+ }
+ if( modrm >= 0xc0 ) {
+ STORE_RM8(modrm, value);
+ CYCLES(CYCLES_SETCC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ WRITE8(ea, value);
+ CYCLES(CYCLES_SETCC_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(stc)() // Opcode 0xf9
+{
+ cpustate->CF = 1;
+ CYCLES(CYCLES_STC);
+}
+
+void I386_OPS_BASE::I386OP(std)() // Opcode 0xfd
+{
+ cpustate->DF = 1;
+ CYCLES(CYCLES_STD);
+}
+
+void I386_OPS_BASE::I386OP(sti)() // Opcode 0xfb
+{
+ if(PROTECTED_MODE)
+ {
+ UINT8 IOPL = cpustate->IOP1 | (cpustate->IOP2 << 1);
+ if(cpustate->CPL > IOPL)
+ FAULT(FAULT_GP,0);
+ }
+ cpustate->delayed_interrupt_enable = 1; // IF is set after the next instruction.
+ CYCLES(CYCLES_STI);
+}
+
+void I386_OPS_BASE::I386OP(stosb)() // Opcode 0xaa
+{
+ UINT32 ead;
+ ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1, 1 );
+ WRITE8(ead, REG8(AL));
+ BUMP_DI(1);
+ CYCLES(CYCLES_STOS);
+}
+
+void I386_OPS_BASE::I386OP(sub_rm8_r8)() // Opcode 0x28
+{
+ UINT8 src, dst;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_REG8(modrm);
+ dst = LOAD_RM8(modrm);
+ dst = SUB8(dst, src);
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ src = LOAD_REG8(modrm);
+ dst = READ8(ea);
+ dst = SUB8(dst, src);
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_ALU_REG_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(sub_r8_rm8)() // Opcode 0x2a
+{
+ UINT8 src, dst;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_RM8(modrm);
+ dst = LOAD_REG8(modrm);
+ dst = SUB8(dst, src);
+ STORE_REG8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,0,1);
+ src = READ8(ea);
+ dst = LOAD_REG8(modrm);
+ dst = SUB8(dst, src);
+ STORE_REG8(modrm, dst);
+ CYCLES(CYCLES_ALU_MEM_REG);
+ }
+}
+
+void I386_OPS_BASE::I386OP(sub_al_i8)() // Opcode 0x2c
+{
+ UINT8 src, dst;
+ src = FETCH();
+ dst = REG8(EAX);
+ dst = SUB8(dst, src);
+ REG8(EAX) = dst;
+ CYCLES(CYCLES_ALU_IMM_ACC);
+}
+
+void I386_OPS_BASE::I386OP(test_al_i8)() // Opcode 0xa8
+{
+ UINT8 src = FETCH();
+ UINT8 dst = REG8(AL);
+ dst = src & dst;
+ SetSZPF8(dst);
+ cpustate->CF = 0;
+ cpustate->OF = 0;
+ CYCLES(CYCLES_ALU_IMM_ACC);
+}
+
+void I386_OPS_BASE::I386OP(test_rm8_r8)() // Opcode 0x84
+{
+ UINT8 src, dst;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_REG8(modrm);
+ dst = LOAD_RM8(modrm);
+ dst = src & dst;
+ SetSZPF8(dst);
+ cpustate->CF = 0;
+ cpustate->OF = 0;
+ CYCLES(CYCLES_TEST_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,0,1);
+ src = LOAD_REG8(modrm);
+ dst = READ8(ea);
+ dst = src & dst;
+ SetSZPF8(dst);
+ cpustate->CF = 0;
+ cpustate->OF = 0;
+ CYCLES(CYCLES_TEST_REG_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(xchg_r8_rm8)() // Opcode 0x86
+{
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ UINT8 src = LOAD_RM8(modrm);
+ UINT8 dst = LOAD_REG8(modrm);
+ STORE_REG8(modrm, src);
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_XCHG_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ UINT8 src = READ8(ea);
+ UINT8 dst = LOAD_REG8(modrm);
+ WRITE8(ea, dst);
+ STORE_REG8(modrm, src);
+ CYCLES(CYCLES_XCHG_REG_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(xor_rm8_r8)() // Opcode 0x30
+{
+ UINT8 src, dst;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_REG8(modrm);
+ dst = LOAD_RM8(modrm);
+ dst = XOR8(dst, src);
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ src = LOAD_REG8(modrm);
+ dst = READ8(ea);
+ dst = XOR8(dst, src);
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_ALU_REG_MEM);
+ }
+}
+
+void I386_OPS_BASE::I386OP(xor_r8_rm8)() // Opcode 0x32
+{
+ UINT32 src, dst;
+ UINT8 modrm = FETCH();
+ if( modrm >= 0xc0 ) {
+ src = LOAD_RM8(modrm);
+ dst = LOAD_REG8(modrm);
+ dst = XOR8(dst, src);
+ STORE_REG8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,0,1);
+ src = READ8(ea);
+ dst = LOAD_REG8(modrm);
+ dst = XOR8(dst, src);
+ STORE_REG8(modrm, dst);
+ CYCLES(CYCLES_ALU_MEM_REG);
+ }
+}
+
+void I386_OPS_BASE::I386OP(xor_al_i8)() // Opcode 0x34
+{
+ UINT8 src, dst;
+ src = FETCH();
+ dst = REG8(AL);
+ dst = XOR8(dst, src);
+ REG8(AL) = dst;
+ CYCLES(CYCLES_ALU_IMM_ACC);
+}
+
+
+
+void I386_OPS_BASE::I386OP(group80_8)() // Opcode 0x80
+{
+ UINT32 ea;
+ UINT8 src, dst;
+ UINT8 modrm = FETCH();
+
+ switch( (modrm >> 3) & 0x7 )
+ {
+ case 0: // ADD Rm8, i8
+ if( modrm >= 0xc0 ) {
+ dst = LOAD_RM8(modrm);
+ src = FETCH();
+ dst = ADD8(dst, src);
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ ea = GetEA(modrm,0,1);
+ dst = READ8(ea);
+ src = FETCH();
+ dst = ADD8(dst, src);
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_ALU_REG_MEM);
+ }
+ break;
+ case 1: // OR Rm8, i8
+ if( modrm >= 0xc0 ) {
+ dst = LOAD_RM8(modrm);
+ src = FETCH();
+ dst = OR8(dst, src);
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ ea = GetEA(modrm,1,1);
+ dst = READ8(ea);
+ src = FETCH();
+ dst = OR8(dst, src);
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_ALU_REG_MEM);
+ }
+ break;
+ case 2: // ADC Rm8, i8
+ if( modrm >= 0xc0 ) {
+ dst = LOAD_RM8(modrm);
+ src = FETCH();
+ dst = ADC8( dst, src, cpustate->CF);
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ ea = GetEA(modrm,1,1);
+ dst = READ8(ea);
+ src = FETCH();
+ dst = ADC8( dst, src, cpustate->CF);
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_ALU_REG_MEM);
+ }
+ break;
+ case 3: // SBB Rm8, i8
+ if( modrm >= 0xc0 ) {
+ dst = LOAD_RM8(modrm);
+ src = FETCH();
+ dst = SBB8( dst, src, cpustate->CF);
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ ea = GetEA(modrm,1,1);
+ dst = READ8(ea);
+ src = FETCH();
+ dst = SBB8( dst, src, cpustate->CF);
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_ALU_REG_MEM);
+ }
+ break;
+ case 4: // AND Rm8, i8
+ if( modrm >= 0xc0 ) {
+ dst = LOAD_RM8(modrm);
+ src = FETCH();
+ dst = AND8(dst, src);
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ ea = GetEA(modrm,1,1);
+ dst = READ8(ea);
+ src = FETCH();
+ dst = AND8(dst, src);
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_ALU_REG_MEM);
+ }
+ break;
+ case 5: // SUB Rm8, i8
+ if( modrm >= 0xc0 ) {
+ dst = LOAD_RM8(modrm);
+ src = FETCH();
+ dst = SUB8(dst, src);
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ ea = GetEA(modrm,1,1);
+ dst = READ8(ea);
+ src = FETCH();
+ dst = SUB8(dst, src);
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_ALU_REG_MEM);
+ }
+ break;
+ case 6: // XOR Rm8, i8
+ if( modrm >= 0xc0 ) {
+ dst = LOAD_RM8(modrm);
+ src = FETCH();
+ dst = XOR8(dst, src);
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_ALU_REG_REG);
+ } else {
+ ea = GetEA(modrm,1,1);
+ dst = READ8(ea);
+ src = FETCH();
+ dst = XOR8(dst, src);
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_ALU_REG_MEM);
+ }
+ break;
+ case 7: // CMP Rm8, i8
+ if( modrm >= 0xc0 ) {
+ dst = LOAD_RM8(modrm);
+ src = FETCH();
+ SUB8(dst, src);
+ CYCLES(CYCLES_CMP_REG_REG);
+ } else {
+ ea = GetEA(modrm,0,1);
+ dst = READ8(ea);
+ src = FETCH();
+ SUB8(dst, src);
+ CYCLES(CYCLES_CMP_REG_MEM);
+ }
+ break;
+ }
+}
+
+void I386_OPS_BASE::I386OP(groupC0_8)() // Opcode 0xc0
+{
+ UINT8 dst;
+ UINT8 modrm = FETCH();
+ UINT8 shift;
+
+ if( modrm >= 0xc0 ) {
+ dst = LOAD_RM8(modrm);
+ shift = FETCH() & 0x1f;
+ dst = i386_shift_rotate8( modrm, dst, shift);
+ STORE_RM8(modrm, dst);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ dst = READ8(ea);
+ shift = FETCH() & 0x1f;
+ dst = i386_shift_rotate8( modrm, dst, shift);
+ WRITE8(ea, dst);
+ }
+}
+
+void I386_OPS_BASE::I386OP(groupD0_8)() // Opcode 0xd0
+{
+ UINT8 dst;
+ UINT8 modrm = FETCH();
+
+ if( modrm >= 0xc0 ) {
+ dst = LOAD_RM8(modrm);
+ dst = i386_shift_rotate8( modrm, dst, 1);
+ STORE_RM8(modrm, dst);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ dst = READ8(ea);
+ dst = i386_shift_rotate8( modrm, dst, 1);
+ WRITE8(ea, dst);
+ }
+}
+
+void I386_OPS_BASE::I386OP(groupD2_8)() // Opcode 0xd2
+{
+ UINT8 dst;
+ UINT8 modrm = FETCH();
+
+ if( modrm >= 0xc0 ) {
+ dst = LOAD_RM8(modrm);
+ dst = i386_shift_rotate8( modrm, dst, REG8(CL));
+ STORE_RM8(modrm, dst);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ dst = READ8(ea);
+ dst = i386_shift_rotate8( modrm, dst, REG8(CL));
+ WRITE8(ea, dst);
+ }
+}
+
+void I386_OPS_BASE::I386OP(groupF6_8)() // Opcode 0xf6
+{
+ UINT8 modrm = FETCH();
+
+ switch( (modrm >> 3) & 0x7 )
+ {
+ case 0: /* TEST Rm8, i8 */
+ if( modrm >= 0xc0 ) {
+ UINT8 dst = LOAD_RM8(modrm);
+ UINT8 src = FETCH();
+ dst &= src;
+ cpustate->CF = cpustate->OF = cpustate->AF = 0;
+ SetSZPF8(dst);
+ CYCLES(CYCLES_TEST_IMM_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,0,1);
+ UINT8 dst = READ8(ea);
+ UINT8 src = FETCH();
+ dst &= src;
+ cpustate->CF = cpustate->OF = cpustate->AF = 0;
+ SetSZPF8(dst);
+ CYCLES(CYCLES_TEST_IMM_MEM);
+ }
+ break;
+ case 2: /* NOT Rm8 */
+ if( modrm >= 0xc0 ) {
+ UINT8 dst = LOAD_RM8(modrm);
+ dst = ~dst;
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_NOT_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ UINT8 dst = READ8(ea);
+ dst = ~dst;
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_NOT_MEM);
+ }
+ break;
+ case 3: /* NEG Rm8 */
+ if( modrm >= 0xc0 ) {
+ UINT8 dst = LOAD_RM8(modrm);
+ dst = SUB8( 0, dst );
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_NEG_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ UINT8 dst = READ8(ea);
+ dst = SUB8( 0, dst );
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_NEG_MEM);
+ }
+ break;
+ case 4: /* MUL AL, Rm8 */
+ {
+ UINT16 result;
+ UINT8 src, dst;
+ if( modrm >= 0xc0 ) {
+ src = LOAD_RM8(modrm);
+ CYCLES(CYCLES_MUL8_ACC_REG); /* TODO: Correct multiply timing */
+ } else {
+ UINT32 ea = GetEA(modrm,0,1);
+ src = READ8(ea);
+ CYCLES(CYCLES_MUL8_ACC_MEM); /* TODO: Correct multiply timing */
+ }
+
+ dst = REG8(AL);
+ result = (UINT16)src * (UINT16)dst;
+ REG16(AX) = (UINT16)result;
+
+ cpustate->CF = cpustate->OF = (REG16(AX) > 0xff);
+ }
+ break;
+ case 5: /* IMUL AL, Rm8 */
+ {
+ INT16 result;
+ INT16 src, dst;
+ if( modrm >= 0xc0 ) {
+ src = (INT16)(INT8)LOAD_RM8(modrm);
+ CYCLES(CYCLES_IMUL8_ACC_REG); /* TODO: Correct multiply timing */
+ } else {
+ UINT32 ea = GetEA(modrm,0,1);
+ src = (INT16)(INT8)READ8(ea);
+ CYCLES(CYCLES_IMUL8_ACC_MEM); /* TODO: Correct multiply timing */
+ }
+
+ dst = (INT16)(INT8)REG8(AL);
+ result = src * dst;
+
+ REG16(AX) = (UINT16)result;
+
+ cpustate->CF = cpustate->OF = !(result == (INT16)(INT8)result);
+ }
+ break;
+ case 6: /* DIV AL, Rm8 */
+ {
+ UINT16 quotient, remainder, result;
+ UINT8 src;
+ if( modrm >= 0xc0 ) {
+ src = LOAD_RM8(modrm);
+ CYCLES(CYCLES_DIV8_ACC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,0,1);
+ src = READ8(ea);
+ CYCLES(CYCLES_DIV8_ACC_MEM);
+ }
+
+ quotient = (UINT16)REG16(AX);
+ if( src ) {
+ remainder = quotient % (UINT16)src;
+ result = quotient / (UINT16)src;
+ if( result > 0xff ) {
+ /* TODO: Divide error */
+ } else {
+ REG8(AH) = (UINT8)remainder & 0xff;
+ REG8(AL) = (UINT8)result & 0xff;
+
+ // this flag is actually undefined, enable on non-cyrix
+ if (cpustate->cpuid_id0 != 0x69727943)
+ cpustate->CF = 1;
+ }
+ } else {
+ i386_trap( 0, 0, 0);
+ }
+ }
+ break;
+ case 7: /* IDIV AL, Rm8 */
+ {
+ INT16 quotient, remainder, result;
+ UINT8 src;
+ if( modrm >= 0xc0 ) {
+ src = LOAD_RM8(modrm);
+ CYCLES(CYCLES_IDIV8_ACC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,0,1);
+ src = READ8(ea);
+ CYCLES(CYCLES_IDIV8_ACC_MEM);
+ }
+
+ quotient = (INT16)REG16(AX);
+ if( src ) {
+ remainder = quotient % (INT16)(INT8)src;
+ result = quotient / (INT16)(INT8)src;
+ if( result > 0xff ) {
+ /* TODO: Divide error */
+ } else {
+ REG8(AH) = (UINT8)remainder & 0xff;
+ REG8(AL) = (UINT8)result & 0xff;
+
+ // this flag is actually undefined, enable on non-cyrix
+ if (cpustate->cpuid_id0 != 0x69727943)
+ cpustate->CF = 1;
+ }
+ } else {
+ i386_trap( 0, 0, 0);
+ }
+ }
+ break;
+ }
+}
+
+void I386_OPS_BASE::I386OP(groupFE_8)() // Opcode 0xfe
+{
+ UINT8 modrm = FETCH();
+
+ switch( (modrm >> 3) & 0x7 )
+ {
+ case 0: /* INC Rm8 */
+ if( modrm >= 0xc0 ) {
+ UINT8 dst = LOAD_RM8(modrm);
+ dst = INC8(dst);
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_INC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ UINT8 dst = READ8(ea);
+ dst = INC8(dst);
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_INC_MEM);
+ }
+ break;
+ case 1: /* DEC Rm8 */
+ if( modrm >= 0xc0 ) {
+ UINT8 dst = LOAD_RM8(modrm);
+ dst = DEC8(dst);
+ STORE_RM8(modrm, dst);
+ CYCLES(CYCLES_DEC_REG);
+ } else {
+ UINT32 ea = GetEA(modrm,1,1);
+ UINT8 dst = READ8(ea);
+ dst = DEC8(dst);
+ WRITE8(ea, dst);
+ CYCLES(CYCLES_DEC_MEM);
+ }
+ break;
+ case 6: /* PUSH Rm8*/
+ {
+ UINT8 value;
+ if( modrm >= 0xc0 ) {
+ value = LOAD_RM8(modrm);
+ } else {
+ UINT32 ea = GetEA(modrm,0,1);
+ value = READ8(ea);
+ }
+ if( cpustate->operand_size ) {
+ PUSH32(value);
+ } else {
+ PUSH16(value);
+ }
+ CYCLES(CYCLES_PUSH_RM);
+ }
+ break;
+ default:
+ report_invalid_modrm( "groupFE_8", modrm);
+ break;
+ }
+}
+
+
+
+void I386_OPS_BASE::I386OP(segment_CS)() // Opcode 0x2e
+{
+ cpustate->segment_prefix = 1;
+ cpustate->segment_override = CS;
+
+ I386OP(decode_opcode)();
+}
+
+void I386_OPS_BASE::I386OP(segment_DS)() // Opcode 0x3e
+{
+ cpustate->segment_prefix = 1;
+ cpustate->segment_override = DS;
+ CYCLES(0); // TODO: Specify cycle count
+ I386OP(decode_opcode)();
+}
+
+void I386_OPS_BASE::I386OP(segment_ES)() // Opcode 0x26
+{
+ cpustate->segment_prefix = 1;
+ cpustate->segment_override = ES;
+ CYCLES(0); // TODO: Specify cycle count
+ I386OP(decode_opcode)();
+}
+
+void I386_OPS_BASE::I386OP(segment_FS)() // Opcode 0x64
+{
+ cpustate->segment_prefix = 1;
+ cpustate->segment_override = FS;
+ CYCLES(1); // TODO: Specify cycle count
+ I386OP(decode_opcode)();
+}
+
+void I386_OPS_BASE::I386OP(segment_GS)() // Opcode 0x65
+{
+ cpustate->segment_prefix = 1;
+ cpustate->segment_override = GS;
+ CYCLES(1); // TODO: Specify cycle count
+ I386OP(decode_opcode)();
+}
+
+void I386_OPS_BASE::I386OP(segment_SS)() // Opcode 0x36
+{
+ cpustate->segment_prefix = 1;
+ cpustate->segment_override = SS;
+ CYCLES(0); // TODO: Specify cycle count
+ I386OP(decode_opcode)();
+}
+
+void I386_OPS_BASE::I386OP(operand_size)() // Opcode prefix 0x66
+{
+ if(cpustate->operand_prefix == 0)
+ {
+ cpustate->operand_size ^= 1;
+ cpustate->xmm_operand_size ^= 1;
+ cpustate->operand_prefix = 1;
+ }
+ cpustate->opcode = FETCH();
+ if (cpustate->opcode == 0x0f)
+ I386OP(decode_three_byte66)();
+ else
+ {
+ if( cpustate->operand_size )
+ (this->*cpustate->opcode_table1_32[cpustate->opcode])();
+ else
+ (this->*cpustate->opcode_table1_16[cpustate->opcode])();
+ }
+}
+
+void I386_OPS_BASE::I386OP(address_size)() // Opcode 0x67
+{
+ if(cpustate->address_prefix == 0)
+ {
+ cpustate->address_size ^= 1;
+ cpustate->address_prefix = 1;
+ }
+ I386_OPS_BASE::I386OP(decode_opcode)();
+}
+
+void I386_OPS_BASE::I386OP(nop)() // Opcode 0x90
+{
+ CYCLES(CYCLES_NOP);
+}
+
+void I386_OPS_BASE::I386OP(int3)() // Opcode 0xcc
+{
+ CYCLES(CYCLES_INT3);
+ cpustate->ext = 0; // not an external interrupt
+ i386_trap(3, 1, 0);
+ cpustate->ext = 1;
+}
+
+void I386_OPS_BASE::I386OP(_int)() // Opcode 0xcd
+{
+ int interrupt = FETCH();
+ CYCLES(CYCLES_INT);
+ // Without pseudo BIOS.
+ cpustate->ext = 0; // not an external interrupt
+ i386_trap(interrupt, 1, 0);
+ cpustate->ext = 1;
+}
+
+void I386_OPS_BASE::I386OP(into)() // Opcode 0xce
+{
+ if( cpustate->OF ) {
+ cpustate->ext = 0;
+ i386_trap(4, 1, 0);
+ cpustate->ext = 1;
+ CYCLES(CYCLES_INTO_OF1);
+ }
+ else
+ {
+ CYCLES(CYCLES_INTO_OF0);
+ }
+}
+
+UINT32 i386_escape_ea; // hack around GCC 4.6 error because we need the side effects of GetEA()
+void I386_OPS_BASE::I386OP(escape)() // Opcodes 0xd8 - 0xdf
+{
+ UINT8 modrm = FETCH();
+ if(modrm < 0xc0)
+ {
+ i386_escape_ea = GetEA(modrm,0,1);
+ }
+ CYCLES(3); // TODO: confirm this
+ (void) LOAD_RM8(modrm);
+}
+
+void I386_OPS_BASE::I386OP(hlt)() // Opcode 0xf4
+{
+ if(PROTECTED_MODE && cpustate->CPL != 0)
+ FAULT(FAULT_GP,0);
+ cpustate->halted = 1;
+ CYCLES(CYCLES_HLT);
+ if (cpustate->cycles > 0)
+ cpustate->cycles = 0;
+}
+
+void I386_OPS_BASE::I386OP(decimal_adjust)( int direction)
+{
+ UINT8 tmpAL = REG8(AL);
+ UINT8 tmpCF = cpustate->CF;
+
+ if (cpustate->AF || ((REG8(AL) & 0xf) > 9))
+ {
+ UINT16 t= (UINT16)REG8(AL) + (direction * 0x06);
+ REG8(AL) = (UINT8)t&0xff;
+ cpustate->AF = 1;
+ if (t & 0x100)
+ cpustate->CF = 1;
+ if (direction > 0)
+ tmpAL = REG8(AL);
+ }
+
+ if (tmpCF || (tmpAL > 0x99))
+ {
+ REG8(AL) += (direction * 0x60);
+ cpustate->CF = 1;
+ }
+
+ SetSZPF8(REG8(AL));
+}
+
+void I386_OPS_BASE::I386OP(daa)() // Opcode 0x27
+{
+ I386OP(decimal_adjust)( +1);
+ CYCLES(CYCLES_DAA);
+}
+
+void I386_OPS_BASE::I386OP(das)() // Opcode 0x2f
+{
+ I386OP(decimal_adjust)( -1);
+ CYCLES(CYCLES_DAS);
+}
+
+void I386_OPS_BASE::I386OP(aaa)() // Opcode 0x37
+{
+ if( ( (REG8(AL) & 0x0f) > 9) || (cpustate->AF != 0) ) {
+ REG16(AX) = REG16(AX) + 6;
+ REG8(AH) = REG8(AH) + 1;
+ cpustate->AF = 1;
+ cpustate->CF = 1;
+ } else {
+ cpustate->AF = 0;
+ cpustate->CF = 0;
+ }
+ REG8(AL) = REG8(AL) & 0x0f;
+ CYCLES(CYCLES_AAA);
+}
+
+void I386_OPS_BASE::I386OP(aas)() // Opcode 0x3f
+{
+ if (cpustate->AF || ((REG8(AL) & 0xf) > 9))
+ {
+ REG16(AX) -= 6;
+ REG8(AH) -= 1;
+ cpustate->AF = 1;
+ cpustate->CF = 1;
+ }
+ else
+ {
+ cpustate->AF = 0;
+ cpustate->CF = 0;
+ }
+ REG8(AL) &= 0x0f;
+ CYCLES(CYCLES_AAS);
+}
+
+void I386_OPS_BASE::I386OP(aad)() // Opcode 0xd5
+{
+ UINT8 tempAL = REG8(AL);
+ UINT8 tempAH = REG8(AH);
+ UINT8 i = FETCH();
+
+ REG8(AL) = (tempAL + (tempAH * i)) & 0xff;
+ REG8(AH) = 0;
+ SetSZPF8( REG8(AL) );
+ CYCLES(CYCLES_AAD);
+}
+
+void I386_OPS_BASE::I386OP(aam)() // Opcode 0xd4
+{
+ UINT8 tempAL = REG8(AL);
+ UINT8 i = FETCH();
+
+ if(!i)
+ {
+ i386_trap( 0, 0, 0);
+ return;
+ }
+ REG8(AH) = tempAL / i;
+ REG8(AL) = tempAL % i;
+ SetSZPF8( REG8(AL) );
+ CYCLES(CYCLES_AAM);
+}
+
+void I386_OPS_BASE::I386OP(clts)() // Opcode 0x0f 0x06
+{
+ // Privileged instruction, CPL must be zero. Can be used in real or v86 mode.
+ if(PROTECTED_MODE && cpustate->CPL != 0)
+ FAULT(FAULT_GP,0)
+ cpustate->cr[0] &= ~0x08; /* clear TS bit */
+ CYCLES(CYCLES_CLTS);
+}
+
+void I386_OPS_BASE::I386OP(wait)() // Opcode 0x9B
+{
+ // TODO
+}
+
+void I386_OPS_BASE::I386OP(lock)() // Opcode 0xf0
+{
+ // lock doesn't depend on iopl on 386
+ cpustate->lock = true;
+ CYCLES(CYCLES_LOCK); // TODO: Determine correct cycle count
+ I386OP(decode_opcode)();
+}
+
+void I386_OPS_BASE::I386OP(mov_r32_tr)() // Opcode 0x0f 24
+{
+ FETCH();
+ CYCLES(1); // TODO: correct cycle count
+}
+
+void I386_OPS_BASE::I386OP(mov_tr_r32)() // Opcode 0x0f 26
+{
+ FETCH();
+ CYCLES(1); // TODO: correct cycle count
+}
+
+void I386_OPS_BASE::I386OP(loadall)() // Opcode 0x0f 0x07 (0x0f 0x05 on 80286), undocumented
+{
+ if(PROTECTED_MODE && (cpustate->CPL != 0))
+ FAULT(FAULT_GP,0)
+ UINT32 ea = i386_translate( ES, REG32(EDI), 0, 204);
+ cpustate->cr[0] = READ32( ea) & 0xfffeffff; // wp not supported on 386
+ set_flags( READ32( ea + 0x04));
+ cpustate->eip = READ32( ea + 0x08);
+ REG32(EDI) = READ32( ea + 0x0c);
+ REG32(ESI) = READ32( ea + 0x10);
+ REG32(EBP) = READ32( ea + 0x14);
+ REG32(ESP) = READ32( ea + 0x18);
+ REG32(EBX) = READ32( ea + 0x1c);
+ REG32(EDX) = READ32( ea + 0x20);
+ REG32(ECX) = READ32( ea + 0x24);
+ REG32(EAX) = READ32( ea + 0x28);
+ cpustate->dr[6] = READ32( ea + 0x2c);
+ cpustate->dr[7] = READ32( ea + 0x30);
+ cpustate->task.segment = READ16( ea + 0x34);
+ cpustate->ldtr.segment = READ16( ea + 0x38);
+ cpustate->sreg[GS].selector = READ16( ea + 0x3c);
+ cpustate->sreg[FS].selector = READ16( ea + 0x40);
+ cpustate->sreg[DS].selector = READ16( ea + 0x44);
+ cpustate->sreg[SS].selector = READ16( ea + 0x48);
+ cpustate->sreg[CS].selector = READ16( ea + 0x4c);
+ cpustate->sreg[ES].selector = READ16( ea + 0x50);
+ cpustate->task.flags = READ32( ea + 0x54) >> 8;
+ cpustate->task.base = READ32( ea + 0x58);
+ cpustate->task.limit = READ32( ea + 0x5c);
+ cpustate->idtr.base = READ32( ea + 0x64);
+ cpustate->idtr.limit = READ32( ea + 0x68);
+ cpustate->gdtr.base = READ32( ea + 0x70);
+ cpustate->gdtr.limit = READ32( ea + 0x74);
+ cpustate->ldtr.flags = READ32( ea + 0x78) >> 8;
+ cpustate->ldtr.base = READ32( ea + 0x7c);
+ cpustate->ldtr.limit = READ32( ea + 0x80);
+ cpustate->sreg[GS].flags = READ32( ea + 0x84) >> 8;
+ cpustate->sreg[GS].base = READ32( ea + 0x88);
+ cpustate->sreg[GS].limit = READ32( ea + 0x8c);
+ cpustate->sreg[FS].flags = READ32( ea + 0x90) >> 8;
+ cpustate->sreg[FS].base = READ32( ea + 0x94);
+ cpustate->sreg[FS].limit = READ32( ea + 0x98);
+ cpustate->sreg[DS].flags = READ32( ea + 0x9c) >> 8;
+ cpustate->sreg[DS].base = READ32( ea + 0xa0);
+ cpustate->sreg[DS].limit = READ32( ea + 0xa4);
+ cpustate->sreg[SS].flags = READ32( ea + 0xa8) >> 8;
+ cpustate->sreg[SS].base = READ32( ea + 0xac);
+ cpustate->sreg[SS].limit = READ32( ea + 0xb0);
+ cpustate->sreg[CS].flags = READ32( ea + 0xb4) >> 8;
+ cpustate->sreg[CS].base = READ32( ea + 0xb8);
+ cpustate->sreg[CS].limit = READ32( ea + 0xbc);
+ cpustate->sreg[ES].flags = READ32( ea + 0xc0) >> 8;
+ cpustate->sreg[ES].base = READ32( ea + 0xc4);
+ cpustate->sreg[ES].limit = READ32( ea + 0xc8);
+ cpustate->CPL = (cpustate->sreg[SS].flags >> 5) & 3; // cpl == dpl of ss
+
+ for(int i = 0; i <= GS; i++)
+ {
+ cpustate->sreg[i].valid = (cpustate->sreg[i].flags & 0x80) ? true : false;
+ cpustate->sreg[i].d = (cpustate->sreg[i].flags & 0x4000) ? 1 : 0;
+ }
+ CHANGE_PC( cpustate->eip);
+}
+
+void I386_OPS_BASE::I386OP(invalid)()
+{
+ report_invalid_opcode();
+ i386_trap( 6, 0, 0);
+}
+
+void I386_OPS_BASE::I386OP(xlat)() // Opcode 0xd7
+{
+ UINT32 ea;
+ if( cpustate->segment_prefix ) {
+ if(!cpustate->address_size)
+ {
+ ea = i386_translate( cpustate->segment_override, REG16(BX) + REG8(AL), 0, 1 );
+ }
+ else
+ {
+ ea = i386_translate( cpustate->segment_override, REG32(EBX) + REG8(AL), 0, 1 );
+ }
+ } else {
+ if(!cpustate->address_size)
+ {
+ ea = i386_translate( DS, REG16(BX) + REG8(AL), 0, 1 );
+ }
+ else
+ {
+ ea = i386_translate( DS, REG32(EBX) + REG8(AL), 0, 1 );
+ }
+ }
+ REG8(AL) = READ8(ea);
+ CYCLES(CYCLES_XLAT);
+}
+
+#else
UINT8 I386_OPS_BASE::I386OP(shift_rotate8)( UINT8 modrm, UINT32 value, UINT8 shift)
{
UINT32 src = value & 0xff;
STORE_RM8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
src = LOAD_REG8(modrm);
dst = READ8(ea);
dst = ADC8( dst, src, cpustate->CF);
STORE_REG8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,1);
src = READ8(ea);
dst = LOAD_REG8(modrm);
dst = ADC8( dst, src, cpustate->CF);
STORE_RM8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
src = LOAD_REG8(modrm);
dst = READ8(ea);
dst = ADD8(dst, src);
STORE_REG8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,1);
src = READ8(ea);
dst = LOAD_REG8(modrm);
dst = ADD8(dst, src);
STORE_RM8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
src = LOAD_REG8(modrm);
dst = READ8(ea);
dst = AND8(dst, src);
STORE_REG8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,1);
src = READ8(ea);
dst = LOAD_REG8(modrm);
dst = AND8(dst, src);
SUB8(dst, src);
CYCLES(CYCLES_CMP_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,1);
src = LOAD_REG8(modrm);
dst = READ8(ea);
SUB8(dst, src);
SUB8(dst, src);
CYCLES(CYCLES_CMP_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,1);
src = READ8(ea);
dst = LOAD_REG8(modrm);
SUB8(dst, src);
UINT32 eas, ead;
UINT8 src, dst;
if( cpustate->segment_prefix ) {
- eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
} else {
- eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
}
- ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0 );
+ ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0, 1 );
src = READ8(eas);
dst = READ8(ead);
SUB8(src, dst);
{
UINT32 eas;
if( cpustate->segment_prefix ) {
- eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
} else {
- eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
}
REG8(AL) = READ8(eas);
BUMP_SI(1);
STORE_RM8(modrm, src);
CYCLES(CYCLES_MOV_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
src = LOAD_REG8(modrm);
WRITE8(ea, src);
CYCLES(CYCLES_MOV_REG_MEM);
STORE_REG8(modrm, src);
CYCLES(CYCLES_MOV_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,1);
src = READ8(ea);
STORE_REG8(modrm, src);
CYCLES(CYCLES_MOV_MEM_REG);
STORE_RM8(modrm, value);
CYCLES(CYCLES_MOV_IMM_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
UINT8 value = FETCH();
WRITE8(ea, value);
CYCLES(CYCLES_MOV_IMM_MEM);
}
/* TODO: Not sure if this is correct... */
if( cpustate->segment_prefix ) {
- ea = i386_translate( cpustate->segment_override, offset, 0 );
+ ea = i386_translate( cpustate->segment_override, offset, 0, 1 );
} else {
- ea = i386_translate( DS, offset, 0 );
+ ea = i386_translate( DS, offset, 0, 1 );
}
REG8(AL) = READ8(ea);
CYCLES(CYCLES_MOV_IMM_MEM);
}
/* TODO: Not sure if this is correct... */
if( cpustate->segment_prefix ) {
- ea = i386_translate( cpustate->segment_override, offset, 1 );
+ ea = i386_translate( cpustate->segment_override, offset, 1, 1 );
} else {
- ea = i386_translate( DS, offset, 1 );
+ ea = i386_translate( DS, offset, 1, 1 );
}
WRITE8( ea, REG8(AL) );
CYCLES(CYCLES_MOV_MEM_ACC);
STORE_RM16(modrm, cpustate->sreg[s].selector);
CYCLES(CYCLES_MOV_SREG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,2);
WRITE16(ea, cpustate->sreg[s].selector);
CYCLES(CYCLES_MOV_SREG_MEM);
}
selector = LOAD_RM16(modrm);
CYCLES(CYCLES_MOV_REG_SREG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,2);
selector = READ16(ea);
CYCLES(CYCLES_MOV_MEM_SREG);
}
UINT32 eas, ead;
UINT8 v;
if( cpustate->segment_prefix ) {
- eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
} else {
- eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
}
- ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1 );
+ ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1, 1 );
v = READ8(eas);
WRITE8(ead, v);
BUMP_SI(1);
STORE_RM8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
src = LOAD_REG8(modrm);
dst = READ8(ea);
dst = OR8(dst, src);
STORE_REG8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,1);
src = READ8(ea);
dst = LOAD_REG8(modrm);
dst = OR8(dst, src);
STORE_RM16(modrm, dst);
}
} else {
- UINT32 ea = GetEA( modrm,1);
+ UINT32 ea = GetEA( modrm,1,2);
src = LOAD_REG16(modrm);
dst = READ16( ea);
if( (dst&0x3) < (src&0x3) ) {
UINT16 vw;
UINT32 vd;
- ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1 );
+ ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1, size );
switch(size) {
case 1:
UINT32 vd;
if( cpustate->segment_prefix ) {
- eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, size );
} else {
- eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, size );
}
switch(size) {
if( cpustate->segment_prefix ) {
// FIXME: the following does not work if both address override and segment override are used
- i386_translate( cpustate->segment_override, cpustate->sreg[cpustate->segment_prefix].d ? REG32(ESI) : REG16(SI), -1 );
+ i386_translate( cpustate->segment_override, cpustate->sreg[cpustate->segment_prefix].d ? REG32(ESI) : REG16(SI), -1, 1 );
} else {
//eas =
- i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), -1 );
+ i386_translate( DS, cpustate->address_size ? REG32(ESI) : REG16(SI), -1, 1 );
}
- i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), -1 );
+ i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), -1, 1 );
switch(opcode)
{
STORE_RM8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
src = LOAD_REG8(modrm);
dst = READ8(ea);
dst = SBB8( dst, src, cpustate->CF);
STORE_REG8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,1);
src = READ8(ea);
dst = LOAD_REG8(modrm);
dst = SBB8( dst, src, cpustate->CF);
{
UINT32 eas;
UINT8 src, dst;
- eas = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0 );
+ eas = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0 , 1);
src = READ8(eas);
dst = REG8(AL);
SUB8(dst, src);
STORE_RM8(modrm, value);
CYCLES(CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
WRITE8(ea, value);
CYCLES(CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
WRITE8(ea, value);
CYCLES(CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
WRITE8(ea, value);
CYCLES(CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
WRITE8(ea, value);
CYCLES(CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
WRITE8(ea, value);
CYCLES(CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
WRITE8(ea, value);
CYCLES(CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
WRITE8(ea, value);
CYCLES(CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
WRITE8(ea, value);
CYCLES(CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
WRITE8(ea, value);
CYCLES(CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
WRITE8(ea, value);
CYCLES(CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
WRITE8(ea, value);
CYCLES(CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
WRITE8(ea, value);
CYCLES(CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
WRITE8(ea, value);
CYCLES(CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
WRITE8(ea, value);
CYCLES(CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
WRITE8(ea, value);
CYCLES(CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
WRITE8(ea, value);
CYCLES(CYCLES_SETCC_MEM);
}
void I386_OPS_BASE::I386OP(stosb)() // Opcode 0xaa
{
UINT32 ead;
- ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1 );
+ ead = i386_translate( ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1, 1 );
WRITE8(ead, REG8(AL));
BUMP_DI(1);
CYCLES(CYCLES_STOS);
STORE_RM8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
src = LOAD_REG8(modrm);
dst = READ8(ea);
dst = SUB8(dst, src);
STORE_REG8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,1);
src = READ8(ea);
dst = LOAD_REG8(modrm);
dst = SUB8(dst, src);
cpustate->OF = 0;
CYCLES(CYCLES_TEST_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,1);
src = LOAD_REG8(modrm);
dst = READ8(ea);
dst = src & dst;
STORE_RM8(modrm, dst);
CYCLES(CYCLES_XCHG_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
UINT8 src = READ8(ea);
UINT8 dst = LOAD_REG8(modrm);
WRITE8(ea, dst);
STORE_RM8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
src = LOAD_REG8(modrm);
dst = READ8(ea);
dst = XOR8(dst, src);
STORE_REG8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,1);
src = READ8(ea);
dst = LOAD_REG8(modrm);
dst = XOR8(dst, src);
STORE_RM8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0,1);
dst = READ8(ea);
src = FETCH();
dst = ADD8(dst, src);
STORE_RM8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,1);
dst = READ8(ea);
src = FETCH();
dst = OR8(dst, src);
STORE_RM8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,1);
dst = READ8(ea);
src = FETCH();
dst = ADC8( dst, src, cpustate->CF);
STORE_RM8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,1);
dst = READ8(ea);
src = FETCH();
dst = SBB8( dst, src, cpustate->CF);
STORE_RM8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,1);
dst = READ8(ea);
src = FETCH();
dst = AND8(dst, src);
STORE_RM8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,1);
dst = READ8(ea);
src = FETCH();
dst = SUB8(dst, src);
STORE_RM8(modrm, dst);
CYCLES(CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm,1,1);
dst = READ8(ea);
src = FETCH();
dst = XOR8(dst, src);
SUB8(dst, src);
CYCLES(CYCLES_CMP_REG_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm,0,1);
dst = READ8(ea);
src = FETCH();
SUB8(dst, src);
dst = i386_shift_rotate8( modrm, dst, shift);
STORE_RM8(modrm, dst);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
dst = READ8(ea);
shift = FETCH() & 0x1f;
dst = i386_shift_rotate8( modrm, dst, shift);
dst = i386_shift_rotate8( modrm, dst, 1);
STORE_RM8(modrm, dst);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
dst = READ8(ea);
dst = i386_shift_rotate8( modrm, dst, 1);
WRITE8(ea, dst);
dst = i386_shift_rotate8( modrm, dst, REG8(CL));
STORE_RM8(modrm, dst);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
dst = READ8(ea);
dst = i386_shift_rotate8( modrm, dst, REG8(CL));
WRITE8(ea, dst);
SetSZPF8(dst);
CYCLES(CYCLES_TEST_IMM_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,1);
UINT8 dst = READ8(ea);
UINT8 src = FETCH();
dst &= src;
STORE_RM8(modrm, dst);
CYCLES(CYCLES_NOT_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
UINT8 dst = READ8(ea);
dst = ~dst;
WRITE8(ea, dst);
STORE_RM8(modrm, dst);
CYCLES(CYCLES_NEG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
UINT8 dst = READ8(ea);
dst = SUB8( 0, dst );
WRITE8(ea, dst);
src = LOAD_RM8(modrm);
CYCLES(CYCLES_MUL8_ACC_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,1);
src = READ8(ea);
CYCLES(CYCLES_MUL8_ACC_MEM); /* TODO: Correct multiply timing */
}
src = (INT16)(INT8)LOAD_RM8(modrm);
CYCLES(CYCLES_IMUL8_ACC_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,1);
src = (INT16)(INT8)READ8(ea);
CYCLES(CYCLES_IMUL8_ACC_MEM); /* TODO: Correct multiply timing */
}
src = LOAD_RM8(modrm);
CYCLES(CYCLES_DIV8_ACC_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,1);
src = READ8(ea);
CYCLES(CYCLES_DIV8_ACC_MEM);
}
src = LOAD_RM8(modrm);
CYCLES(CYCLES_IDIV8_ACC_REG);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,1);
src = READ8(ea);
CYCLES(CYCLES_IDIV8_ACC_MEM);
}
STORE_RM8(modrm, dst);
CYCLES(CYCLES_INC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
UINT8 dst = READ8(ea);
dst = INC8(dst);
WRITE8(ea, dst);
STORE_RM8(modrm, dst);
CYCLES(CYCLES_DEC_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm,1,1);
UINT8 dst = READ8(ea);
dst = DEC8(dst);
WRITE8(ea, dst);
if( modrm >= 0xc0 ) {
value = LOAD_RM8(modrm);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm,0,1);
value = READ8(ea);
}
if( cpustate->operand_size ) {
cpustate->ext = 1;
}
-void I386_OPS_BASE::I386_OPS_BASE::I386OP(int)() // Opcode 0xcd
+void I386_OPS_BASE::I386OP(int)() // Opcode 0xcd
{
int interrupt = FETCH();
CYCLES(CYCLES_INT);
UINT8 modrm = FETCH();
if(modrm < 0xc0)
{
- i386_escape_ea = GetEA(modrm,0);
+ i386_escape_ea = GetEA(modrm,0,1);
}
CYCLES(3); // TODO: confirm this
(void) LOAD_RM8(modrm);
{
if(PROTECTED_MODE && (cpustate->CPL != 0))
FAULT(FAULT_GP,0)
- UINT32 ea = i386_translate(ES, REG32(EDI), 0);
+ UINT32 ea = i386_translate(ES, REG32(EDI), 0, 204);
cpustate->cr[0] = READ32(ea) & 0xfffeffff; // wp not supported on 386
set_flags(READ32(ea + 0x04));
cpustate->eip = READ32( ea + 0x08);
if( cpustate->segment_prefix ) {
if(!cpustate->address_size)
{
- ea = i386_translate( cpustate->segment_override, REG16(BX) + REG8(AL), 0 );
+ ea = i386_translate( cpustate->segment_override, REG16(BX) + REG8(AL), 0, 1);
}
else
{
- ea = i386_translate( cpustate->segment_override, REG32(EBX) + REG8(AL), 0 );
+ ea = i386_translate( cpustate->segment_override, REG32(EBX) + REG8(AL), 0, 1);
}
} else {
if(!cpustate->address_size)
{
- ea = i386_translate( DS, REG16(BX) + REG8(AL), 0 );
+ ea = i386_translate( DS, REG16(BX) + REG8(AL), 0, 1);
}
else
{
- ea = i386_translate( DS, REG32(EBX) + REG8(AL), 0 );
+ ea = i386_translate( DS, REG32(EBX) + REG8(AL), 0, 1);
}
}
REG8(AL) = READ8(ea);
CYCLES(CYCLES_XLAT);
}
+#endif
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Phil Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
#ifndef __LIB_I386_OPS_OPS_H__
#define __LIB_I386_OPS_OPS_H__
class I386_OPS_BASE;
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
#pragma once
#ifndef __LIB_I386_PRIV_H__
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
// Intel 486+ specific opcodes
#include "./i386_opdef.h"
}
} else {
// TODO: Check write if needed
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 1);
UINT8 dst = READ8(ea);
UINT8 src = LOAD_REG8(modrm);
CYCLES(CYCLES_CMPXCHG_REG_REG_F);
}
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
UINT16 dst = READ16(ea);
UINT16 src = LOAD_REG16(modrm);
CYCLES(CYCLES_CMPXCHG_REG_REG_F);
}
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
UINT32 dst = READ32(ea);
UINT32 src = LOAD_REG32(modrm);
STORE_RM8(modrm, dst + src);
CYCLES(CYCLES_XADD_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm, 1, 1);
UINT8 dst = READ8(ea);
UINT8 src = LOAD_REG8(modrm);
WRITE8(ea, dst + src);
STORE_RM16(modrm, dst + src);
CYCLES(CYCLES_XADD_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm, 1, 2);
UINT16 dst = READ16(ea);
UINT16 src = LOAD_REG16(modrm);
WRITE16(ea, dst + src);
STORE_RM32(modrm, dst + src);
CYCLES(CYCLES_XADD_REG_REG);
} else {
- UINT32 ea = GetEA(modrm,1);
+ UINT32 ea = GetEA(modrm, 1, 4);
UINT32 dst = READ32(ea);
UINT32 src = LOAD_REG32(modrm);
WRITE32(ea, dst + src);
{
if( modrm >= 0xc0 ) {
address = LOAD_RM16(modrm);
- ea = i386_translate( CS, address, 1 );
+ ea = i386_translate( CS, address, 1, 6 );
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm, 1, 6);
}
WRITE16(ea, cpustate->gdtr.limit);
WRITE32(ea + 2, cpustate->gdtr.base & 0xffffff);
if (modrm >= 0xc0)
{
address = LOAD_RM16(modrm);
- ea = i386_translate( CS, address, 1 );
+ ea = i386_translate( CS, address, 1, 6 );
}
else
{
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm, 1, 6);
}
WRITE16(ea, cpustate->idtr.limit);
WRITE32(ea + 2, cpustate->idtr.base & 0xffffff);
FAULT(FAULT_GP,0)
if( modrm >= 0xc0 ) {
address = LOAD_RM16(modrm);
- ea = i386_translate( CS, address, 0 );
+ ea = i386_translate( CS, address, 0, 6 );
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm, 0, 6);
}
cpustate->gdtr.limit = READ16(ea);
cpustate->gdtr.base = READ32(ea + 2) & 0xffffff;
FAULT(FAULT_GP,0)
if( modrm >= 0xc0 ) {
address = LOAD_RM16(modrm);
- ea = i386_translate( CS, address, 0 );
+ ea = i386_translate( CS, address, 0, 6 );
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm, 0, 6);
}
cpustate->idtr.limit = READ16(ea);
cpustate->idtr.base = READ32(ea + 2) & 0xffffff;
STORE_RM16(modrm, cpustate->cr[0]);
CYCLES(CYCLES_SMSW_REG);
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm, 1, 2);
WRITE16(ea, cpustate->cr[0]);
CYCLES(CYCLES_SMSW_MEM);
}
b = LOAD_RM16(modrm);
CYCLES(CYCLES_LMSW_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm, 0, 2);
CYCLES(CYCLES_LMSW_MEM);
b = READ16(ea);
}
logerror("i486: invlpg with modrm %02X\n", modrm);
FAULT(FAULT_UD,0)
}
- ea = GetEA(modrm,-1);
+ ea = GetEA(modrm, -1, 1);
CYCLES(25); // TODO: add to cycles.h
vtlb_flush_address(cpustate->vtlb, ea);
break;
{
if( modrm >= 0xc0 ) {
address = LOAD_RM32(modrm);
- ea = i386_translate( CS, address, 1 );
+ ea = i386_translate( CS, address, 1, 6 );
} else {
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm, 1, 6);
}
WRITE16(ea, cpustate->gdtr.limit);
WRITE32(ea + 2, cpustate->gdtr.base);
if (modrm >= 0xc0)
{
address = LOAD_RM32(modrm);
- ea = i386_translate( CS, address, 1 );
+ ea = i386_translate( CS, address, 1, 6 );
}
else
{
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm, 1, 6);
}
WRITE16(ea, cpustate->idtr.limit);
WRITE32(ea + 2, cpustate->idtr.base);
FAULT(FAULT_GP,0)
if( modrm >= 0xc0 ) {
address = LOAD_RM32(modrm);
- ea = i386_translate( CS, address, 0 );
+ ea = i386_translate( CS, address, 0, 6 );
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm, 0, 6);
}
cpustate->gdtr.limit = READ16(ea);
cpustate->gdtr.base = READ32(ea + 2);
FAULT(FAULT_GP,0)
if( modrm >= 0xc0 ) {
address = LOAD_RM32(modrm);
- ea = i386_translate( CS, address, 0 );
+ ea = i386_translate( CS, address, 0, 6 );
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm, 0, 6);
}
cpustate->idtr.limit = READ16(ea);
cpustate->idtr.base = READ32(ea + 2);
CYCLES(CYCLES_SMSW_REG);
} else {
/* always 16-bit memory operand */
- ea = GetEA(modrm,1);
+ ea = GetEA(modrm, 1, 2);
WRITE16(ea, cpustate->cr[0]);
CYCLES(CYCLES_SMSW_MEM);
}
b = LOAD_RM16(modrm);
CYCLES(CYCLES_LMSW_REG);
} else {
- ea = GetEA(modrm,0);
+ ea = GetEA(modrm, 0, 2);
CYCLES(CYCLES_LMSW_MEM);
b = READ16(ea);
}
logerror("i486: invlpg with modrm %02X\n", modrm);
FAULT(FAULT_UD,0)
}
- ea = GetEA(modrm,-1);
+ ea = GetEA(modrm, -1, 1);
CYCLES(25); // TODO: add to cycles.h
vtlb_flush_address(cpustate->vtlb, ea);
break;
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
// Pentium+ specific opcodes
#include "./i386_opdef.h"
void I386_OPS_BASE::PENTIUMOP(prefetch_m8)() // Opcode 0x0f 18
{
UINT8 modrm = FETCH();
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 1);
CYCLES(1+(ea & 1)); // TODO: correct cycle count
}
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
if (cpustate->OF == 1)
{
src = READ16(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
if (cpustate->OF == 1)
{
src = READ32(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
if (cpustate->OF == 0)
{
src = READ16(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
if (cpustate->OF == 0)
{
src = READ32(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
if (cpustate->CF == 1)
{
src = READ16(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
if (cpustate->CF == 1)
{
src = READ32(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
if (cpustate->CF == 0)
{
src = READ16(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
if (cpustate->CF == 0)
{
src = READ32(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
if (cpustate->ZF == 1)
{
src = READ16(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
if (cpustate->ZF == 1)
{
src = READ32(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
if (cpustate->ZF == 0)
{
src = READ16(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
if (cpustate->ZF == 0)
{
src = READ32(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
if ((cpustate->CF == 1) || (cpustate->ZF == 1))
{
src = READ16(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
if ((cpustate->CF == 1) || (cpustate->ZF == 1))
{
src = READ32(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
if ((cpustate->CF == 0) && (cpustate->ZF == 0))
{
src = READ16(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
if ((cpustate->CF == 0) && (cpustate->ZF == 0))
{
src = READ32(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
if (cpustate->SF == 1)
{
src = READ16(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
if (cpustate->SF == 1)
{
src = READ32(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
if (cpustate->SF == 0)
{
src = READ16(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
if (cpustate->SF == 0)
{
src = READ32(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
if (cpustate->PF == 1)
{
src = READ16(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
if (cpustate->PF == 1)
{
src = READ32(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
if (cpustate->PF == 0)
{
src = READ16(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
if (cpustate->PF == 0)
{
src = READ32(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
if (cpustate->SF != cpustate->OF)
{
src = READ16(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
if (cpustate->SF != cpustate->OF)
{
src = READ32(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
if (cpustate->SF == cpustate->OF)
{
src = READ16(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
if (cpustate->SF == cpustate->OF)
{
src = READ32(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
if ((cpustate->ZF == 1) || (cpustate->SF != cpustate->OF))
{
src = READ16(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
if ((cpustate->ZF == 1) || (cpustate->SF != cpustate->OF))
{
src = READ32(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
if ((cpustate->ZF == 0) && (cpustate->SF == cpustate->OF))
{
src = READ16(ea);
}
else
{
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
if ((cpustate->ZF == 0) && (cpustate->SF == cpustate->OF))
{
src = READ32(ea);
CYCLES(1); // TODO: correct cycle count
} else {
// since cache is not implemented
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 2);
WRITE16(ea,LOAD_RM16(modrm));
CYCLES(1); // TODO: correct cycle count
}
CYCLES(1); // TODO: correct cycle count
} else {
// since cache is not implemented
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
WRITE32(ea,LOAD_RM32(modrm));
CYCLES(1); // TODO: correct cycle count
}
if( modm >= 0xc0 ) {
report_invalid_modrm( "cmpxchg8b_m64", modm);
} else {
- UINT32 ea = GetEA(modm, 0);
+ UINT32 ea = GetEA(modm, 0, 8);
UINT64 value = READ64( ea);
UINT64 edx_eax = (((UINT64) REG32(EDX)) << 32) | REG32(EAX);
UINT64 ecx_ebx = (((UINT64) REG32(ECX)) << 32) | REG32(EBX);
CYCLES(1); // unsupported
} else {
// since cache is not implemented
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
WRITEMMX( ea, MMX((modrm >> 3) & 0x7));
CYCLES(1); // TODO: correct cycle count
}
{
int s,m,n;
UINT8 modm = FETCH();
- UINT32 ea = GetEA(7, 0); // ds:di/edi/rdi register
+ UINT32 ea = GetEA(7, 0, 8); // ds:di/edi/rdi register
MMXPROLOG();
s=(modm >> 3) & 7;
m=modm & 7;
{
int s,m,n;
UINT8 modm = FETCH();
- UINT32 ea = GetEA(7, 0); // ds:di/edi/rdi register
+ UINT32 ea = GetEA(7, 0, 16); // ds:di/edi/rdi register
s=(modm >> 3) & 7;
m=modm & 7;
for (n=0;n < 16;n++)
if( modrm >= 0xc0 ) {
src = LOAD_RM16(modrm);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 2);
src = READ16(ea);
}
count=0;
if( modrm >= 0xc0 ) {
src = LOAD_RM32(modrm);
} else {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 4);
src = READ32(ea);
}
count=0;
MMX((modrm >> 3) & 0x7).w[3]=MMX((modrm >> 3) & 0x7).w[3] >> count;
} else {
MMX_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, src);
int count=(int)src.q;
MMX((modrm >> 3) & 0x7).w[0]=MMX((modrm >> 3) & 0x7).w[0] >> count;
MMX((modrm >> 3) & 0x7).d[1]=MMX((modrm >> 3) & 0x7).d[1] >> count;
} else {
MMX_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, src);
int count=(int)src.q;
MMX((modrm >> 3) & 0x7).d[0]=MMX((modrm >> 3) & 0x7).d[0] >> count;
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q >> count;
} else {
MMX_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, src);
int count=(int)src.q;
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q >> count;
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q+MMX(modrm & 7).q;
} else {
MMX_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, src);
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q+src.q;
}
MMX((modrm >> 3) & 0x7).w[3]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[3]*(INT32)MMX(modrm & 7).s[3]) & 0xffff;
} else {
MMX_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, src);
MMX((modrm >> 3) & 0x7).w[0]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[0]*(INT32)src.s[0]) & 0xffff;
MMX((modrm >> 3) & 0x7).w[1]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[1]*(INT32)src.s[1]) & 0xffff;
MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] < MMX(modrm & 7).b[n] ? 0 : MMX((modrm >> 3) & 0x7).b[n]-MMX(modrm & 7).b[n];
} else {
MMX_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, src);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] < src.b[n] ? 0 : MMX((modrm >> 3) & 0x7).b[n]-src.b[n];
MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] < MMX(modrm & 7).w[n] ? 0 : MMX((modrm >> 3) & 0x7).w[n]-MMX(modrm & 7).w[n];
} else {
MMX_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, src);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] < src.w[n] ? 0 : MMX((modrm >> 3) & 0x7).w[n]-src.w[n];
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q & MMX(modrm & 7).q;
} else {
MMX_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, src);
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q & src.q;
}
MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] > (0xff-MMX(modrm & 7).b[n]) ? 0xff : MMX((modrm >> 3) & 0x7).b[n]+MMX(modrm & 7).b[n];
} else {
MMX_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, src);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] > (0xff-src.b[n]) ? 0xff : MMX((modrm >> 3) & 0x7).b[n]+src.b[n];
MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] > (0xffff-MMX(modrm & 7).w[n]) ? 0xffff : MMX((modrm >> 3) & 0x7).w[n]+MMX(modrm & 7).w[n];
} else {
MMX_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, src);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] > (0xffff-src.w[n]) ? 0xffff : MMX((modrm >> 3) & 0x7).w[n]+src.w[n];
MMX((modrm >> 3) & 0x7).q=(~MMX((modrm >> 3) & 0x7).q) & MMX(modrm & 7).q;
} else {
MMX_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, src);
MMX((modrm >> 3) & 0x7).q=(~MMX((modrm >> 3) & 0x7).q) & src.q;
}
MMX((modrm >> 3) & 0x7).s[3]=MMX((modrm >> 3) & 0x7).s[3] >> count;
} else {
MMX_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, src);
int count=(int)src.q;
MMX((modrm >> 3) & 0x7).s[0]=MMX((modrm >> 3) & 0x7).s[0] >> count;
MMX((modrm >> 3) & 0x7).i[1]=MMX((modrm >> 3) & 0x7).i[1] >> count;
} else {
MMX_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, src);
int count=(int)src.q;
MMX((modrm >> 3) & 0x7).i[0]=MMX((modrm >> 3) & 0x7).i[0] >> count;
MMX((modrm >> 3) & 0x7).w[3]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[3]*(INT32)MMX(modrm & 7).s[3]) >> 16;
} else {
MMX_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, src);
MMX((modrm >> 3) & 0x7).w[0]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[0]*(INT32)src.s[0]) >> 16;
MMX((modrm >> 3) & 0x7).w[1]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[1]*(INT32)src.s[1]) >> 16;
MMX((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)MMX((modrm >> 3) & 0x7).c[n] - (INT16)MMX(modrm & 7).c[n]);
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)MMX((modrm >> 3) & 0x7).c[n] - (INT16)s.c[n]);
MMX((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)MMX((modrm >> 3) & 0x7).s[n] - (INT32)MMX(modrm & 7).s[n]);
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)MMX((modrm >> 3) & 0x7).s[n] - (INT32)s.s[n]);
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q | MMX(modrm & 7).q;
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q | s.q;
}
MMX((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)MMX((modrm >> 3) & 0x7).c[n] + (INT16)MMX(modrm & 7).c[n]);
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)MMX((modrm >> 3) & 0x7).c[n] + (INT16)s.c[n]);
MMX((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)MMX((modrm >> 3) & 0x7).s[n] + (INT32)MMX(modrm & 7).s[n]);
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)MMX((modrm >> 3) & 0x7).s[n] + (INT32)s.s[n]);
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q ^ MMX(modrm & 7).q;
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q ^ s.q;
}
MMX((modrm >> 3) & 0x7).w[3]=MMX((modrm >> 3) & 0x7).w[3] << count;
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
int count=(int)s.q;
MMX((modrm >> 3) & 0x7).w[0]=MMX((modrm >> 3) & 0x7).w[0] << count;
MMX((modrm >> 3) & 0x7).d[1]=MMX((modrm >> 3) & 0x7).d[1] << count;
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
int count=(int)s.q;
MMX((modrm >> 3) & 0x7).d[0]=MMX((modrm >> 3) & 0x7).d[0] << count;
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q << count;
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
int count=(int)s.q;
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q << count;
(INT32)MMX((modrm >> 3) & 0x7).s[3]*(INT32)MMX(modrm & 7).s[3];
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
MMX((modrm >> 3) & 0x7).i[0]=(INT32)MMX((modrm >> 3) & 0x7).s[0]*(INT32)s.s[0]+
(INT32)MMX((modrm >> 3) & 0x7).s[1]*(INT32)s.s[1];
MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] - MMX(modrm & 7).b[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] - s.b[n];
MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] - MMX(modrm & 7).w[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] - s.w[n];
MMX((modrm >> 3) & 0x7).d[n]=MMX((modrm >> 3) & 0x7).d[n] - MMX(modrm & 7).d[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (n=0;n < 2;n++)
MMX((modrm >> 3) & 0x7).d[n]=MMX((modrm >> 3) & 0x7).d[n] - s.d[n];
MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] + MMX(modrm & 7).b[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] + s.b[n];
MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] + MMX(modrm & 7).w[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] + s.w[n];
MMX((modrm >> 3) & 0x7).d[n]=MMX((modrm >> 3) & 0x7).d[n] + MMX(modrm & 7).d[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (n=0;n < 2;n++)
MMX((modrm >> 3) & 0x7).d[n]=MMX((modrm >> 3) & 0x7).d[n] + s.d[n];
UINT8 modrm = FETCH();
if( modrm < 0xc0 ) {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 10);
int index = (modrm >> 3) & 7;
int limit;
switch (index)
UINT8 modrm = FETCH();
if( modrm < 0xc0 ) {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 10);
int index = (modrm >> 3) & 7;
UINT16 flags;
UINT32 base;
UINT8 modrm = FETCH();
if( !(modrm & 0xf8) ) {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 10);
UINT32 limit = cpustate->ldtr.limit;
if (cpustate->ldtr.flags & 0x8000) //G bit
UINT8 modrm = FETCH();
if( !(modrm & 0xf8) ) {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 10);
UINT16 flags = READ16(ea + 5);
UINT32 base = (READ32(ea + 2) | 0x00ffffff) | (READ8(ea + 7) << 24);
UINT32 limit = READ16(ea + 0) | ((flags & 3) << 16);
UINT8 modrm = FETCH();
if( !(modrm & 0xf8) ) {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 10);
UINT32 limit = cpustate->task.limit;
if (cpustate->task.flags & 0x8000) //G bit
UINT8 modrm = FETCH();
if( !(modrm & 0xf8) ) {
- UINT32 ea = GetEA(modrm,0);
+ UINT32 ea = GetEA(modrm, 0, 10);
UINT16 flags = READ16(ea + 5);
UINT32 base = (READ32(ea + 2) | 0x00ffffff) | (READ8(ea + 7) << 24);
UINT32 limit = READ16(ea + 0) | ((flags & 3) << 16);
if( modrm >= 0xc0 ) {
MMX((modrm >> 3) & 0x7).d[0]=LOAD_RM32(modrm);
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
MMX((modrm >> 3) & 0x7).d[0]=READ32(ea);
}
MMX((modrm >> 3) & 0x7).d[1]=0;
if( modrm >= 0xc0 ) {
MMX((modrm >> 3) & 0x7).l=MMX(modrm & 0x7).l;
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, MMX((modrm >> 3) & 0x7));
}
CYCLES(1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
STORE_RM32(modrm, MMX((modrm >> 3) & 0x7).d[0]);
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
WRITE32(ea, MMX((modrm >> 3) & 0x7).d[0]);
}
CYCLES(1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
MMX(modrm & 0x7)=MMX((modrm >> 3) & 0x7);
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
WRITEMMX( ea, MMX((modrm >> 3) & 0x7));
}
CYCLES(1); // TODO: correct cycle count
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (c=0;c <= 7;c++)
MMX(d).b[c]=(MMX(d).b[c] == s.b[c]) ? 0xff : 0;
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
MMX(d).w[0]=(MMX(d).w[0] == s.w[0]) ? 0xffff : 0;
MMX(d).w[1]=(MMX(d).w[1] == s.w[1]) ? 0xffff : 0;
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
MMX(d).d[0]=(MMX(d).d[0] == s.d[0]) ? 0xffffffff : 0;
MMX(d).d[1]=(MMX(d).d[1] == s.d[1]) ? 0xffffffff : 0;
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
UINT8 imm8 = FETCH();
READMMX( ea, s);
MMX(d).w[0]=s.w[imm8 & 3];
else {
XMM_REG xd, xs;
int d = (modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
xd.l[0] = XMM(d).l[0];
xs.q[0] = READ64( ea);
for (int n = 0; n < 8; n++) {
else {
XMM_REG xd, xs;
int d = (modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
xd.l[0] = XMM(d).l[0];
xs.q[0] = READ64( ea);
for (int n = 0; n < 4; n++) {
else {
XMM_REG xd, xs;
int d = (modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
xd.l[0] = XMM(d).l[0];
xs.q[0] = READ64( ea);
for (int n = 0; n < 2; n++) {
else {
XMM_REG xd, xs;
int d = (modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
xd.l[0] = XMM(d).l[0];
xs.q[0] = READ64( ea);
XMM(d).q[0] = xd.q[0];
} else {
UINT32 s,t;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
s = READ32(ea);
t=MMX(d).d[0];
MMX(d).b[0]=t & 0xff;
UINT32 s;
UINT16 t;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
s = READ32(ea);
t=MMX(d).w[1];
MMX(d).w[0]=MMX(d).w[0];
} else {
UINT32 s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
s = READ32(ea);
MMX(d).d[0]=MMX(d).d[0];
MMX(d).d[1]=s;
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
MMX(d).c[0]=SaturatedSignedWordToSignedByte(MMX(d).s[0]);
MMX(d).c[1]=SaturatedSignedWordToSignedByte(MMX(d).s[1]);
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (c=0;c <= 7;c++)
MMX(d).b[c]=(MMX(d).c[c] > s.c[c]) ? 0xff : 0;
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (c=0;c <= 3;c++)
MMX(d).w[c]=(MMX(d).s[c] > s.s[c]) ? 0xffff : 0;
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (c=0;c <= 1;c++)
MMX(d).d[c]=(MMX(d).i[c] > s.i[c]) ? 0xffffffff : 0;
} else {
MMX_REG s,t;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
t.q = MMX(d).q;
MMX(d).b[0]=SaturatedSignedWordToUnsignedByte(t.s[0]);
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
MMX(d).b[0]=MMX(d).b[4];
MMX(d).b[1]=s.b[4];
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
MMX(d).w[0]=MMX(d).w[2];
MMX(d).w[1]=s.w[2];
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
MMX(d).d[0]=MMX(d).d[1];
MMX(d).d[1]=s.d[1];
MMX_REG s;
INT32 t1, t2;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
t1 = MMX(d).i[0];
t2 = MMX(d).i[1];
switch ( (modm & 0x38) >> 3 )
{
case 2: // ldmxcsr m32
- ea = GetEA(modm, 0);
+ ea = GetEA(modm, 0, 4);
cpustate->mxcsr = READ32(ea);
break;
case 3: // stmxcsr m32
- ea = GetEA(modm, 0);
+ ea = GetEA(modm, 0, 4);
WRITE32(ea, cpustate->mxcsr);
break;
case 7: // clflush m8
XMM((modrm >> 3) & 0x7).i[3]=(INT32)XMM(modrm & 0x7).f[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).i[0]=(INT32)src.f[0];
XMM((modrm >> 3) & 0x7).i[1]=(INT32)src.f[1];
XMM((modrm >> 3) & 0x7).f64[0] = XMM(modrm & 0x7).f[0];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
s.d[0] = READ32(ea);
XMM((modrm >> 3) & 0x7).f64[0] = s.f[0];
}
src = (INT32)XMM(modrm & 0x7).f[0^NATIVE_ENDIAN_VALUE_LE_BE(0,1)];
} else { // otherwise is a memory address
XMM_REG t;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
t.d[0] = READ32(ea);
src = (INT32)t.f[0];
}
src = (INT32)XMM(modrm & 0x7).f[0];
} else {
XMM_REG t;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
t.d[0] = READ32(ea);
src = (INT32)t.f[0];
}
if( modrm >= 0xc0 ) {
XMM((modrm >> 3) & 0x7).f[0] = (INT32)LOAD_RM32(modrm);
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
XMM((modrm >> 3) & 0x7).f[0] = (INT32)READ32(ea);
}
CYCLES(1); // TODO: correct cycle count
XMM((modrm >> 3) & 0x7).f[1] = (float)MMX(modrm & 0x7).i[1];
} else {
MMX_REG r;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, r);
XMM((modrm >> 3) & 0x7).f[0] = (float)r.i[0];
XMM((modrm >> 3) & 0x7).f[1] = (float)r.i[1];
MMX((modrm >> 3) & 0x7).i[1] = XMM(modrm & 0x7).f[1];
} else {
XMM_REG r;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, r);
XMM((modrm >> 3) & 0x7).i[0] = r.f[0];
XMM((modrm >> 3) & 0x7).i[1] = r.f[1];
MMX((modrm >> 3) & 0x7).i[1] = XMM(modrm & 0x7).f[1];
} else {
XMM_REG r;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, r);
XMM((modrm >> 3) & 0x7).i[0] = r.f[0];
XMM((modrm >> 3) & 0x7).i[1] = r.f[1];
XMM((modrm >> 3) & 0x7).f64[1] = (double)XMM(modrm & 0x7).f[1];
} else {
MMX_REG r;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, r);
XMM((modrm >> 3) & 0x7).f64[0] = (double)r.f[0];
XMM((modrm >> 3) & 0x7).f64[1] = (double)r.f[1];
XMM((modrm >> 3) & 0x7).f[3] = (float)XMM(modrm & 0x7).i[3];
} else {
XMM_REG r;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, r);
XMM((modrm >> 3) & 0x7).f[0] = (float)r.i[0];
XMM((modrm >> 3) & 0x7).f[1] = (float)r.i[1];
XMM((modrm >> 3) & 0x7).f64[1] = (double)XMM(modrm & 0x7).i[1];
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
XMM((modrm >> 3) & 0x7).f64[0] = (double)s.i[0];
XMM((modrm >> 3) & 0x7).f64[1] = (double)s.i[1];
if( modrm >= 0xc0 ) {
XMM((modrm >> 3) & 0x7).d[0] = XMM(modrm & 0x7).d[0];
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
XMM((modrm >> 3) & 0x7).d[0] = READ32(ea);
}
CYCLES(1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
XMM(modrm & 0x7).d[0] = XMM((modrm >> 3) & 0x7).d[0];
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
WRITE32(ea, XMM((modrm >> 3) & 0x7).d[0]);
}
CYCLES(1); // TODO: correct cycle count
XMM((modrm >> 3) & 0x7).d[3] = XMM(modrm & 0x7).d[2];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).d[0] = src.d[0];
XMM((modrm >> 3) & 0x7).d[1] = src.d[0];
XMM((modrm >> 3) & 0x7).d[3] = XMM(modrm & 0x7).d[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).d[0] = src.d[1];
XMM((modrm >> 3) & 0x7).d[1] = src.d[1];
if( modrm >= 0xc0 ) {
XMM((modrm >> 3) & 0x7) = XMM(modrm & 0x7);
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
XMM(modrm & 0x7) = XMM((modrm >> 3) & 0x7);
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
WRITEXMM( ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
XMM((modrm >> 3) & 0x7) = XMM(modrm & 0x7);
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, XMM((modrm >> 3) & 0x7)); // address does not need to be 16-byte aligned
}
CYCLES(1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
XMM((modrm >> 3) & 0x7) = XMM(modrm & 0x7);
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, XMM((modrm >> 3) & 0x7)); // address does not need to be 16-byte aligned
}
CYCLES(1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
XMM(modrm & 0x7) = XMM((modrm >> 3) & 0x7);
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
WRITEXMM( ea, XMM((modrm >> 3) & 0x7)); // address does not need to be 16-byte aligned
}
CYCLES(1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
XMM(modrm & 0x7) = XMM((modrm >> 3) & 0x7);
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
WRITEXMM( ea, XMM((modrm >> 3) & 0x7)); // address does not need to be 16-byte aligned
}
CYCLES(1); // TODO: correct cycle count
CYCLES(1); // TODO: correct cycle count
} else {
// MOVLPS opcode
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READXMM_LO64( ea, XMM((modrm >> 3) & 0x7));
CYCLES(1); // TODO: correct cycle count
}
CYCLES(1); // TODO: correct cycle count
} else {
// MOVLPS opcode
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READXMM_LO64( ea, XMM((modrm >> 3) & 0x7));
CYCLES(1); // TODO: correct cycle count
}
// unsupported by cpu
CYCLES(1); // TODO: correct cycle count
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
WRITEXMM_LO64( ea, XMM((modrm >> 3) & 0x7));
CYCLES(1); // TODO: correct cycle count
}
// unsupported by cpu
CYCLES(1); // TODO: correct cycle count
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
WRITEXMM_LO64( ea, XMM((modrm >> 3) & 0x7));
CYCLES(1); // TODO: correct cycle count
}
CYCLES(1); // TODO: correct cycle count
} else {
// MOVHPS opcode
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READXMM_HI64( ea, XMM((modrm >> 3) & 0x7));
CYCLES(1); // TODO: correct cycle count
}
CYCLES(1); // TODO: correct cycle count
} else {
// MOVHPS opcode
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READXMM_HI64( ea, XMM((modrm >> 3) & 0x7));
CYCLES(1); // TODO: correct cycle count
}
// unsupported by cpu
CYCLES(1); // TODO: correct cycle count
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
WRITEXMM_HI64( ea, XMM((modrm >> 3) & 0x7));
CYCLES(1); // TODO: correct cycle count
}
// unsupported by cpu
CYCLES(1); // TODO: correct cycle count
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
WRITEXMM_HI64( ea, XMM((modrm >> 3) & 0x7));
CYCLES(1); // TODO: correct cycle count
}
CYCLES(1); // TODO: correct cycle count
} else {
// since cache is not implemented
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
WRITEXMM( ea, XMM((modrm >> 3) & 0x7));
CYCLES(1); // TODO: correct cycle count
}
XMM((modrm >> 3) & 0x7).q[0] = XMM(modrm & 0x7).q[0];
XMM((modrm >> 3) & 0x7).q[1] = XMM(modrm & 0x7).q[1];
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(1); // TODO: correct cycle count
XMM(modrm & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0];
XMM(modrm & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1];
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
WRITEXMM( ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(1); // TODO: correct cycle count
XMM((modrm >> 3) & 0x7).d[0] = LOAD_RM32(modrm);
}
else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
XMM((modrm >> 3) & 0x7).d[0] = READ32(ea);
}
XMM((modrm >> 3) & 0x7).d[1] = 0;
XMM((modrm >> 3) & 0x7).q[1] = XMM(modrm & 0x7).q[1];
}
else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(1); // TODO: correct cycle count
XMM((modrm >> 3) & 0x7).q[0] = XMM(modrm & 0x7).q[0];
XMM((modrm >> 3) & 0x7).q[1] = 0;
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
XMM((modrm >> 3) & 0x7).q[0] = READ64( ea);
XMM((modrm >> 3) & 0x7).q[1] = 0;
}
STORE_RM32(modrm, XMM((modrm >> 3) & 0x7).d[0]);
}
else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
WRITE32(ea, XMM((modrm >> 3) & 0x7).d[0]);
}
CYCLES(1); // TODO: correct cycle count
XMM(modrm & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1];
}
else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
WRITEXMM( ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(1); // TODO: correct cycle count
XMM((modrm >> 3) & 0x7).d[3] = XMM((modrm >> 3) & 0x7).d[3] ^ XMM(modrm & 0x7).d[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).d[0] = XMM((modrm >> 3) & 0x7).d[0] ^ src.d[0];
XMM((modrm >> 3) & 0x7).d[1] = XMM((modrm >> 3) & 0x7).d[1] ^ src.d[1];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] ^ XMM(modrm & 0x7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] ^ src.q[0];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] ^ src.q[1];
XMM((modrm >> 3) & 0x7).f[3] = XMM((modrm >> 3) & 0x7).f[3] + XMM(modrm & 0x7).f[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] + src.f[0];
XMM((modrm >> 3) & 0x7).f[1] = XMM((modrm >> 3) & 0x7).f[1] + src.f[1];
XMM((modrm >> 3) & 0x7).f[3] = sqrt(XMM(modrm & 0x7).f[3]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f[0] = sqrt(src.f[0]);
XMM((modrm >> 3) & 0x7).f[1] = sqrt(src.f[1]);
XMM((modrm >> 3) & 0x7).f[3] = 1.0 / sqrt(XMM(modrm & 0x7).f[3]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f[0] = 1.0 / sqrt(src.f[0]);
XMM((modrm >> 3) & 0x7).f[1] = 1.0 / sqrt(src.f[1]);
XMM((modrm >> 3) & 0x7).f[3] = 1.0f / XMM(modrm & 0x7).f[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f[0] = 1.0f / src.f[0];
XMM((modrm >> 3) & 0x7).f[1] = 1.0f / src.f[1];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] & XMM(modrm & 0x7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] & src.q[0];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] & src.q[1];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] & XMM(modrm & 0x7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] & src.q[0];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] & src.q[1];
XMM((modrm >> 3) & 0x7).q[1] = ~(XMM((modrm >> 3) & 0x7).q[1]) & XMM(modrm & 0x7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).q[0] = ~(XMM((modrm >> 3) & 0x7).q[0]) & src.q[0];
XMM((modrm >> 3) & 0x7).q[1] = ~(XMM((modrm >> 3) & 0x7).q[1]) & src.q[1];
XMM((modrm >> 3) & 0x7).q[1] = ~(XMM((modrm >> 3) & 0x7).q[1]) & XMM(modrm & 0x7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).q[0] = ~(XMM((modrm >> 3) & 0x7).q[0]) & src.q[0];
XMM((modrm >> 3) & 0x7).q[1] = ~(XMM((modrm >> 3) & 0x7).q[1]) & src.q[1];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] | XMM(modrm & 0x7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] | src.q[0];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] | src.q[1];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] | XMM(modrm & 0x7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] | src.q[0];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] | src.q[1];
XMM((modrm >> 3) & 0x7).f[3] = XMM((modrm >> 3) & 0x7).f[3] * XMM(modrm & 0x7).f[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] * src.f[0];
XMM((modrm >> 3) & 0x7).f[1] = XMM((modrm >> 3) & 0x7).f[1] * src.f[1];
XMM((modrm >> 3) & 0x7).f[3] = XMM((modrm >> 3) & 0x7).f[3] - XMM(modrm & 0x7).f[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] - src.f[0];
XMM((modrm >> 3) & 0x7).f[1] = XMM((modrm >> 3) & 0x7).f[1] - src.f[1];
XMM((modrm >> 3) & 0x7).f[3] = sse_min_single(XMM((modrm >> 3) & 0x7).f[3], XMM(modrm & 0x7).f[3]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f[0] = sse_min_single(XMM((modrm >> 3) & 0x7).f[0], src.f[0]);
XMM((modrm >> 3) & 0x7).f[1] = sse_min_single(XMM((modrm >> 3) & 0x7).f[1], src.f[1]);
XMM((modrm >> 3) & 0x7).f[3] = XMM((modrm >> 3) & 0x7).f[3] / XMM(modrm & 0x7).f[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] / src.f[0];
XMM((modrm >> 3) & 0x7).f[1] = XMM((modrm >> 3) & 0x7).f[1] / src.f[1];
XMM((modrm >> 3) & 0x7).f[3] = sse_max_single(XMM((modrm >> 3) & 0x7).f[3], XMM(modrm & 0x7).f[3]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f[0] = sse_max_single(XMM((modrm >> 3) & 0x7).f[0], src.f[0]);
XMM((modrm >> 3) & 0x7).f[1] = sse_max_single(XMM((modrm >> 3) & 0x7).f[1], src.f[1]);
XMM((modrm >> 3) & 0x7).f[0] = sse_max_single(XMM((modrm >> 3) & 0x7).f[0], XMM(modrm & 0x7).f[0]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
src.d[0]=READ32(ea);
XMM((modrm >> 3) & 0x7).f[0] = sse_max_single(XMM((modrm >> 3) & 0x7).f[0], src.f[0]);
}
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] + XMM(modrm & 0x7).f[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] + src.f[0];
}
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] - XMM(modrm & 0x7).f[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] - src.f[0];
}
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] * XMM(modrm & 0x7).f[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] * src.f[0];
}
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] / XMM(modrm & 0x7).f[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] / src.f[0];
}
XMM((modrm >> 3) & 0x7).f[0] = 1.0f / XMM(modrm & 0x7).f[0];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
s.d[0]=READ32(ea);
XMM((modrm >> 3) & 0x7).f[0] = 1.0f / s.f[0];
}
XMM((modrm >> 3) & 0x7).f[0] = sqrt(XMM(modrm & 0x7).f[0]);
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
s.d[0]=READ32(ea);
XMM((modrm >> 3) & 0x7).f[0] = sqrt(s.f[0]);
}
XMM((modrm >> 3) & 0x7).f[0] = 1.0 / sqrt(XMM(modrm & 0x7).f[0]);
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
s.d[0]=READ32(ea);
XMM((modrm >> 3) & 0x7).f[0] = 1.0 / sqrt(s.f[0]);
}
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] < XMM(modrm & 0x7).f[0] ? XMM((modrm >> 3) & 0x7).f[0] : XMM(modrm & 0x7).f[0];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
s.d[0] = READ32(ea);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] < s.f[0] ? XMM((modrm >> 3) & 0x7).f[0] : s.f[0];
}
b = XMM(modrm & 0x7).d[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
a = XMM((modrm >> 3) & 0x7).d[0];
b = src.d[0];
b = XMM(modrm & 0x7).q[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
a = XMM((modrm >> 3) & 0x7).q[0];
b = src.q[0];
b = XMM(modrm & 0x7).d[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
a = XMM((modrm >> 3) & 0x7).d[0];
b = src.d[0];
b = XMM(modrm & 0x7).q[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
a = XMM((modrm >> 3) & 0x7).q[0];
b = src.q[0];
} else {
UINT32 t1,t2;
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
t1=XMM(d).d[m1];
t2=XMM(d).d[m2];
} else {
UINT64 t1;
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
t1=XMM(d).q[m1];
XMM(d).q[0]=t1;
XMM(d).d[0]=t4;
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
t2 = XMM(d).d[1];
XMM(d).d[3]=src.d[1];
XMM(d).q[0]=XMM(d).q[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM(d).q[1]=src.q[0];
XMM(d).q[0]=XMM(d).q[0];
XMM(d).d[3]=t4;
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
t1 = XMM(d).d[2];
t2 = XMM(d).d[3];
XMM(d).q[1]=XMM(s).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM(d).q[0]=XMM(d).q[1];
XMM(d).q[1]=src.q[1];
} else {
int d;
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
UINT8 imm8 = FETCH();
READXMM( ea, s);
d=(modrm >> 3) & 0x7;
} else {
int d;
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
UINT8 imm8 = FETCH();
READXMM( ea, s);
d=(modrm >> 3) & 0x7;
} else {
int d;
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
UINT8 imm8 = FETCH();
s.d[0]=READ32(ea);
d=(modrm >> 3) & 0x7;
else
MMX((modrm >> 3) & 0x7).w[imm8 & 3] = v;
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 2);
UINT8 imm8 = FETCH();
UINT16 v = READ16(ea);
if (cpustate->xmm_operand_size)
UINT16 v = (UINT16)LOAD_RM32(modrm);
MMX((modrm >> 3) & 0x7).w[imm8 & 3] = v;
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 2);
UINT8 imm8 = FETCH();
UINT16 v = READ16(ea);
MMX((modrm >> 3) & 0x7).w[imm8 & 3] = v;
XMM((modrm >> 3) & 0x7).w[imm8 & 7] = v;
}
else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 2);
UINT8 imm8 = FETCH();
UINT16 v = READ16(ea);
XMM((modrm >> 3) & 0x7).w[imm8 & 7] = v;
MMX((modrm >> 3) & 0x7).b[n] = MMX((modrm >> 3) & 0x7).b[n] < MMX(modrm & 0x7).b[n] ? MMX((modrm >> 3) & 0x7).b[n] : MMX(modrm & 0x7).b[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).b[n] = MMX((modrm >> 3) & 0x7).b[n] < s.b[n] ? MMX((modrm >> 3) & 0x7).b[n] : s.b[n];
XMM((modrm >> 3) & 0x7).b[n] = XMM((modrm >> 3) & 0x7).b[n] < XMM(modrm & 0x7).b[n] ? XMM((modrm >> 3) & 0x7).b[n] : XMM(modrm & 0x7).b[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).b[n] = XMM((modrm >> 3) & 0x7).b[n] < s.b[n] ? XMM((modrm >> 3) & 0x7).b[n] : s.b[n];
MMX((modrm >> 3) & 0x7).b[n] = MMX((modrm >> 3) & 0x7).b[n] > MMX(modrm & 0x7).b[n] ? MMX((modrm >> 3) & 0x7).b[n] : MMX(modrm & 0x7).b[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).b[n] = MMX((modrm >> 3) & 0x7).b[n] > s.b[n] ? MMX((modrm >> 3) & 0x7).b[n] : s.b[n];
MMX((modrm >> 3) & 0x7).b[n] = ((UINT16)MMX((modrm >> 3) & 0x7).b[n] + (UINT16)MMX(modrm & 0x7).b[n] + 1) >> 1;
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).b[n] = ((UINT16)MMX((modrm >> 3) & 0x7).b[n] + (UINT16)s.b[n] + 1) >> 1;
MMX((modrm >> 3) & 0x7).w[n] = ((UINT32)MMX((modrm >> 3) & 0x7).w[n] + (UINT32)MMX(modrm & 0x7).w[n] + 1) >> 1;
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).w[n] = ((UINT32)MMX((modrm >> 3) & 0x7).w[n] + (UINT32)s.w[n] + 1) >> 1;
MMX((modrm >> 3) & 0x7).w[3]=((UINT32)MMX((modrm >> 3) & 0x7).w[3]*(UINT32)MMX(modrm & 7).w[3]) >> 16;
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
MMX((modrm >> 3) & 0x7).w[0]=((UINT32)MMX((modrm >> 3) & 0x7).w[0]*(UINT32)s.w[0]) >> 16;
MMX((modrm >> 3) & 0x7).w[1]=((UINT32)MMX((modrm >> 3) & 0x7).w[1]*(UINT32)s.w[1]) >> 16;
MMX((modrm >> 3) & 0x7).s[n] = MMX((modrm >> 3) & 0x7).s[n] < MMX(modrm & 0x7).s[n] ? MMX((modrm >> 3) & 0x7).s[n] : MMX(modrm & 0x7).s[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).s[n] = MMX((modrm >> 3) & 0x7).s[n] < s.s[n] ? MMX((modrm >> 3) & 0x7).s[n] : s.s[n];
MMX((modrm >> 3) & 0x7).s[n] = MMX((modrm >> 3) & 0x7).s[n] > MMX(modrm & 0x7).s[n] ? MMX((modrm >> 3) & 0x7).s[n] : MMX(modrm & 0x7).s[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).s[n] = MMX((modrm >> 3) & 0x7).s[n] > s.s[n] ? MMX((modrm >> 3) & 0x7).s[n] : s.s[n];
MMX((modrm >> 3) & 0x7).q = (UINT64)MMX((modrm >> 3) & 0x7).d[0] * (UINT64)MMX(modrm & 0x7).d[0];
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
MMX((modrm >> 3) & 0x7).q = (UINT64)MMX((modrm >> 3) & 0x7).d[0] * (UINT64)s.d[0];
}
XMM((modrm >> 3) & 0x7).q[1] = (UINT64)XMM((modrm >> 3) & 0x7).d[2] * (UINT64)XMM(modrm & 0x7).d[2];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
XMM((modrm >> 3) & 0x7).q[0] = (UINT64)XMM((modrm >> 3) & 0x7).d[0] * (UINT64)s.d[0];
XMM((modrm >> 3) & 0x7).q[1] = (UINT64)XMM((modrm >> 3) & 0x7).d[2] * (UINT64)s.d[2];
MMX((modrm >> 3) & 0x7).l=(UINT64)temp & 0xffff;
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
temp=0;
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q - MMX(modrm & 7).q;
} else {
MMX_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, s);
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q - s.q;
}
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] - XMM(modrm & 7).q[1];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] - s.q[0];
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] - s.q[1];
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
UINT8 imm8 = FETCH();
READXMM( ea, s);
XMM(d).d[0]=s.d[(imm8 & 3)];
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
UINT8 imm8 = FETCH();
READXMM( ea, s);
XMM(d).q[1]=s.q[1];
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
UINT8 imm8 = FETCH();
READXMM( ea, s);
XMM(d).q[0]=s.q[0];
else {
XMM_REG s;
int d = (modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n = 0; n < 8; n++)
XMM(d).c[n] = SaturatedSignedWordToSignedByte(XMM(d).s[n]);
else {
XMM_REG s;
int d = (modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
XMM(d).s[0] = SaturatedSignedDwordToSignedWord(XMM(d).i[0]);
XMM(d).s[1] = SaturatedSignedDwordToSignedWord(XMM(d).i[1]);
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int c=0;c <= 15;c++)
XMM(d).b[c]=(XMM(d).c[c] > s.c[c]) ? 0xff : 0;
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int c=0;c <= 7;c++)
XMM(d).w[c]=(XMM(d).s[c] > s.s[c]) ? 0xffff : 0;
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int c=0;c <= 3;c++)
XMM(d).d[c]=(XMM(d).i[c] > s.i[c]) ? 0xffffffff : 0;
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n = 0; n < 8;n++)
XMM(d).b[n]=SaturatedSignedWordToUnsignedByte(XMM(d).s[n]);
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n = 0; n < 16; n += 2) {
XMM(d).b[n]=XMM(d).b[8+(n >> 1)];
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n = 0; n < 8; n += 2) {
XMM(d).w[n]=XMM(d).w[4+(n >> 1)];
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
XMM(d).d[0]=XMM(d).d[2];
XMM(d).d[1]=s.d[2];
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
XMM(d).q[0]=XMM(d).q[1];
XMM(d).q[1]=s.q[1];
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int c=0;c <= 15;c++)
XMM(d).b[c]=(XMM(d).c[c] == s.c[c]) ? 0xff : 0;
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int c=0;c <= 7;c++)
XMM(d).w[c]=(XMM(d).s[c] == s.s[c]) ? 0xffff : 0;
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int c=0;c <= 3;c++)
XMM(d).d[c]=(XMM(d).i[c] == s.i[c]) ? 0xffffffff : 0;
} else {
XMM_REG src;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM(d).q[0]=XMM(d).q[0]+src.q[0];
XMM(d).q[1]=XMM(d).q[1]+src.q[1];
} else {
XMM_REG src;
int d;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
d=(modrm >> 3) & 0x7;
for (int n = 0; n < 8;n++)
XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] + XMM(modrm & 7).b[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] + s.b[n];
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] + XMM(modrm & 7).w[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] + s.w[n];
XMM((modrm >> 3) & 0x7).d[n]=XMM((modrm >> 3) & 0x7).d[n] + XMM(modrm & 7).d[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 4;n++)
XMM((modrm >> 3) & 0x7).d[n]=XMM((modrm >> 3) & 0x7).d[n] + s.d[n];
XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] < XMM(modrm & 7).b[n] ? 0 : XMM((modrm >> 3) & 0x7).b[n]-XMM(modrm & 7).b[n];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] < src.b[n] ? 0 : XMM((modrm >> 3) & 0x7).b[n]-src.b[n];
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] < XMM(modrm & 7).w[n] ? 0 : XMM((modrm >> 3) & 0x7).w[n]-XMM(modrm & 7).w[n];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] < src.w[n] ? 0 : XMM((modrm >> 3) & 0x7).w[n]-src.w[n];
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] & XMM(modrm & 7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] & src.q[0];
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] & src.q[1];
XMM((modrm >> 3) & 0x7).q[1]=(~XMM((modrm >> 3) & 0x7).q[1]) & XMM(modrm & 7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).q[0]=(~XMM((modrm >> 3) & 0x7).q[0]) & src.q[0];
XMM((modrm >> 3) & 0x7).q[1]=(~XMM((modrm >> 3) & 0x7).q[1]) & src.q[1];
XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] > (0xff-XMM(modrm & 7).b[n]) ? 0xff : XMM((modrm >> 3) & 0x7).b[n]+XMM(modrm & 7).b[n];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] > (0xff-src.b[n]) ? 0xff : XMM((modrm >> 3) & 0x7).b[n]+src.b[n];
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] > (0xffff-XMM(modrm & 7).w[n]) ? 0xffff : XMM((modrm >> 3) & 0x7).w[n]+XMM(modrm & 7).w[n];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] > (0xffff-src.w[n]) ? 0xffff : XMM((modrm >> 3) & 0x7).w[n]+src.w[n];
XMM((modrm >> 3) & 0x7).b[n] = XMM((modrm >> 3) & 0x7).b[n] > XMM(modrm & 0x7).b[n] ? XMM((modrm >> 3) & 0x7).b[n] : XMM(modrm & 0x7).b[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).b[n] = XMM((modrm >> 3) & 0x7).b[n] > s.b[n] ? XMM((modrm >> 3) & 0x7).b[n] : s.b[n];
XMM((modrm >> 3) & 0x7).w[n]=((UINT32)XMM((modrm >> 3) & 0x7).w[n]*(UINT32)XMM(modrm & 7).w[n]) >> 16;
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).w[n]=((UINT32)XMM((modrm >> 3) & 0x7).w[n]*(UINT32)s.w[n]) >> 16;
XMM((modrm >> 3) & 0x7).w[n]=(UINT32)((INT32)XMM((modrm >> 3) & 0x7).s[n]*(INT32)XMM(modrm & 7).s[n]) >> 16;
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).w[n]=(UINT32)((INT32)XMM((modrm >> 3) & 0x7).s[n]*(INT32)src.s[n]) >> 16;
XMM((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)XMM((modrm >> 3) & 0x7).c[n] - (INT16)XMM(modrm & 7).c[n]);
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)XMM((modrm >> 3) & 0x7).c[n] - (INT16)s.c[n]);
XMM((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)XMM((modrm >> 3) & 0x7).s[n] - (INT32)XMM(modrm & 7).s[n]);
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)XMM((modrm >> 3) & 0x7).s[n] - (INT32)s.s[n]);
XMM((modrm >> 3) & 0x7).s[n] = XMM((modrm >> 3) & 0x7).s[n] < XMM(modrm & 0x7).s[n] ? XMM((modrm >> 3) & 0x7).s[n] : XMM(modrm & 0x7).s[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).s[n] = XMM((modrm >> 3) & 0x7).s[n] < s.s[n] ? XMM((modrm >> 3) & 0x7).s[n] : s.s[n];
XMM((modrm >> 3) & 0x7).s[n] = XMM((modrm >> 3) & 0x7).s[n] > XMM(modrm & 0x7).s[n] ? XMM((modrm >> 3) & 0x7).s[n] : XMM(modrm & 0x7).s[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).s[n] = XMM((modrm >> 3) & 0x7).s[n] > s.s[n] ? XMM((modrm >> 3) & 0x7).s[n] : s.s[n];
XMM((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)XMM((modrm >> 3) & 0x7).c[n] + (INT16)XMM(modrm & 7).c[n]);
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)XMM((modrm >> 3) & 0x7).c[n] + (INT16)s.c[n]);
XMM((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)XMM((modrm >> 3) & 0x7).s[n] + (INT32)XMM(modrm & 7).s[n]);
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)XMM((modrm >> 3) & 0x7).s[n] + (INT32)s.s[n]);
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] | XMM(modrm & 7).q[1];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] | s.q[0];
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] | s.q[1];
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] ^ XMM(modrm & 7).q[1];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] ^ s.q[0];
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] ^ s.q[1];
(INT32)XMM((modrm >> 3) & 0x7).s[n]*(INT32)XMM(modrm & 7).s[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 4;n++)
XMM((modrm >> 3) & 0x7).i[n]=(INT32)XMM((modrm >> 3) & 0x7).s[n]*(INT32)s.s[n]+
XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] - XMM(modrm & 7).b[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] - s.b[n];
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] - XMM(modrm & 7).w[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] - s.w[n];
XMM((modrm >> 3) & 0x7).d[n]=XMM((modrm >> 3) & 0x7).d[n] - XMM(modrm & 7).d[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 4;n++)
XMM((modrm >> 3) & 0x7).d[n]=XMM((modrm >> 3) & 0x7).d[n] - s.d[n];
XMM((modrm >> 3) & 0x7).l[1]=(UINT64)temp & 0xffff;
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
temp=0;
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).b[n] = ((UINT16)XMM((modrm >> 3) & 0x7).b[n] + (UINT16)XMM(modrm & 0x7).b[n] + 1) >> 1;
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).b[n] = ((UINT16)XMM((modrm >> 3) & 0x7).b[n] + (UINT16)s.b[n] + 1) >> 1;
XMM((modrm >> 3) & 0x7).w[n] = ((UINT32)XMM((modrm >> 3) & 0x7).w[n] + (UINT32)XMM(modrm & 0x7).w[n] + 1) >> 1;
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).w[n] = ((UINT32)XMM((modrm >> 3) & 0x7).w[n] + (UINT32)s.w[n] + 1) >> 1;
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] >> count;
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
int count=(int)src.q[0];
for (int n=0; n < 8;n++)
XMM((modrm >> 3) & 0x7).d[3]=XMM((modrm >> 3) & 0x7).d[3] >> count;
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
int count=(int)src.q[0];
XMM((modrm >> 3) & 0x7).d[0]=XMM((modrm >> 3) & 0x7).d[0] >> count;
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] >> count;
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
int count=(int)src.q[0];
XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] >> count;
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] << count;
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
int count=(int)s.q[0];
for (int n=0; n < 8;n++)
XMM((modrm >> 3) & 0x7).d[3]=XMM((modrm >> 3) & 0x7).d[3] << count;
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
int count=(int)s.q[0];
XMM((modrm >> 3) & 0x7).d[0]=XMM((modrm >> 3) & 0x7).d[0] << count;
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] << count;
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, s);
int count=(int)s.q[0];
XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] << count;
XMM((modrm >> 3) & 0x7).s[n]=XMM((modrm >> 3) & 0x7).s[n] >> count;
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
int count=(int)src.q[0];
for (int n=0; n < 8;n++)
XMM((modrm >> 3) & 0x7).i[3]=XMM((modrm >> 3) & 0x7).i[3] >> count;
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
int count=(int)src.q[0];
XMM((modrm >> 3) & 0x7).i[0]=XMM((modrm >> 3) & 0x7).i[0] >> count;
CYCLES(1); // unsupported
} else {
// since cache is not implemented
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
WRITEXMM( ea, XMM((modrm >> 3) & 0x7));
CYCLES(1); // TODO: correct cycle count
}
XMM((modrm >> 3) & 0x7).q[1] = 0;
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).i[0]=(INT32)src.f64[0];
XMM((modrm >> 3) & 0x7).i[1]=(INT32)src.f64[1];
XMM(modrm & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0];
XMM(modrm & 0x7).q[1] = 0;
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
WRITE64( ea, XMM((modrm >> 3) & 0x7).q[0]);
}
CYCLES(1); // TODO: correct cycle count
} else {
XMM_REG src;
int d;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
d=(modrm >> 3) & 0x7;
READXMM( ea, src);
XMM(d).f64[0]=XMM(d).f64[0]-src.f64[0];
} else {
XMM_REG src;
int d;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
d=(modrm >> 3) & 0x7;
READXMM( ea, src);
XMM(d).f64[0]=XMM(d).f64[0]+XMM(d).f64[1];
} else {
XMM_REG src;
int d;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
d=(modrm >> 3) & 0x7;
READXMM( ea, src);
XMM(d).f64[0]=XMM(d).f64[0]-XMM(d).f64[1];
} else {
XMM_REG src;
int d;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
d=(modrm >> 3) & 0x7;
READXMM( ea, src);
XMM(d).f64[0]=sqrt(src.f64[0]);
XMM((modrm >> 3) & 0x7).f64[1] = (double)MMX(modrm & 0x7).i[1];
} else {
MMX_REG r;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READMMX( ea, r);
XMM((modrm >> 3) & 0x7).f64[0] = (double)r.i[0];
XMM((modrm >> 3) & 0x7).f64[1] = (double)r.i[1];
MMX((modrm >> 3) & 0x7).i[1] = XMM(modrm & 0x7).f64[1];
} else {
XMM_REG r;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, r);
MMX((modrm >> 3) & 0x7).i[0] = r.f64[0];
MMX((modrm >> 3) & 0x7).i[1] = r.f64[1];
MMX((modrm >> 3) & 0x7).i[1] = XMM(modrm & 0x7).f64[1];
} else {
XMM_REG r;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, r);
MMX((modrm >> 3) & 0x7).i[0] = r.f64[0];
MMX((modrm >> 3) & 0x7).i[1] = r.f64[1];
XMM((modrm >> 3) & 0x7).q[1] = 0;
} else {
XMM_REG r;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, r);
XMM((modrm >> 3) & 0x7).f[0] = (float)r.f64[0];
XMM((modrm >> 3) & 0x7).f[1] = (float)r.f64[1];
XMM((modrm >> 3) & 0x7).i[3] = XMM(modrm & 0x7).f[3];
} else {
XMM_REG r;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, r);
XMM((modrm >> 3) & 0x7).i[0] = r.f[0];
XMM((modrm >> 3) & 0x7).i[1] = r.f[1];
XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] + XMM(modrm & 0x7).f64[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] + src.f64[0];
XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] + src.f64[1];
XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] * XMM(modrm & 0x7).f64[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] * src.f64[0];
XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] * src.f64[1];
XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] - XMM(modrm & 0x7).f64[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] - src.f64[0];
XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] - src.f64[1];
XMM((modrm >> 3) & 0x7).f64[1] = sse_min_double(XMM((modrm >> 3) & 0x7).f64[1], XMM(modrm & 0x7).f64[1]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = sse_min_double(XMM((modrm >> 3) & 0x7).f64[0], src.f64[0]);
XMM((modrm >> 3) & 0x7).f64[1] = sse_min_double(XMM((modrm >> 3) & 0x7).f64[1], src.f64[1]);
XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] / XMM(modrm & 0x7).f64[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] / src.f64[0];
XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] / src.f64[1];
XMM((modrm >> 3) & 0x7).f64[1] = sse_max_double(XMM((modrm >> 3) & 0x7).f64[1], XMM(modrm & 0x7).f64[1]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = sse_max_double(XMM((modrm >> 3) & 0x7).f64[0], src.f64[0]);
XMM((modrm >> 3) & 0x7).f64[1] = sse_max_double(XMM((modrm >> 3) & 0x7).f64[1], src.f64[1]);
CYCLES(1); // TODO: correct cycle count
} else {
// since cache is not implemented
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
WRITEXMM( ea, XMM((modrm >> 3) & 0x7));
CYCLES(1); // TODO: correct cycle count
}
if( modrm >= 0xc0 ) {
XMM((modrm >> 3) & 0x7) = XMM(modrm & 0x7);
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
XMM(modrm & 0x7) = XMM((modrm >> 3) & 0x7);
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
WRITEXMM( ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
XMM((modrm >> 3) & 0x7).q[0] = XMM(modrm & 0x7).q[0];
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READXMM_LO64( ea, XMM((modrm >> 3) & 0x7));
XMM((modrm >> 3) & 0x7).q[1] = 0;
}
if( modrm >= 0xc0 ) {
XMM(modrm & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0];
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
WRITEXMM_LO64( ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(1); // TODO: correct cycle count
XMM((modrm >> 3) & 0x7).q[0] = XMM(modrm & 0x7).q[0];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[0];
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READXMM_LO64( ea, XMM((modrm >> 3) & 0x7));
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[0];
}
if( modrm >= 0xc0 ) {
XMM((modrm >> 3) & 0x7).f64[0] = (INT32)LOAD_RM32(modrm);
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 4);
XMM((modrm >> 3) & 0x7).f64[0] = (INT32)READ32(ea);
}
CYCLES(1); // TODO: correct cycle count
src = (INT32)XMM(modrm & 0x7).f64[0];
} else { // otherwise is a memory address
XMM_REG t;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READXMM_LO64( ea, t);
src = (INT32)t.f64[0];
}
src = (INT32)XMM(modrm & 0x7).f64[0];
} else { // otherwise is a memory address
XMM_REG t;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READXMM_LO64( ea, t);
src = (INT32)t.f64[0];
}
} else {
XMM_REG src;
int d;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
d=(modrm >> 3) & 0x7;
READXMM( ea, src);
XMM(d).f64[0]=sqrt(src.f64[0]);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] + XMM(modrm & 0x7).f64[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] + src.f64[0];
}
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] * XMM(modrm & 0x7).f64[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] * src.f64[0];
}
XMM((modrm >> 3) & 0x7).f[0] = XMM(modrm & 0x7).f64[0];
} else {
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
READXMM_LO64( ea, s);
XMM((modrm >> 3) & 0x7).f[0] = s.f64[0];
}
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] - XMM(modrm & 0x7).f64[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] - src.f64[0];
}
XMM((modrm >> 3) & 0x7).f64[0] = sse_min_double(XMM((modrm >> 3) & 0x7).f64[0], XMM(modrm & 0x7).f64[0]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = sse_min_double(XMM((modrm >> 3) & 0x7).f64[0], src.f64[0]);
}
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] / XMM(modrm & 0x7).f64[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] / src.f64[0];
}
XMM((modrm >> 3) & 0x7).f64[0] = sse_max_double(XMM((modrm >> 3) & 0x7).f64[0], XMM(modrm & 0x7).f64[0]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = sse_max_double(XMM((modrm >> 3) & 0x7).f64[0], src.f64[0]);
}
XMM_REG src;
int d;
float f1, f2;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
d=(modrm >> 3) & 0x7;
READXMM( ea, src);
f1=XMM(d).f[0]+XMM(d).f[1];
XMM_REG src;
int d;
float f1, f2;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
d=(modrm >> 3) & 0x7;
READXMM( ea, src);
f1=XMM(d).f[0]-XMM(d).f[1];
} else {
int d;
XMM_REG s;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 8);
UINT8 imm8 = FETCH();
READXMM_LO64( ea, s);
d=(modrm >> 3) & 0x7;
XMM((modrm >> 3) & 0x7).f[3]=XMM((modrm >> 3) & 0x7).f[3] + XMM(modrm & 0x7).f[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).f[0]=XMM((modrm >> 3) & 0x7).f[0] - src.f[0];
XMM((modrm >> 3) & 0x7).f[1]=XMM((modrm >> 3) & 0x7).f[1] + src.f[1];
XMM((modrm >> 3) & 0x7).q[1] = 0;
} else {
XMM_REG src;
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM( ea, src);
XMM((modrm >> 3) & 0x7).i[0]=(INT32)src.f64[0];
XMM((modrm >> 3) & 0x7).i[1]=(INT32)src.f64[1];
// unsupported by cpu
CYCLES(1); // TODO: correct cycle count
} else {
- UINT32 ea = GetEA(modrm, 0);
+ UINT32 ea = GetEA(modrm, 0, 16);
READXMM(ea, XMM((modrm >> 3) & 0x7));
}
}
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 2);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 2);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 2);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 2);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 2);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 result;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 2);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 value;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (x87_dec_stack())
{
UINT32 m32real = READ32( ea);
{
floatx80 value;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 8);
if (x87_dec_stack())
{
UINT64 m64real = READ64( ea);
{
floatx80 value;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 10);
if (x87_dec_stack())
{
cpustate->x87_sw &= ~X87_SW_C1;
{
floatx80 value;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 2);
if (!x87_dec_stack())
{
value = fx80_inan;
{
floatx80 value;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (!x87_dec_stack())
{
value = fx80_inan;
{
floatx80 value;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 8);
if (!x87_dec_stack())
{
value = fx80_inan;
{
floatx80 value;
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 10);
if (!x87_dec_stack())
{
value = fx80_inan;
{
floatx80 value;
- UINT32 ea = GetEA( modrm, 1);
+ UINT32 ea = GetEA( modrm, 1, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 value;
- UINT32 ea = GetEA( modrm, 1);
+ UINT32 ea = GetEA( modrm, 1, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
{
floatx80 value;
- UINT32 ea = GetEA( modrm, 1);
+ UINT32 ea = GetEA( modrm, 1, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
}
- UINT32 ea = GetEA( modrm, 1);
+ UINT32 ea = GetEA( modrm, 1, 8);
if (x87_check_exceptions())
{
UINT64 m64real = floatx80_to_float64(value);
value = ST(0);
}
- UINT32 ea = GetEA( modrm, 1);
+ UINT32 ea = GetEA( modrm, 1, 10);
if (x87_check_exceptions())
{
WRITE80( ea, value);
m16int = -32768;
}
- UINT32 ea = GetEA( modrm, 1);
+ UINT32 ea = GetEA( modrm, 1, 2);
if (x87_check_exceptions())
{
WRITE16( ea, m16int);
m32int = 0x80000000;
}
- UINT32 ea = GetEA( modrm, 1);
+ UINT32 ea = GetEA( modrm, 1, 4);
if (x87_check_exceptions())
{
WRITE32( ea, m32int);
m16int = (UINT16)0x8000;
}
- UINT32 ea = GetEA( modrm, 1);
+ UINT32 ea = GetEA( modrm, 1, 2);
if (x87_check_exceptions())
{
WRITE16( ea, m16int);
m32int = 0x80000000;
}
- UINT32 ea = GetEA( modrm, 1);
+ UINT32 ea = GetEA( modrm, 1, 4);
if (x87_check_exceptions())
{
WRITE32( ea, m32int);
m64int = U64(0x8000000000000000);
}
- UINT32 ea = GetEA( modrm, 1);
+ UINT32 ea = GetEA( modrm, 1, 8);
if (x87_check_exceptions())
{
WRITE64( ea, m64int);
result.high |= ST(0).high & 0x8000;
}
- UINT32 ea = GetEA( modrm, 1);
+ UINT32 ea = GetEA( modrm, 1, 10);
if (x87_check_exceptions())
{
WRITE80( ea, result);
void I386_OPS_BASE::x87_ficom_m16int( UINT8 modrm)
{
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 2);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
void I386_OPS_BASE::x87_ficom_m32int( UINT8 modrm)
{
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
void I386_OPS_BASE::x87_ficomp_m16int( UINT8 modrm)
{
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 2);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
void I386_OPS_BASE::x87_ficomp_m32int( UINT8 modrm)
{
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
void I386_OPS_BASE::x87_fcom_m32real( UINT8 modrm)
{
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
void I386_OPS_BASE::x87_fcom_m64real( UINT8 modrm)
{
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
void I386_OPS_BASE::x87_fcomp_m32real( UINT8 modrm)
{
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
void I386_OPS_BASE::x87_fcomp_m64real( UINT8 modrm)
{
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow();
void I386_OPS_BASE::x87_fldcw( UINT8 modrm)
{
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 2);
UINT16 cw = READ16( ea);
x87_write_cw( cw);
void I386_OPS_BASE::x87_fstcw( UINT8 modrm)
{
- UINT32 ea = GetEA( modrm, 1);
+ UINT32 ea = GetEA( modrm, 1, 2);
WRITE16( ea, cpustate->x87_cw);
CYCLES( 3);
void I386_OPS_BASE::x87_fldenv( UINT8 modrm)
{
// TODO: Pointers and selectors
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 2);
if (cpustate->operand_size)
{
void I386_OPS_BASE::x87_fstenv( UINT8 modrm)
{
- UINT32 ea = GetEA( modrm, 1);
+ UINT32 ea;
// TODO: Pointers and selectors
switch((cpustate->cr[0] & 1)|(cpustate->operand_size & 1)<<1)
{
case 0: // 16-bit real mode
+ ea = GetEA( modrm, 1, 6);
WRITE16( ea + 0, cpustate->x87_cw);
WRITE16( ea + 2, cpustate->x87_sw);
WRITE16( ea + 4, cpustate->x87_tw);
// WRITE16( ea + 12, (cpustate->fpu_inst_ptr & 0x0f0000) >> 4);
break;
case 1: // 16-bit protected mode
+ ea = GetEA( modrm, 1, 6);
WRITE16(ea + 0, cpustate->x87_cw);
WRITE16(ea + 2, cpustate->x87_sw);
WRITE16(ea + 4, cpustate->x87_tw);
// WRITE16(ea + 12, (cpustate->fpu_inst_ptr & 0x0f0000) >> 4);
break;
case 2: // 32-bit real mode
+ ea = GetEA( modrm, 1, 10);
WRITE16( ea + 0, cpustate->x87_cw);
WRITE16( ea + 4, cpustate->x87_sw);
WRITE16( ea + 8, cpustate->x87_tw);
// WRITE32( ea + 24, (cpustate->fpu_data_ptr >> 16) << 12);
break;
case 3: // 32-bit protected mode
+ ea = GetEA( modrm, 1, 10);
WRITE16( ea + 0, cpustate->x87_cw);
WRITE16( ea + 4, cpustate->x87_sw);
WRITE16( ea + 8, cpustate->x87_tw);
void I386_OPS_BASE::x87_fsave( UINT8 modrm)
{
- UINT32 ea = GetEA( modrm, 1);
+ UINT32 ea = GetEA( modrm, 1, 80);
// TODO: Pointers and selectors
switch((cpustate->cr[0] & 1)|(cpustate->operand_size & 1)<<1)
void I386_OPS_BASE::x87_frstor( UINT8 modrm)
{
- UINT32 ea = GetEA( modrm, 0);
+ UINT32 ea = GetEA( modrm, 0, 80);
// TODO: Pointers and selectors
switch((cpustate->cr[0] & 1)|(cpustate->operand_size & 1)<<1)
void I386_OPS_BASE::x87_fstsw_m2byte( UINT8 modrm)
{
- UINT32 ea = GetEA( modrm, 1);
+ UINT32 ea = GetEA( modrm, 1, 2);
WRITE16( ea, cpustate->x87_sw);
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
#pragma once
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
/*
Intel 386 emulator
return ea;
}
-static UINT32 GetEA(i386_state *cpustate,UINT8 modrm, int rwn)
+static UINT32 GetEA(i386_state *cpustate,UINT8 modrm, int rwn, UINT32 size)
{
UINT8 segment;
UINT32 ea;
modrm_to_EA(cpustate, modrm, &ea, &segment );
- return i386_translate(cpustate, segment, ea, rwn );
+ return i386_translate(cpustate, segment, ea, rwn, size );
}
/* Check segment register for validity when changing privilege level after an RETF */
}
}
-static int i386_limit_check(i386_state *cpustate, int seg, UINT32 offset)
+static int i386_limit_check(i386_state *cpustate, int seg, UINT32 offset, UINT32 size)
{
if(PROTECTED_MODE && !V8086_MODE)
{
if((cpustate->sreg[seg].flags & 0x0018) == 0x0010 && cpustate->sreg[seg].flags & 0x0004) // if expand-down data segment
{
// compare if greater then 0xffffffff when we're passed the access size
- if((offset <= cpustate->sreg[seg].limit) || ((cpustate->sreg[seg].d)?0:(offset > 0xffff)))
+ if((offset <= cpustate->sreg[seg].limit) || ((cpustate->sreg[seg].d)?0:((offset + size - 1) > 0xffff)))
{
logerror("Limit check at 0x%08x failed. Segment %04x, limit %08x, offset %08x (expand-down)\n",cpustate->pc,cpustate->sreg[seg].selector,cpustate->sreg[seg].limit,offset);
return 1;
}
else
{
- if(offset > cpustate->sreg[seg].limit)
+ if((offset + size - 1) > cpustate->sreg[seg].limit)
{
logerror("Limit check at 0x%08x failed. Segment %04x, limit %08x, offset %08x\n",cpustate->pc,cpustate->sreg[seg].selector,cpustate->sreg[seg].limit,offset);
return 1;
if (operand32 != 0) // if 32-bit
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) - 8 : (REG16(SP) - 8) & 0xffff);
- if(i386_limit_check(cpustate, SS, offset))
+ if(i386_limit_check(cpustate, SS, offset, 8))
{
logerror("CALL (%08x): Stack has no room for return address.\n",cpustate->pc);
FAULT(FAULT_SS,0) // #SS(0)
else
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) - 4 : (REG16(SP) - 4) & 0xffff);
- if(i386_limit_check(cpustate, SS, offset))
+ if(i386_limit_check(cpustate, SS, offset, 4))
{
logerror("CALL (%08x): Stack has no room for return address.\n",cpustate->pc);
FAULT(FAULT_SS,0) // #SS(0)
if (operand32 != 0) // if 32-bit
{
UINT32 stkoff = (STACK_32BIT ? REG32(ESP) - 8 : (REG16(SP) - 8) & 0xffff);
- if(i386_limit_check(cpustate, SS, stkoff))
+ if(i386_limit_check(cpustate, SS, stkoff, 8))
{
logerror("CALL: Stack has no room for return address.\n");
FAULT(FAULT_SS,0) // #SS(0)
else
{
UINT32 stkoff = (STACK_32BIT ? REG32(ESP) - 4 : (REG16(SP) - 4) & 0xffff);
- if(i386_limit_check(cpustate, SS, stkoff))
+ if(i386_limit_check(cpustate, SS, stkoff, 4))
{
logerror("CALL: Stack has no room for return address.\n");
FAULT(FAULT_SS,0) // #SS(0)
I386_SREG desc;
UINT8 CPL, RPL, DPL;
- UINT32 ea = i386_translate(cpustate, SS, (STACK_32BIT)?REG32(ESP):REG16(SP), 0);
+ UINT32 ea = i386_translate(cpustate, SS, (STACK_32BIT)?REG32(ESP):REG16(SP), 0, (operand32)?8:4);
if(operand32 == 0)
{
if(operand32 == 0)
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+count+3) != 0)
+ if(i386_limit_check(cpustate,SS,offset,count+4) != 0)
{
logerror("RETF (%08x): SP is past stack segment limit.\n",cpustate->pc);
FAULT(FAULT_SS,0)
else
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+count+7) != 0)
+ if(i386_limit_check(cpustate,SS,offset,count+8) != 0)
{
logerror("RETF: ESP is past stack segment limit.\n");
FAULT(FAULT_SS,0)
if(operand32 == 0)
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+count+7) != 0)
+ if(i386_limit_check(cpustate,SS,offset,count+8) != 0)
{
logerror("RETF (%08x): SP is past stack segment limit.\n",cpustate->pc);
FAULT(FAULT_SS,0)
else
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+count+15) != 0)
+ if(i386_limit_check(cpustate,SS,offset,count+16) != 0)
{
logerror("RETF: ESP is past stack segment limit.\n");
FAULT(FAULT_SS,0)
UINT8 IOPL = cpustate->IOP1 | (cpustate->IOP2 << 1);
CPL = cpustate->CPL;
- UINT32 ea = i386_translate(cpustate, SS, (STACK_32BIT)?REG32(ESP):REG16(SP), 0);
+ UINT32 ea = i386_translate(cpustate, SS, (STACK_32BIT)?REG32(ESP):REG16(SP), 0, (operand32)?12:6);
if(operand32 == 0)
{
newEIP = READ16(cpustate, ea) & 0xffff;
if(operand32 == 0)
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+3) != 0)
+ if(i386_limit_check(cpustate,SS,offset,4) != 0)
{
logerror("IRET: Data on stack is past SS limit.\n");
FAULT(FAULT_SS,0)
else
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+7) != 0)
+ if(i386_limit_check(cpustate,SS,offset,8) != 0)
{
logerror("IRET: Data on stack is past SS limit.\n");
FAULT(FAULT_SS,0)
if(operand32 == 0)
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+5) != 0)
+ if(i386_limit_check(cpustate,SS,offset,6) != 0)
{
logerror("IRET (%08x): Data on stack is past SS limit.\n",cpustate->pc);
FAULT(FAULT_SS,0)
else
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+11) != 0)
+ if(i386_limit_check(cpustate,SS,offset,12) != 0)
{
logerror("IRET (%08x): Data on stack is past SS limit.\n",cpustate->pc);
FAULT(FAULT_SS,0)
if(operand32 == 0)
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+9) != 0)
+ if(i386_limit_check(cpustate,SS,offset,10) != 0)
{
logerror("IRET: SP is past SS limit.\n");
FAULT(FAULT_SS,0)
else
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+19) != 0)
+ if(i386_limit_check(cpustate,SS,offset,20) != 0)
{
logerror("IRET: ESP is past SS limit.\n");
FAULT(FAULT_SS,0)
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
#pragma once
#ifndef __I386INTF_H__
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
static UINT16 I386OP(shift_rotate16)(i386_state *cpustate, UINT8 modrm, UINT32 value, UINT8 shift)
{
UINT32 src = value & 0xffff;
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
src = LOAD_REG16(modrm);
dst = READ16(cpustate,ea);
dst = ADC16(cpustate, dst, src, cpustate->CF);
STORE_REG16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = READ16(cpustate,ea);
dst = LOAD_REG16(modrm);
dst = ADC16(cpustate, dst, src, cpustate->CF);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
src = LOAD_REG16(modrm);
dst = READ16(cpustate,ea);
dst = ADD16(cpustate,dst, src);
STORE_REG16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = READ16(cpustate,ea);
dst = LOAD_REG16(modrm);
dst = ADD16(cpustate,dst, src);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
src = LOAD_REG16(modrm);
dst = READ16(cpustate,ea);
dst = AND16(cpustate,dst, src);
STORE_REG16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = READ16(cpustate,ea);
dst = LOAD_REG16(modrm);
dst = AND16(cpustate,dst, src);
if( modrm >= 0xc0 ) {
src = LOAD_RM16(modrm);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = READ16(cpustate,ea);
}
if( modrm >= 0xc0 ) {
src = LOAD_RM16(modrm);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = READ16(cpustate,ea);
}
UINT32 ea = GetNonTranslatedEA(cpustate,modrm,&segment);
UINT16 bit = LOAD_REG16(modrm);
ea += 2*(bit/16);
- ea = i386_translate(cpustate,segment,(cpustate->address_size)?ea:(ea&0xffff),0);
+ ea = i386_translate(cpustate,segment,(cpustate->address_size)?ea:(ea&0xffff),0,2);
bit %= 16;
UINT16 dst = READ16(cpustate,ea);
UINT32 ea = GetNonTranslatedEA(cpustate,modrm,&segment);
UINT16 bit = LOAD_REG16(modrm);
ea += 2*(bit/16);
- ea = i386_translate(cpustate,segment,(cpustate->address_size)?ea:(ea&0xffff),1);
+ ea = i386_translate(cpustate,segment,(cpustate->address_size)?ea:(ea&0xffff),1,2);
bit %= 16;
UINT16 dst = READ16(cpustate,ea);
UINT32 ea = GetNonTranslatedEA(cpustate,modrm,&segment);
UINT16 bit = LOAD_REG16(modrm);
ea += 2*(bit/16);
- ea = i386_translate(cpustate,segment,(cpustate->address_size)?ea:(ea&0xffff),1);
+ ea = i386_translate(cpustate,segment,(cpustate->address_size)?ea:(ea&0xffff),1,2);
bit %= 16;
UINT16 dst = READ16(cpustate,ea);
UINT32 ea = GetNonTranslatedEA(cpustate,modrm,&segment);
UINT16 bit = LOAD_REG16(modrm);
ea += 2*(bit/16);
- ea = i386_translate(cpustate,segment,(cpustate->address_size)?ea:(ea&0xffff),1);
+ ea = i386_translate(cpustate,segment,(cpustate->address_size)?ea:(ea&0xffff),1,2);
bit %= 16;
UINT16 dst = READ16(cpustate,ea);
SUB16(cpustate,dst, src);
CYCLES(cpustate,CYCLES_CMP_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = LOAD_REG16(modrm);
dst = READ16(cpustate,ea);
SUB16(cpustate,dst, src);
SUB16(cpustate,dst, src);
CYCLES(cpustate,CYCLES_CMP_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = READ16(cpustate,ea);
dst = LOAD_REG16(modrm);
SUB16(cpustate,dst, src);
UINT32 eas, ead;
UINT16 src, dst;
if( cpustate->segment_prefix ) {
- eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 2 );
} else {
- eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 2 );
}
- ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0 );
+ ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0, 2 );
src = READ16(cpustate,eas);
dst = READ16(cpustate,ead);
SUB16(cpustate,src,dst);
src = (INT32)(INT16)LOAD_RM16(modrm);
CYCLES(cpustate,CYCLES_IMUL16_REG_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = (INT32)(INT16)READ16(cpustate,ea);
CYCLES(cpustate,CYCLES_IMUL16_REG_MEM); /* TODO: Correct multiply timing */
}
dst = (INT32)(INT16)LOAD_RM16(modrm);
CYCLES(cpustate,CYCLES_IMUL16_REG_IMM_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
dst = (INT32)(INT16)READ16(cpustate,ea);
CYCLES(cpustate,CYCLES_IMUL16_MEM_IMM_REG); /* TODO: Correct multiply timing */
}
dst = (INT32)(INT16)LOAD_RM16(modrm);
CYCLES(cpustate,CYCLES_IMUL16_REG_IMM_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
dst = (INT32)(INT16)READ16(cpustate,ea);
CYCLES(cpustate,CYCLES_IMUL16_MEM_IMM_REG); /* TODO: Correct multiply timing */
}
{
UINT32 eas;
if( cpustate->segment_prefix ) {
- eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 2 );
} else {
- eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 2 );
}
REG16(AX) = READ16(cpustate,eas);
BUMP_SI(cpustate,2);
STORE_RM16(modrm, src);
CYCLES(cpustate,CYCLES_MOV_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
src = LOAD_REG16(modrm);
WRITE16(cpustate,ea, src);
CYCLES(cpustate,CYCLES_MOV_REG_MEM);
STORE_REG16(modrm, src);
CYCLES(cpustate,CYCLES_MOV_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
- // NEC PC-9801RA's ITF routine intentionally raise general protection fault :-(
- int segment = DS;
- if( cpustate->segment_prefix ) {
- segment = cpustate->segment_override;
- }
- if( i386_limit_check(cpustate, segment, (ea + 1) & 0xffff) == 0 ) {
- src = READ16(cpustate,ea);
- STORE_REG16(modrm, src);
- } else {
- FAULT(FAULT_GP, 0)
- }
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
+ src = READ16(cpustate,ea);
+ STORE_REG16(modrm, src);
CYCLES(cpustate,CYCLES_MOV_MEM_REG);
}
}
STORE_RM16(modrm, value);
CYCLES(cpustate,CYCLES_MOV_IMM_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
UINT16 value = FETCH16(cpustate);
WRITE16(cpustate,ea, value);
CYCLES(cpustate,CYCLES_MOV_IMM_MEM);
}
/* TODO: Not sure if this is correct... */
if( cpustate->segment_prefix ) {
- ea = i386_translate(cpustate, cpustate->segment_override, offset, 0 );
+ ea = i386_translate(cpustate, cpustate->segment_override, offset, 0, 2 );
} else {
- ea = i386_translate(cpustate, DS, offset, 0 );
+ ea = i386_translate(cpustate, DS, offset, 0, 2 );
}
REG16(AX) = READ16(cpustate,ea);
CYCLES(cpustate,CYCLES_MOV_MEM_ACC);
}
/* TODO: Not sure if this is correct... */
if( cpustate->segment_prefix ) {
- ea = i386_translate(cpustate, cpustate->segment_override, offset, 1 );
+ ea = i386_translate(cpustate, cpustate->segment_override, offset, 1, 2 );
} else {
- ea = i386_translate(cpustate, DS, offset, 1 );
+ ea = i386_translate(cpustate, DS, offset, 1, 2 );
}
WRITE16(cpustate, ea, REG16(AX) );
CYCLES(cpustate,CYCLES_MOV_ACC_MEM);
UINT32 eas, ead;
UINT16 v;
if( cpustate->segment_prefix ) {
- eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 2 );
} else {
- eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 2 );
}
- ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1 );
+ ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1, 2 );
v = READ16(cpustate,eas);
WRITE16(cpustate,ead, v);
BUMP_SI(cpustate,2);
STORE_REG16(modrm, src);
CYCLES(cpustate,CYCLES_MOVSX_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
INT16 src = (INT8)READ8(cpustate,ea);
STORE_REG16(modrm, src);
CYCLES(cpustate,CYCLES_MOVSX_MEM_REG);
STORE_REG16(modrm, src);
CYCLES(cpustate,CYCLES_MOVZX_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
UINT16 src = (UINT8)READ8(cpustate,ea);
STORE_REG16(modrm, src);
CYCLES(cpustate,CYCLES_MOVZX_MEM_REG);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
src = LOAD_REG16(modrm);
dst = READ16(cpustate,ea);
dst = OR16(cpustate,dst, src);
STORE_REG16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = READ16(cpustate,ea);
dst = LOAD_REG16(modrm);
dst = OR16(cpustate,dst, src);
static void I386OP(pop_ax)(i386_state *cpustate) // Opcode 0x58
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+1) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
REG16(AX) = POP16(cpustate);
else
FAULT(FAULT_SS,0)
static void I386OP(pop_cx)(i386_state *cpustate) // Opcode 0x59
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+1) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
REG16(CX) = POP16(cpustate);
else
FAULT(FAULT_SS,0)
static void I386OP(pop_dx)(i386_state *cpustate) // Opcode 0x5a
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+1) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
REG16(DX) = POP16(cpustate);
else
FAULT(FAULT_SS,0)
static void I386OP(pop_bx)(i386_state *cpustate) // Opcode 0x5b
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+1) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
REG16(BX) = POP16(cpustate);
else
FAULT(FAULT_SS,0)
static void I386OP(pop_sp)(i386_state *cpustate) // Opcode 0x5c
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+1) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
REG16(SP) = POP16(cpustate);
else
FAULT(FAULT_SS,0)
static void I386OP(pop_bp)(i386_state *cpustate) // Opcode 0x5d
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+1) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
REG16(BP) = POP16(cpustate);
else
FAULT(FAULT_SS,0)
static void I386OP(pop_si)(i386_state *cpustate) // Opcode 0x5e
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+1) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
REG16(SI) = POP16(cpustate);
else
FAULT(FAULT_SS,0)
static void I386OP(pop_di)(i386_state *cpustate) // Opcode 0x5f
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+1) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
REG16(DI) = POP16(cpustate);
else
FAULT(FAULT_SS,0)
UINT32 ea, offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
UINT16 value;
bool fault;
- if(i386_limit_check(cpustate,SS,offset+1) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
{
- ea = i386_translate(cpustate, SS, offset, 0);
+ ea = i386_translate(cpustate, SS, offset, 0, 2);
value = READ16(cpustate, ea);
i386_sreg_load(cpustate,value, segment, &fault);
if(fault) return false;
UINT16 value;
UINT32 ea, offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+1) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
{
UINT32 temp_sp = REG32(ESP);
value = POP16(cpustate);
if( modrm >= 0xc0 ) {
STORE_RM16(modrm, value);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
try
{
WRITE16(cpustate,ea, value);
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+15) == 0)
+ if(i386_limit_check(cpustate,SS,offset,16) == 0)
{
REG16(DI) = POP16(cpustate);
REG16(SI) = POP16(cpustate);
mask &= ~0x00003000; // IOPL cannot be changed while in V8086 mode
}
- if(i386_limit_check(cpustate,SS,offset+1) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
{
value = POP16(cpustate);
set_flags(cpustate,(current & ~mask) | (value & mask)); // mask out reserved bits
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
PUSH16(cpustate, REG16(AX) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
PUSH16(cpustate, REG16(CX) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
PUSH16(cpustate, REG16(DX) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
PUSH16(cpustate, REG16(BX) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
PUSH16(cpustate, REG16(SP) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
PUSH16(cpustate, REG16(BP) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
PUSH16(cpustate, REG16(SI) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
PUSH16(cpustate, REG16(DI) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
PUSH16(cpustate, cpustate->sreg[CS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
PUSH16(cpustate, cpustate->sreg[DS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
PUSH16(cpustate, cpustate->sreg[ES].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
PUSH16(cpustate, cpustate->sreg[FS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
PUSH16(cpustate, cpustate->sreg[GS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
PUSH16(cpustate, cpustate->sreg[SS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
PUSH16(cpustate,value);
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 16;
else
offset = (REG16(SP) - 16) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,16) == 0)
{
PUSH16(cpustate, REG16(AX) );
PUSH16(cpustate, REG16(CX) );
offset = REG32(ESP) - 2;
else
offset = (REG16(SP) - 2) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,2) == 0)
PUSH16(cpustate, get_flags(cpustate) & 0xffff );
else
FAULT(FAULT_SS,0)
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
src = LOAD_REG16(modrm);
dst = READ16(cpustate,ea);
dst = SBB16(cpustate, dst, src, cpustate->CF);
STORE_REG16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = READ16(cpustate,ea);
dst = LOAD_REG16(modrm);
dst = SBB16(cpustate, dst, src, cpustate->CF);
{
UINT32 eas;
UINT16 src, dst;
- eas = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0 );
+ eas = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0, 2 );
src = READ16(cpustate,eas);
dst = REG16(AX);
SUB16(cpustate,dst, src);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_SHLD_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
UINT16 dst = READ16(cpustate,ea);
UINT16 upper = LOAD_REG16(modrm);
UINT8 shift = FETCH(cpustate);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_SHLD_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
UINT16 dst = READ16(cpustate,ea);
UINT16 upper = LOAD_REG16(modrm);
UINT8 shift = REG8(CL);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_SHRD_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
UINT16 dst = READ16(cpustate,ea);
UINT16 upper = LOAD_REG16(modrm);
UINT8 shift = FETCH(cpustate);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_SHRD_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
UINT16 dst = READ16(cpustate,ea);
UINT16 upper = LOAD_REG16(modrm);
UINT8 shift = REG8(CL);
static void I386OP(stosw)(i386_state *cpustate) // Opcode 0xab
{
UINT32 ead;
- ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1 );
+ ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1, 2 );
WRITE16(cpustate,ead, REG16(AX));
BUMP_DI(cpustate,2);
CYCLES(cpustate,CYCLES_STOS);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
src = LOAD_REG16(modrm);
dst = READ16(cpustate,ea);
dst = SUB16(cpustate,dst, src);
STORE_REG16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = READ16(cpustate,ea);
dst = LOAD_REG16(modrm);
dst = SUB16(cpustate,dst, src);
cpustate->OF = 0;
CYCLES(cpustate,CYCLES_TEST_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = LOAD_REG16(modrm);
dst = READ16(cpustate,ea);
dst = src & dst;
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_XCHG_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
UINT16 src = READ16(cpustate,ea);
UINT16 dst = LOAD_REG16(modrm);
STORE_REG16(modrm, src);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
src = LOAD_REG16(modrm);
dst = READ16(cpustate,ea);
dst = XOR16(cpustate,dst, src);
STORE_REG16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = READ16(cpustate,ea);
dst = LOAD_REG16(modrm);
dst = XOR16(cpustate,dst, src);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
dst = READ16(cpustate,ea);
src = FETCH16(cpustate);
dst = ADD16(cpustate,dst, src);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
dst = READ16(cpustate,ea);
src = FETCH16(cpustate);
dst = OR16(cpustate,dst, src);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
dst = READ16(cpustate,ea);
src = FETCH16(cpustate);
dst = ADC16(cpustate, dst, src, cpustate->CF);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
dst = READ16(cpustate,ea);
src = FETCH16(cpustate);
dst = SBB16(cpustate, dst, src, cpustate->CF);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
dst = READ16(cpustate,ea);
src = FETCH16(cpustate);
dst = AND16(cpustate,dst, src);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
dst = READ16(cpustate,ea);
src = FETCH16(cpustate);
dst = SUB16(cpustate,dst, src);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
dst = READ16(cpustate,ea);
src = FETCH16(cpustate);
dst = XOR16(cpustate,dst, src);
SUB16(cpustate,dst, src);
CYCLES(cpustate,CYCLES_CMP_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,2);
dst = READ16(cpustate,ea);
src = FETCH16(cpustate);
SUB16(cpustate,dst, src);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
dst = READ16(cpustate,ea);
src = (UINT16)(INT16)(INT8)FETCH(cpustate);
dst = ADD16(cpustate,dst, src);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
dst = READ16(cpustate,ea);
src = (UINT16)(INT16)(INT8)FETCH(cpustate);
dst = OR16(cpustate,dst, src);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
dst = READ16(cpustate,ea);
src = (UINT16)(INT16)(INT8)FETCH(cpustate);
dst = ADC16(cpustate, dst, src, cpustate->CF);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
dst = READ16(cpustate,ea);
src = ((UINT16)(INT16)(INT8)FETCH(cpustate));
dst = SBB16(cpustate, dst, src, cpustate->CF);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
dst = READ16(cpustate,ea);
src = (UINT16)(INT16)(INT8)FETCH(cpustate);
dst = AND16(cpustate,dst, src);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
dst = READ16(cpustate,ea);
src = (UINT16)(INT16)(INT8)FETCH(cpustate);
dst = SUB16(cpustate,dst, src);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
dst = READ16(cpustate,ea);
src = (UINT16)(INT16)(INT8)FETCH(cpustate);
dst = XOR16(cpustate,dst, src);
SUB16(cpustate,dst, src);
CYCLES(cpustate,CYCLES_CMP_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,2);
dst = READ16(cpustate,ea);
src = (UINT16)(INT16)(INT8)FETCH(cpustate);
SUB16(cpustate,dst, src);
dst = i386_shift_rotate16(cpustate, modrm, dst, shift);
STORE_RM16(modrm, dst);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
dst = READ16(cpustate,ea);
shift = FETCH(cpustate) & 0x1f;
dst = i386_shift_rotate16(cpustate, modrm, dst, shift);
dst = i386_shift_rotate16(cpustate, modrm, dst, 1);
STORE_RM16(modrm, dst);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
dst = READ16(cpustate,ea);
dst = i386_shift_rotate16(cpustate, modrm, dst, 1);
WRITE16(cpustate,ea, dst);
dst = i386_shift_rotate16(cpustate, modrm, dst, REG8(CL));
STORE_RM16(modrm, dst);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
dst = READ16(cpustate,ea);
dst = i386_shift_rotate16(cpustate, modrm, dst, REG8(CL));
WRITE16(cpustate,ea, dst);
SetSZPF16(dst);
CYCLES(cpustate,CYCLES_TEST_IMM_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
UINT16 dst = READ16(cpustate,ea);
UINT16 src = FETCH16(cpustate);
dst &= src;
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_NOT_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
UINT16 dst = READ16(cpustate,ea);
dst = ~dst;
WRITE16(cpustate,ea, dst);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_NEG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
UINT16 dst = READ16(cpustate,ea);
dst = SUB16(cpustate, 0, dst );
WRITE16(cpustate,ea, dst);
src = LOAD_RM16(modrm);
CYCLES(cpustate,CYCLES_MUL16_ACC_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = READ16(cpustate,ea);
CYCLES(cpustate,CYCLES_MUL16_ACC_MEM); /* TODO: Correct multiply timing */
}
src = (INT32)(INT16)LOAD_RM16(modrm);
CYCLES(cpustate,CYCLES_IMUL16_ACC_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = (INT32)(INT16)READ16(cpustate,ea);
CYCLES(cpustate,CYCLES_IMUL16_ACC_MEM); /* TODO: Correct multiply timing */
}
src = LOAD_RM16(modrm);
CYCLES(cpustate,CYCLES_DIV16_ACC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = READ16(cpustate,ea);
CYCLES(cpustate,CYCLES_DIV16_ACC_MEM);
}
src = LOAD_RM16(modrm);
CYCLES(cpustate,CYCLES_IDIV16_ACC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = READ16(cpustate,ea);
CYCLES(cpustate,CYCLES_IDIV16_ACC_MEM);
}
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_INC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
UINT16 dst = READ16(cpustate,ea);
dst = INC16(cpustate,dst);
WRITE16(cpustate,ea, dst);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_DEC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
UINT16 dst = READ16(cpustate,ea);
dst = DEC16(cpustate,dst);
WRITE16(cpustate,ea, dst);
address = LOAD_RM16(modrm);
CYCLES(cpustate,CYCLES_CALL_REG); /* TODO: Timing = 7 + m */
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
address = READ16(cpustate,ea);
CYCLES(cpustate,CYCLES_CALL_MEM); /* TODO: Timing = 10 + m */
}
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
address = READ16(cpustate,ea + 0);
selector = READ16(cpustate,ea + 2);
CYCLES(cpustate,CYCLES_CALL_MEM_INTERSEG); /* TODO: Timing = 10 + m */
address = LOAD_RM16(modrm);
CYCLES(cpustate,CYCLES_JMP_REG); /* TODO: Timing = 7 + m */
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
address = READ16(cpustate,ea);
CYCLES(cpustate,CYCLES_JMP_MEM); /* TODO: Timing = 10 + m */
}
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
address = READ16(cpustate,ea + 0);
selector = READ16(cpustate,ea + 2);
CYCLES(cpustate,CYCLES_JMP_MEM_INTERSEG); /* TODO: Timing = 10 + m */
if( modrm >= 0xc0 ) {
value = LOAD_RM16(modrm);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
value = READ16(cpustate,ea);
}
PUSH16(cpustate,value);
STORE_RM16(modrm, cpustate->ldtr.segment);
CYCLES(cpustate,CYCLES_SLDT_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
WRITE16(cpustate, ea, cpustate->ldtr.segment);
CYCLES(cpustate,CYCLES_SLDT_MEM);
}
STORE_RM16(modrm, cpustate->task.segment);
CYCLES(cpustate,CYCLES_STR_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
WRITE16(cpustate, ea, cpustate->task.segment);
CYCLES(cpustate,CYCLES_STR_MEM);
}
cpustate->ldtr.segment = address;
CYCLES(cpustate,CYCLES_LLDT_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,2);
cpustate->ldtr.segment = READ16(cpustate,ea);
CYCLES(cpustate,CYCLES_LLDT_MEM);
}
cpustate->task.segment = address;
CYCLES(cpustate,CYCLES_LTR_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,2);
cpustate->task.segment = READ16(cpustate,ea);
CYCLES(cpustate,CYCLES_LTR_MEM);
}
address = LOAD_RM16(modrm);
CYCLES(cpustate,CYCLES_VERR_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,2);
address = READ16(cpustate,ea);
CYCLES(cpustate,CYCLES_VERR_MEM);
}
address = LOAD_RM16(modrm);
CYCLES(cpustate,CYCLES_VERW_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,2);
address = READ16(cpustate,ea);
CYCLES(cpustate,CYCLES_VERW_MEM);
}
{
if( modrm >= 0xc0 ) {
address = LOAD_RM16(modrm);
- ea = i386_translate(cpustate, CS, address, 1 );
+ ea = i386_translate(cpustate, CS, address, 1, 6 );
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,6);
}
WRITE16(cpustate,ea, cpustate->gdtr.limit);
WRITE32(cpustate,ea + 2, cpustate->gdtr.base);
if (modrm >= 0xc0)
{
address = LOAD_RM16(modrm);
- ea = i386_translate(cpustate, CS, address, 1 );
+ ea = i386_translate(cpustate, CS, address, 1, 6 );
}
else
{
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,6);
}
WRITE16(cpustate,ea, cpustate->idtr.limit);
WRITE32(cpustate,ea + 2, cpustate->idtr.base);
FAULT(FAULT_GP,0)
if( modrm >= 0xc0 ) {
address = LOAD_RM16(modrm);
- ea = i386_translate(cpustate, CS, address, 0 );
+ ea = i386_translate(cpustate, CS, address, 0, 6 );
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,6);
}
cpustate->gdtr.limit = READ16(cpustate,ea);
cpustate->gdtr.base = READ32(cpustate,ea + 2) & 0xffffff;
FAULT(FAULT_GP,0)
if( modrm >= 0xc0 ) {
address = LOAD_RM16(modrm);
- ea = i386_translate(cpustate, CS, address, 0 );
+ ea = i386_translate(cpustate, CS, address, 0, 6 );
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,6);
}
cpustate->idtr.limit = READ16(cpustate,ea);
cpustate->idtr.base = READ32(cpustate,ea + 2) & 0xffffff;
STORE_RM16(modrm, cpustate->cr[0]);
CYCLES(cpustate,CYCLES_SMSW_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
WRITE16(cpustate,ea, cpustate->cr[0]);
CYCLES(cpustate,CYCLES_SMSW_MEM);
}
b = LOAD_RM16(modrm);
CYCLES(cpustate,CYCLES_LMSW_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,2);
CYCLES(cpustate,CYCLES_LMSW_MEM);
b = READ16(cpustate,ea);
}
CYCLES(cpustate,CYCLES_BT_IMM_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
UINT16 dst = READ16(cpustate,ea);
UINT8 bit = FETCH(cpustate);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_BTS_IMM_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
UINT16 dst = READ16(cpustate,ea);
UINT8 bit = FETCH(cpustate);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_BTR_IMM_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
UINT16 dst = READ16(cpustate,ea);
UINT8 bit = FETCH(cpustate);
STORE_RM16(modrm, dst);
CYCLES(cpustate,CYCLES_BTC_IMM_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
UINT16 dst = READ16(cpustate,ea);
UINT8 bit = FETCH(cpustate);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
seg.selector = READ16(cpustate,ea);
CYCLES(cpustate,CYCLES_LAR_MEM);
}
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
seg.selector = READ16(cpustate,ea);
}
if(seg.selector == 0)
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
low = READ16(cpustate,ea + 0);
high = READ16(cpustate,ea + 2);
}
i386_trap(cpustate,6, 0, 0);
return false;
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
STORE_REG16(modrm, READ16(cpustate,ea + 0));
selector = READ16(cpustate,ea + 2);
i386_sreg_load(cpustate,selector,s,NULL);
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
static UINT32 I386OP(shift_rotate32)(i386_state *cpustate, UINT8 modrm, UINT32 value, UINT8 shift)
{
UINT32 dst, src;
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
src = LOAD_REG32(modrm);
dst = READ32(cpustate,ea);
dst = ADC32(cpustate, dst, src, cpustate->CF);
STORE_REG32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = READ32(cpustate,ea);
dst = LOAD_REG32(modrm);
dst = ADC32(cpustate, dst, src, cpustate->CF);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
src = LOAD_REG32(modrm);
dst = READ32(cpustate,ea);
dst = ADD32(cpustate,dst, src);
STORE_REG32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = READ32(cpustate,ea);
dst = LOAD_REG32(modrm);
dst = ADD32(cpustate,dst, src);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
src = LOAD_REG32(modrm);
dst = READ32(cpustate,ea);
dst = AND32(cpustate,dst, src);
STORE_REG32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = READ32(cpustate,ea);
dst = LOAD_REG32(modrm);
dst = AND32(cpustate,dst, src);
if( modrm >= 0xc0 ) {
src = LOAD_RM32(modrm);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = READ32(cpustate,ea);
}
if( modrm >= 0xc0 ) {
src = LOAD_RM32(modrm);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = READ32(cpustate,ea);
}
UINT32 ea = GetNonTranslatedEA(cpustate,modrm,&segment);
UINT32 bit = LOAD_REG32(modrm);
ea += 4*(bit/32);
- ea = i386_translate(cpustate,segment,(cpustate->address_size)?ea:(ea&0xffff),0);
+ ea = i386_translate(cpustate,segment,(cpustate->address_size)?ea:(ea&0xffff),0,4);
bit %= 32;
UINT32 dst = READ32(cpustate,ea);
UINT32 ea = GetNonTranslatedEA(cpustate,modrm,&segment);
UINT32 bit = LOAD_REG32(modrm);
ea += 4*(bit/32);
- ea = i386_translate(cpustate,segment,(cpustate->address_size)?ea:(ea&0xffff),1);
+ ea = i386_translate(cpustate,segment,(cpustate->address_size)?ea:(ea&0xffff),1,4);
bit %= 32;
UINT32 dst = READ32(cpustate,ea);
UINT32 ea = GetNonTranslatedEA(cpustate,modrm,&segment);
UINT32 bit = LOAD_REG32(modrm);
ea += 4*(bit/32);
- ea = i386_translate(cpustate,segment,(cpustate->address_size)?ea:(ea&0xffff),1);
+ ea = i386_translate(cpustate,segment,(cpustate->address_size)?ea:(ea&0xffff),1,4);
bit %= 32;
UINT32 dst = READ32(cpustate,ea);
UINT32 ea = GetNonTranslatedEA(cpustate,modrm,&segment);
UINT32 bit = LOAD_REG32(modrm);
ea += 4*(bit/32);
- ea = i386_translate(cpustate,segment,(cpustate->address_size)?ea:(ea&0xffff),1);
+ ea = i386_translate(cpustate,segment,(cpustate->address_size)?ea:(ea&0xffff),1,4);
bit %= 32;
UINT32 dst = READ32(cpustate,ea);
SUB32(cpustate,dst, src);
CYCLES(cpustate,CYCLES_CMP_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = LOAD_REG32(modrm);
dst = READ32(cpustate,ea);
SUB32(cpustate,dst, src);
SUB32(cpustate,dst, src);
CYCLES(cpustate,CYCLES_CMP_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = READ32(cpustate,ea);
dst = LOAD_REG32(modrm);
SUB32(cpustate,dst, src);
{
UINT32 eas, ead, src, dst;
if( cpustate->segment_prefix ) {
- eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 4 );
} else {
- eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 4 );
}
- ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0 );
+ ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0, 4 );
src = READ32(cpustate,eas);
dst = READ32(cpustate,ead);
SUB32(cpustate,src,dst);
src = (INT64)(INT32)LOAD_RM32(modrm);
CYCLES(cpustate,CYCLES_IMUL32_REG_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = (INT64)(INT32)READ32(cpustate,ea);
CYCLES(cpustate,CYCLES_IMUL32_REG_REG); /* TODO: Correct multiply timing */
}
dst = (INT64)(INT32)LOAD_RM32(modrm);
CYCLES(cpustate,CYCLES_IMUL32_REG_IMM_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
dst = (INT64)(INT32)READ32(cpustate,ea);
CYCLES(cpustate,CYCLES_IMUL32_MEM_IMM_REG); /* TODO: Correct multiply timing */
}
dst = (INT64)(INT32)LOAD_RM32(modrm);
CYCLES(cpustate,CYCLES_IMUL32_REG_IMM_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
dst = (INT64)(INT32)READ32(cpustate,ea);
CYCLES(cpustate,CYCLES_IMUL32_MEM_IMM_REG); /* TODO: Correct multiply timing */
}
{
UINT32 eas;
if( cpustate->segment_prefix ) {
- eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 4 );
} else {
- eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 4 );
}
REG32(EAX) = READ32(cpustate,eas);
BUMP_SI(cpustate,4);
STORE_RM32(modrm, src);
CYCLES(cpustate,CYCLES_MOV_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
src = LOAD_REG32(modrm);
WRITE32(cpustate,ea, src);
CYCLES(cpustate,CYCLES_MOV_REG_MEM);
STORE_REG32(modrm, src);
CYCLES(cpustate,CYCLES_MOV_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = READ32(cpustate,ea);
STORE_REG32(modrm, src);
CYCLES(cpustate,CYCLES_MOV_MEM_REG);
STORE_RM32(modrm, value);
CYCLES(cpustate,CYCLES_MOV_IMM_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
UINT32 value = FETCH32(cpustate);
WRITE32(cpustate,ea, value);
CYCLES(cpustate,CYCLES_MOV_IMM_MEM);
offset = FETCH16(cpustate);
}
if( cpustate->segment_prefix ) {
- ea = i386_translate(cpustate, cpustate->segment_override, offset, 0 );
+ ea = i386_translate(cpustate, cpustate->segment_override, offset, 0, 4 );
} else {
- ea = i386_translate(cpustate, DS, offset, 0 );
+ ea = i386_translate(cpustate, DS, offset, 0, 4 );
}
REG32(EAX) = READ32(cpustate,ea);
CYCLES(cpustate,CYCLES_MOV_MEM_ACC);
offset = FETCH16(cpustate);
}
if( cpustate->segment_prefix ) {
- ea = i386_translate(cpustate, cpustate->segment_override, offset, 1 );
+ ea = i386_translate(cpustate, cpustate->segment_override, offset, 1, 4 );
} else {
- ea = i386_translate(cpustate, DS, offset, 1 );
+ ea = i386_translate(cpustate, DS, offset, 1, 4 );
}
WRITE32(cpustate, ea, REG32(EAX) );
CYCLES(cpustate,CYCLES_MOV_ACC_MEM);
{
UINT32 eas, ead, v;
if( cpustate->segment_prefix ) {
- eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 4 );
} else {
- eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 4 );
}
- ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1 );
+ ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1, 4 );
v = READ32(cpustate,eas);
WRITE32(cpustate,ead, v);
BUMP_SI(cpustate,4);
STORE_REG32(modrm, src);
CYCLES(cpustate,CYCLES_MOVSX_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
INT32 src = (INT8)READ8(cpustate,ea);
STORE_REG32(modrm, src);
CYCLES(cpustate,CYCLES_MOVSX_MEM_REG);
STORE_REG32(modrm, src);
CYCLES(cpustate,CYCLES_MOVSX_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
INT32 src = (INT16)READ16(cpustate,ea);
STORE_REG32(modrm, src);
CYCLES(cpustate,CYCLES_MOVSX_MEM_REG);
STORE_REG32(modrm, src);
CYCLES(cpustate,CYCLES_MOVZX_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
UINT32 src = (UINT8)READ8(cpustate,ea);
STORE_REG32(modrm, src);
CYCLES(cpustate,CYCLES_MOVZX_MEM_REG);
STORE_REG32(modrm, src);
CYCLES(cpustate,CYCLES_MOVZX_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
UINT32 src = (UINT16)READ16(cpustate,ea);
STORE_REG32(modrm, src);
CYCLES(cpustate,CYCLES_MOVZX_MEM_REG);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
src = LOAD_REG32(modrm);
dst = READ32(cpustate,ea);
dst = OR32(cpustate,dst, src);
STORE_REG32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = READ32(cpustate,ea);
dst = LOAD_REG32(modrm);
dst = OR32(cpustate,dst, src);
static void I386OP(pop_eax)(i386_state *cpustate) // Opcode 0x58
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+3) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
REG32(EAX) = POP32(cpustate);
else
FAULT(FAULT_SS,0)
static void I386OP(pop_ecx)(i386_state *cpustate) // Opcode 0x59
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+3) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
REG32(ECX) = POP32(cpustate);
else
FAULT(FAULT_SS,0)
static void I386OP(pop_edx)(i386_state *cpustate) // Opcode 0x5a
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+3) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
REG32(EDX) = POP32(cpustate);
else
FAULT(FAULT_SS,0)
static void I386OP(pop_ebx)(i386_state *cpustate) // Opcode 0x5b
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+3) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
REG32(EBX) = POP32(cpustate);
else
FAULT(FAULT_SS,0)
static void I386OP(pop_esp)(i386_state *cpustate) // Opcode 0x5c
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+3) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
REG32(ESP) = POP32(cpustate);
else
FAULT(FAULT_SS,0)
static void I386OP(pop_ebp)(i386_state *cpustate) // Opcode 0x5d
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+3) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
REG32(EBP) = POP32(cpustate);
else
FAULT(FAULT_SS,0)
static void I386OP(pop_esi)(i386_state *cpustate) // Opcode 0x5e
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+3) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
REG32(ESI) = POP32(cpustate);
else
FAULT(FAULT_SS,0)
static void I386OP(pop_edi)(i386_state *cpustate) // Opcode 0x5f
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+3) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
REG32(EDI) = POP32(cpustate);
else
FAULT(FAULT_SS,0)
UINT32 ea, offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
UINT32 value;
bool fault;
- if(i386_limit_check(cpustate,SS,offset+3) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
{
- ea = i386_translate(cpustate, SS, offset, 0);
+ ea = i386_translate(cpustate, SS, offset, 0, 4);
value = READ32(cpustate, ea);
i386_sreg_load(cpustate,value, segment, &fault);
if(fault) return false;
UINT8 modrm = FETCH(cpustate);
UINT32 value;
UINT32 ea, offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+3) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
{
// be careful here, if the write references the esp register
// it expects the post-pop value but esp must be wound back
if( modrm >= 0xc0 ) {
STORE_RM32(modrm, value);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,4);
try
{
WRITE32(cpustate,ea, value);
static void I386OP(popad)(i386_state *cpustate) // Opcode 0x61
{
UINT32 offset = (STACK_32BIT ? REG32(ESP) : REG16(SP));
- if(i386_limit_check(cpustate,SS,offset+31) == 0)
+ if(i386_limit_check(cpustate,SS,offset,32) == 0)
{
REG32(EDI) = POP32(cpustate);
REG32(ESI) = POP32(cpustate);
mask &= ~0x00003000; // IOPL cannot be changed while in V8086 mode
}
- if(i386_limit_check(cpustate,SS,offset+3) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
{
value = POP32(cpustate);
value &= ~0x00010000; // RF will always return zero
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
PUSH32(cpustate, REG32(EAX) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
PUSH32(cpustate, REG32(ECX) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
PUSH32(cpustate, REG32(EDX) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
PUSH32(cpustate, REG32(EBX) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
PUSH32(cpustate, REG32(ESP) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
PUSH32(cpustate, REG32(EBP) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
PUSH32(cpustate, REG32(ESI) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
PUSH32(cpustate, REG32(EDI) );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
PUSH32SEG(cpustate, cpustate->sreg[CS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
PUSH32SEG(cpustate, cpustate->sreg[DS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
PUSH32SEG(cpustate, cpustate->sreg[ES].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
PUSH32SEG(cpustate, cpustate->sreg[FS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
PUSH32SEG(cpustate, cpustate->sreg[GS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
PUSH32SEG(cpustate, cpustate->sreg[SS].selector );
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
PUSH32(cpustate,value);
else
FAULT(FAULT_SS,0)
offset = REG32(ESP) - 32;
else
offset = (REG16(SP) - 32) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,32) == 0)
{
PUSH32(cpustate, REG32(EAX) );
PUSH32(cpustate, REG32(ECX) );
offset = REG32(ESP) - 4;
else
offset = (REG16(SP) - 4) & 0xffff;
- if(i386_limit_check(cpustate,SS,offset) == 0)
+ if(i386_limit_check(cpustate,SS,offset,4) == 0)
PUSH32(cpustate, get_flags(cpustate) & 0x00fcffff );
else
FAULT(FAULT_SS,0)
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
src = LOAD_REG32(modrm);
dst = READ32(cpustate,ea);
dst = SBB32(cpustate, dst, src, cpustate->CF);
STORE_REG32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = READ32(cpustate,ea);
dst = LOAD_REG32(modrm);
dst = SBB32(cpustate, dst, src, cpustate->CF);
static void I386OP(scasd)(i386_state *cpustate) // Opcode 0xaf
{
UINT32 eas, src, dst;
- eas = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0 );
+ eas = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0, 4 );
src = READ32(cpustate,eas);
dst = REG32(EAX);
SUB32(cpustate,dst, src);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_SHLD_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
UINT32 dst = READ32(cpustate,ea);
UINT32 upper = LOAD_REG32(modrm);
UINT8 shift = FETCH(cpustate);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_SHLD_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
UINT32 dst = READ32(cpustate,ea);
UINT32 upper = LOAD_REG32(modrm);
UINT8 shift = REG8(CL);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_SHRD_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
UINT32 dst = READ32(cpustate,ea);
UINT32 upper = LOAD_REG32(modrm);
UINT8 shift = FETCH(cpustate);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_SHRD_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
UINT32 dst = READ32(cpustate,ea);
UINT32 upper = LOAD_REG32(modrm);
UINT8 shift = REG8(CL);
static void I386OP(stosd)(i386_state *cpustate) // Opcode 0xab
{
- UINT32 eas = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1 );
+ UINT32 eas = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1, 4 );
WRITE32(cpustate,eas, REG32(EAX));
BUMP_DI(cpustate,4);
CYCLES(cpustate,CYCLES_STOS);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
src = LOAD_REG32(modrm);
dst = READ32(cpustate,ea);
dst = SUB32(cpustate,dst, src);
STORE_REG32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = READ32(cpustate,ea);
dst = LOAD_REG32(modrm);
dst = SUB32(cpustate,dst, src);
cpustate->OF = 0;
CYCLES(cpustate,CYCLES_TEST_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = LOAD_REG32(modrm);
dst = READ32(cpustate,ea);
dst = src & dst;
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_XCHG_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
UINT32 src = READ32(cpustate,ea);
UINT32 dst = LOAD_REG32(modrm);
WRITE32(cpustate,ea, dst);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
src = LOAD_REG32(modrm);
dst = READ32(cpustate,ea);
dst = XOR32(cpustate,dst, src);
STORE_REG32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = READ32(cpustate,ea);
dst = LOAD_REG32(modrm);
dst = XOR32(cpustate,dst, src);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,4);
dst = READ32(cpustate,ea);
src = FETCH32(cpustate);
dst = ADD32(cpustate,dst, src);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,4);
dst = READ32(cpustate,ea);
src = FETCH32(cpustate);
dst = OR32(cpustate,dst, src);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,4);
dst = READ32(cpustate,ea);
src = FETCH32(cpustate);
dst = ADC32(cpustate, dst, src, cpustate->CF);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,4);
dst = READ32(cpustate,ea);
src = FETCH32(cpustate);
dst = SBB32(cpustate, dst, src, cpustate->CF);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,4);
dst = READ32(cpustate,ea);
src = FETCH32(cpustate);
dst = AND32(cpustate,dst, src);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,4);
dst = READ32(cpustate,ea);
src = FETCH32(cpustate);
dst = SUB32(cpustate,dst, src);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,4);
dst = READ32(cpustate,ea);
src = FETCH32(cpustate);
dst = XOR32(cpustate,dst, src);
SUB32(cpustate,dst, src);
CYCLES(cpustate,CYCLES_CMP_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,4);
dst = READ32(cpustate,ea);
src = FETCH32(cpustate);
SUB32(cpustate,dst, src);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,4);
dst = READ32(cpustate,ea);
src = (UINT32)(INT32)(INT8)FETCH(cpustate);
dst = ADD32(cpustate,dst, src);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,4);
dst = READ32(cpustate,ea);
src = (UINT32)(INT32)(INT8)FETCH(cpustate);
dst = OR32(cpustate,dst, src);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,4);
dst = READ32(cpustate,ea);
src = (UINT32)(INT32)(INT8)FETCH(cpustate);
dst = ADC32(cpustate, dst, src, cpustate->CF);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,4);
dst = READ32(cpustate,ea);
src = ((UINT32)(INT32)(INT8)FETCH(cpustate));
dst = SBB32(cpustate, dst, src, cpustate->CF);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,4);
dst = READ32(cpustate,ea);
src = (UINT32)(INT32)(INT8)FETCH(cpustate);
dst = AND32(cpustate,dst, src);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,4);
dst = READ32(cpustate,ea);
src = (UINT32)(INT32)(INT8)FETCH(cpustate);
dst = SUB32(cpustate,dst, src);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,4);
dst = READ32(cpustate,ea);
src = (UINT32)(INT32)(INT8)FETCH(cpustate);
dst = XOR32(cpustate,dst, src);
SUB32(cpustate,dst, src);
CYCLES(cpustate,CYCLES_CMP_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,4);
dst = READ32(cpustate,ea);
src = (UINT32)(INT32)(INT8)FETCH(cpustate);
SUB32(cpustate,dst, src);
dst = i386_shift_rotate32(cpustate, modrm, dst, shift);
STORE_RM32(modrm, dst);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
dst = READ32(cpustate,ea);
shift = FETCH(cpustate) & 0x1f;
dst = i386_shift_rotate32(cpustate, modrm, dst, shift);
dst = i386_shift_rotate32(cpustate, modrm, dst, 1);
STORE_RM32(modrm, dst);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
dst = READ32(cpustate,ea);
dst = i386_shift_rotate32(cpustate, modrm, dst, 1);
WRITE32(cpustate,ea, dst);
dst = i386_shift_rotate32(cpustate, modrm, dst, REG8(CL));
STORE_RM32(modrm, dst);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
dst = READ32(cpustate,ea);
dst = i386_shift_rotate32(cpustate, modrm, dst, REG8(CL));
WRITE32(cpustate,ea, dst);
SetSZPF32(dst);
CYCLES(cpustate,CYCLES_TEST_IMM_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
UINT32 dst = READ32(cpustate,ea);
UINT32 src = FETCH32(cpustate);
dst &= src;
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_NOT_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
UINT32 dst = READ32(cpustate,ea);
dst = ~dst;
WRITE32(cpustate,ea, dst);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_NEG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
UINT32 dst = READ32(cpustate,ea);
dst = SUB32(cpustate, 0, dst );
WRITE32(cpustate,ea, dst);
src = LOAD_RM32(modrm);
CYCLES(cpustate,CYCLES_MUL32_ACC_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = READ32(cpustate,ea);
CYCLES(cpustate,CYCLES_MUL32_ACC_MEM); /* TODO: Correct multiply timing */
}
src = (INT64)(INT32)LOAD_RM32(modrm);
CYCLES(cpustate,CYCLES_IMUL32_ACC_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = (INT64)(INT32)READ32(cpustate,ea);
CYCLES(cpustate,CYCLES_IMUL32_ACC_MEM); /* TODO: Correct multiply timing */
}
src = LOAD_RM32(modrm);
CYCLES(cpustate,CYCLES_DIV32_ACC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = READ32(cpustate,ea);
CYCLES(cpustate,CYCLES_DIV32_ACC_MEM);
}
src = LOAD_RM32(modrm);
CYCLES(cpustate,CYCLES_IDIV32_ACC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = READ32(cpustate,ea);
CYCLES(cpustate,CYCLES_IDIV32_ACC_MEM);
}
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_INC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
UINT32 dst = READ32(cpustate,ea);
dst = INC32(cpustate,dst);
WRITE32(cpustate,ea, dst);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_DEC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
UINT32 dst = READ32(cpustate,ea);
dst = DEC32(cpustate,dst);
WRITE32(cpustate,ea, dst);
address = LOAD_RM32(modrm);
CYCLES(cpustate,CYCLES_CALL_REG); /* TODO: Timing = 7 + m */
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
address = READ32(cpustate,ea);
CYCLES(cpustate,CYCLES_CALL_MEM); /* TODO: Timing = 10 + m */
}
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,6);
address = READ32(cpustate,ea + 0);
selector = READ16(cpustate,ea + 4);
CYCLES(cpustate,CYCLES_CALL_MEM_INTERSEG); /* TODO: Timing = 10 + m */
address = LOAD_RM32(modrm);
CYCLES(cpustate,CYCLES_JMP_REG); /* TODO: Timing = 7 + m */
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
address = READ32(cpustate,ea);
CYCLES(cpustate,CYCLES_JMP_MEM); /* TODO: Timing = 10 + m */
}
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,6);
address = READ32(cpustate,ea + 0);
selector = READ16(cpustate,ea + 4);
CYCLES(cpustate,CYCLES_JMP_MEM_INTERSEG); /* TODO: Timing = 10 + m */
if( modrm >= 0xc0 ) {
value = LOAD_RM32(modrm);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
value = READ32(cpustate,ea);
}
PUSH32(cpustate,value);
STORE_RM32(modrm, cpustate->ldtr.segment);
CYCLES(cpustate,CYCLES_SLDT_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
WRITE16(cpustate, ea, cpustate->ldtr.segment);
CYCLES(cpustate,CYCLES_SLDT_MEM);
}
STORE_RM32(modrm, cpustate->task.segment);
CYCLES(cpustate,CYCLES_STR_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
WRITE16(cpustate, ea, cpustate->task.segment);
CYCLES(cpustate,CYCLES_STR_MEM);
}
cpustate->ldtr.segment = address;
CYCLES(cpustate,CYCLES_LLDT_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,4);
cpustate->ldtr.segment = READ32(cpustate,ea);
CYCLES(cpustate,CYCLES_LLDT_MEM);
}
cpustate->task.segment = address;
CYCLES(cpustate,CYCLES_LTR_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,4);
cpustate->task.segment = READ32(cpustate,ea);
CYCLES(cpustate,CYCLES_LTR_MEM);
}
address = LOAD_RM32(modrm);
CYCLES(cpustate,CYCLES_VERR_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,4);
address = READ32(cpustate,ea);
CYCLES(cpustate,CYCLES_VERR_MEM);
}
address = LOAD_RM16(modrm);
CYCLES(cpustate,CYCLES_VERW_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,2);
address = READ16(cpustate,ea);
CYCLES(cpustate,CYCLES_VERW_MEM);
}
{
if( modrm >= 0xc0 ) {
address = LOAD_RM32(modrm);
- ea = i386_translate(cpustate, CS, address, 1 );
+ ea = i386_translate(cpustate, CS, address, 1, 6 );
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,6);
}
WRITE16(cpustate,ea, cpustate->gdtr.limit);
WRITE32(cpustate,ea + 2, cpustate->gdtr.base);
if (modrm >= 0xc0)
{
address = LOAD_RM32(modrm);
- ea = i386_translate(cpustate, CS, address, 1 );
+ ea = i386_translate(cpustate, CS, address, 1, 6 );
}
else
{
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,6);
}
WRITE16(cpustate,ea, cpustate->idtr.limit);
WRITE32(cpustate,ea + 2, cpustate->idtr.base);
FAULT(FAULT_GP,0)
if( modrm >= 0xc0 ) {
address = LOAD_RM32(modrm);
- ea = i386_translate(cpustate, CS, address, 0 );
+ ea = i386_translate(cpustate, CS, address, 0, 6 );
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,6);
}
cpustate->gdtr.limit = READ16(cpustate,ea);
cpustate->gdtr.base = READ32(cpustate,ea + 2);
FAULT(FAULT_GP,0)
if( modrm >= 0xc0 ) {
address = LOAD_RM32(modrm);
- ea = i386_translate(cpustate, CS, address, 0 );
+ ea = i386_translate(cpustate, CS, address, 0, 6 );
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,6);
}
cpustate->idtr.limit = READ16(cpustate,ea);
cpustate->idtr.base = READ32(cpustate,ea + 2);
CYCLES(cpustate,CYCLES_SMSW_REG);
} else {
/* always 16-bit memory operand */
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
WRITE16(cpustate,ea, cpustate->cr[0]);
CYCLES(cpustate,CYCLES_SMSW_MEM);
}
b = LOAD_RM16(modrm);
CYCLES(cpustate,CYCLES_LMSW_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,2);
CYCLES(cpustate,CYCLES_LMSW_MEM);
b = READ16(cpustate,ea);
}
CYCLES(cpustate,CYCLES_BT_IMM_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
UINT32 dst = READ32(cpustate,ea);
UINT8 bit = FETCH(cpustate);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_BTS_IMM_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
UINT32 dst = READ32(cpustate,ea);
UINT8 bit = FETCH(cpustate);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_BTR_IMM_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
UINT32 dst = READ32(cpustate,ea);
UINT8 bit = FETCH(cpustate);
STORE_RM32(modrm, dst);
CYCLES(cpustate,CYCLES_BTC_IMM_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
UINT32 dst = READ32(cpustate,ea);
UINT8 bit = FETCH(cpustate);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
seg.selector = READ32(cpustate,ea);
CYCLES(cpustate,CYCLES_LAR_MEM);
}
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
seg.selector = READ32(cpustate,ea);
}
if(seg.selector == 0)
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,8);
low = READ32(cpustate,ea + 0);
high = READ32(cpustate,ea + 4);
}
if( modrm >= 0xc0 ) {
report_invalid_modrm(cpustate, "load_far_pointer32", modrm);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,6);
STORE_REG32(modrm, READ32(cpustate,ea + 0));
selector = READ16(cpustate,ea + 4);
i386_sreg_load(cpustate,selector,s,NULL);
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
static UINT8 I386OP(shift_rotate8)(i386_state *cpustate, UINT8 modrm, UINT32 value, UINT8 shift)
{
UINT32 src = value & 0xff;
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
src = LOAD_REG8(modrm);
dst = READ8(cpustate,ea);
dst = ADC8(cpustate, dst, src, cpustate->CF);
STORE_REG8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
src = READ8(cpustate,ea);
dst = LOAD_REG8(modrm);
dst = ADC8(cpustate, dst, src, cpustate->CF);
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
src = LOAD_REG8(modrm);
dst = READ8(cpustate,ea);
dst = ADD8(cpustate,dst, src);
STORE_REG8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
src = READ8(cpustate,ea);
dst = LOAD_REG8(modrm);
dst = ADD8(cpustate,dst, src);
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
src = LOAD_REG8(modrm);
dst = READ8(cpustate,ea);
dst = AND8(cpustate,dst, src);
STORE_REG8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
src = READ8(cpustate,ea);
dst = LOAD_REG8(modrm);
dst = AND8(cpustate,dst, src);
SUB8(cpustate,dst, src);
CYCLES(cpustate,CYCLES_CMP_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
src = LOAD_REG8(modrm);
dst = READ8(cpustate,ea);
SUB8(cpustate,dst, src);
SUB8(cpustate,dst, src);
CYCLES(cpustate,CYCLES_CMP_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
src = READ8(cpustate,ea);
dst = LOAD_REG8(modrm);
SUB8(cpustate,dst, src);
UINT32 eas, ead;
UINT8 src, dst;
if( cpustate->segment_prefix ) {
- eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
} else {
- eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
}
- ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0 );
+ ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0, 1 );
src = READ8(cpustate,eas);
dst = READ8(cpustate,ead);
SUB8(cpustate,src, dst);
{
UINT32 eas;
if( cpustate->segment_prefix ) {
- eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
} else {
- eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
}
REG8(AL) = READ8(cpustate,eas);
BUMP_SI(cpustate,1);
STORE_RM8(modrm, src);
CYCLES(cpustate,CYCLES_MOV_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
src = LOAD_REG8(modrm);
WRITE8(cpustate,ea, src);
CYCLES(cpustate,CYCLES_MOV_REG_MEM);
STORE_REG8(modrm, src);
CYCLES(cpustate,CYCLES_MOV_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
src = READ8(cpustate,ea);
STORE_REG8(modrm, src);
CYCLES(cpustate,CYCLES_MOV_MEM_REG);
STORE_RM8(modrm, value);
CYCLES(cpustate,CYCLES_MOV_IMM_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
UINT8 value = FETCH(cpustate);
WRITE8(cpustate,ea, value);
CYCLES(cpustate,CYCLES_MOV_IMM_MEM);
}
/* TODO: Not sure if this is correct... */
if( cpustate->segment_prefix ) {
- ea = i386_translate(cpustate, cpustate->segment_override, offset, 0 );
+ ea = i386_translate(cpustate, cpustate->segment_override, offset, 0, 1 );
} else {
- ea = i386_translate(cpustate, DS, offset, 0 );
+ ea = i386_translate(cpustate, DS, offset, 0, 1 );
}
REG8(AL) = READ8(cpustate,ea);
CYCLES(cpustate,CYCLES_MOV_IMM_MEM);
}
/* TODO: Not sure if this is correct... */
if( cpustate->segment_prefix ) {
- ea = i386_translate(cpustate, cpustate->segment_override, offset, 1 );
+ ea = i386_translate(cpustate, cpustate->segment_override, offset, 1, 1 );
} else {
- ea = i386_translate(cpustate, DS, offset, 1 );
+ ea = i386_translate(cpustate, DS, offset, 1, 1 );
}
WRITE8(cpustate, ea, REG8(AL) );
CYCLES(cpustate,CYCLES_MOV_MEM_ACC);
STORE_RM16(modrm, cpustate->sreg[s].selector);
CYCLES(cpustate,CYCLES_MOV_SREG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
WRITE16(cpustate,ea, cpustate->sreg[s].selector);
CYCLES(cpustate,CYCLES_MOV_SREG_MEM);
}
selector = LOAD_RM16(modrm);
CYCLES(cpustate,CYCLES_MOV_REG_SREG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
selector = READ16(cpustate,ea);
CYCLES(cpustate,CYCLES_MOV_MEM_SREG);
}
UINT32 eas, ead;
UINT8 v;
if( cpustate->segment_prefix ) {
- eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
} else {
- eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, 1 );
}
- ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1 );
+ ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1, 1 );
v = READ8(cpustate,eas);
WRITE8(cpustate,ead, v);
BUMP_SI(cpustate,1);
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
src = LOAD_REG8(modrm);
dst = READ8(cpustate,ea);
dst = OR8(cpustate,dst, src);
STORE_REG8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
src = READ8(cpustate,ea);
dst = LOAD_REG8(modrm);
dst = OR8(cpustate,dst, src);
STORE_RM16(modrm, dst);
}
} else {
- UINT32 ea = GetEA(cpustate, modrm,1);
+ UINT32 ea = GetEA(cpustate, modrm,1,2);
src = LOAD_REG16(modrm);
dst = READ16(cpustate, ea);
if( (dst&0x3) < (src&0x3) ) {
UINT16 vw;
UINT32 vd;
- ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1 );
+ ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1, size);
switch(size) {
case 1:
UINT32 vd;
if( cpustate->segment_prefix ) {
- eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, cpustate->segment_override, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, size );
} else {
- eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0 );
+ eas = i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), 0, size );
}
switch(size) {
if( cpustate->segment_prefix ) {
// FIXME: the following does not work if both address override and segment override are used
- i386_translate(cpustate, cpustate->segment_override, cpustate->sreg[cpustate->segment_prefix].d ? REG32(ESI) : REG16(SI), -1 );
+ i386_translate(cpustate, cpustate->segment_override, cpustate->sreg[cpustate->segment_prefix].d ? REG32(ESI) : REG16(SI), -1, 1 );
} else {
//eas =
- i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), -1 );
+ i386_translate(cpustate, DS, cpustate->address_size ? REG32(ESI) : REG16(SI), -1, 1 );
}
- i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), -1 );
+ i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), -1, 1 );
switch(opcode)
{
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
src = LOAD_REG8(modrm);
dst = READ8(cpustate,ea);
dst = SBB8(cpustate, dst, src, cpustate->CF);
STORE_REG8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
src = READ8(cpustate,ea);
dst = LOAD_REG8(modrm);
dst = SBB8(cpustate, dst, src, cpustate->CF);
{
UINT32 eas;
UINT8 src, dst;
- eas = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0 );
+ eas = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 0, 1 );
src = READ8(cpustate,eas);
dst = REG8(AL);
SUB8(cpustate,dst, src);
STORE_RM8(modrm, value);
CYCLES(cpustate,CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
WRITE8(cpustate,ea, value);
CYCLES(cpustate,CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(cpustate,CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
WRITE8(cpustate,ea, value);
CYCLES(cpustate,CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(cpustate,CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
WRITE8(cpustate,ea, value);
CYCLES(cpustate,CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(cpustate,CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
WRITE8(cpustate,ea, value);
CYCLES(cpustate,CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(cpustate,CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
WRITE8(cpustate,ea, value);
CYCLES(cpustate,CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(cpustate,CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
WRITE8(cpustate,ea, value);
CYCLES(cpustate,CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(cpustate,CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
WRITE8(cpustate,ea, value);
CYCLES(cpustate,CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(cpustate,CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
WRITE8(cpustate,ea, value);
CYCLES(cpustate,CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(cpustate,CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
WRITE8(cpustate,ea, value);
CYCLES(cpustate,CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(cpustate,CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
WRITE8(cpustate,ea, value);
CYCLES(cpustate,CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(cpustate,CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
WRITE8(cpustate,ea, value);
CYCLES(cpustate,CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(cpustate,CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
WRITE8(cpustate,ea, value);
CYCLES(cpustate,CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(cpustate,CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
WRITE8(cpustate,ea, value);
CYCLES(cpustate,CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(cpustate,CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
WRITE8(cpustate,ea, value);
CYCLES(cpustate,CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(cpustate,CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
WRITE8(cpustate,ea, value);
CYCLES(cpustate,CYCLES_SETCC_MEM);
}
STORE_RM8(modrm, value);
CYCLES(cpustate,CYCLES_SETCC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
WRITE8(cpustate,ea, value);
CYCLES(cpustate,CYCLES_SETCC_MEM);
}
static void I386OP(stosb)(i386_state *cpustate) // Opcode 0xaa
{
UINT32 ead;
- ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1 );
+ ead = i386_translate(cpustate, ES, cpustate->address_size ? REG32(EDI) : REG16(DI), 1, 1 );
WRITE8(cpustate,ead, REG8(AL));
BUMP_DI(cpustate,1);
CYCLES(cpustate,CYCLES_STOS);
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
src = LOAD_REG8(modrm);
dst = READ8(cpustate,ea);
dst = SUB8(cpustate,dst, src);
STORE_REG8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
src = READ8(cpustate,ea);
dst = LOAD_REG8(modrm);
dst = SUB8(cpustate,dst, src);
cpustate->OF = 0;
CYCLES(cpustate,CYCLES_TEST_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
src = LOAD_REG8(modrm);
dst = READ8(cpustate,ea);
dst = src & dst;
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_XCHG_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
UINT8 src = READ8(cpustate,ea);
UINT8 dst = LOAD_REG8(modrm);
WRITE8(cpustate,ea, dst);
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
src = LOAD_REG8(modrm);
dst = READ8(cpustate,ea);
dst = XOR8(cpustate,dst, src);
STORE_REG8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
src = READ8(cpustate,ea);
dst = LOAD_REG8(modrm);
dst = XOR8(cpustate,dst, src);
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,1);
dst = READ8(cpustate,ea);
src = FETCH(cpustate);
dst = ADD8(cpustate,dst, src);
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,1);
dst = READ8(cpustate,ea);
src = FETCH(cpustate);
dst = OR8(cpustate,dst, src);
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,1);
dst = READ8(cpustate,ea);
src = FETCH(cpustate);
dst = ADC8(cpustate, dst, src, cpustate->CF);
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,1);
dst = READ8(cpustate,ea);
src = FETCH(cpustate);
dst = SBB8(cpustate, dst, src, cpustate->CF);
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,1);
dst = READ8(cpustate,ea);
src = FETCH(cpustate);
dst = AND8(cpustate,dst, src);
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,1);
dst = READ8(cpustate,ea);
src = FETCH(cpustate);
dst = SUB8(cpustate,dst, src);
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_ALU_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,1);
dst = READ8(cpustate,ea);
src = FETCH(cpustate);
dst = XOR8(cpustate,dst, src);
SUB8(cpustate,dst, src);
CYCLES(cpustate,CYCLES_CMP_REG_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,1);
dst = READ8(cpustate,ea);
src = FETCH(cpustate);
SUB8(cpustate,dst, src);
dst = i386_shift_rotate8(cpustate, modrm, dst, shift);
STORE_RM8(modrm, dst);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
dst = READ8(cpustate,ea);
shift = FETCH(cpustate) & 0x1f;
dst = i386_shift_rotate8(cpustate, modrm, dst, shift);
dst = i386_shift_rotate8(cpustate, modrm, dst, 1);
STORE_RM8(modrm, dst);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
dst = READ8(cpustate,ea);
dst = i386_shift_rotate8(cpustate, modrm, dst, 1);
WRITE8(cpustate,ea, dst);
dst = i386_shift_rotate8(cpustate, modrm, dst, REG8(CL));
STORE_RM8(modrm, dst);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
dst = READ8(cpustate,ea);
dst = i386_shift_rotate8(cpustate, modrm, dst, REG8(CL));
WRITE8(cpustate,ea, dst);
SetSZPF8(dst);
CYCLES(cpustate,CYCLES_TEST_IMM_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
UINT8 dst = READ8(cpustate,ea);
UINT8 src = FETCH(cpustate);
dst &= src;
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_NOT_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
UINT8 dst = READ8(cpustate,ea);
dst = ~dst;
WRITE8(cpustate,ea, dst);
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_NEG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
UINT8 dst = READ8(cpustate,ea);
dst = SUB8(cpustate, 0, dst );
WRITE8(cpustate,ea, dst);
src = LOAD_RM8(modrm);
CYCLES(cpustate,CYCLES_MUL8_ACC_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
src = READ8(cpustate,ea);
CYCLES(cpustate,CYCLES_MUL8_ACC_MEM); /* TODO: Correct multiply timing */
}
src = (INT16)(INT8)LOAD_RM8(modrm);
CYCLES(cpustate,CYCLES_IMUL8_ACC_REG); /* TODO: Correct multiply timing */
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
src = (INT16)(INT8)READ8(cpustate,ea);
CYCLES(cpustate,CYCLES_IMUL8_ACC_MEM); /* TODO: Correct multiply timing */
}
src = LOAD_RM8(modrm);
CYCLES(cpustate,CYCLES_DIV8_ACC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
src = READ8(cpustate,ea);
CYCLES(cpustate,CYCLES_DIV8_ACC_MEM);
}
src = LOAD_RM8(modrm);
CYCLES(cpustate,CYCLES_IDIV8_ACC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
src = READ8(cpustate,ea);
CYCLES(cpustate,CYCLES_IDIV8_ACC_MEM);
}
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_INC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
UINT8 dst = READ8(cpustate,ea);
dst = INC8(cpustate,dst);
WRITE8(cpustate,ea, dst);
STORE_RM8(modrm, dst);
CYCLES(cpustate,CYCLES_DEC_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
UINT8 dst = READ8(cpustate,ea);
dst = DEC8(cpustate,dst);
WRITE8(cpustate,ea, dst);
if( modrm >= 0xc0 ) {
value = LOAD_RM8(modrm);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
value = READ8(cpustate,ea);
}
if( cpustate->operand_size ) {
UINT8 modrm = FETCH(cpustate);
if(modrm < 0xc0)
{
- i386_escape_ea = GetEA(cpustate,modrm,0);
+ i386_escape_ea = GetEA(cpustate,modrm,0,1);
}
CYCLES(cpustate,3); // TODO: confirm this
(void) LOAD_RM8(modrm);
{
if(PROTECTED_MODE && (cpustate->CPL != 0))
FAULT(FAULT_GP,0)
- UINT32 ea = i386_translate(cpustate, ES, REG32(EDI), 0);
+ UINT32 ea = i386_translate(cpustate, ES, REG32(EDI), 0, 204);
cpustate->cr[0] = READ32(cpustate, ea) & 0xfffeffff; // wp not supported on 386
set_flags(cpustate, READ32(cpustate, ea + 0x04));
cpustate->eip = READ32(cpustate, ea + 0x08);
if( cpustate->segment_prefix ) {
if(!cpustate->address_size)
{
- ea = i386_translate(cpustate, cpustate->segment_override, REG16(BX) + REG8(AL), 0 );
+ ea = i386_translate(cpustate, cpustate->segment_override, REG16(BX) + REG8(AL), 0, 1 );
}
else
{
- ea = i386_translate(cpustate, cpustate->segment_override, REG32(EBX) + REG8(AL), 0 );
+ ea = i386_translate(cpustate, cpustate->segment_override, REG32(EBX) + REG8(AL), 0, 1 );
}
} else {
if(!cpustate->address_size)
{
- ea = i386_translate(cpustate, DS, REG16(BX) + REG8(AL), 0 );
+ ea = i386_translate(cpustate, DS, REG16(BX) + REG8(AL), 0, 1 );
}
else
{
- ea = i386_translate(cpustate, DS, REG32(EBX) + REG8(AL), 0 );
+ ea = i386_translate(cpustate, DS, REG32(EBX) + REG8(AL), 0, 1 );
}
}
REG8(AL) = READ8(cpustate,ea);
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
struct X86_OPCODE {
UINT8 opcode;
UINT32 flags;
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
#pragma once
#ifndef __I386_H__
};
extern int i386_parity_table[256];
-static int i386_limit_check(i386_state *cpustate, int seg, UINT32 offset);
+static int i386_limit_check(i386_state *cpustate, int seg, UINT32 offset, UINT32 size);
#define FAULT_THROW(fault,error) { throw (UINT64)(fault | (UINT64)error << 32); }
#define PF_THROW(error) { cpustate->cr[2] = address; FAULT_THROW(FAULT_PF,error); }
/***********************************************************************************/
-INLINE UINT32 i386_translate(i386_state *cpustate, int segment, UINT32 ip, int rwn)
+INLINE UINT32 i386_translate(i386_state *cpustate, int segment, UINT32 ip, int rwn, UINT32 size)
{
// TODO: segment limit access size, execution permission, handle exception thrown from exception handler
if(PROTECTED_MODE && !V8086_MODE && (rwn != -1))
{
if(!(cpustate->sreg[segment].valid))
FAULT_THROW((segment==SS)?FAULT_SS:FAULT_GP, 0);
- if(i386_limit_check(cpustate, segment, ip))
+ if(i386_limit_check(cpustate, segment, ip, size))
FAULT_THROW((segment==SS)?FAULT_SS:FAULT_GP, 0);
if((rwn == 0) && ((cpustate->sreg[segment].flags & 8) && !(cpustate->sreg[segment].flags & 2)))
FAULT_THROW(FAULT_GP, 0);
INLINE void CHANGE_PC(i386_state *cpustate, UINT32 pc)
{
- cpustate->pc = i386_translate(cpustate, CS, pc, -1 );
+ cpustate->pc = i386_translate(cpustate, CS, pc, -1, 1 );
}
INLINE void NEAR_BRANCH(i386_state *cpustate, INT32 offs)
if(!translate_address(cpustate,cpustate->CPL,TRANSLATE_WRITE,&address,&error))
PF_THROW(error);
- ea &= cpustate->a20_mask;
+ address &= cpustate->a20_mask;
cpustate->program->write_data32(address, value);
}
}
if(!translate_address(cpustate,cpustate->CPL,TRANSLATE_WRITE,&address,&error))
PF_THROW(error);
- ea &= cpustate->a20_mask;
+ address &= cpustate->a20_mask;
cpustate->program->write_data32(address+0, value & 0xffffffff);
cpustate->program->write_data32(address+4, (value >> 32) & 0xffffffff);
}
UINT32 ea, new_esp;
if( STACK_32BIT ) {
new_esp = REG32(ESP) - 2;
- ea = i386_translate(cpustate, SS, new_esp, 1);
+ ea = i386_translate(cpustate, SS, new_esp, 1, 2);
WRITE16(cpustate, ea, value );
REG32(ESP) = new_esp;
} else {
new_esp = (REG16(SP) - 2) & 0xffff;
- ea = i386_translate(cpustate, SS, new_esp, 1);
+ ea = i386_translate(cpustate, SS, new_esp, 1, 2);
WRITE16(cpustate, ea, value );
REG16(SP) = new_esp;
}
UINT32 ea, new_esp;
if( STACK_32BIT ) {
new_esp = REG32(ESP) - 4;
- ea = i386_translate(cpustate, SS, new_esp, 1);
+ ea = i386_translate(cpustate, SS, new_esp, 1, 4);
WRITE32(cpustate, ea, value );
REG32(ESP) = new_esp;
} else {
new_esp = (REG16(SP) - 4) & 0xffff;
- ea = i386_translate(cpustate, SS, new_esp, 1);
+ ea = i386_translate(cpustate, SS, new_esp, 1, 4);
WRITE32(cpustate, ea, value );
REG16(SP) = new_esp;
}
UINT32 ea, new_esp;
if( STACK_32BIT ) {
new_esp = REG32(ESP) - 4;
- ea = i386_translate(cpustate, SS, new_esp, 1);
- ((cpustate->cpu_version & 0xf00) == 0x300) ? WRITE16(cpustate, ea, value) : WRITE32(cpustate, ea, value ); // 486 also?
+ if( (cpustate->cpu_version & 0xf00) == 0x300 ) {
+ ea = i386_translate(cpustate, SS, new_esp, 1, 2);
+ WRITE16(cpustate, ea, value); // 486 also?
+ } else {
+ ea = i386_translate(cpustate, SS, new_esp, 1, 4);
+ WRITE32(cpustate, ea, value ); // 486 also?
+ }
REG32(ESP) = new_esp;
} else {
new_esp = (REG16(SP) - 4) & 0xffff;
- ea = i386_translate(cpustate, SS, new_esp, 1);
- ((cpustate->cpu_version & 0xf00) == 0x300) ? WRITE16(cpustate, ea, value) : WRITE32(cpustate, ea, value );
+ if( (cpustate->cpu_version & 0xf00) == 0x300 ) {
+ ea = i386_translate(cpustate, SS, new_esp, 1, 2);
+ WRITE16(cpustate, ea, value);
+ } else {
+ ea = i386_translate(cpustate, SS, new_esp, 1, 4);
+ WRITE32(cpustate, ea, value );
+ }
REG16(SP) = new_esp;
}
}
UINT32 ea, new_esp;
if( STACK_32BIT ) {
new_esp = REG32(ESP) + 1;
- ea = i386_translate(cpustate, SS, new_esp - 1, 0);
+ ea = i386_translate(cpustate, SS, new_esp - 1, 0, 1);
value = READ8(cpustate, ea );
REG32(ESP) = new_esp;
} else {
new_esp = REG16(SP) + 1;
- ea = i386_translate(cpustate, SS, (new_esp - 1) & 0xffff, 0);
+ ea = i386_translate(cpustate, SS, (new_esp - 1) & 0xffff, 0, 1);
value = READ8(cpustate, ea );
REG16(SP) = new_esp;
}
UINT32 ea, new_esp;
if( STACK_32BIT ) {
new_esp = REG32(ESP) + 2;
- ea = i386_translate(cpustate, SS, new_esp - 2, 0);
+ ea = i386_translate(cpustate, SS, new_esp - 2, 0, 2);
value = READ16(cpustate, ea );
REG32(ESP) = new_esp;
} else {
new_esp = REG16(SP) + 2;
- ea = i386_translate(cpustate, SS, (new_esp - 2) & 0xffff, 0);
+ ea = i386_translate(cpustate, SS, (new_esp - 2) & 0xffff, 0, 2);
value = READ16(cpustate, ea );
REG16(SP) = new_esp;
}
UINT32 ea, new_esp;
if( STACK_32BIT ) {
new_esp = REG32(ESP) + 4;
- ea = i386_translate(cpustate, SS, new_esp - 4, 0);
+ ea = i386_translate(cpustate, SS, new_esp - 4, 0, 4);
value = READ32(cpustate, ea );
REG32(ESP) = new_esp;
} else {
new_esp = REG16(SP) + 4;
- ea = i386_translate(cpustate, SS, (new_esp - 4) & 0xffff, 0);
+ ea = i386_translate(cpustate, SS, (new_esp - 4) & 0xffff, 0, 4);
value = READ32(cpustate, ea );
REG16(SP) = new_esp;
}
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett
// Intel 486+ specific opcodes
static void I486OP(cpuid)(i386_state *cpustate) // Opcode 0x0F A2
}
} else {
// TODO: Check write if needed
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
UINT8 dst = READ8(cpustate,ea);
UINT8 src = LOAD_REG8(modrm);
CYCLES(cpustate,CYCLES_CMPXCHG_REG_REG_F);
}
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
UINT16 dst = READ16(cpustate,ea);
UINT16 src = LOAD_REG16(modrm);
CYCLES(cpustate,CYCLES_CMPXCHG_REG_REG_F);
}
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
UINT32 dst = READ32(cpustate,ea);
UINT32 src = LOAD_REG32(modrm);
STORE_RM8(modrm, dst + src);
CYCLES(cpustate,CYCLES_XADD_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,1);
UINT8 dst = READ8(cpustate,ea);
UINT8 src = LOAD_REG8(modrm);
WRITE8(cpustate,ea, dst + src);
STORE_RM16(modrm, dst + src);
CYCLES(cpustate,CYCLES_XADD_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,2);
UINT16 dst = READ16(cpustate,ea);
UINT16 src = LOAD_REG16(modrm);
WRITE16(cpustate,ea, dst + src);
STORE_RM32(modrm, dst + src);
CYCLES(cpustate,CYCLES_XADD_REG_REG);
} else {
- UINT32 ea = GetEA(cpustate,modrm,1);
+ UINT32 ea = GetEA(cpustate,modrm,1,4);
UINT32 dst = READ32(cpustate,ea);
UINT32 src = LOAD_REG32(modrm);
WRITE32(cpustate,ea, dst + src);
{
if( modrm >= 0xc0 ) {
address = LOAD_RM16(modrm);
- ea = i386_translate( cpustate, CS, address, 1 );
+ ea = i386_translate( cpustate, CS, address, 1, 6 );
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,6);
}
WRITE16(cpustate,ea, cpustate->gdtr.limit);
WRITE32(cpustate,ea + 2, cpustate->gdtr.base & 0xffffff);
if (modrm >= 0xc0)
{
address = LOAD_RM16(modrm);
- ea = i386_translate( cpustate, CS, address, 1 );
+ ea = i386_translate( cpustate, CS, address, 1, 6 );
}
else
{
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,6);
}
WRITE16(cpustate,ea, cpustate->idtr.limit);
WRITE32(cpustate,ea + 2, cpustate->idtr.base & 0xffffff);
FAULT(FAULT_GP,0)
if( modrm >= 0xc0 ) {
address = LOAD_RM16(modrm);
- ea = i386_translate( cpustate, CS, address, 0 );
+ ea = i386_translate( cpustate, CS, address, 0, 6 );
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,6);
}
cpustate->gdtr.limit = READ16(cpustate,ea);
cpustate->gdtr.base = READ32(cpustate,ea + 2) & 0xffffff;
FAULT(FAULT_GP,0)
if( modrm >= 0xc0 ) {
address = LOAD_RM16(modrm);
- ea = i386_translate( cpustate, CS, address, 0 );
+ ea = i386_translate( cpustate, CS, address, 0, 6 );
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,6);
}
cpustate->idtr.limit = READ16(cpustate,ea);
cpustate->idtr.base = READ32(cpustate,ea + 2) & 0xffffff;
STORE_RM16(modrm, cpustate->cr[0]);
CYCLES(cpustate,CYCLES_SMSW_REG);
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
WRITE16(cpustate,ea, cpustate->cr[0]);
CYCLES(cpustate,CYCLES_SMSW_MEM);
}
b = LOAD_RM16(modrm);
CYCLES(cpustate,CYCLES_LMSW_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,2);
CYCLES(cpustate,CYCLES_LMSW_MEM);
b = READ16(cpustate,ea);
}
logerror("i486: invlpg with modrm %02X\n", modrm);
FAULT(FAULT_UD,0)
}
- ea = GetEA(cpustate,modrm,-1);
+ ea = GetEA(cpustate,modrm,-1,1);
CYCLES(cpustate,25); // TODO: add to cycles.h
vtlb_flush_address(cpustate->vtlb, ea);
break;
{
if( modrm >= 0xc0 ) {
address = LOAD_RM32(modrm);
- ea = i386_translate( cpustate, CS, address, 1 );
+ ea = i386_translate( cpustate, CS, address, 1, 6 );
} else {
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,6);
}
WRITE16(cpustate,ea, cpustate->gdtr.limit);
WRITE32(cpustate,ea + 2, cpustate->gdtr.base);
if (modrm >= 0xc0)
{
address = LOAD_RM32(modrm);
- ea = i386_translate( cpustate, CS, address, 1 );
+ ea = i386_translate( cpustate, CS, address, 1, 6 );
}
else
{
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,6);
}
WRITE16(cpustate,ea, cpustate->idtr.limit);
WRITE32(cpustate,ea + 2, cpustate->idtr.base);
FAULT(FAULT_GP,0)
if( modrm >= 0xc0 ) {
address = LOAD_RM32(modrm);
- ea = i386_translate( cpustate, CS, address, 0 );
+ ea = i386_translate( cpustate, CS, address, 0, 6 );
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,6);
}
cpustate->gdtr.limit = READ16(cpustate,ea);
cpustate->gdtr.base = READ32(cpustate,ea + 2);
FAULT(FAULT_GP,0)
if( modrm >= 0xc0 ) {
address = LOAD_RM32(modrm);
- ea = i386_translate( cpustate, CS, address, 0 );
+ ea = i386_translate( cpustate, CS, address, 0, 6 );
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,6);
}
cpustate->idtr.limit = READ16(cpustate,ea);
cpustate->idtr.base = READ32(cpustate,ea + 2);
CYCLES(cpustate,CYCLES_SMSW_REG);
} else {
/* always 16-bit memory operand */
- ea = GetEA(cpustate,modrm,1);
+ ea = GetEA(cpustate,modrm,1,2);
WRITE16(cpustate,ea, cpustate->cr[0]);
CYCLES(cpustate,CYCLES_SMSW_MEM);
}
b = LOAD_RM16(modrm);
CYCLES(cpustate,CYCLES_LMSW_REG);
} else {
- ea = GetEA(cpustate,modrm,0);
+ ea = GetEA(cpustate,modrm,0,2);
CYCLES(cpustate,CYCLES_LMSW_MEM);
b = READ16(cpustate,ea);
}
logerror("i486: invlpg with modrm %02X\n", modrm);
FAULT(FAULT_UD,0)
}
- ea = GetEA(cpustate,modrm,-1);
+ ea = GetEA(cpustate,modrm,-1,1);
CYCLES(cpustate,25); // TODO: add to cycles.h
vtlb_flush_address(cpustate->vtlb, ea);
break;
// license:BSD-3-Clause
-// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philp Bennett
+// copyright-holders:Ville Linde, Barry Rodewald, Carl, Philip Bennett, Samuele Zannoli
// Pentium+ specific opcodes
extern flag float32_is_nan( float32 a ); // since its not defined in softfloat.h
static void PENTIUMOP(prefetch_m8)(i386_state* cpustate) // Opcode 0x0f 18
{
UINT8 modrm = FETCH(cpustate);
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,1);
CYCLES(cpustate,1+(ea & 1)); // TODO: correct cycle count
}
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
if (cpustate->OF == 1)
{
src = READ16(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
if (cpustate->OF == 1)
{
src = READ32(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
if (cpustate->OF == 0)
{
src = READ16(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
if (cpustate->OF == 0)
{
src = READ32(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
if (cpustate->CF == 1)
{
src = READ16(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
if (cpustate->CF == 1)
{
src = READ32(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
if (cpustate->CF == 0)
{
src = READ16(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
if (cpustate->CF == 0)
{
src = READ32(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
if (cpustate->ZF == 1)
{
src = READ16(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
if (cpustate->ZF == 1)
{
src = READ32(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
if (cpustate->ZF == 0)
{
src = READ16(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
if (cpustate->ZF == 0)
{
src = READ32(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
if ((cpustate->CF == 1) || (cpustate->ZF == 1))
{
src = READ16(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
if ((cpustate->CF == 1) || (cpustate->ZF == 1))
{
src = READ32(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
if ((cpustate->CF == 0) && (cpustate->ZF == 0))
{
src = READ16(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
if ((cpustate->CF == 0) && (cpustate->ZF == 0))
{
src = READ32(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
if (cpustate->SF == 1)
{
src = READ16(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
if (cpustate->SF == 1)
{
src = READ32(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
if (cpustate->SF == 0)
{
src = READ16(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
if (cpustate->SF == 0)
{
src = READ32(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
if (cpustate->PF == 1)
{
src = READ16(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
if (cpustate->PF == 1)
{
src = READ32(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
if (cpustate->PF == 0)
{
src = READ16(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
if (cpustate->PF == 0)
{
src = READ32(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
if (cpustate->SF != cpustate->OF)
{
src = READ16(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
if (cpustate->SF != cpustate->OF)
{
src = READ32(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
if (cpustate->SF == cpustate->OF)
{
src = READ16(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
if (cpustate->SF == cpustate->OF)
{
src = READ32(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
if ((cpustate->ZF == 1) || (cpustate->SF != cpustate->OF))
{
src = READ16(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
if ((cpustate->ZF == 1) || (cpustate->SF != cpustate->OF))
{
src = READ32(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
if ((cpustate->ZF == 0) && (cpustate->SF == cpustate->OF))
{
src = READ16(cpustate,ea);
}
else
{
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
if ((cpustate->ZF == 0) && (cpustate->SF == cpustate->OF))
{
src = READ32(cpustate,ea);
CYCLES(cpustate,1); // TODO: correct cycle count
} else {
// since cache is not implemented
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 2);
WRITE16(cpustate,ea,LOAD_RM16(modrm));
CYCLES(cpustate,1); // TODO: correct cycle count
}
CYCLES(cpustate,1); // TODO: correct cycle count
} else {
// since cache is not implemented
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
WRITE32(cpustate,ea,LOAD_RM32(modrm));
CYCLES(cpustate,1); // TODO: correct cycle count
}
if( modm >= 0xc0 ) {
report_invalid_modrm(cpustate, "cmpxchg8b_m64", modm);
} else {
- UINT32 ea = GetEA(cpustate,modm, 0);
+ UINT32 ea = GetEA(cpustate,modm, 0, 8);
UINT64 value = READ64(cpustate, ea);
UINT64 edx_eax = (((UINT64) REG32(EDX)) << 32) | REG32(EAX);
UINT64 ecx_ebx = (((UINT64) REG32(ECX)) << 32) | REG32(EBX);
CYCLES(cpustate,1); // unsupported
} else {
// since cache is not implemented
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
WRITEMMX(cpustate, ea, MMX((modrm >> 3) & 0x7));
CYCLES(cpustate,1); // TODO: correct cycle count
}
{
int s,m,n;
UINT8 modm = FETCH(cpustate);
- UINT32 ea = GetEA(cpustate,7, 0); // ds:di/edi/rdi register
+ UINT32 ea = GetEA(cpustate,7, 0, 8); // ds:di/edi/rdi register
MMXPROLOG(cpustate);
s=(modm >> 3) & 7;
m=modm & 7;
{
int s,m,n;
UINT8 modm = FETCH(cpustate);
- UINT32 ea = GetEA(cpustate,7, 0); // ds:di/edi/rdi register
+ UINT32 ea = GetEA(cpustate,7, 0, 16); // ds:di/edi/rdi register
s=(modm >> 3) & 7;
m=modm & 7;
for (n=0;n < 16;n++)
if( modrm >= 0xc0 ) {
src = LOAD_RM16(modrm);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,2);
src = READ16(cpustate,ea);
}
count=0;
if( modrm >= 0xc0 ) {
src = LOAD_RM32(modrm);
} else {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,4);
src = READ32(cpustate,ea);
}
count=0;
MMX((modrm >> 3) & 0x7).w[3]=MMX((modrm >> 3) & 0x7).w[3] >> count;
} else {
MMX_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, src);
int count=(int)src.q;
MMX((modrm >> 3) & 0x7).w[0]=MMX((modrm >> 3) & 0x7).w[0] >> count;
MMX((modrm >> 3) & 0x7).d[1]=MMX((modrm >> 3) & 0x7).d[1] >> count;
} else {
MMX_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, src);
int count=(int)src.q;
MMX((modrm >> 3) & 0x7).d[0]=MMX((modrm >> 3) & 0x7).d[0] >> count;
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q >> count;
} else {
MMX_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, src);
int count=(int)src.q;
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q >> count;
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q+MMX(modrm & 7).q;
} else {
MMX_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, src);
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q+src.q;
}
MMX((modrm >> 3) & 0x7).w[3]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[3]*(INT32)MMX(modrm & 7).s[3]) & 0xffff;
} else {
MMX_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, src);
MMX((modrm >> 3) & 0x7).w[0]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[0]*(INT32)src.s[0]) & 0xffff;
MMX((modrm >> 3) & 0x7).w[1]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[1]*(INT32)src.s[1]) & 0xffff;
MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] < MMX(modrm & 7).b[n] ? 0 : MMX((modrm >> 3) & 0x7).b[n]-MMX(modrm & 7).b[n];
} else {
MMX_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, src);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] < src.b[n] ? 0 : MMX((modrm >> 3) & 0x7).b[n]-src.b[n];
MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] < MMX(modrm & 7).w[n] ? 0 : MMX((modrm >> 3) & 0x7).w[n]-MMX(modrm & 7).w[n];
} else {
MMX_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, src);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] < src.w[n] ? 0 : MMX((modrm >> 3) & 0x7).w[n]-src.w[n];
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q & MMX(modrm & 7).q;
} else {
MMX_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, src);
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q & src.q;
}
MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] > (0xff-MMX(modrm & 7).b[n]) ? 0xff : MMX((modrm >> 3) & 0x7).b[n]+MMX(modrm & 7).b[n];
} else {
MMX_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, src);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] > (0xff-src.b[n]) ? 0xff : MMX((modrm >> 3) & 0x7).b[n]+src.b[n];
MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] > (0xffff-MMX(modrm & 7).w[n]) ? 0xffff : MMX((modrm >> 3) & 0x7).w[n]+MMX(modrm & 7).w[n];
} else {
MMX_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, src);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] > (0xffff-src.w[n]) ? 0xffff : MMX((modrm >> 3) & 0x7).w[n]+src.w[n];
MMX((modrm >> 3) & 0x7).q=(~MMX((modrm >> 3) & 0x7).q) & MMX(modrm & 7).q;
} else {
MMX_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, src);
MMX((modrm >> 3) & 0x7).q=(~MMX((modrm >> 3) & 0x7).q) & src.q;
}
MMX((modrm >> 3) & 0x7).s[3]=MMX((modrm >> 3) & 0x7).s[3] >> count;
} else {
MMX_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, src);
int count=(int)src.q;
MMX((modrm >> 3) & 0x7).s[0]=MMX((modrm >> 3) & 0x7).s[0] >> count;
MMX((modrm >> 3) & 0x7).i[1]=MMX((modrm >> 3) & 0x7).i[1] >> count;
} else {
MMX_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, src);
int count=(int)src.q;
MMX((modrm >> 3) & 0x7).i[0]=MMX((modrm >> 3) & 0x7).i[0] >> count;
MMX((modrm >> 3) & 0x7).w[3]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[3]*(INT32)MMX(modrm & 7).s[3]) >> 16;
} else {
MMX_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, src);
MMX((modrm >> 3) & 0x7).w[0]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[0]*(INT32)src.s[0]) >> 16;
MMX((modrm >> 3) & 0x7).w[1]=(UINT32)((INT32)MMX((modrm >> 3) & 0x7).s[1]*(INT32)src.s[1]) >> 16;
MMX((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)MMX((modrm >> 3) & 0x7).c[n] - (INT16)MMX(modrm & 7).c[n]);
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)MMX((modrm >> 3) & 0x7).c[n] - (INT16)s.c[n]);
MMX((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)MMX((modrm >> 3) & 0x7).s[n] - (INT32)MMX(modrm & 7).s[n]);
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)MMX((modrm >> 3) & 0x7).s[n] - (INT32)s.s[n]);
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q | MMX(modrm & 7).q;
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q | s.q;
}
MMX((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)MMX((modrm >> 3) & 0x7).c[n] + (INT16)MMX(modrm & 7).c[n]);
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)MMX((modrm >> 3) & 0x7).c[n] + (INT16)s.c[n]);
MMX((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)MMX((modrm >> 3) & 0x7).s[n] + (INT32)MMX(modrm & 7).s[n]);
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)MMX((modrm >> 3) & 0x7).s[n] + (INT32)s.s[n]);
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q ^ MMX(modrm & 7).q;
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q ^ s.q;
}
MMX((modrm >> 3) & 0x7).w[3]=MMX((modrm >> 3) & 0x7).w[3] << count;
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
int count=(int)s.q;
MMX((modrm >> 3) & 0x7).w[0]=MMX((modrm >> 3) & 0x7).w[0] << count;
MMX((modrm >> 3) & 0x7).d[1]=MMX((modrm >> 3) & 0x7).d[1] << count;
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
int count=(int)s.q;
MMX((modrm >> 3) & 0x7).d[0]=MMX((modrm >> 3) & 0x7).d[0] << count;
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q << count;
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
int count=(int)s.q;
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q << count;
(INT32)MMX((modrm >> 3) & 0x7).s[3]*(INT32)MMX(modrm & 7).s[3];
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
MMX((modrm >> 3) & 0x7).i[0]=(INT32)MMX((modrm >> 3) & 0x7).s[0]*(INT32)s.s[0]+
(INT32)MMX((modrm >> 3) & 0x7).s[1]*(INT32)s.s[1];
MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] - MMX(modrm & 7).b[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] - s.b[n];
MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] - MMX(modrm & 7).w[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] - s.w[n];
MMX((modrm >> 3) & 0x7).d[n]=MMX((modrm >> 3) & 0x7).d[n] - MMX(modrm & 7).d[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (n=0;n < 2;n++)
MMX((modrm >> 3) & 0x7).d[n]=MMX((modrm >> 3) & 0x7).d[n] - s.d[n];
MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] + MMX(modrm & 7).b[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).b[n]=MMX((modrm >> 3) & 0x7).b[n] + s.b[n];
MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] + MMX(modrm & 7).w[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).w[n]=MMX((modrm >> 3) & 0x7).w[n] + s.w[n];
MMX((modrm >> 3) & 0x7).d[n]=MMX((modrm >> 3) & 0x7).d[n] + MMX(modrm & 7).d[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (n=0;n < 2;n++)
MMX((modrm >> 3) & 0x7).d[n]=MMX((modrm >> 3) & 0x7).d[n] + s.d[n];
UINT8 modrm = FETCH(cpustate);
if( modrm < 0xc0 ) {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,10);
int index = (modrm >> 3) & 7;
int limit;
switch (index)
UINT8 modrm = FETCH(cpustate);
if( modrm < 0xc0 ) {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,10);
int index = (modrm >> 3) & 7;
UINT16 flags;
UINT32 base;
UINT8 modrm = FETCH(cpustate);
if( !(modrm & 0xf8) ) {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,10);
UINT32 limit = cpustate->ldtr.limit;
if (cpustate->ldtr.flags & 0x8000) //G bit
UINT8 modrm = FETCH(cpustate);
if( !(modrm & 0xf8) ) {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,10);
UINT16 flags = READ16(cpustate,ea + 5);
UINT32 base = (READ32(cpustate,ea + 2) | 0x00ffffff) | (READ8(cpustate,ea + 7) << 24);
UINT32 limit = READ16(cpustate,ea + 0) | ((flags & 3) << 16);
UINT8 modrm = FETCH(cpustate);
if( !(modrm & 0xf8) ) {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,10);
UINT32 limit = cpustate->task.limit;
if (cpustate->task.flags & 0x8000) //G bit
UINT8 modrm = FETCH(cpustate);
if( !(modrm & 0xf8) ) {
- UINT32 ea = GetEA(cpustate,modrm,0);
+ UINT32 ea = GetEA(cpustate,modrm,0,10);
UINT16 flags = READ16(cpustate,ea + 5);
UINT32 base = (READ32(cpustate,ea + 2) | 0x00ffffff) | (READ8(cpustate,ea + 7) << 24);
UINT32 limit = READ16(cpustate,ea + 0) | ((flags & 3) << 16);
if( modrm >= 0xc0 ) {
MMX((modrm >> 3) & 0x7).d[0]=LOAD_RM32(modrm);
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
MMX((modrm >> 3) & 0x7).d[0]=READ32(cpustate,ea);
}
MMX((modrm >> 3) & 0x7).d[1]=0;
if( modrm >= 0xc0 ) {
MMX((modrm >> 3) & 0x7).l=MMX(modrm & 0x7).l;
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, MMX((modrm >> 3) & 0x7));
}
CYCLES(cpustate,1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
STORE_RM32(modrm, MMX((modrm >> 3) & 0x7).d[0]);
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
WRITE32(cpustate,ea, MMX((modrm >> 3) & 0x7).d[0]);
}
CYCLES(cpustate,1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
MMX(modrm & 0x7)=MMX((modrm >> 3) & 0x7);
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
WRITEMMX(cpustate, ea, MMX((modrm >> 3) & 0x7));
}
CYCLES(cpustate,1); // TODO: correct cycle count
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (c=0;c <= 7;c++)
MMX(d).b[c]=(MMX(d).b[c] == s.b[c]) ? 0xff : 0;
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
MMX(d).w[0]=(MMX(d).w[0] == s.w[0]) ? 0xffff : 0;
MMX(d).w[1]=(MMX(d).w[1] == s.w[1]) ? 0xffff : 0;
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
MMX(d).d[0]=(MMX(d).d[0] == s.d[0]) ? 0xffffffff : 0;
MMX(d).d[1]=(MMX(d).d[1] == s.d[1]) ? 0xffffffff : 0;
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
UINT8 imm8 = FETCH(cpustate);
READMMX(cpustate, ea, s);
MMX(d).w[0]=s.w[imm8 & 3];
else {
XMM_REG xd, xs;
int d = (modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
xd.l[0] = XMM(d).l[0];
xs.q[0] = READ64(cpustate, ea);
for (int n = 0; n < 8; n++) {
else {
XMM_REG xd, xs;
int d = (modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
xd.l[0] = XMM(d).l[0];
xs.q[0] = READ64(cpustate, ea);
for (int n = 0; n < 4; n++) {
else {
XMM_REG xd, xs;
int d = (modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
xd.l[0] = XMM(d).l[0];
xs.q[0] = READ64(cpustate, ea);
for (int n = 0; n < 2; n++) {
else {
XMM_REG xd, xs;
int d = (modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
xd.l[0] = XMM(d).l[0];
xs.q[0] = READ64(cpustate, ea);
XMM(d).q[0] = xd.q[0];
} else {
UINT32 s,t;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
s = READ32(cpustate,ea);
t=MMX(d).d[0];
MMX(d).b[0]=t & 0xff;
UINT32 s;
UINT16 t;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
s = READ32(cpustate,ea);
t=MMX(d).w[1];
MMX(d).w[0]=MMX(d).w[0];
} else {
UINT32 s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
s = READ32(cpustate,ea);
MMX(d).d[0]=MMX(d).d[0];
MMX(d).d[1]=s;
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
MMX(d).c[0]=SaturatedSignedWordToSignedByte(MMX(d).s[0]);
MMX(d).c[1]=SaturatedSignedWordToSignedByte(MMX(d).s[1]);
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (c=0;c <= 7;c++)
MMX(d).b[c]=(MMX(d).c[c] > s.c[c]) ? 0xff : 0;
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (c=0;c <= 3;c++)
MMX(d).w[c]=(MMX(d).s[c] > s.s[c]) ? 0xffff : 0;
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (c=0;c <= 1;c++)
MMX(d).d[c]=(MMX(d).i[c] > s.i[c]) ? 0xffffffff : 0;
} else {
MMX_REG s,t;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
t.q = MMX(d).q;
MMX(d).b[0]=SaturatedSignedWordToUnsignedByte(t.s[0]);
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
MMX(d).b[0]=MMX(d).b[4];
MMX(d).b[1]=s.b[4];
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
MMX(d).w[0]=MMX(d).w[2];
MMX(d).w[1]=s.w[2];
} else {
MMX_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
MMX(d).d[0]=MMX(d).d[1];
MMX(d).d[1]=s.d[1];
MMX_REG s;
INT32 t1, t2;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
t1 = MMX(d).i[0];
t2 = MMX(d).i[1];
switch ( (modm & 0x38) >> 3 )
{
case 2: // ldmxcsr m32
- ea = GetEA(cpustate,modm, 0);
+ ea = GetEA(cpustate,modm, 0, 4);
cpustate->mxcsr = READ32(cpustate,ea);
break;
case 3: // stmxcsr m32
- ea = GetEA(cpustate,modm, 0);
+ ea = GetEA(cpustate,modm, 0, 4);
WRITE32(cpustate,ea, cpustate->mxcsr);
break;
case 7: // clflush m8
XMM((modrm >> 3) & 0x7).i[3]=(INT32)XMM(modrm & 0x7).f[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).i[0]=(INT32)src.f[0];
XMM((modrm >> 3) & 0x7).i[1]=(INT32)src.f[1];
XMM((modrm >> 3) & 0x7).f64[0] = XMM(modrm & 0x7).f[0];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
s.d[0] = READ32(cpustate,ea);
XMM((modrm >> 3) & 0x7).f64[0] = s.f[0];
}
src = (INT32)XMM(modrm & 0x7).f[0^NATIVE_ENDIAN_VALUE_LE_BE(0,1)];
} else { // otherwise is a memory address
XMM_REG t;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
t.d[0] = READ32(cpustate,ea);
src = (INT32)t.f[0];
}
src = (INT32)XMM(modrm & 0x7).f[0];
} else {
XMM_REG t;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
t.d[0] = READ32(cpustate,ea);
src = (INT32)t.f[0];
}
if( modrm >= 0xc0 ) {
XMM((modrm >> 3) & 0x7).f[0] = (INT32)LOAD_RM32(modrm);
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
XMM((modrm >> 3) & 0x7).f[0] = (INT32)READ32(cpustate,ea);
}
CYCLES(cpustate,1); // TODO: correct cycle count
XMM((modrm >> 3) & 0x7).f[1] = (float)MMX(modrm & 0x7).i[1];
} else {
MMX_REG r;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, r);
XMM((modrm >> 3) & 0x7).f[0] = (float)r.i[0];
XMM((modrm >> 3) & 0x7).f[1] = (float)r.i[1];
MMX((modrm >> 3) & 0x7).i[1] = XMM(modrm & 0x7).f[1];
} else {
XMM_REG r;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, r);
XMM((modrm >> 3) & 0x7).i[0] = r.f[0];
XMM((modrm >> 3) & 0x7).i[1] = r.f[1];
MMX((modrm >> 3) & 0x7).i[1] = XMM(modrm & 0x7).f[1];
} else {
XMM_REG r;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, r);
XMM((modrm >> 3) & 0x7).i[0] = r.f[0];
XMM((modrm >> 3) & 0x7).i[1] = r.f[1];
XMM((modrm >> 3) & 0x7).f64[1] = (double)XMM(modrm & 0x7).f[1];
} else {
MMX_REG r;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, r);
XMM((modrm >> 3) & 0x7).f64[0] = (double)r.f[0];
XMM((modrm >> 3) & 0x7).f64[1] = (double)r.f[1];
XMM((modrm >> 3) & 0x7).f[3] = (float)XMM(modrm & 0x7).i[3];
} else {
XMM_REG r;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, r);
XMM((modrm >> 3) & 0x7).f[0] = (float)r.i[0];
XMM((modrm >> 3) & 0x7).f[1] = (float)r.i[1];
XMM((modrm >> 3) & 0x7).f64[1] = (double)XMM(modrm & 0x7).i[1];
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
XMM((modrm >> 3) & 0x7).f64[0] = (double)s.i[0];
XMM((modrm >> 3) & 0x7).f64[1] = (double)s.i[1];
if( modrm >= 0xc0 ) {
XMM((modrm >> 3) & 0x7).d[0] = XMM(modrm & 0x7).d[0];
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
XMM((modrm >> 3) & 0x7).d[0] = READ32(cpustate,ea);
}
CYCLES(cpustate,1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
XMM(modrm & 0x7).d[0] = XMM((modrm >> 3) & 0x7).d[0];
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
WRITE32(cpustate,ea, XMM((modrm >> 3) & 0x7).d[0]);
}
CYCLES(cpustate,1); // TODO: correct cycle count
XMM((modrm >> 3) & 0x7).d[3] = XMM(modrm & 0x7).d[2];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).d[0] = src.d[0];
XMM((modrm >> 3) & 0x7).d[1] = src.d[0];
XMM((modrm >> 3) & 0x7).d[3] = XMM(modrm & 0x7).d[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).d[0] = src.d[1];
XMM((modrm >> 3) & 0x7).d[1] = src.d[1];
if( modrm >= 0xc0 ) {
XMM((modrm >> 3) & 0x7) = XMM(modrm & 0x7);
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(cpustate,1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
XMM(modrm & 0x7) = XMM((modrm >> 3) & 0x7);
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
WRITEXMM(cpustate, ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(cpustate,1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
XMM((modrm >> 3) & 0x7) = XMM(modrm & 0x7);
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, XMM((modrm >> 3) & 0x7)); // address does not need to be 16-byte aligned
}
CYCLES(cpustate,1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
XMM((modrm >> 3) & 0x7) = XMM(modrm & 0x7);
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, XMM((modrm >> 3) & 0x7)); // address does not need to be 16-byte aligned
}
CYCLES(cpustate,1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
XMM(modrm & 0x7) = XMM((modrm >> 3) & 0x7);
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
WRITEXMM(cpustate, ea, XMM((modrm >> 3) & 0x7)); // address does not need to be 16-byte aligned
}
CYCLES(cpustate,1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
XMM(modrm & 0x7) = XMM((modrm >> 3) & 0x7);
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
WRITEXMM(cpustate, ea, XMM((modrm >> 3) & 0x7)); // address does not need to be 16-byte aligned
}
CYCLES(cpustate,1); // TODO: correct cycle count
CYCLES(cpustate,1); // TODO: correct cycle count
} else {
// MOVLPS opcode
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READXMM_LO64(cpustate, ea, XMM((modrm >> 3) & 0x7));
CYCLES(cpustate,1); // TODO: correct cycle count
}
CYCLES(cpustate,1); // TODO: correct cycle count
} else {
// MOVLPS opcode
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READXMM_LO64(cpustate, ea, XMM((modrm >> 3) & 0x7));
CYCLES(cpustate,1); // TODO: correct cycle count
}
// unsupported by cpu
CYCLES(cpustate,1); // TODO: correct cycle count
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
WRITEXMM_LO64(cpustate, ea, XMM((modrm >> 3) & 0x7));
CYCLES(cpustate,1); // TODO: correct cycle count
}
// unsupported by cpu
CYCLES(cpustate,1); // TODO: correct cycle count
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
WRITEXMM_LO64(cpustate, ea, XMM((modrm >> 3) & 0x7));
CYCLES(cpustate,1); // TODO: correct cycle count
}
CYCLES(cpustate,1); // TODO: correct cycle count
} else {
// MOVHPS opcode
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READXMM_HI64(cpustate, ea, XMM((modrm >> 3) & 0x7));
CYCLES(cpustate,1); // TODO: correct cycle count
}
CYCLES(cpustate,1); // TODO: correct cycle count
} else {
// MOVHPS opcode
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READXMM_HI64(cpustate, ea, XMM((modrm >> 3) & 0x7));
CYCLES(cpustate,1); // TODO: correct cycle count
}
// unsupported by cpu
CYCLES(cpustate,1); // TODO: correct cycle count
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
WRITEXMM_HI64(cpustate, ea, XMM((modrm >> 3) & 0x7));
CYCLES(cpustate,1); // TODO: correct cycle count
}
// unsupported by cpu
CYCLES(cpustate,1); // TODO: correct cycle count
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
WRITEXMM_HI64(cpustate, ea, XMM((modrm >> 3) & 0x7));
CYCLES(cpustate,1); // TODO: correct cycle count
}
CYCLES(cpustate,1); // TODO: correct cycle count
} else {
// since cache is not implemented
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
WRITEXMM(cpustate, ea, XMM((modrm >> 3) & 0x7));
CYCLES(cpustate,1); // TODO: correct cycle count
}
XMM((modrm >> 3) & 0x7).q[0] = XMM(modrm & 0x7).q[0];
XMM((modrm >> 3) & 0x7).q[1] = XMM(modrm & 0x7).q[1];
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(cpustate,1); // TODO: correct cycle count
XMM(modrm & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0];
XMM(modrm & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1];
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
WRITEXMM(cpustate, ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(cpustate,1); // TODO: correct cycle count
XMM((modrm >> 3) & 0x7).d[0] = LOAD_RM32(modrm);
}
else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
XMM((modrm >> 3) & 0x7).d[0] = READ32(cpustate,ea);
}
XMM((modrm >> 3) & 0x7).d[1] = 0;
XMM((modrm >> 3) & 0x7).q[1] = XMM(modrm & 0x7).q[1];
}
else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(cpustate,1); // TODO: correct cycle count
XMM((modrm >> 3) & 0x7).q[0] = XMM(modrm & 0x7).q[0];
XMM((modrm >> 3) & 0x7).q[1] = 0;
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
XMM((modrm >> 3) & 0x7).q[0] = READ64(cpustate, ea);
XMM((modrm >> 3) & 0x7).q[1] = 0;
}
STORE_RM32(modrm, XMM((modrm >> 3) & 0x7).d[0]);
}
else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
WRITE32(cpustate,ea, XMM((modrm >> 3) & 0x7).d[0]);
}
CYCLES(cpustate,1); // TODO: correct cycle count
XMM(modrm & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1];
}
else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
WRITEXMM(cpustate, ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(cpustate,1); // TODO: correct cycle count
XMM((modrm >> 3) & 0x7).d[3] = XMM((modrm >> 3) & 0x7).d[3] ^ XMM(modrm & 0x7).d[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).d[0] = XMM((modrm >> 3) & 0x7).d[0] ^ src.d[0];
XMM((modrm >> 3) & 0x7).d[1] = XMM((modrm >> 3) & 0x7).d[1] ^ src.d[1];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] ^ XMM(modrm & 0x7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] ^ src.q[0];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] ^ src.q[1];
XMM((modrm >> 3) & 0x7).f[3] = XMM((modrm >> 3) & 0x7).f[3] + XMM(modrm & 0x7).f[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] + src.f[0];
XMM((modrm >> 3) & 0x7).f[1] = XMM((modrm >> 3) & 0x7).f[1] + src.f[1];
XMM((modrm >> 3) & 0x7).f[3] = sqrt(XMM(modrm & 0x7).f[3]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f[0] = sqrt(src.f[0]);
XMM((modrm >> 3) & 0x7).f[1] = sqrt(src.f[1]);
XMM((modrm >> 3) & 0x7).f[3] = 1.0 / sqrt(XMM(modrm & 0x7).f[3]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f[0] = 1.0 / sqrt(src.f[0]);
XMM((modrm >> 3) & 0x7).f[1] = 1.0 / sqrt(src.f[1]);
XMM((modrm >> 3) & 0x7).f[3] = 1.0f / XMM(modrm & 0x7).f[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f[0] = 1.0f / src.f[0];
XMM((modrm >> 3) & 0x7).f[1] = 1.0f / src.f[1];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] & XMM(modrm & 0x7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] & src.q[0];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] & src.q[1];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] & XMM(modrm & 0x7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] & src.q[0];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] & src.q[1];
XMM((modrm >> 3) & 0x7).q[1] = ~(XMM((modrm >> 3) & 0x7).q[1]) & XMM(modrm & 0x7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).q[0] = ~(XMM((modrm >> 3) & 0x7).q[0]) & src.q[0];
XMM((modrm >> 3) & 0x7).q[1] = ~(XMM((modrm >> 3) & 0x7).q[1]) & src.q[1];
XMM((modrm >> 3) & 0x7).q[1] = ~(XMM((modrm >> 3) & 0x7).q[1]) & XMM(modrm & 0x7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).q[0] = ~(XMM((modrm >> 3) & 0x7).q[0]) & src.q[0];
XMM((modrm >> 3) & 0x7).q[1] = ~(XMM((modrm >> 3) & 0x7).q[1]) & src.q[1];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] | XMM(modrm & 0x7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] | src.q[0];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] | src.q[1];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] | XMM(modrm & 0x7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0] | src.q[0];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[1] | src.q[1];
XMM((modrm >> 3) & 0x7).f[3] = XMM((modrm >> 3) & 0x7).f[3] * XMM(modrm & 0x7).f[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] * src.f[0];
XMM((modrm >> 3) & 0x7).f[1] = XMM((modrm >> 3) & 0x7).f[1] * src.f[1];
XMM((modrm >> 3) & 0x7).f[3] = XMM((modrm >> 3) & 0x7).f[3] - XMM(modrm & 0x7).f[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] - src.f[0];
XMM((modrm >> 3) & 0x7).f[1] = XMM((modrm >> 3) & 0x7).f[1] - src.f[1];
XMM((modrm >> 3) & 0x7).f[3] = sse_min_single(XMM((modrm >> 3) & 0x7).f[3], XMM(modrm & 0x7).f[3]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f[0] = sse_min_single(XMM((modrm >> 3) & 0x7).f[0], src.f[0]);
XMM((modrm >> 3) & 0x7).f[1] = sse_min_single(XMM((modrm >> 3) & 0x7).f[1], src.f[1]);
XMM((modrm >> 3) & 0x7).f[3] = XMM((modrm >> 3) & 0x7).f[3] / XMM(modrm & 0x7).f[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] / src.f[0];
XMM((modrm >> 3) & 0x7).f[1] = XMM((modrm >> 3) & 0x7).f[1] / src.f[1];
XMM((modrm >> 3) & 0x7).f[3] = sse_max_single(XMM((modrm >> 3) & 0x7).f[3], XMM(modrm & 0x7).f[3]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f[0] = sse_max_single(XMM((modrm >> 3) & 0x7).f[0], src.f[0]);
XMM((modrm >> 3) & 0x7).f[1] = sse_max_single(XMM((modrm >> 3) & 0x7).f[1], src.f[1]);
XMM((modrm >> 3) & 0x7).f[0] = sse_max_single(XMM((modrm >> 3) & 0x7).f[0], XMM(modrm & 0x7).f[0]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
src.d[0]=READ32(cpustate,ea);
XMM((modrm >> 3) & 0x7).f[0] = sse_max_single(XMM((modrm >> 3) & 0x7).f[0], src.f[0]);
}
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] + XMM(modrm & 0x7).f[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] + src.f[0];
}
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] - XMM(modrm & 0x7).f[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] - src.f[0];
}
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] * XMM(modrm & 0x7).f[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] * src.f[0];
}
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] / XMM(modrm & 0x7).f[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] / src.f[0];
}
XMM((modrm >> 3) & 0x7).f[0] = 1.0f / XMM(modrm & 0x7).f[0];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
s.d[0]=READ32(cpustate,ea);
XMM((modrm >> 3) & 0x7).f[0] = 1.0f / s.f[0];
}
XMM((modrm >> 3) & 0x7).f[0] = sqrt(XMM(modrm & 0x7).f[0]);
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
s.d[0]=READ32(cpustate,ea);
XMM((modrm >> 3) & 0x7).f[0] = sqrt(s.f[0]);
}
XMM((modrm >> 3) & 0x7).f[0] = 1.0 / sqrt(XMM(modrm & 0x7).f[0]);
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
s.d[0]=READ32(cpustate,ea);
XMM((modrm >> 3) & 0x7).f[0] = 1.0 / sqrt(s.f[0]);
}
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] < XMM(modrm & 0x7).f[0] ? XMM((modrm >> 3) & 0x7).f[0] : XMM(modrm & 0x7).f[0];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
s.d[0] = READ32(cpustate,ea);
XMM((modrm >> 3) & 0x7).f[0] = XMM((modrm >> 3) & 0x7).f[0] < s.f[0] ? XMM((modrm >> 3) & 0x7).f[0] : s.f[0];
}
b = XMM(modrm & 0x7).d[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
a = XMM((modrm >> 3) & 0x7).d[0];
b = src.d[0];
b = XMM(modrm & 0x7).q[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
a = XMM((modrm >> 3) & 0x7).q[0];
b = src.q[0];
b = XMM(modrm & 0x7).d[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
a = XMM((modrm >> 3) & 0x7).d[0];
b = src.d[0];
b = XMM(modrm & 0x7).q[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
a = XMM((modrm >> 3) & 0x7).q[0];
b = src.q[0];
} else {
UINT32 t1,t2;
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
t1=XMM(d).d[m1];
t2=XMM(d).d[m2];
} else {
UINT64 t1;
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
t1=XMM(d).q[m1];
XMM(d).q[0]=t1;
XMM(d).d[0]=t4;
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
t2 = XMM(d).d[1];
XMM(d).d[3]=src.d[1];
XMM(d).q[0]=XMM(d).q[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM(d).q[1]=src.q[0];
XMM(d).q[0]=XMM(d).q[0];
XMM(d).d[3]=t4;
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
t1 = XMM(d).d[2];
t2 = XMM(d).d[3];
XMM(d).q[1]=XMM(s).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM(d).q[0]=XMM(d).q[1];
XMM(d).q[1]=src.q[1];
} else {
int d;
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
UINT8 imm8 = FETCH(cpustate);
READXMM(cpustate, ea, s);
d=(modrm >> 3) & 0x7;
} else {
int d;
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
UINT8 imm8 = FETCH(cpustate);
READXMM(cpustate, ea, s);
d=(modrm >> 3) & 0x7;
} else {
int d;
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
UINT8 imm8 = FETCH(cpustate);
s.d[0]=READ32(cpustate,ea);
d=(modrm >> 3) & 0x7;
else
MMX((modrm >> 3) & 0x7).w[imm8 & 3] = v;
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 2);
UINT8 imm8 = FETCH(cpustate);
UINT16 v = READ16(cpustate,ea);
if (cpustate->xmm_operand_size)
UINT16 v = (UINT16)LOAD_RM32(modrm);
MMX((modrm >> 3) & 0x7).w[imm8 & 3] = v;
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 2);
UINT8 imm8 = FETCH(cpustate);
UINT16 v = READ16(cpustate,ea);
MMX((modrm >> 3) & 0x7).w[imm8 & 3] = v;
XMM((modrm >> 3) & 0x7).w[imm8 & 7] = v;
}
else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 2);
UINT8 imm8 = FETCH(cpustate);
UINT16 v = READ16(cpustate,ea);
XMM((modrm >> 3) & 0x7).w[imm8 & 7] = v;
MMX((modrm >> 3) & 0x7).b[n] = MMX((modrm >> 3) & 0x7).b[n] < MMX(modrm & 0x7).b[n] ? MMX((modrm >> 3) & 0x7).b[n] : MMX(modrm & 0x7).b[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).b[n] = MMX((modrm >> 3) & 0x7).b[n] < s.b[n] ? MMX((modrm >> 3) & 0x7).b[n] : s.b[n];
XMM((modrm >> 3) & 0x7).b[n] = XMM((modrm >> 3) & 0x7).b[n] < XMM(modrm & 0x7).b[n] ? XMM((modrm >> 3) & 0x7).b[n] : XMM(modrm & 0x7).b[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).b[n] = XMM((modrm >> 3) & 0x7).b[n] < s.b[n] ? XMM((modrm >> 3) & 0x7).b[n] : s.b[n];
MMX((modrm >> 3) & 0x7).b[n] = MMX((modrm >> 3) & 0x7).b[n] > MMX(modrm & 0x7).b[n] ? MMX((modrm >> 3) & 0x7).b[n] : MMX(modrm & 0x7).b[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).b[n] = MMX((modrm >> 3) & 0x7).b[n] > s.b[n] ? MMX((modrm >> 3) & 0x7).b[n] : s.b[n];
MMX((modrm >> 3) & 0x7).b[n] = ((UINT16)MMX((modrm >> 3) & 0x7).b[n] + (UINT16)MMX(modrm & 0x7).b[n] + 1) >> 1;
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).b[n] = ((UINT16)MMX((modrm >> 3) & 0x7).b[n] + (UINT16)s.b[n] + 1) >> 1;
MMX((modrm >> 3) & 0x7).w[n] = ((UINT32)MMX((modrm >> 3) & 0x7).w[n] + (UINT32)MMX(modrm & 0x7).w[n] + 1) >> 1;
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).w[n] = ((UINT32)MMX((modrm >> 3) & 0x7).w[n] + (UINT32)s.w[n] + 1) >> 1;
MMX((modrm >> 3) & 0x7).w[3]=((UINT32)MMX((modrm >> 3) & 0x7).w[3]*(UINT32)MMX(modrm & 7).w[3]) >> 16;
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
MMX((modrm >> 3) & 0x7).w[0]=((UINT32)MMX((modrm >> 3) & 0x7).w[0]*(UINT32)s.w[0]) >> 16;
MMX((modrm >> 3) & 0x7).w[1]=((UINT32)MMX((modrm >> 3) & 0x7).w[1]*(UINT32)s.w[1]) >> 16;
MMX((modrm >> 3) & 0x7).s[n] = MMX((modrm >> 3) & 0x7).s[n] < MMX(modrm & 0x7).s[n] ? MMX((modrm >> 3) & 0x7).s[n] : MMX(modrm & 0x7).s[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).s[n] = MMX((modrm >> 3) & 0x7).s[n] < s.s[n] ? MMX((modrm >> 3) & 0x7).s[n] : s.s[n];
MMX((modrm >> 3) & 0x7).s[n] = MMX((modrm >> 3) & 0x7).s[n] > MMX(modrm & 0x7).s[n] ? MMX((modrm >> 3) & 0x7).s[n] : MMX(modrm & 0x7).s[n];
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
for (n=0;n < 4;n++)
MMX((modrm >> 3) & 0x7).s[n] = MMX((modrm >> 3) & 0x7).s[n] > s.s[n] ? MMX((modrm >> 3) & 0x7).s[n] : s.s[n];
MMX((modrm >> 3) & 0x7).q = (UINT64)MMX((modrm >> 3) & 0x7).d[0] * (UINT64)MMX(modrm & 0x7).d[0];
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
MMX((modrm >> 3) & 0x7).q = (UINT64)MMX((modrm >> 3) & 0x7).d[0] * (UINT64)s.d[0];
}
XMM((modrm >> 3) & 0x7).q[1] = (UINT64)XMM((modrm >> 3) & 0x7).d[2] * (UINT64)XMM(modrm & 0x7).d[2];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
XMM((modrm >> 3) & 0x7).q[0] = (UINT64)XMM((modrm >> 3) & 0x7).d[0] * (UINT64)s.d[0];
XMM((modrm >> 3) & 0x7).q[1] = (UINT64)XMM((modrm >> 3) & 0x7).d[2] * (UINT64)s.d[2];
MMX((modrm >> 3) & 0x7).l=(UINT64)temp & 0xffff;
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
temp=0;
for (n=0;n < 8;n++)
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q - MMX(modrm & 7).q;
} else {
MMX_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, s);
MMX((modrm >> 3) & 0x7).q=MMX((modrm >> 3) & 0x7).q - s.q;
}
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] - XMM(modrm & 7).q[1];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] - s.q[0];
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] - s.q[1];
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
UINT8 imm8 = FETCH(cpustate);
READXMM(cpustate, ea, s);
XMM(d).d[0]=s.d[(imm8 & 3)];
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
UINT8 imm8 = FETCH(cpustate);
READXMM(cpustate, ea, s);
XMM(d).q[1]=s.q[1];
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
UINT8 imm8 = FETCH(cpustate);
READXMM(cpustate, ea, s);
XMM(d).q[0]=s.q[0];
else {
XMM_REG s;
int d = (modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n = 0; n < 8; n++)
XMM(d).c[n] = SaturatedSignedWordToSignedByte(XMM(d).s[n]);
else {
XMM_REG s;
int d = (modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
XMM(d).s[0] = SaturatedSignedDwordToSignedWord(XMM(d).i[0]);
XMM(d).s[1] = SaturatedSignedDwordToSignedWord(XMM(d).i[1]);
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int c=0;c <= 15;c++)
XMM(d).b[c]=(XMM(d).c[c] > s.c[c]) ? 0xff : 0;
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int c=0;c <= 7;c++)
XMM(d).w[c]=(XMM(d).s[c] > s.s[c]) ? 0xffff : 0;
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int c=0;c <= 3;c++)
XMM(d).d[c]=(XMM(d).i[c] > s.i[c]) ? 0xffffffff : 0;
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n = 0; n < 8;n++)
XMM(d).b[n]=SaturatedSignedWordToUnsignedByte(XMM(d).s[n]);
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n = 0; n < 16; n += 2) {
XMM(d).b[n]=XMM(d).b[8+(n >> 1)];
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n = 0; n < 8; n += 2) {
XMM(d).w[n]=XMM(d).w[4+(n >> 1)];
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
XMM(d).d[0]=XMM(d).d[2];
XMM(d).d[1]=s.d[2];
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
XMM(d).q[0]=XMM(d).q[1];
XMM(d).q[1]=s.q[1];
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int c=0;c <= 15;c++)
XMM(d).b[c]=(XMM(d).c[c] == s.c[c]) ? 0xff : 0;
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int c=0;c <= 7;c++)
XMM(d).w[c]=(XMM(d).s[c] == s.s[c]) ? 0xffff : 0;
} else {
XMM_REG s;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int c=0;c <= 3;c++)
XMM(d).d[c]=(XMM(d).i[c] == s.i[c]) ? 0xffffffff : 0;
} else {
XMM_REG src;
int d=(modrm >> 3) & 0x7;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM(d).q[0]=XMM(d).q[0]+src.q[0];
XMM(d).q[1]=XMM(d).q[1]+src.q[1];
} else {
XMM_REG src;
int d;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
d=(modrm >> 3) & 0x7;
for (int n = 0; n < 8;n++)
XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] + XMM(modrm & 7).b[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] + s.b[n];
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] + XMM(modrm & 7).w[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] + s.w[n];
XMM((modrm >> 3) & 0x7).d[n]=XMM((modrm >> 3) & 0x7).d[n] + XMM(modrm & 7).d[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 4;n++)
XMM((modrm >> 3) & 0x7).d[n]=XMM((modrm >> 3) & 0x7).d[n] + s.d[n];
XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] < XMM(modrm & 7).b[n] ? 0 : XMM((modrm >> 3) & 0x7).b[n]-XMM(modrm & 7).b[n];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] < src.b[n] ? 0 : XMM((modrm >> 3) & 0x7).b[n]-src.b[n];
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] < XMM(modrm & 7).w[n] ? 0 : XMM((modrm >> 3) & 0x7).w[n]-XMM(modrm & 7).w[n];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] < src.w[n] ? 0 : XMM((modrm >> 3) & 0x7).w[n]-src.w[n];
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] & XMM(modrm & 7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] & src.q[0];
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] & src.q[1];
XMM((modrm >> 3) & 0x7).q[1]=(~XMM((modrm >> 3) & 0x7).q[1]) & XMM(modrm & 7).q[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).q[0]=(~XMM((modrm >> 3) & 0x7).q[0]) & src.q[0];
XMM((modrm >> 3) & 0x7).q[1]=(~XMM((modrm >> 3) & 0x7).q[1]) & src.q[1];
XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] > (0xff-XMM(modrm & 7).b[n]) ? 0xff : XMM((modrm >> 3) & 0x7).b[n]+XMM(modrm & 7).b[n];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] > (0xff-src.b[n]) ? 0xff : XMM((modrm >> 3) & 0x7).b[n]+src.b[n];
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] > (0xffff-XMM(modrm & 7).w[n]) ? 0xffff : XMM((modrm >> 3) & 0x7).w[n]+XMM(modrm & 7).w[n];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] > (0xffff-src.w[n]) ? 0xffff : XMM((modrm >> 3) & 0x7).w[n]+src.w[n];
XMM((modrm >> 3) & 0x7).b[n] = XMM((modrm >> 3) & 0x7).b[n] > XMM(modrm & 0x7).b[n] ? XMM((modrm >> 3) & 0x7).b[n] : XMM(modrm & 0x7).b[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).b[n] = XMM((modrm >> 3) & 0x7).b[n] > s.b[n] ? XMM((modrm >> 3) & 0x7).b[n] : s.b[n];
XMM((modrm >> 3) & 0x7).w[n]=((UINT32)XMM((modrm >> 3) & 0x7).w[n]*(UINT32)XMM(modrm & 7).w[n]) >> 16;
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).w[n]=((UINT32)XMM((modrm >> 3) & 0x7).w[n]*(UINT32)s.w[n]) >> 16;
XMM((modrm >> 3) & 0x7).w[n]=(UINT32)((INT32)XMM((modrm >> 3) & 0x7).s[n]*(INT32)XMM(modrm & 7).s[n]) >> 16;
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).w[n]=(UINT32)((INT32)XMM((modrm >> 3) & 0x7).s[n]*(INT32)src.s[n]) >> 16;
XMM((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)XMM((modrm >> 3) & 0x7).c[n] - (INT16)XMM(modrm & 7).c[n]);
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)XMM((modrm >> 3) & 0x7).c[n] - (INT16)s.c[n]);
XMM((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)XMM((modrm >> 3) & 0x7).s[n] - (INT32)XMM(modrm & 7).s[n]);
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)XMM((modrm >> 3) & 0x7).s[n] - (INT32)s.s[n]);
XMM((modrm >> 3) & 0x7).s[n] = XMM((modrm >> 3) & 0x7).s[n] < XMM(modrm & 0x7).s[n] ? XMM((modrm >> 3) & 0x7).s[n] : XMM(modrm & 0x7).s[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).s[n] = XMM((modrm >> 3) & 0x7).s[n] < s.s[n] ? XMM((modrm >> 3) & 0x7).s[n] : s.s[n];
XMM((modrm >> 3) & 0x7).s[n] = XMM((modrm >> 3) & 0x7).s[n] > XMM(modrm & 0x7).s[n] ? XMM((modrm >> 3) & 0x7).s[n] : XMM(modrm & 0x7).s[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).s[n] = XMM((modrm >> 3) & 0x7).s[n] > s.s[n] ? XMM((modrm >> 3) & 0x7).s[n] : s.s[n];
XMM((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)XMM((modrm >> 3) & 0x7).c[n] + (INT16)XMM(modrm & 7).c[n]);
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).c[n]=SaturatedSignedWordToSignedByte((INT16)XMM((modrm >> 3) & 0x7).c[n] + (INT16)s.c[n]);
XMM((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)XMM((modrm >> 3) & 0x7).s[n] + (INT32)XMM(modrm & 7).s[n]);
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).s[n]=SaturatedSignedDwordToSignedWord((INT32)XMM((modrm >> 3) & 0x7).s[n] + (INT32)s.s[n]);
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] | XMM(modrm & 7).q[1];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] | s.q[0];
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] | s.q[1];
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] ^ XMM(modrm & 7).q[1];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] ^ s.q[0];
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] ^ s.q[1];
(INT32)XMM((modrm >> 3) & 0x7).s[n]*(INT32)XMM(modrm & 7).s[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 4;n++)
XMM((modrm >> 3) & 0x7).i[n]=(INT32)XMM((modrm >> 3) & 0x7).s[n]*(INT32)s.s[n]+
XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] - XMM(modrm & 7).b[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).b[n]=XMM((modrm >> 3) & 0x7).b[n] - s.b[n];
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] - XMM(modrm & 7).w[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] - s.w[n];
XMM((modrm >> 3) & 0x7).d[n]=XMM((modrm >> 3) & 0x7).d[n] - XMM(modrm & 7).d[n];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 4;n++)
XMM((modrm >> 3) & 0x7).d[n]=XMM((modrm >> 3) & 0x7).d[n] - s.d[n];
XMM((modrm >> 3) & 0x7).l[1]=(UINT64)temp & 0xffff;
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
temp=0;
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).b[n] = ((UINT16)XMM((modrm >> 3) & 0x7).b[n] + (UINT16)XMM(modrm & 0x7).b[n] + 1) >> 1;
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 16;n++)
XMM((modrm >> 3) & 0x7).b[n] = ((UINT16)XMM((modrm >> 3) & 0x7).b[n] + (UINT16)s.b[n] + 1) >> 1;
XMM((modrm >> 3) & 0x7).w[n] = ((UINT32)XMM((modrm >> 3) & 0x7).w[n] + (UINT32)XMM(modrm & 0x7).w[n] + 1) >> 1;
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
for (int n=0;n < 8;n++)
XMM((modrm >> 3) & 0x7).w[n] = ((UINT32)XMM((modrm >> 3) & 0x7).w[n] + (UINT32)s.w[n] + 1) >> 1;
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] >> count;
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
int count=(int)src.q[0];
for (int n=0; n < 8;n++)
XMM((modrm >> 3) & 0x7).d[3]=XMM((modrm >> 3) & 0x7).d[3] >> count;
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
int count=(int)src.q[0];
XMM((modrm >> 3) & 0x7).d[0]=XMM((modrm >> 3) & 0x7).d[0] >> count;
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] >> count;
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
int count=(int)src.q[0];
XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] >> count;
XMM((modrm >> 3) & 0x7).w[n]=XMM((modrm >> 3) & 0x7).w[n] << count;
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
int count=(int)s.q[0];
for (int n=0; n < 8;n++)
XMM((modrm >> 3) & 0x7).d[3]=XMM((modrm >> 3) & 0x7).d[3] << count;
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
int count=(int)s.q[0];
XMM((modrm >> 3) & 0x7).d[0]=XMM((modrm >> 3) & 0x7).d[0] << count;
XMM((modrm >> 3) & 0x7).q[1]=XMM((modrm >> 3) & 0x7).q[1] << count;
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, s);
int count=(int)s.q[0];
XMM((modrm >> 3) & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0] << count;
XMM((modrm >> 3) & 0x7).s[n]=XMM((modrm >> 3) & 0x7).s[n] >> count;
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
int count=(int)src.q[0];
for (int n=0; n < 8;n++)
XMM((modrm >> 3) & 0x7).i[3]=XMM((modrm >> 3) & 0x7).i[3] >> count;
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
int count=(int)src.q[0];
XMM((modrm >> 3) & 0x7).i[0]=XMM((modrm >> 3) & 0x7).i[0] >> count;
CYCLES(cpustate,1); // unsupported
} else {
// since cache is not implemented
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
WRITEXMM(cpustate, ea, XMM((modrm >> 3) & 0x7));
CYCLES(cpustate,1); // TODO: correct cycle count
}
XMM((modrm >> 3) & 0x7).q[1] = 0;
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).i[0]=(INT32)src.f64[0];
XMM((modrm >> 3) & 0x7).i[1]=(INT32)src.f64[1];
XMM(modrm & 0x7).q[0]=XMM((modrm >> 3) & 0x7).q[0];
XMM(modrm & 0x7).q[1] = 0;
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
WRITE64(cpustate, ea, XMM((modrm >> 3) & 0x7).q[0]);
}
CYCLES(cpustate,1); // TODO: correct cycle count
} else {
XMM_REG src;
int d;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
d=(modrm >> 3) & 0x7;
READXMM(cpustate, ea, src);
XMM(d).f64[0]=XMM(d).f64[0]-src.f64[0];
} else {
XMM_REG src;
int d;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
d=(modrm >> 3) & 0x7;
READXMM(cpustate, ea, src);
XMM(d).f64[0]=XMM(d).f64[0]+XMM(d).f64[1];
} else {
XMM_REG src;
int d;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
d=(modrm >> 3) & 0x7;
READXMM(cpustate, ea, src);
XMM(d).f64[0]=XMM(d).f64[0]-XMM(d).f64[1];
} else {
XMM_REG src;
int d;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
d=(modrm >> 3) & 0x7;
READXMM(cpustate, ea, src);
XMM(d).f64[0]=sqrt(src.f64[0]);
XMM((modrm >> 3) & 0x7).f64[1] = (double)MMX(modrm & 0x7).i[1];
} else {
MMX_REG r;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READMMX(cpustate, ea, r);
XMM((modrm >> 3) & 0x7).f64[0] = (double)r.i[0];
XMM((modrm >> 3) & 0x7).f64[1] = (double)r.i[1];
MMX((modrm >> 3) & 0x7).i[1] = XMM(modrm & 0x7).f64[1];
} else {
XMM_REG r;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, r);
MMX((modrm >> 3) & 0x7).i[0] = r.f64[0];
MMX((modrm >> 3) & 0x7).i[1] = r.f64[1];
MMX((modrm >> 3) & 0x7).i[1] = XMM(modrm & 0x7).f64[1];
} else {
XMM_REG r;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, r);
MMX((modrm >> 3) & 0x7).i[0] = r.f64[0];
MMX((modrm >> 3) & 0x7).i[1] = r.f64[1];
XMM((modrm >> 3) & 0x7).q[1] = 0;
} else {
XMM_REG r;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, r);
XMM((modrm >> 3) & 0x7).f[0] = (float)r.f64[0];
XMM((modrm >> 3) & 0x7).f[1] = (float)r.f64[1];
XMM((modrm >> 3) & 0x7).i[3] = XMM(modrm & 0x7).f[3];
} else {
XMM_REG r;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, r);
XMM((modrm >> 3) & 0x7).i[0] = r.f[0];
XMM((modrm >> 3) & 0x7).i[1] = r.f[1];
XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] + XMM(modrm & 0x7).f64[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] + src.f64[0];
XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] + src.f64[1];
XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] * XMM(modrm & 0x7).f64[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] * src.f64[0];
XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] * src.f64[1];
XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] - XMM(modrm & 0x7).f64[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] - src.f64[0];
XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] - src.f64[1];
XMM((modrm >> 3) & 0x7).f64[1] = sse_min_double(XMM((modrm >> 3) & 0x7).f64[1], XMM(modrm & 0x7).f64[1]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = sse_min_double(XMM((modrm >> 3) & 0x7).f64[0], src.f64[0]);
XMM((modrm >> 3) & 0x7).f64[1] = sse_min_double(XMM((modrm >> 3) & 0x7).f64[1], src.f64[1]);
XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] / XMM(modrm & 0x7).f64[1];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] / src.f64[0];
XMM((modrm >> 3) & 0x7).f64[1] = XMM((modrm >> 3) & 0x7).f64[1] / src.f64[1];
XMM((modrm >> 3) & 0x7).f64[1] = sse_max_double(XMM((modrm >> 3) & 0x7).f64[1], XMM(modrm & 0x7).f64[1]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = sse_max_double(XMM((modrm >> 3) & 0x7).f64[0], src.f64[0]);
XMM((modrm >> 3) & 0x7).f64[1] = sse_max_double(XMM((modrm >> 3) & 0x7).f64[1], src.f64[1]);
CYCLES(cpustate,1); // TODO: correct cycle count
} else {
// since cache is not implemented
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
WRITEXMM(cpustate, ea, XMM((modrm >> 3) & 0x7));
CYCLES(cpustate,1); // TODO: correct cycle count
}
if( modrm >= 0xc0 ) {
XMM((modrm >> 3) & 0x7) = XMM(modrm & 0x7);
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(cpustate,1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
XMM(modrm & 0x7) = XMM((modrm >> 3) & 0x7);
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
WRITEXMM(cpustate, ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(cpustate,1); // TODO: correct cycle count
if( modrm >= 0xc0 ) {
XMM((modrm >> 3) & 0x7).q[0] = XMM(modrm & 0x7).q[0];
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READXMM_LO64(cpustate, ea, XMM((modrm >> 3) & 0x7));
XMM((modrm >> 3) & 0x7).q[1] = 0;
}
if( modrm >= 0xc0 ) {
XMM(modrm & 0x7).q[0] = XMM((modrm >> 3) & 0x7).q[0];
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
WRITEXMM_LO64(cpustate, ea, XMM((modrm >> 3) & 0x7));
}
CYCLES(cpustate,1); // TODO: correct cycle count
XMM((modrm >> 3) & 0x7).q[0] = XMM(modrm & 0x7).q[0];
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[0];
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READXMM_LO64(cpustate, ea, XMM((modrm >> 3) & 0x7));
XMM((modrm >> 3) & 0x7).q[1] = XMM((modrm >> 3) & 0x7).q[0];
}
if( modrm >= 0xc0 ) {
XMM((modrm >> 3) & 0x7).f64[0] = (INT32)LOAD_RM32(modrm);
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 4);
XMM((modrm >> 3) & 0x7).f64[0] = (INT32)READ32(cpustate,ea);
}
CYCLES(cpustate,1); // TODO: correct cycle count
src = (INT32)XMM(modrm & 0x7).f64[0];
} else { // otherwise is a memory address
XMM_REG t;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READXMM_LO64(cpustate, ea, t);
src = (INT32)t.f64[0];
}
src = (INT32)XMM(modrm & 0x7).f64[0];
} else { // otherwise is a memory address
XMM_REG t;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READXMM_LO64(cpustate, ea, t);
src = (INT32)t.f64[0];
}
} else {
XMM_REG src;
int d;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
d=(modrm >> 3) & 0x7;
READXMM(cpustate, ea, src);
XMM(d).f64[0]=sqrt(src.f64[0]);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] + XMM(modrm & 0x7).f64[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] + src.f64[0];
}
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] * XMM(modrm & 0x7).f64[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] * src.f64[0];
}
XMM((modrm >> 3) & 0x7).f[0] = XMM(modrm & 0x7).f64[0];
} else {
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
READXMM_LO64(cpustate, ea, s);
XMM((modrm >> 3) & 0x7).f[0] = s.f64[0];
}
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] - XMM(modrm & 0x7).f64[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] - src.f64[0];
}
XMM((modrm >> 3) & 0x7).f64[0] = sse_min_double(XMM((modrm >> 3) & 0x7).f64[0], XMM(modrm & 0x7).f64[0]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = sse_min_double(XMM((modrm >> 3) & 0x7).f64[0], src.f64[0]);
}
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] / XMM(modrm & 0x7).f64[0];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = XMM((modrm >> 3) & 0x7).f64[0] / src.f64[0];
}
XMM((modrm >> 3) & 0x7).f64[0] = sse_max_double(XMM((modrm >> 3) & 0x7).f64[0], XMM(modrm & 0x7).f64[0]);
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f64[0] = sse_max_double(XMM((modrm >> 3) & 0x7).f64[0], src.f64[0]);
}
XMM_REG src;
int d;
float f1, f2;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
d=(modrm >> 3) & 0x7;
READXMM(cpustate, ea, src);
f1=XMM(d).f[0]+XMM(d).f[1];
XMM_REG src;
int d;
float f1, f2;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
d=(modrm >> 3) & 0x7;
READXMM(cpustate, ea, src);
f1=XMM(d).f[0]-XMM(d).f[1];
} else {
int d;
XMM_REG s;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 8);
UINT8 imm8 = FETCH(cpustate);
READXMM_LO64(cpustate, ea, s);
d=(modrm >> 3) & 0x7;
XMM((modrm >> 3) & 0x7).f[3]=XMM((modrm >> 3) & 0x7).f[3] + XMM(modrm & 0x7).f[3];
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).f[0]=XMM((modrm >> 3) & 0x7).f[0] - src.f[0];
XMM((modrm >> 3) & 0x7).f[1]=XMM((modrm >> 3) & 0x7).f[1] + src.f[1];
XMM((modrm >> 3) & 0x7).q[1] = 0;
} else {
XMM_REG src;
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, src);
XMM((modrm >> 3) & 0x7).i[0]=(INT32)src.f64[0];
XMM((modrm >> 3) & 0x7).i[1]=(INT32)src.f64[1];
// unsupported by cpu
CYCLES(cpustate,1); // TODO: correct cycle count
} else {
- UINT32 ea = GetEA(cpustate,modrm, 0);
+ UINT32 ea = GetEA(cpustate,modrm, 0, 16);
READXMM(cpustate, ea, XMM((modrm >> 3) & 0x7));
}
}
Fixes in MAME 0.154 to 0.197 are applied.
cycle_table_rm/pm are changed from dynamic array to static array.
+
convert char to _TCHAR in disassembler.
-mov_r16_rm16 is modified to check limit for NEC PC-9801RA's ITF routine.
+
+i386_limit_check is improved to consider data size.
// license:BSD-3-Clause
-// copyright-holders:Philp Bennett
+// copyright-holders:Philip Bennett
/***************************************************************************
x87 FPU emulation
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 2);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 2);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 2);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 2);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
}
else
{
- INT16 m16int = READ32(cpustate, ea);
+ INT16 m16int = READ16(cpustate, ea);
floatx80 a = ST(0);
floatx80 b = int32_to_floatx80(m16int);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 2);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
}
else
{
- INT16 m16int = READ32(cpustate, ea);
+ INT16 m16int = READ16(cpustate, ea);
floatx80 a = int32_to_floatx80(m16int);
floatx80 b = ST(0);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 result;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 2);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 value;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (x87_dec_stack(cpustate))
{
UINT32 m32real = READ32(cpustate, ea);
{
floatx80 value;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 8);
if (x87_dec_stack(cpustate))
{
UINT64 m64real = READ64(cpustate, ea);
{
floatx80 value;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 10);
if (x87_dec_stack(cpustate))
{
cpustate->x87_sw &= ~X87_SW_C1;
{
floatx80 value;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 2);
if (!x87_dec_stack(cpustate))
{
value = fx80_inan;
{
floatx80 value;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (!x87_dec_stack(cpustate))
{
value = fx80_inan;
{
floatx80 value;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 8);
if (!x87_dec_stack(cpustate))
{
value = fx80_inan;
{
floatx80 value;
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 10);
if (!x87_dec_stack(cpustate))
{
value = fx80_inan;
{
floatx80 value;
- UINT32 ea = GetEA(cpustate, modrm, 1);
+ UINT32 ea = GetEA(cpustate, modrm, 1, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 value;
- UINT32 ea = GetEA(cpustate, modrm, 1);
+ UINT32 ea = GetEA(cpustate, modrm, 1, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
{
floatx80 value;
- UINT32 ea = GetEA(cpustate, modrm, 1);
+ UINT32 ea = GetEA(cpustate, modrm, 1, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
}
- UINT32 ea = GetEA(cpustate, modrm, 1);
+ UINT32 ea = GetEA(cpustate, modrm, 1, 8);
if (x87_check_exceptions(cpustate))
{
UINT64 m64real = floatx80_to_float64(value);
value = ST(0);
}
- UINT32 ea = GetEA(cpustate, modrm, 1);
+ UINT32 ea = GetEA(cpustate, modrm, 1, 10);
if (x87_check_exceptions(cpustate))
{
WRITE80(cpustate, ea, value);
m16int = -32768;
}
- UINT32 ea = GetEA(cpustate, modrm, 1);
+ UINT32 ea = GetEA(cpustate, modrm, 1, 2);
if (x87_check_exceptions(cpustate))
{
WRITE16(cpustate, ea, m16int);
m32int = 0x80000000;
}
- UINT32 ea = GetEA(cpustate, modrm, 1);
+ UINT32 ea = GetEA(cpustate, modrm, 1, 4);
if (x87_check_exceptions(cpustate))
{
WRITE32(cpustate, ea, m32int);
m16int = (UINT16)0x8000;
}
- UINT32 ea = GetEA(cpustate, modrm, 1);
+ UINT32 ea = GetEA(cpustate, modrm, 1, 2);
if (x87_check_exceptions(cpustate))
{
WRITE16(cpustate, ea, m16int);
m32int = 0x80000000;
}
- UINT32 ea = GetEA(cpustate, modrm, 1);
+ UINT32 ea = GetEA(cpustate, modrm, 1, 4);
if (x87_check_exceptions(cpustate))
{
WRITE32(cpustate, ea, m32int);
m64int = U64(0x8000000000000000);
}
- UINT32 ea = GetEA(cpustate, modrm, 1);
+ UINT32 ea = GetEA(cpustate, modrm, 1, 8);
if (x87_check_exceptions(cpustate))
{
WRITE64(cpustate, ea, m64int);
result.high |= ST(0).high & 0x8000;
}
- UINT32 ea = GetEA(cpustate, modrm, 1);
+ UINT32 ea = GetEA(cpustate, modrm, 1, 10);
if (x87_check_exceptions(cpustate))
{
WRITE80(cpustate, ea, result);
void x87_ficom_m16int(i386_state *cpustate, UINT8 modrm)
{
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 2);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
void x87_ficom_m32int(i386_state *cpustate, UINT8 modrm)
{
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
void x87_ficomp_m16int(i386_state *cpustate, UINT8 modrm)
{
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 2);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
void x87_ficomp_m32int(i386_state *cpustate, UINT8 modrm)
{
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
void x87_fcom_m32real(i386_state *cpustate, UINT8 modrm)
{
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
void x87_fcom_m64real(i386_state *cpustate, UINT8 modrm)
{
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
void x87_fcomp_m32real(i386_state *cpustate, UINT8 modrm)
{
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 4);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
void x87_fcomp_m64real(i386_state *cpustate, UINT8 modrm)
{
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 8);
if (X87_IS_ST_EMPTY(0))
{
x87_set_stack_underflow(cpustate);
void x87_fldcw(i386_state *cpustate, UINT8 modrm)
{
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 2);
UINT16 cw = READ16(cpustate, ea);
x87_write_cw(cpustate, cw);
void x87_fstcw(i386_state *cpustate, UINT8 modrm)
{
- UINT32 ea = GetEA(cpustate, modrm, 1);
+ UINT32 ea = GetEA(cpustate, modrm, 1, 2);
WRITE16(cpustate, ea, cpustate->x87_cw);
CYCLES(cpustate, 3);
void x87_fldenv(i386_state *cpustate, UINT8 modrm)
{
// TODO: Pointers and selectors
- UINT32 ea = GetEA(cpustate, modrm, 0);
-
if (cpustate->operand_size)
{
// 32-bit real/protected mode
+ UINT32 ea = GetEA(cpustate, modrm, 0, 10);
x87_write_cw(cpustate, READ16(cpustate, ea));
cpustate->x87_sw = READ16(cpustate, ea + 4);
cpustate->x87_tw = READ16(cpustate, ea + 8);
else
{
// 16-bit real/protected mode
+ UINT32 ea = GetEA(cpustate, modrm, 0, 6);
x87_write_cw(cpustate, READ16(cpustate, ea));
cpustate->x87_sw = READ16(cpustate, ea + 2);
cpustate->x87_tw = READ16(cpustate, ea + 4);
void x87_fstenv(i386_state *cpustate, UINT8 modrm)
{
- UINT32 ea = GetEA(cpustate, modrm, 1);
+ UINT32 ea;
// TODO: Pointers and selectors
switch((cpustate->cr[0] & 1)|(cpustate->operand_size & 1)<<1)
{
case 0: // 16-bit real mode
+ ea = GetEA(cpustate, modrm, 1, 6);
WRITE16(cpustate, ea + 0, cpustate->x87_cw);
WRITE16(cpustate, ea + 2, cpustate->x87_sw);
WRITE16(cpustate, ea + 4, cpustate->x87_tw);
// WRITE16(cpustate, ea + 12, (cpustate->fpu_inst_ptr & 0x0f0000) >> 4);
break;
case 1: // 16-bit protected mode
- WRITE16(cpustate,ea + 0, cpustate->x87_cw);
+ ea = GetEA(cpustate, modrm, 1, 6);
+ WRITE16(cpustate, ea + 0, cpustate->x87_cw);
WRITE16(cpustate,ea + 2, cpustate->x87_sw);
WRITE16(cpustate,ea + 4, cpustate->x87_tw);
// WRITE16(cpustate,ea + 6, cpustate->fpu_inst_ptr & 0xffff);
// WRITE16(cpustate,ea + 12, (cpustate->fpu_inst_ptr & 0x0f0000) >> 4);
break;
case 2: // 32-bit real mode
+ ea = GetEA(cpustate, modrm, 1, 10);
WRITE16(cpustate, ea + 0, cpustate->x87_cw);
WRITE16(cpustate, ea + 4, cpustate->x87_sw);
WRITE16(cpustate, ea + 8, cpustate->x87_tw);
// WRITE32(cpustate, ea + 24, (cpustate->fpu_data_ptr >> 16) << 12);
break;
case 3: // 32-bit protected mode
- WRITE16(cpustate, ea + 0, cpustate->x87_cw);
+ ea = GetEA(cpustate, modrm, 1, 10);
+ WRITE16(cpustate, ea + 0, cpustate->x87_cw);
WRITE16(cpustate, ea + 4, cpustate->x87_sw);
WRITE16(cpustate, ea + 8, cpustate->x87_tw);
// WRITE32(cpustate, ea + 12, cpustate->fpu_inst_ptr);
void x87_fsave(i386_state *cpustate, UINT8 modrm)
{
- UINT32 ea = GetEA(cpustate, modrm, 1);
+ UINT32 ea = GetEA(cpustate, modrm, 1, 80);
// TODO: Pointers and selectors
switch((cpustate->cr[0] & 1)|(cpustate->operand_size & 1)<<1)
void x87_frstor(i386_state *cpustate, UINT8 modrm)
{
- UINT32 ea = GetEA(cpustate, modrm, 0);
+ UINT32 ea = GetEA(cpustate, modrm, 0, 80);
// TODO: Pointers and selectors
switch((cpustate->cr[0] & 1)|(cpustate->operand_size & 1)<<1)
void x87_fstsw_m2byte(i386_state *cpustate, UINT8 modrm)
{
- UINT32 ea = GetEA(cpustate, modrm, 1);
+ UINT32 ea = GetEA(cpustate, modrm, 1, 2);
WRITE16(cpustate, ea, cpustate->x87_sw);
palette_pc[15] = RGB_COLOR(0xFF,0xFF,0xFF); // COL080 = FFFFFF ;mk2\81` \94\92
// register event
- register_vline_event(this);
#endif
+ register_vline_event(this);
}
void MEMORY::reset()
portF1 = 0xdd;
CRTMode1 = CRTMode2 = CRTMode3 = 0;
CSS3=CSS2=CSS1=0;
- CGSW93 = CRTKILL = 0;
CurKANJIROM = KANJIROM;
#endif
+ CGSW93 = CRTKILL = 0;
}
void MEMORY::write_data8(uint32_t addr, uint32_t data)
return(RdMem[addr >> 13][addr & 0x1FFF]);
}
+void MEMORY::write_data8w(uint32_t addr, uint32_t data, int *wait)
+{
+#ifdef _PC6001
+ *wait = addr < 0x8000 ? 1 : 0;
+#else
+ bool is_rom;
+ uint32_t portF3 = d_timer->read_io8(0xf3);
+#if defined(_PC6601SR) || defined(_PC6001MK2SR)
+ if (static_cast<VM *>(vm)->sr_mode) {
+ is_rom = (port60[8 + (addr >> 13)] & 0xf0) > 0x20 ? true: false;
+ } else
+#endif
+ {
+ is_rom = EnWrite[addr >> 14] ? false : true;
+ }
+ *wait = is_rom && (portF3 & 0x40) || !is_rom && (portF3 & 0x20) ? 1 : 0;
+#endif
+ write_data8(addr, data);
+}
+
+uint32_t MEMORY::read_data8w(uint32_t addr, int *wait)
+{
+#ifdef _PC6001
+ *wait = addr < 0x8000 ? 1 : 0;
+#else
+ bool is_rom;
+ uint32_t portF3 = d_timer->read_io8(0xf3);
+#if defined(_PC6601SR) || defined(_PC6001MK2SR)
+ if (static_cast<VM *>(vm)->sr_mode) {
+ is_rom = (port60[addr >> 13] & 0xf0) > 0x20 ? true : false;
+ } else
+#endif
+ {
+ if (CGSW93 && 0x6000 <= addr && addr < 0x8000) {
+ is_rom = true;
+ } else if (addr < 0x4000) {
+ is_rom = (portF0 & 0x0f) == 0x0d || (portF0 & 0x0f) == 0x0e ? false : true;
+ } else if (addr < 0x8000) {
+ is_rom = (portF0 & 0xf0) == 0xd0 || (portF0 & 0xf0) == 0xe0 ? false : true;
+ } else if (addr < 0xc000) {
+ is_rom = (portF1 & 0x0f) == 0x0d || (portF1 & 0x0f) == 0x0e ? false : true;
+ } else {
+ is_rom = (portF1 & 0xf0) == 0xd0 || (portF1 & 0xf0) == 0xe0 ? false : true;
+ }
+ }
+ *wait = is_rom && (portF3 & 0x40) || !is_rom && (portF3 & 0x20) ? 1 : 0;
+#endif
+ return read_data8(addr);
+}
+
+uint32_t MEMORY::fetch_op(uint32_t addr, int *wait)
+{
+#ifndef _PC6001
+ uint32_t portF3 = d_timer->read_io8(0xf3);
+ if ((portF3 & 0x80) == 0) {
+ return read_data8w(addr, wait);
+ }
+#endif
+ *wait = 1;
+ return read_data8(addr);
+}
+
void MEMORY::write_io8(uint32_t addr, uint32_t data)
{
unsigned int VRAMHead[2][4] = {
}
return(Value);
}
+#endif
+
+void MEMORY::write_io8w(uint32_t addr, uint32_t data, int* wait)
+{
+ *wait = (addr & 0xf0) == 0xa0 ? 1 : 0;
+ write_io8(addr, data);
+}
+
+uint32_t MEMORY::read_io8w(uint32_t addr, int* wait)
+{
+ *wait = (addr & 0xf0) == 0xa0 ? 1 : 0;
+ return read_io8(addr);
+}
#define EVENT_HBLANK 1
} else
#endif
{
- if(!CRTKILL) {
- if(v < (CRTMode1 ? 200 : 192)) {
+ if (!CRTKILL) {
+#ifdef _PC6001
+ if (v < 192) {
+ d_cpu->write_signal(SIG_CPU_BUSREQ, 1, 1);
+ register_event_by_clock(this, EVENT_HBLANK, (double)CPU_CLOCKS / FRAMES_PER_SEC / LINES_PER_FRAME * 296 / 455, false, NULL);
+ }
+#else
+ if (v < (CRTMode1 ? 200 : 192)) {
d_cpu->write_signal(SIG_CPU_BUSREQ, 1, 1);
- register_event_by_clock(this, EVENT_HBLANK, CPU_CLOCKS / FRAMES_PER_SEC / LINES_PER_FRAME * 368 / 456, false, NULL);
+ register_event_by_clock(this, EVENT_HBLANK, (double)CPU_CLOCKS / FRAMES_PER_SEC / LINES_PER_FRAME * (CRTMode1 ? 368 : 304) / 456, false, NULL);
}
+#endif
}
}
}
d_cpu->write_signal(SIG_CPU_BUSREQ, 0, 0);
}
}
-#endif
void MEMORY::write_signal(int id, uint32_t data, uint32_t mask)
{
} else {
CGSW93=1; RdMem[3]=CGROM;
}
- CRTKILL = (data & 2) ? 0 : 1;
#endif
+ CRTKILL = (data & 2) ? 0 : 1;
+ if (CRTKILL) {
+ d_cpu->write_signal(SIG_CPU_BUSREQ, 0, 0);
+ }
}
}
uint8_t EnWrite[4]; // MEMORY MAPPING WRITE ENABLE [N60/N66]
uint8_t CGSW93;
bool inserted;
-#ifndef _PC6001
uint8_t CRTKILL;
+#ifndef _PC6001
// uint8_t VOICEROM[0x4000];
// uint8_t KANJIROM[0x8000];
uint8_t *CurKANJIROM;
void reset();
void write_data8(uint32_t addr, uint32_t data);
uint32_t read_data8(uint32_t addr);
+ void write_data8w(uint32_t addr, uint32_t data, int *wait);
+ uint32_t read_data8w(uint32_t addr, int *wait);
+ uint32_t fetch_op(uint32_t addr, int *wait);
void write_io8(uint32_t addr, uint32_t data);
#ifndef _PC6001
uint32_t read_io8(uint32_t addr);
+#endif
+ void write_io8w(uint32_t addr, uint32_t data, int* wait);
+ uint32_t read_io8w(uint32_t addr, int* wait);
void event_vline(int v, int clock);
void event_callback(int event_id, int err);
-#endif
void write_signal(int id, uint32_t data, uint32_t mask);
bool process_state(FILEIO* state_fio, bool loading);
display->set_vram_ptr(memory->get_vram());
display->set_context_timer(timer);
vdp->load_font_image(create_local_path(_T("CGROM60.60")));
- vdp->set_context_cpu(cpu);
+// vdp->set_context_cpu(cpu);
pio_sub->set_context_port_c(vdp, SIG_MC6847_ENABLE, 0x02, 0); // CRTKILL
#else
voice = new UPD7752(this, emu);
#define SCREEN_HEIGHT 192
#define CPU_CLOCKS 3993600
#define HAS_AY_3_8910
+#define TIMER_PERIOD (8192. / CPU_CLOCKS * 1000000)
#elif defined(_PC6001MK2)
#define DEVICE_NAME "NEC PC-6001mkII"
#define CONFIG_NAME "pc6001mk2"
#define SCREEN_WIDTH 640
#define SCREEN_HEIGHT 400
#define WINDOW_HEIGHT_ASPECT 480
-#define CPU_CLOCKS 4000000
+#define CPU_CLOCKS 3993600
#define HAS_AY_3_8910
+#define TIMER_PERIOD (8192. / CPU_CLOCKS * 1000000)
#elif defined(_PC6001MK2SR)
#define DEVICE_NAME "NEC PC-6001mkIISR"
#define CONFIG_NAME "pc6001mk2sr"
#define SCREEN_HEIGHT 400
#define WINDOW_HEIGHT_ASPECT 480
#define CPU_CLOCKS 3580000
+#define TIMER_PERIOD (2000/.999)
#elif defined(_PC6601)
#define DEVICE_NAME "NEC PC-6601"
#define CONFIG_NAME "pc6601"
#define WINDOW_HEIGHT_ASPECT 480
#define CPU_CLOCKS 4000000
#define HAS_AY_3_8910
+#define TIMER_PERIOD (8192. / CPU_CLOCKS * 1000000)
#elif defined(_PC6601SR)
#define DEVICE_NAME "NEC PC-6601SR"
#define CONFIG_NAME "pc6601sr"
#define SCREEN_HEIGHT 400
#define WINDOW_HEIGHT_ASPECT 480
#define CPU_CLOCKS 3580000
+#define TIMER_PERIOD (2000 / .999)
#endif
+//memory wait
+#define Z80_MEMORY_WAIT
+#define Z80_IO_WAIT
+
// device informations for virtual machine
#define FRAMES_PER_SEC 60
#define LINES_PER_FRAME 262
StrigEventID = -1;
}
// register_event(this, EVENT_STRIG, 3000, false, &StrigEventID); // 3msec
- register_event(this, EVENT_STRIG, 100, false, &StrigEventID); // 0.1nsec
+ register_event(this, EVENT_STRIG, 100, false, &StrigEventID); // 0.1msec
}
else if (data==0x3e || data==0x3d) { // \82P\81|\82P\81j0x3E \8eó\90M(1200baud\81j\81@\82Ü\82½\82Í\81@0x3D \8eó\90M(600baud\81j
- CasMode=CAS_NONE;
CasBaud=(data==0x3e)?1200:600;
}
else if (data==0x39) { ///
CasMode=CAS_SAVEBYTE;
}
else if (data==0x1e || data==0x1d) { // \82P\81|\82P\81j0x1E \8eó\90M(1200baud\81j\81@\82Ü\82½\82Í\81@0x1D \8eó\90M(600baud\81j
- CasMode=CAS_NONE;
CasBaud=(data==0x1e)?1200:600;
}
else if (data==0x1a && CasMode!=CAS_NONE) { /* CMT LOAD STOP */
}
/* CMT LOAD OPEN(0x1E,0x19(1200baud)/0x1D,0x19(600baud)) */
else if (data==0x19) {
- if(play /*&& CasBaud == FileBaud*/) {
+ if (play && CasMode != CAS_LOADING /*&& CasBaud == FileBaud*/) {
register_event(this, EVENT_CASSETTE, 1000000.0 / (CasBaud / 12), false, NULL);
}
CasRecv=0xff;
timer_id = -1;
// register next event
#ifdef _PC6001
- register_event(this, EVENT_TIMER, 2000.0, false, &timer_id);
+ register_event(this, EVENT_TIMER, TIMER_PERIOD, false, &timer_id);
#else
#if defined(_PC6601SR) || defined(_PC6001MK2SR)
if(static_cast<VM *>(vm)->sr_mode) {
- register_event(this, EVENT_TIMER, 2000.0 * (portF6 + 1) / 0x80, false, &timer_id);
+ register_event(this, EVENT_TIMER, TIMER_PERIOD * (portF6 + 1.) / 0x80, false, &timer_id);
} else
#endif
- register_event(this, EVENT_TIMER, 2000.0 * (portF6 + 1) / 4, false, &timer_id);
+ register_event(this, EVENT_TIMER, TIMER_PERIOD * (portF6 + 1.) / 4, false, &timer_id);
#endif
}
}
if(timer_id == -1) {
#ifdef _PC6001
// first period is 1msec
- register_event(this, EVENT_TIMER, 1000.0, false, &timer_id);
+ register_event(this, EVENT_TIMER, TIMER_PERIOD / 2, false, &timer_id);
#else
#if defined(_PC6601SR) || defined(_PC6001MK2SR)
if(static_cast<VM *>(vm)->sr_mode) {
- register_event(this, EVENT_TIMER, 2000.0 * (portF6 + 1) / 0x80, false, &timer_id);
+ register_event(this, EVENT_TIMER, TIMER_PERIOD * (portF6 + 1.) / 0x80, false, &timer_id);
} else
#endif
- register_event(this, EVENT_TIMER, 2000.0 * (portF6 + 1) / 4, false, &timer_id);
+ register_event(this, EVENT_TIMER, TIMER_PERIOD * (portF6 + 1.) / 4, false, &timer_id);
#endif
}
}
request_intr(IRQ_VRTC, true);
update_gvram_wait();
}
+ // update palette
+#if !defined(_PC8001SR)
+ if(v < (disp_line <= 200 ? 200 : 400)) {
+#else
+ if(v < 200) {
+#endif
+ if(update_palette) {
+ static const int pex[8] = {
+ 0, 36, 73, 109, 146, 182, 219, 255 // from m88
+ };
+#if defined(_PC8001SR)
+ if(config.boot_mode != MODE_PC80_V2) {
+ if(Port31_V1_320x200) {
+ for(int i = 0; i < 3; i++) {
+ uint8_t b = (port[0x31] & 4) ? 7 : 0;
+ uint8_t r = (i & 1) ? 7 : 0;
+ uint8_t g = (i & 2) ? 7 : 0;
+ palette_graph_pc[i] = RGB_COLOR(pex[r], pex[g], pex[b]);
+ }
+ palette_graph_pc[3] = RGB_COLOR(pex[palette[8].r], pex[palette[8].g], pex[palette[8].b]);
+ } else if(Port31_V1_MONO) {
+ palette_graph_pc[0] = 0;
+ palette_graph_pc[1] = RGB_COLOR(pex[palette[8].r], pex[palette[8].g], pex[palette[8].b]);
+ } else {
+ for(int i = 1; i < 8; i++) {
+ palette_graph_pc[i] = RGB_COLOR((i & 2) ? 255 : 0, (i & 4) ? 255 : 0, (i & 1) ? 255 : 0);
+ }
+ palette_graph_pc[0] = RGB_COLOR(pex[palette[8].r], pex[palette[8].g], pex[palette[8].b]);
+ }
+ if(Port31_V1_320x200) {
+ palette_text_pc[0] = 0;
+ } else {
+ palette_text_pc[0] = palette_graph_pc[0];
+ }
+ } else {
+ for(int i = 0; i < 8; i++) {
+ uint8_t b = (port[0x54 + i] & 1) ? 7 : 0;
+ uint8_t r = (port[0x54 + i] & 2) ? 7 : 0;
+ uint8_t g = (port[0x54 + i] & 4) ? 7 : 0;
+ palette_graph_pc[i] = RGB_COLOR(pex[r], pex[g], pex[b]);
+ }
+ if(!Port31_HCOLOR) {
+ palette_graph_pc[0] = RGB_COLOR(pex[palette[8].r], pex[palette[8].g], pex[palette[8].b]);
+ }
+ palette_text_pc[0] = palette_graph_pc[0];
+ }
+#else
+ for(int i = 0; i < 8; i++) {
+ palette_graph_pc[i] = RGB_COLOR(pex[palette[i].r], pex[palette[i].g], pex[palette[i].b]);
+ }
+ if(!Port31_HCOLOR && !Port32_PMODE) {
+ palette_graph_pc[0] = RGB_COLOR(pex[palette[8].r], pex[palette[8].g], pex[palette[8].b]);
+ }
+ palette_text_pc[0] = palette_graph_pc[0];
+#endif
+ update_palette = false;
+ }
+ for(int i = 0; i < 9; i++) {
+ line_palette_text_pc[v][i] = palette_text_pc[i];
+ line_palette_graph_pc[v][i] = palette_graph_pc[i];
+ }
+ }
}
void PC88::key_down(int code, bool repeat)
}
#endif
- // update palette
- if(update_palette) {
- static const int pex[8] = {
- 0, 36, 73, 109, 146, 182, 219, 255 // from m88
- };
-#if defined(_PC8001SR)
- if(config.boot_mode != MODE_PC80_V2) {
- if(Port31_V1_320x200) {
- for(int i = 0; i < 3; i++) {
- uint8_t b = (port[0x31] & 4) ? 7 : 0;
- uint8_t r = (i & 1) ? 7 : 0;
- uint8_t g = (i & 2) ? 7 : 0;
- palette_graph_pc[i] = RGB_COLOR(pex[r], pex[g], pex[b]);
- }
- palette_graph_pc[3] = RGB_COLOR(pex[palette[8].r], pex[palette[8].g], pex[palette[8].b]);
- } else if(Port31_V1_MONO) {
- palette_graph_pc[0] = 0;
- palette_graph_pc[1] = RGB_COLOR(pex[palette[8].r], pex[palette[8].g], pex[palette[8].b]);
- } else {
- for(int i = 1; i < 8; i++) {
- palette_graph_pc[i] = RGB_COLOR((i & 2) ? 255 : 0, (i & 4) ? 255 : 0, (i & 1) ? 255 : 0);
- }
- palette_graph_pc[0] = RGB_COLOR(pex[palette[8].r], pex[palette[8].g], pex[palette[8].b]);
- }
- if(Port31_V1_320x200) {
- palette_text_pc[0] = 0;
- } else {
- palette_text_pc[0] = palette_graph_pc[0];
- }
- } else {
- for(int i = 0; i < 8; i++) {
- uint8_t b = (port[0x54 + i] & 1) ? 7 : 0;
- uint8_t r = (port[0x54 + i] & 2) ? 7 : 0;
- uint8_t g = (port[0x54 + i] & 4) ? 7 : 0;
- palette_graph_pc[i] = RGB_COLOR(pex[r], pex[g], pex[b]);
- }
- if(!Port31_HCOLOR) {
- palette_graph_pc[0] = RGB_COLOR(pex[palette[8].r], pex[palette[8].g], pex[palette[8].b]);
- }
- palette_text_pc[0] = palette_graph_pc[0];
- }
-#else
- for(int i = 0; i < 8; i++) {
- palette_graph_pc[i] = RGB_COLOR(pex[palette[i].r], pex[palette[i].g], pex[palette[i].b]);
- }
- if(!Port31_HCOLOR && !Port32_PMODE) {
- palette_graph_pc[0] = RGB_COLOR(pex[palette[8].r], pex[palette[8].g], pex[palette[8].b]);
- }
- palette_text_pc[0] = palette_graph_pc[0];
-#endif
- update_palette = false;
- }
-
// set back color to black if cg screen is off in color mode
- scrntype_t palette_text_back = palette_text_pc[0];
- scrntype_t palette_graph_back = palette_graph_pc[0];
+#if !defined(_PC8001SR)
+ int disp_line = crtc.height * crtc.char_height;
+ int shift = (disp_line <= 200) ? 0 : 1;
- if(!disp_color_graph) {
- palette_text_pc[0] = palette_graph_pc[0] = 0;
+ for(int y = 0; y < (disp_line <= 200 ? 200 : 400); y++) {
+#else
+ for(int y = 0; y < 200; y++) {
+#endif
+ if(!disp_color_graph) {
+ line_palette_text_pc[y][0] = line_palette_graph_pc[y][0] = 0;
+ }
+ line_palette_graph_pc[y][8] = /*line_palette_text_pc[y][8] = */line_palette_text_pc[y][0];
}
- palette_graph_pc[8] = /*palette_text_pc[8] = */palette_text_pc[0];
// copy to screen buffer
#if !defined(_PC8001SR)
scrntype_t* dest1 = emu->get_screen_buffer(y * 2 + 1);
uint8_t* src_t = text[y];
uint8_t* src_g = graph[y];
-
#if defined(_PC8001SR)
+ scrntype_t* pal_t = line_palette_text_pc[y];
+ scrntype_t* pal_g = line_palette_graph_pc[y];
+
if(port[0x33] & 8) {
for(int x = 0; x < 640; x++) {
uint32_t g = src_g[x];
- dest0[x] = g ? palette_graph_pc[g] : palette_text_pc[src_t[x]];
+ dest0[x] = g ? pal_g[g] : pal_t[src_t[x]];
}
} else {
for(int x = 0; x < 640; x++) {
uint32_t t = src_t[x];
- dest0[x] = t ? palette_text_pc[t] : palette_graph_pc[src_g[x]];
+ dest0[x] = t ? pal_t[t] : pal_g[src_g[x]];
}
}
#else
+ scrntype_t* pal_t = line_palette_text_pc[y << shift];
+ scrntype_t* pal_g = line_palette_graph_pc[y << shift];
+
if(Port31_HCOLOR) {
for(int x = 0; x < 640; x++) {
uint32_t t = src_t[x];
- dest0[x] = t ? palette_text_pc[t] : palette_graph_pc[src_g[x]];
+ dest0[x] = t ? pal_t[t] : pal_g[src_g[x]];
}
} else if(Port32_PMODE) {
for(int x = 0; x < 640; x++) {
uint32_t t = src_t[x];
- dest0[x] = palette_graph_pc[t ? t : src_g[x]];
+ dest0[x] = pal_g[t ? t : src_g[x]];
}
} else {
for(int x = 0; x < 640; x++) {
uint32_t t = src_t[x];
- dest0[x] = palette_text_pc[t ? t : src_g[x]];
+ dest0[x] = pal_t[t ? t : src_g[x]];
}
}
#endif
scrntype_t* dest = emu->get_screen_buffer(y);
uint8_t* src_t = text[y >> 1];
uint8_t* src_g = graph[y];
+ scrntype_t* pal_t = line_palette_text_pc[y];
+ scrntype_t* pal_g = line_palette_graph_pc[y];
// if(Port31_HCOLOR) {
// for(int x = 0; x < 640; x++) {
// uint32_t t = src_t[x];
-// dest[x] = t ? palette_text_pc[t] : palette_graph_pc[src_g[x]];
+// dest[x] = t ? pal_t[t] : pal_g[src_g[x]];
// }
// } else
if(Port32_PMODE) {
for(int x = 0; x < 640; x++) {
uint32_t t = src_t[x];
- dest[x] = palette_graph_pc[t ? t : src_g[x]];
+ dest[x] = pal_g[t ? t : src_g[x]];
}
} else {
for(int x = 0; x < 640; x++) {
uint32_t t = src_t[x];
- dest[x] = palette_text_pc[t ? t : src_g[x]];
+ dest[x] = pal_t[t ? t : src_g[x]];
}
}
}
emu->screen_skip_line(false);
}
#endif
-
- // restore back color palette
- palette_text_pc[0] = palette_text_back;
- palette_graph_pc[0] = palette_graph_back;
}
/*
uint8_t graph[400][640];
scrntype_t palette_text_pc[9]; // 0 = back color for attrib mode, 8 = black
scrntype_t palette_graph_pc[9];
+ scrntype_t line_palette_text_pc[400][9];
+ scrntype_t line_palette_graph_pc[400][9];
void draw_text();
#if defined(_PC8001SR)
}
}
-#define STATE_VERSION 13
+#define STATE_VERSION 14
bool VM::process_state(FILEIO* state_fio, bool loading)
{
#if !defined(SUPPORT_HIRESO)
#define SUPPORT_BIOS_RAM
#endif
+ // PC-9801-86
+ #define SUPPORT_PC98_OPNA
#endif
#if defined(SUPPORT_24BIT_ADDRESS) || defined(SUPPORT_32BIT_ADDRESS)
#define MEMORY_ADDR_MAX 0x1000000 // 16MB
#define MEMORY_BANK_SIZE 0x800
#define IO_ADDR_MAX 0x10000
-// PC-9801-86
-//#define SUPPORT_PC98_OPNA
-
#if defined(_PC98DO) || defined(_PC98DOPLUS)
#define MODE_PC98 0
#define MODE_PC88_V1S 1
#ifdef USE_SOUND_VOLUME
static const _TCHAR *sound_device_caption[] = {
#if defined(SUPPORT_PC98_OPNA)
- _T("PC-9801-86 (FM)"), _T("PC-9801-86 (PSG)"), _T("PC-9801-86 (ADPCM)"), _T("PC-9801-86 (Rhythm)"),
+ _T("OPNA (FM)"), _T("OPNA (PSG)"), _T("OPNA (ADPCM)"), _T("OPNA (Rhythm)"),
#else
- _T("PC-9801-26 (FM)"), _T("PC-9801-26 (PSG)"),
+ _T("OPN (FM)"), _T("OPN (PSG)"),
#endif
_T("PC-9801-14"), _T("Beep"),
#if defined(_PC98DO) || defined(_PC98DOPLUS)
#if defined(SUPPORT_PC88_OPNA)
- _T("PC-88 OPNA (FM)"), _T("PC-88 OPNA (PSG)"), _T("PC-88 OPNA (ADPCM)"), _T("PC-88 OPNA (Rhythm)"),
+ _T("PC-88 (FM)"), _T("PC-88 (PSG)"), _T("PC-88 (ADPCM)"), _T("PC-88 (Rhythm)"),
#else
- _T("PC-88 OPN (FM)"), _T("PC-88 OPN (PSG)"),
+ _T("PC-88 (FM)"), _T("PC-88 (PSG)"),
#endif
- _T("PC-88 Beep"),
+ _T("PC-88 (Beep)"),
#endif
_T("Noise (FDD)"),
};
#else
d_dma->write_signal(SIG_I8237_CH0, data, mask);
#endif
- } else {
- if(data & mask) {
- #ifdef _SCSI_DEBUG_LOG
- this->out_debug_log(_T("[SASI] DMAE=0, change IRQ\n"));
- #endif
- write_signal(SIG_SASI_IRQ, data, mask);
- }
+// } else {
+// if(data & mask) {
+// #ifdef _SCSI_DEBUG_LOG
+// this->out_debug_log(_T("[SASI] DMAE=0, change IRQ\n"));
+// #endif
+// write_signal(SIG_SASI_IRQ, data, mask);
+// }
}
drq_status = ((data & mask) != 0);
break;
buffer->write(data_bus);
break;
}
- set_req_delay(0, 1.0);
+ set_req_delay(0, 0.1);
} else if(prev_status && !ack_status) {
// H -> L
if(atn_pending) {
if(!prev_status && req_status) {
// L -> H
// if(bsy_status) {
- if(!cd_status && !msg_status) {
+ if(!cd_status) {
// data phase
set_drq(true);
access = true;
- } else if(cd_status) {
- // command/status/message phase
+ } else if(!msg_status && io_status) {
+ // status phase
set_irq(true);
}
// }
if(cond) { \
JR(); \
icount -= cc_ex[opcode]; \
- } else PC++; \
+ } else FETCH8(); \
} while(0)
#define CALL() do { \
OSDN Git Service
