From 51040fc61e89c49dc6bc9dfb8e9482a81fe1eb3d Mon Sep 17 00:00:00 2001 From: =?utf8?q?Herm=C3=A8s=20B=C3=A9lusca-Ma=C3=AFto?= Date: Sat, 19 Oct 2013 16:55:51 +0000 Subject: [PATCH] Bye bye Soft386, welcome Fast486, courtesy Aleksandar Andrejevic. [NTVDM]: Define by default NEW_EMULATOR, i.e. use Fast486 instead of softx86. svn path=/branches/ntvdm/; revision=60703 --- include/reactos/libs/fast486/fast486.h | 397 +++ include/reactos/libs/soft386/soft386.h | 397 --- lib/CMakeLists.txt | 2 +- lib/fast486/CMakeLists.txt | 11 + lib/{soft386 => fast486}/COPYING | 0 lib/{soft386 => fast486}/common.c | 132 +- lib/{soft386 => fast486}/common.h | 44 +- lib/{soft386 => fast486}/common.inl | 262 +- lib/{soft386 => fast486}/extraops.c | 64 +- lib/{soft386 => fast486}/extraops.h | 6 +- lib/{soft386/soft386.c => fast486/fast486.c} | 200 +- lib/{soft386 => fast486}/opcodes.c | 2894 +++++++++--------- lib/fast486/opcodes.h | 159 + lib/{soft386 => fast486}/opgroups.c | 500 +-- lib/{soft386 => fast486}/opgroups.h | 34 +- lib/soft386/CMakeLists.txt | 11 - lib/soft386/opcodes.h | 159 - subsystems/ntvdm/CMakeLists.txt | 4 +- subsystems/ntvdm/emulator.c | 40 +- subsystems/ntvdm/emulator.h | 4 +- subsystems/ntvdm/ntvdm.h | 4 +- 21 files changed, 2662 insertions(+), 2662 deletions(-) create mode 100644 include/reactos/libs/fast486/fast486.h delete mode 100644 include/reactos/libs/soft386/soft386.h create mode 100644 lib/fast486/CMakeLists.txt rename lib/{soft386 => fast486}/COPYING (100%) rename lib/{soft386 => fast486}/common.c (76%) rename lib/{soft386 => fast486}/common.h (79%) rename lib/{soft386 => fast486}/common.inl (75%) rename lib/{soft386 => fast486}/extraops.c (91%) rename lib/{soft386 => fast486}/extraops.h (87%) rename lib/{soft386/soft386.c => fast486/fast486.c} (55%) rename lib/{soft386 => fast486}/opcodes.c (64%) create mode 100644 lib/fast486/opcodes.h rename lib/{soft386 => fast486}/opgroups.c (73%) rename lib/{soft386 => fast486}/opgroups.h (55%) delete mode 100644 lib/soft386/CMakeLists.txt delete mode 100644 lib/soft386/opcodes.h diff --git a/include/reactos/libs/fast486/fast486.h b/include/reactos/libs/fast486/fast486.h new file mode 100644 index 00000000000..9188043c27c --- /dev/null +++ b/include/reactos/libs/fast486/fast486.h @@ -0,0 +1,397 @@ +/* + * Fast486 386/486 CPU Emulation Library + * fast486.h + * + * Copyright (C) 2013 Aleksandar Andrejevic + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef _FAST486_H_ +#define _FAST486_H_ + +/* DEFINES ********************************************************************/ + +#define FAST486_NUM_GEN_REGS 8 +#define FAST486_NUM_SEG_REGS 6 +#define FAST486_NUM_CTRL_REGS 8 +#define FAST486_NUM_DBG_REGS 8 + +#define FAST486_CR0_PE (1 << 0) +#define FAST486_CR0_MP (1 << 1) +#define FAST486_CR0_EM (1 << 2) +#define FAST486_CR0_TS (1 << 3) +#define FAST486_CR0_ET (1 << 4) +#define FAST486_CR0_NE (1 << 5) +#define FAST486_CR0_WP (1 << 16) +#define FAST486_CR0_AM (1 << 18) +#define FAST486_CR0_NW (1 << 29) +#define FAST486_CR0_CD (1 << 30) +#define FAST486_CR0_PG (1 << 31) + +#define FAST486_IDT_TASK_GATE 0x5 +#define FAST486_IDT_INT_GATE 0x6 +#define FAST486_IDT_TRAP_GATE 0x7 +#define FAST486_IDT_INT_GATE_32 0xE +#define FAST486_IDT_TRAP_GATE_32 0xF + +#define FAST486_PREFIX_SEG (1 << 0) +#define FAST486_PREFIX_OPSIZE (1 << 1) +#define FAST486_PREFIX_ADSIZE (1 << 2) +#define FAST486_PREFIX_LOCK (1 << 3) +#define FAST486_PREFIX_REPNZ (1 << 4) +#define FAST486_PREFIX_REP (1 << 5) + +struct _FAST486_STATE; +typedef struct _FAST486_STATE FAST486_STATE, *PFAST486_STATE; + +typedef enum _FAST486_GEN_REGS +{ + FAST486_REG_EAX, + FAST486_REG_ECX, + FAST486_REG_EDX, + FAST486_REG_EBX, + FAST486_REG_ESP, + FAST486_REG_EBP, + FAST486_REG_ESI, + FAST486_REG_EDI +} FAST486_GEN_REGS, *PFAST486_GEN_REGS; + +typedef enum _FAST486_SEG_REGS +{ + FAST486_REG_ES, + FAST486_REG_CS, + FAST486_REG_SS, + FAST486_REG_DS, + FAST486_REG_FS, + FAST486_REG_GS +} FAST486_SEG_REGS, *PFAST486_SEG_REGS; + +typedef enum _FAST486_CTRL_REGS +{ + FAST486_REG_CR0, + FAST486_REG_CR1, + FAST486_REG_CR2, + FAST486_REG_CR3, + FAST486_REG_CR4, + FAST486_REG_CR5, + FAST486_REG_CR6, + FAST486_REG_CR7 +} FAST486_CTRL_REGS, *PFAST486_CTRL_REGS; + +typedef enum _FAST486_DBG_REGS +{ + FAST486_REG_DR0, + FAST486_REG_DR1, + FAST486_REG_DR2, + FAST486_REG_DR3, + FAST486_REG_DR4, + FAST486_REG_DR5, + FAST486_REG_DR6, + FAST486_REG_DR7 +} FAST486_DBG_REGS, *PFAST486_DBG_REGS; + +typedef enum _FAST486_EXCEPTIONS +{ + FAST486_EXCEPTION_DE = 0x00, + FAST486_EXCEPTION_DB = 0x01, + FAST486_EXCEPTION_BP = 0x03, + FAST486_EXCEPTION_OF = 0x04, + FAST486_EXCEPTION_BR = 0x05, + FAST486_EXCEPTION_UD = 0x06, + FAST486_EXCEPTION_NM = 0x07, + FAST486_EXCEPTION_DF = 0x08, + FAST486_EXCEPTION_TS = 0x0A, + FAST486_EXCEPTION_NP = 0x0B, + FAST486_EXCEPTION_SS = 0x0C, + FAST486_EXCEPTION_GP = 0x0D, + FAST486_EXCEPTION_PF = 0x0E, + FAST486_EXCEPTION_MF = 0x10, + FAST486_EXCEPTION_AC = 0x11, + FAST486_EXCEPTION_MC = 0x12 +} FAST486_EXCEPTIONS, *PFAST486_EXCEPTIONS; + +typedef +BOOLEAN +(NTAPI *FAST486_MEM_READ_PROC) +( + PFAST486_STATE State, + ULONG Address, + PVOID Buffer, + ULONG Size +); + +typedef +BOOLEAN +(NTAPI *FAST486_MEM_WRITE_PROC) +( + PFAST486_STATE State, + ULONG Address, + PVOID Buffer, + ULONG Size +); + +typedef +VOID +(NTAPI *FAST486_IO_READ_PROC) +( + PFAST486_STATE State, + ULONG Port, + PVOID Buffer, + ULONG Size +); + +typedef +VOID +(NTAPI *FAST486_IO_WRITE_PROC) +( + PFAST486_STATE State, + ULONG Port, + PVOID Buffer, + ULONG Size +); + +typedef +VOID +(NTAPI *FAST486_IDLE_PROC) +( + PFAST486_STATE State +); + +typedef +VOID +(NTAPI *FAST486_BOP_PROC) +( + PFAST486_STATE State, + USHORT BopCode +); + +typedef union _FAST486_REG +{ + union + { + struct + { + UCHAR LowByte; + UCHAR HighByte; + }; + USHORT LowWord; + }; + ULONG Long; +} FAST486_REG, *PFAST486_REG; + +typedef struct _FAST486_SEG_REG +{ + USHORT Selector; + + /* Descriptor cache */ + ULONG Accessed : 1; + ULONG ReadWrite : 1; + ULONG DirConf : 1; + ULONG Executable : 1; + ULONG SystemType : 1; + ULONG Dpl : 2; + ULONG Present : 1; + ULONG Size : 1; + ULONG Limit; + ULONG Base; +} FAST486_SEG_REG, *PFAST486_SEG_REG; + +typedef struct +{ + ULONG Limit : 16; + ULONG Base : 24; + ULONG Accessed : 1; + ULONG ReadWrite : 1; + ULONG DirConf : 1; + ULONG Executable : 1; + ULONG SystemType : 1; + ULONG Dpl : 2; + ULONG Present : 1; + ULONG LimitHigh : 4; + ULONG Avl : 1; + ULONG Reserved : 1; + ULONG Size : 1; + ULONG Granularity : 1; + ULONG BaseHigh : 8; +} FAST486_GDT_ENTRY, *PFAST486_GDT_ENTRY; + +typedef struct +{ + ULONG Offset : 16; + ULONG Selector : 16; + ULONG ParamCount : 5; + ULONG Reserved : 3; + ULONG Type : 4; + ULONG SystemType : 1; + ULONG Dpl : 2; + ULONG Present : 1; + ULONG OffsetHigh : 16; +} FAST486_CALL_GATE, *PFAST486_CALL_GATE; + +typedef struct +{ + ULONG Offset : 16; + ULONG Selector : 16; + ULONG Zero : 8; + ULONG Type : 4; + ULONG Storage : 1; + ULONG Dpl : 2; + ULONG Present : 1; + ULONG OffsetHigh : 16; +} FAST486_IDT_ENTRY, *PFAST486_IDT_ENTRY; + +typedef struct _FAST486_TABLE_REG +{ + USHORT Size; + ULONG Address; +} FAST486_TABLE_REG, *PFAST486_TABLE_REG; + +typedef union _FAST486_FLAGS_REG +{ + USHORT LowWord; + ULONG Long; + + struct + { + ULONG Cf : 1; + ULONG AlwaysSet : 1; + ULONG Pf : 1; + ULONG Reserved0 : 1; + ULONG Af : 1; + ULONG Reserved1 : 1; + ULONG Zf : 1; + ULONG Sf : 1; + ULONG Tf : 1; + ULONG If : 1; + ULONG Df : 1; + ULONG Of : 1; + ULONG Iopl : 2; + ULONG Nt : 1; + ULONG Reserved2 : 1; + ULONG Rf : 1; + ULONG Vm : 1; + ULONG Ac : 1; + ULONG Vif : 1; + ULONG Vip : 1; + ULONG Id : 1; + + // ULONG Reserved : 10; + }; +} FAST486_FLAGS_REG, *PFAST486_FLAGS_REG; + +typedef struct _FAST486_TSS +{ + ULONG Link; + ULONG Esp0; + ULONG Ss0; + ULONG Esp1; + ULONG Ss1; + ULONG Esp2; + ULONG Ss2; + ULONG Cr3; + ULONG Eip; + ULONG Eflags; + ULONG Eax; + ULONG Ecx; + ULONG Edx; + ULONG Ebx; + ULONG Esp; + ULONG Ebp; + ULONG Esi; + ULONG Edi; + ULONG Es; + ULONG Cs; + ULONG Ss; + ULONG Ds; + ULONG Fs; + ULONG Gs; + ULONG Ldtr; + ULONG IopbOffset; +} FAST486_TSS, *PFAST486_TSS; + +struct _FAST486_STATE +{ + FAST486_MEM_READ_PROC MemReadCallback; + FAST486_MEM_WRITE_PROC MemWriteCallback; + FAST486_IO_READ_PROC IoReadCallback; + FAST486_IO_WRITE_PROC IoWriteCallback; + FAST486_IDLE_PROC IdleCallback; + FAST486_BOP_PROC BopCallback; + FAST486_REG GeneralRegs[FAST486_NUM_GEN_REGS]; + FAST486_SEG_REG SegmentRegs[FAST486_NUM_SEG_REGS]; + FAST486_REG InstPtr, SavedInstPtr; + FAST486_FLAGS_REG Flags; + FAST486_TABLE_REG Gdtr, Idtr, Ldtr, Tss; + ULONGLONG TimeStampCounter; + ULONG ControlRegisters[FAST486_NUM_CTRL_REGS]; + ULONG DebugRegisters[FAST486_NUM_DBG_REGS]; + ULONG ExceptionCount; + ULONG PrefixFlags; + FAST486_SEG_REGS SegmentOverride; + BOOLEAN HardwareInt; + UCHAR PendingIntNum; +}; + +/* FUNCTIONS ******************************************************************/ + +VOID +NTAPI +Fast486Continue(PFAST486_STATE State); + +VOID +NTAPI +Fast486StepInto(PFAST486_STATE State); + +VOID +NTAPI +Fast486StepOver(PFAST486_STATE State); + +VOID +NTAPI +Fast486StepOut(PFAST486_STATE State); + +VOID +NTAPI +Fast486DumpState(PFAST486_STATE State); + +VOID +NTAPI +Fast486Reset(PFAST486_STATE State); + +VOID +NTAPI +Fast486Interrupt(PFAST486_STATE State, UCHAR Number); + +VOID +NTAPI +Fast486ExecuteAt(PFAST486_STATE State, USHORT Segment, ULONG Offset); + +VOID +NTAPI +Fast486SetStack(PFAST486_STATE State, USHORT Segment, ULONG Offset); + +VOID +NTAPI +Fast486SetSegment +( + PFAST486_STATE State, + FAST486_SEG_REGS Segment, + USHORT Selector +); + +#endif // _FAST486_H_ + +/* EOF */ diff --git a/include/reactos/libs/soft386/soft386.h b/include/reactos/libs/soft386/soft386.h deleted file mode 100644 index 4e9bd0bc94d..00000000000 --- a/include/reactos/libs/soft386/soft386.h +++ /dev/null @@ -1,397 +0,0 @@ -/* - * Soft386 386/486 CPU Emulation Library - * soft386.h - * - * Copyright (C) 2013 Aleksandar Andrejevic - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -#ifndef _SOFT386_H_ -#define _SOFT386_H_ - -/* DEFINES ********************************************************************/ - -#define SOFT386_NUM_GEN_REGS 8 -#define SOFT386_NUM_SEG_REGS 6 -#define SOFT386_NUM_CTRL_REGS 8 -#define SOFT386_NUM_DBG_REGS 8 - -#define SOFT386_CR0_PE (1 << 0) -#define SOFT386_CR0_MP (1 << 1) -#define SOFT386_CR0_EM (1 << 2) -#define SOFT386_CR0_TS (1 << 3) -#define SOFT386_CR0_ET (1 << 4) -#define SOFT386_CR0_NE (1 << 5) -#define SOFT386_CR0_WP (1 << 16) -#define SOFT386_CR0_AM (1 << 18) -#define SOFT386_CR0_NW (1 << 29) -#define SOFT386_CR0_CD (1 << 30) -#define SOFT386_CR0_PG (1 << 31) - -#define SOFT386_IDT_TASK_GATE 0x5 -#define SOFT386_IDT_INT_GATE 0x6 -#define SOFT386_IDT_TRAP_GATE 0x7 -#define SOFT386_IDT_INT_GATE_32 0xE -#define SOFT386_IDT_TRAP_GATE_32 0xF - -#define SOFT386_PREFIX_SEG (1 << 0) -#define SOFT386_PREFIX_OPSIZE (1 << 1) -#define SOFT386_PREFIX_ADSIZE (1 << 2) -#define SOFT386_PREFIX_LOCK (1 << 3) -#define SOFT386_PREFIX_REPNZ (1 << 4) -#define SOFT386_PREFIX_REP (1 << 5) - -struct _SOFT386_STATE; -typedef struct _SOFT386_STATE SOFT386_STATE, *PSOFT386_STATE; - -typedef enum _SOFT386_GEN_REGS -{ - SOFT386_REG_EAX, - SOFT386_REG_ECX, - SOFT386_REG_EDX, - SOFT386_REG_EBX, - SOFT386_REG_ESP, - SOFT386_REG_EBP, - SOFT386_REG_ESI, - SOFT386_REG_EDI -} SOFT386_GEN_REGS, *PSOFT386_GEN_REGS; - -typedef enum _SOFT386_SEG_REGS -{ - SOFT386_REG_ES, - SOFT386_REG_CS, - SOFT386_REG_SS, - SOFT386_REG_DS, - SOFT386_REG_FS, - SOFT386_REG_GS -} SOFT386_SEG_REGS, *PSOFT386_SEG_REGS; - -typedef enum _SOFT386_CTRL_REGS -{ - SOFT386_REG_CR0, - SOFT386_REG_CR1, - SOFT386_REG_CR2, - SOFT386_REG_CR3, - SOFT386_REG_CR4, - SOFT386_REG_CR5, - SOFT386_REG_CR6, - SOFT386_REG_CR7 -} SOFT386_CTRL_REGS, *PSOFT386_CTRL_REGS; - -typedef enum _SOFT386_DBG_REGS -{ - SOFT386_REG_DR0, - SOFT386_REG_DR1, - SOFT386_REG_DR2, - SOFT386_REG_DR3, - SOFT386_REG_DR4, - SOFT386_REG_DR5, - SOFT386_REG_DR6, - SOFT386_REG_DR7 -} SOFT386_DBG_REGS, *PSOFT386_DBG_REGS; - -typedef enum _SOFT386_EXCEPTIONS -{ - SOFT386_EXCEPTION_DE = 0x00, - SOFT386_EXCEPTION_DB = 0x01, - SOFT386_EXCEPTION_BP = 0x03, - SOFT386_EXCEPTION_OF = 0x04, - SOFT386_EXCEPTION_BR = 0x05, - SOFT386_EXCEPTION_UD = 0x06, - SOFT386_EXCEPTION_NM = 0x07, - SOFT386_EXCEPTION_DF = 0x08, - SOFT386_EXCEPTION_TS = 0x0A, - SOFT386_EXCEPTION_NP = 0x0B, - SOFT386_EXCEPTION_SS = 0x0C, - SOFT386_EXCEPTION_GP = 0x0D, - SOFT386_EXCEPTION_PF = 0x0E, - SOFT386_EXCEPTION_MF = 0x10, - SOFT386_EXCEPTION_AC = 0x11, - SOFT386_EXCEPTION_MC = 0x12 -} SOFT386_EXCEPTIONS, *PSOFT386_EXCEPTIONS; - -typedef -BOOLEAN -(NTAPI *SOFT386_MEM_READ_PROC) -( - PSOFT386_STATE State, - ULONG Address, - PVOID Buffer, - ULONG Size -); - -typedef -BOOLEAN -(NTAPI *SOFT386_MEM_WRITE_PROC) -( - PSOFT386_STATE State, - ULONG Address, - PVOID Buffer, - ULONG Size -); - -typedef -VOID -(NTAPI *SOFT386_IO_READ_PROC) -( - PSOFT386_STATE State, - ULONG Port, - PVOID Buffer, - ULONG Size -); - -typedef -VOID -(NTAPI *SOFT386_IO_WRITE_PROC) -( - PSOFT386_STATE State, - ULONG Port, - PVOID Buffer, - ULONG Size -); - -typedef -VOID -(NTAPI *SOFT386_IDLE_PROC) -( - PSOFT386_STATE State -); - -typedef -VOID -(NTAPI *SOFT386_BOP_PROC) -( - PSOFT386_STATE State, - USHORT BopCode -); - -typedef union _SOFT386_REG -{ - union - { - struct - { - UCHAR LowByte; - UCHAR HighByte; - }; - USHORT LowWord; - }; - ULONG Long; -} SOFT386_REG, *PSOFT386_REG; - -typedef struct _SOFT386_SEG_REG -{ - USHORT Selector; - - /* Descriptor cache */ - ULONG Accessed : 1; - ULONG ReadWrite : 1; - ULONG DirConf : 1; - ULONG Executable : 1; - ULONG SystemType : 1; - ULONG Dpl : 2; - ULONG Present : 1; - ULONG Size : 1; - ULONG Limit; - ULONG Base; -} SOFT386_SEG_REG, *PSOFT386_SEG_REG; - -typedef struct -{ - ULONG Limit : 16; - ULONG Base : 24; - ULONG Accessed : 1; - ULONG ReadWrite : 1; - ULONG DirConf : 1; - ULONG Executable : 1; - ULONG SystemType : 1; - ULONG Dpl : 2; - ULONG Present : 1; - ULONG LimitHigh : 4; - ULONG Avl : 1; - ULONG Reserved : 1; - ULONG Size : 1; - ULONG Granularity : 1; - ULONG BaseHigh : 8; -} SOFT386_GDT_ENTRY, *PSOFT386_GDT_ENTRY; - -typedef struct -{ - ULONG Offset : 16; - ULONG Selector : 16; - ULONG ParamCount : 5; - ULONG Reserved : 3; - ULONG Type : 4; - ULONG SystemType : 1; - ULONG Dpl : 2; - ULONG Present : 1; - ULONG OffsetHigh : 16; -} SOFT386_CALL_GATE, *PSOFT386_CALL_GATE; - -typedef struct -{ - ULONG Offset : 16; - ULONG Selector : 16; - ULONG Zero : 8; - ULONG Type : 4; - ULONG Storage : 1; - ULONG Dpl : 2; - ULONG Present : 1; - ULONG OffsetHigh : 16; -} SOFT386_IDT_ENTRY, *PSOFT386_IDT_ENTRY; - -typedef struct _SOFT386_TABLE_REG -{ - USHORT Size; - ULONG Address; -} SOFT386_TABLE_REG, *PSOFT386_TABLE_REG; - -typedef union _SOFT386_FLAGS_REG -{ - USHORT LowWord; - ULONG Long; - - struct - { - ULONG Cf : 1; - ULONG AlwaysSet : 1; - ULONG Pf : 1; - ULONG Reserved0 : 1; - ULONG Af : 1; - ULONG Reserved1 : 1; - ULONG Zf : 1; - ULONG Sf : 1; - ULONG Tf : 1; - ULONG If : 1; - ULONG Df : 1; - ULONG Of : 1; - ULONG Iopl : 2; - ULONG Nt : 1; - ULONG Reserved2 : 1; - ULONG Rf : 1; - ULONG Vm : 1; - ULONG Ac : 1; - ULONG Vif : 1; - ULONG Vip : 1; - ULONG Id : 1; - - // ULONG Reserved : 10; - }; -} SOFT386_FLAGS_REG, *PSOFT386_FLAGS_REG; - -typedef struct _SOFT386_TSS -{ - ULONG Link; - ULONG Esp0; - ULONG Ss0; - ULONG Esp1; - ULONG Ss1; - ULONG Esp2; - ULONG Ss2; - ULONG Cr3; - ULONG Eip; - ULONG Eflags; - ULONG Eax; - ULONG Ecx; - ULONG Edx; - ULONG Ebx; - ULONG Esp; - ULONG Ebp; - ULONG Esi; - ULONG Edi; - ULONG Es; - ULONG Cs; - ULONG Ss; - ULONG Ds; - ULONG Fs; - ULONG Gs; - ULONG Ldtr; - ULONG IopbOffset; -} SOFT386_TSS, *PSOFT386_TSS; - -struct _SOFT386_STATE -{ - SOFT386_MEM_READ_PROC MemReadCallback; - SOFT386_MEM_WRITE_PROC MemWriteCallback; - SOFT386_IO_READ_PROC IoReadCallback; - SOFT386_IO_WRITE_PROC IoWriteCallback; - SOFT386_IDLE_PROC IdleCallback; - SOFT386_BOP_PROC BopCallback; - SOFT386_REG GeneralRegs[SOFT386_NUM_GEN_REGS]; - SOFT386_SEG_REG SegmentRegs[SOFT386_NUM_SEG_REGS]; - SOFT386_REG InstPtr, SavedInstPtr; - SOFT386_FLAGS_REG Flags; - SOFT386_TABLE_REG Gdtr, Idtr, Ldtr, Tss; - ULONGLONG TimeStampCounter; - ULONG ControlRegisters[SOFT386_NUM_CTRL_REGS]; - ULONG DebugRegisters[SOFT386_NUM_DBG_REGS]; - ULONG ExceptionCount; - ULONG PrefixFlags; - SOFT386_SEG_REGS SegmentOverride; - BOOLEAN HardwareInt; - UCHAR PendingIntNum; -}; - -/* FUNCTIONS ******************************************************************/ - -VOID -NTAPI -Soft386Continue(PSOFT386_STATE State); - -VOID -NTAPI -Soft386StepInto(PSOFT386_STATE State); - -VOID -NTAPI -Soft386StepOver(PSOFT386_STATE State); - -VOID -NTAPI -Soft386StepOut(PSOFT386_STATE State); - -VOID -NTAPI -Soft386DumpState(PSOFT386_STATE State); - -VOID -NTAPI -Soft386Reset(PSOFT386_STATE State); - -VOID -NTAPI -Soft386Interrupt(PSOFT386_STATE State, UCHAR Number); - -VOID -NTAPI -Soft386ExecuteAt(PSOFT386_STATE State, USHORT Segment, ULONG Offset); - -VOID -NTAPI -Soft386SetStack(PSOFT386_STATE State, USHORT Segment, ULONG Offset); - -VOID -NTAPI -Soft386SetSegment -( - PSOFT386_STATE State, - SOFT386_SEG_REGS Segment, - USHORT Selector -); - -#endif // _SOFT386_H_ - -/* EOF */ diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt index 537b7fe3e6e..4bb532590b5 100644 --- a/lib/CMakeLists.txt +++ b/lib/CMakeLists.txt @@ -10,6 +10,7 @@ add_subdirectory(cportlib) #add_subdirectory(dnslib) Nothing links to this lib. add_subdirectory(drivers) add_subdirectory(epsapi) +add_subdirectory(fast486) add_subdirectory(fslib) add_subdirectory(lsalib) add_subdirectory(ppcmmu) @@ -24,7 +25,6 @@ add_subdirectory(rtl) add_subdirectory(sdk) add_subdirectory(smlib) add_subdirectory(tdilib) -add_subdirectory(soft386) else() diff --git a/lib/fast486/CMakeLists.txt b/lib/fast486/CMakeLists.txt new file mode 100644 index 00000000000..a25d370ddf9 --- /dev/null +++ b/lib/fast486/CMakeLists.txt @@ -0,0 +1,11 @@ + +include_directories(${REACTOS_SOURCE_DIR}/include/reactos/libs/fast486) + +list(APPEND SOURCE + fast486.c + opcodes.c + opgroups.c + extraops.c + common.c) + +add_library(fast486 ${SOURCE}) diff --git a/lib/soft386/COPYING b/lib/fast486/COPYING similarity index 100% rename from lib/soft386/COPYING rename to lib/fast486/COPYING diff --git a/lib/soft386/common.c b/lib/fast486/common.c similarity index 76% rename from lib/soft386/common.c rename to lib/fast486/common.c index 569c1cf48fc..9cd40a198d5 100644 --- a/lib/soft386/common.c +++ b/lib/fast486/common.c @@ -1,5 +1,5 @@ /* - * Soft386 386/486 CPU Emulation Library + * Fast486 386/486 CPU Emulation Library * common.c * * Copyright (C) 2013 Aleksandar Andrejevic @@ -28,14 +28,14 @@ // #define NDEBUG #include -#include +#include #include "common.h" /* PRIVATE FUNCTIONS **********************************************************/ static inline ULONG -Soft386GetPageTableEntry(PSOFT386_STATE State, +Fast486GetPageTableEntry(PFAST486_STATE State, ULONG VirtualAddress) { // TODO: NOT IMPLEMENTED @@ -47,18 +47,18 @@ Soft386GetPageTableEntry(PSOFT386_STATE State, /* PUBLIC FUNCTIONS ***********************************************************/ BOOLEAN -Soft386ReadMemory(PSOFT386_STATE State, - SOFT386_SEG_REGS SegmentReg, +Fast486ReadMemory(PFAST486_STATE State, + FAST486_SEG_REGS SegmentReg, ULONG Offset, BOOLEAN InstFetch, PVOID Buffer, ULONG Size) { ULONG LinearAddress; - PSOFT386_SEG_REG CachedDescriptor; - INT Cpl = Soft386GetCurrentPrivLevel(State); + PFAST486_SEG_REG CachedDescriptor; + INT Cpl = Fast486GetCurrentPrivLevel(State); - ASSERT(SegmentReg < SOFT386_NUM_SEG_REGS); + ASSERT(SegmentReg < FAST486_NUM_SEG_REGS); /* Get the cached descriptor */ CachedDescriptor = &State->SegmentRegs[SegmentReg]; @@ -66,25 +66,25 @@ Soft386ReadMemory(PSOFT386_STATE State, if ((Offset + Size - 1) > CachedDescriptor->Limit) { /* Read beyond limit */ - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } /* Check for protected mode */ - if (State->ControlRegisters[0] & SOFT386_CR0_PE) + if (State->ControlRegisters[0] & FAST486_CR0_PE) { /* Privilege checks */ if (!CachedDescriptor->Present) { - Soft386Exception(State, SOFT386_EXCEPTION_NP); + Fast486Exception(State, FAST486_EXCEPTION_NP); return FALSE; } if (GET_SEGMENT_RPL(CachedDescriptor->Selector) > CachedDescriptor->Dpl) { - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } @@ -94,7 +94,7 @@ Soft386ReadMemory(PSOFT386_STATE State, { /* Data segment not executable */ - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } } @@ -104,7 +104,7 @@ Soft386ReadMemory(PSOFT386_STATE State, { /* Code segment not readable */ - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } } @@ -114,10 +114,10 @@ Soft386ReadMemory(PSOFT386_STATE State, LinearAddress = CachedDescriptor->Base + Offset; /* Check if paging is enabled */ - if (State->ControlRegisters[SOFT386_REG_CR0] & SOFT386_CR0_PG) + if (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PG) { ULONG Page; - SOFT386_PAGE_TABLE TableEntry; + FAST486_PAGE_TABLE TableEntry; for (Page = PAGE_ALIGN(LinearAddress); Page <= PAGE_ALIGN(LinearAddress + Size - 1); @@ -126,13 +126,13 @@ Soft386ReadMemory(PSOFT386_STATE State, ULONG PageOffset = 0, PageLength = PAGE_SIZE; /* Get the table entry */ - TableEntry.Value = Soft386GetPageTableEntry(State, Page); + TableEntry.Value = Fast486GetPageTableEntry(State, Page); if (!TableEntry.Present || (!TableEntry.Usermode && (Cpl > 0))) { /* Exception */ - Soft386ExceptionWithErrorCode(State, - SOFT386_EXCEPTION_PF, + Fast486ExceptionWithErrorCode(State, + FAST486_EXCEPTION_PF, TableEntry.Value & 0x07); return FALSE; } @@ -188,17 +188,17 @@ Soft386ReadMemory(PSOFT386_STATE State, } BOOLEAN -Soft386WriteMemory(PSOFT386_STATE State, - SOFT386_SEG_REGS SegmentReg, +Fast486WriteMemory(PFAST486_STATE State, + FAST486_SEG_REGS SegmentReg, ULONG Offset, PVOID Buffer, ULONG Size) { ULONG LinearAddress; - PSOFT386_SEG_REG CachedDescriptor; - INT Cpl = Soft386GetCurrentPrivLevel(State); + PFAST486_SEG_REG CachedDescriptor; + INT Cpl = Fast486GetCurrentPrivLevel(State); - ASSERT(SegmentReg < SOFT386_NUM_SEG_REGS); + ASSERT(SegmentReg < FAST486_NUM_SEG_REGS); /* Get the cached descriptor */ CachedDescriptor = &State->SegmentRegs[SegmentReg]; @@ -206,25 +206,25 @@ Soft386WriteMemory(PSOFT386_STATE State, if ((Offset + Size - 1) > CachedDescriptor->Limit) { /* Write beyond limit */ - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } /* Check for protected mode */ - if (State->ControlRegisters[0] & SOFT386_CR0_PE) + if (State->ControlRegisters[0] & FAST486_CR0_PE) { /* Privilege checks */ if (!CachedDescriptor->Present) { - Soft386Exception(State, SOFT386_EXCEPTION_NP); + Fast486Exception(State, FAST486_EXCEPTION_NP); return FALSE; } if (GET_SEGMENT_RPL(CachedDescriptor->Selector) > CachedDescriptor->Dpl) { - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } @@ -232,14 +232,14 @@ Soft386WriteMemory(PSOFT386_STATE State, { /* Code segment not writable */ - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } else if (!CachedDescriptor->ReadWrite) { /* Data segment not writeable */ - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } } @@ -248,10 +248,10 @@ Soft386WriteMemory(PSOFT386_STATE State, LinearAddress = CachedDescriptor->Base + Offset; /* Check if paging is enabled */ - if (State->ControlRegisters[SOFT386_REG_CR0] & SOFT386_CR0_PG) + if (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PG) { ULONG Page; - SOFT386_PAGE_TABLE TableEntry; + FAST486_PAGE_TABLE TableEntry; for (Page = PAGE_ALIGN(LinearAddress); Page <= PAGE_ALIGN(LinearAddress + Size - 1); @@ -260,15 +260,15 @@ Soft386WriteMemory(PSOFT386_STATE State, ULONG PageOffset = 0, PageLength = PAGE_SIZE; /* Get the table entry */ - TableEntry.Value = Soft386GetPageTableEntry(State, Page); + TableEntry.Value = Fast486GetPageTableEntry(State, Page); if ((!TableEntry.Present || (!TableEntry.Usermode && (Cpl > 0))) - || ((State->ControlRegisters[SOFT386_REG_CR0] & SOFT386_CR0_WP) + || ((State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_WP) && !TableEntry.Writeable)) { /* Exception */ - Soft386ExceptionWithErrorCode(State, - SOFT386_EXCEPTION_PF, + Fast486ExceptionWithErrorCode(State, + FAST486_EXCEPTION_PF, TableEntry.Value & 0x07); return FALSE; } @@ -324,20 +324,20 @@ Soft386WriteMemory(PSOFT386_STATE State, } BOOLEAN -Soft386InterruptInternal(PSOFT386_STATE State, +Fast486InterruptInternal(PFAST486_STATE State, USHORT SegmentSelector, ULONG Offset, BOOLEAN InterruptGate) { /* Check for protected mode */ - if (State->ControlRegisters[SOFT386_REG_CR0] & SOFT386_CR0_PE) + if (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE) { - SOFT386_TSS Tss; - USHORT OldSs = State->SegmentRegs[SOFT386_REG_SS].Selector; - ULONG OldEsp = State->GeneralRegs[SOFT386_REG_ESP].Long; + FAST486_TSS Tss; + USHORT OldSs = State->SegmentRegs[FAST486_REG_SS].Selector; + ULONG OldEsp = State->GeneralRegs[FAST486_REG_ESP].Long; /* Check if the interrupt handler is more privileged */ - if (Soft386GetCurrentPrivLevel(State) > GET_SEGMENT_RPL(SegmentSelector)) + if (Fast486GetCurrentPrivLevel(State) > GET_SEGMENT_RPL(SegmentSelector)) { /* Read the TSS */ // FIXME: This code is only correct when paging is disabled!!! @@ -358,36 +358,36 @@ Soft386InterruptInternal(PSOFT386_STATE State, { case 0: { - if (!Soft386LoadSegment(State, SOFT386_REG_SS, Tss.Ss0)) + if (!Fast486LoadSegment(State, FAST486_REG_SS, Tss.Ss0)) { /* Exception occurred */ return FALSE; } - State->GeneralRegs[SOFT386_REG_ESP].Long = Tss.Esp0; + State->GeneralRegs[FAST486_REG_ESP].Long = Tss.Esp0; break; } case 1: { - if (!Soft386LoadSegment(State, SOFT386_REG_SS, Tss.Ss1)) + if (!Fast486LoadSegment(State, FAST486_REG_SS, Tss.Ss1)) { /* Exception occurred */ return FALSE; } - State->GeneralRegs[SOFT386_REG_ESP].Long = Tss.Esp1; + State->GeneralRegs[FAST486_REG_ESP].Long = Tss.Esp1; break; } case 2: { - if (!Soft386LoadSegment(State, SOFT386_REG_SS, Tss.Ss2)) + if (!Fast486LoadSegment(State, FAST486_REG_SS, Tss.Ss2)) { /* Exception occurred */ return FALSE; } - State->GeneralRegs[SOFT386_REG_ESP].Long = Tss.Esp2; + State->GeneralRegs[FAST486_REG_ESP].Long = Tss.Esp2; break; } @@ -400,21 +400,21 @@ Soft386InterruptInternal(PSOFT386_STATE State, } /* Push SS selector */ - if (!Soft386StackPush(State, OldSs)) return FALSE; + if (!Fast486StackPush(State, OldSs)) return FALSE; /* Push stack pointer */ - if (!Soft386StackPush(State, OldEsp)) return FALSE; + if (!Fast486StackPush(State, OldEsp)) return FALSE; } } /* Push EFLAGS */ - if (!Soft386StackPush(State, State->Flags.Long)) return FALSE; + if (!Fast486StackPush(State, State->Flags.Long)) return FALSE; /* Push CS selector */ - if (!Soft386StackPush(State, State->SegmentRegs[SOFT386_REG_CS].Selector)) return FALSE; + if (!Fast486StackPush(State, State->SegmentRegs[FAST486_REG_CS].Selector)) return FALSE; /* Push the instruction pointer */ - if (!Soft386StackPush(State, State->InstPtr.Long)) return FALSE; + if (!Fast486StackPush(State, State->InstPtr.Long)) return FALSE; if (InterruptGate) { @@ -423,13 +423,13 @@ Soft386InterruptInternal(PSOFT386_STATE State, } /* Load new CS */ - if (!Soft386LoadSegment(State, SOFT386_REG_CS, SegmentSelector)) + if (!Fast486LoadSegment(State, FAST486_REG_CS, SegmentSelector)) { /* An exception occurred during the jump */ return FALSE; } - if (State->SegmentRegs[SOFT386_REG_CS].Size) + if (State->SegmentRegs[FAST486_REG_CS].Size) { /* 32-bit code segment, use EIP */ State->InstPtr.Long = Offset; @@ -445,11 +445,11 @@ Soft386InterruptInternal(PSOFT386_STATE State, VOID FASTCALL -Soft386ExceptionWithErrorCode(PSOFT386_STATE State, - SOFT386_EXCEPTIONS ExceptionCode, +Fast486ExceptionWithErrorCode(PFAST486_STATE State, + FAST486_EXCEPTIONS ExceptionCode, ULONG ErrorCode) { - SOFT386_IDT_ENTRY IdtEntry; + FAST486_IDT_ENTRY IdtEntry; /* Increment the exception count */ State->ExceptionCount++; @@ -458,47 +458,47 @@ Soft386ExceptionWithErrorCode(PSOFT386_STATE State, if (State->ExceptionCount > 1) { /* Then this is a double fault */ - ExceptionCode = SOFT386_EXCEPTION_DF; + ExceptionCode = FAST486_EXCEPTION_DF; } /* Check if this is a triple fault */ if (State->ExceptionCount == 3) { /* Reset the CPU */ - Soft386Reset(State); + Fast486Reset(State); return; } /* Restore the IP to the saved IP */ State->InstPtr = State->SavedInstPtr; - if (!Soft386GetIntVector(State, ExceptionCode, &IdtEntry)) + if (!Fast486GetIntVector(State, ExceptionCode, &IdtEntry)) { /* - * If this function failed, that means Soft386Exception + * If this function failed, that means Fast486Exception * was called again, so just return in this case. */ return; } /* Perform the interrupt */ - if (!Soft386InterruptInternal(State, + if (!Fast486InterruptInternal(State, IdtEntry.Selector, MAKELONG(IdtEntry.Offset, IdtEntry.OffsetHigh), IdtEntry.Type)) { /* - * If this function failed, that means Soft386Exception + * If this function failed, that means Fast486Exception * was called again, so just return in this case. */ return; } if (EXCEPTION_HAS_ERROR_CODE(ExceptionCode) - && (State->ControlRegisters[SOFT386_REG_CR0] & SOFT386_CR0_PE)) + && (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE)) { /* Push the error code */ - Soft386StackPush(State, ErrorCode); + Fast486StackPush(State, ErrorCode); } } diff --git a/lib/soft386/common.h b/lib/fast486/common.h similarity index 79% rename from lib/soft386/common.h rename to lib/fast486/common.h index e6154e4ef8d..76d962942b1 100644 --- a/lib/soft386/common.h +++ b/lib/fast486/common.h @@ -1,5 +1,5 @@ /* - * Soft386 386/486 CPU Emulation Library + * Fast486 386/486 CPU Emulation Library * common.h * * Copyright (C) 2013 Aleksandar Andrejevic @@ -48,20 +48,20 @@ #define PAGE_SIZE 4096 #endif -typedef struct _SOFT386_MOD_REG_RM +typedef struct _FAST486_MOD_REG_RM { - SOFT386_GEN_REGS Register; + FAST486_GEN_REGS Register; BOOLEAN Memory; union { - SOFT386_GEN_REGS SecondRegister; + FAST486_GEN_REGS SecondRegister; ULONG MemoryAddress; }; -} SOFT386_MOD_REG_RM, *PSOFT386_MOD_REG_RM; +} FAST486_MOD_REG_RM, *PFAST486_MOD_REG_RM; #pragma pack(push, 1) -typedef union _SOFT386_PAGE_DIR +typedef union _FAST486_PAGE_DIR { struct { @@ -77,9 +77,9 @@ typedef union _SOFT386_PAGE_DIR ULONG TableAddress : 20; }; ULONG Value; -} SOFT386_PAGE_DIR, *PSOFT386_PAGE_DIR; +} FAST486_PAGE_DIR, *PFAST486_PAGE_DIR; -typedef union _SOFT386_PAGE_TABLE +typedef union _FAST486_PAGE_TABLE { struct { @@ -96,17 +96,17 @@ typedef union _SOFT386_PAGE_TABLE ULONG Address : 20; }; ULONG Value; -} SOFT386_PAGE_TABLE, *PSOFT386_PAGE_TABLE; +} FAST486_PAGE_TABLE, *PFAST486_PAGE_TABLE; #pragma pack(pop) /* FUNCTIONS ******************************************************************/ BOOLEAN -Soft386ReadMemory +Fast486ReadMemory ( - PSOFT386_STATE State, - SOFT386_SEG_REGS SegmentReg, + PFAST486_STATE State, + FAST486_SEG_REGS SegmentReg, ULONG Offset, BOOLEAN InstFetch, PVOID Buffer, @@ -114,19 +114,19 @@ Soft386ReadMemory ); BOOLEAN -Soft386WriteMemory +Fast486WriteMemory ( - PSOFT386_STATE State, - SOFT386_SEG_REGS SegmentReg, + PFAST486_STATE State, + FAST486_SEG_REGS SegmentReg, ULONG Offset, PVOID Buffer, ULONG Size ); BOOLEAN -Soft386InterruptInternal +Fast486InterruptInternal ( - PSOFT386_STATE State, + PFAST486_STATE State, USHORT SegmentSelector, ULONG Offset, BOOLEAN InterruptGate @@ -134,10 +134,10 @@ Soft386InterruptInternal VOID FASTCALL -Soft386ExceptionWithErrorCode +Fast486ExceptionWithErrorCode ( - PSOFT386_STATE State, - SOFT386_EXCEPTIONS ExceptionCode, + PFAST486_STATE State, + FAST486_EXCEPTIONS ExceptionCode, ULONG ErrorCode ); @@ -145,9 +145,9 @@ Soft386ExceptionWithErrorCode /* static */ FORCEINLINE INT -Soft386GetCurrentPrivLevel(PSOFT386_STATE State) +Fast486GetCurrentPrivLevel(PFAST486_STATE State) { - return GET_SEGMENT_RPL(State->SegmentRegs[SOFT386_REG_CS].Selector); + return GET_SEGMENT_RPL(State->SegmentRegs[FAST486_REG_CS].Selector); } #include "common.inl" diff --git a/lib/soft386/common.inl b/lib/fast486/common.inl similarity index 75% rename from lib/soft386/common.inl rename to lib/fast486/common.inl index 072354bf628..9eeb4dd6465 100644 --- a/lib/soft386/common.inl +++ b/lib/fast486/common.inl @@ -1,5 +1,5 @@ /* - * Soft386 386/486 CPU Emulation Library + * Fast486 386/486 CPU Emulation Library * common.inl * * Copyright (C) 2013 Aleksandar Andrejevic @@ -23,42 +23,42 @@ FORCEINLINE VOID -Soft386Exception(PSOFT386_STATE State, - SOFT386_EXCEPTIONS ExceptionCode) +Fast486Exception(PFAST486_STATE State, + FAST486_EXCEPTIONS ExceptionCode) { /* Call the internal function */ - Soft386ExceptionWithErrorCode(State, ExceptionCode, 0); + Fast486ExceptionWithErrorCode(State, ExceptionCode, 0); } FORCEINLINE BOOLEAN -Soft386StackPush(PSOFT386_STATE State, +Fast486StackPush(PFAST486_STATE State, ULONG Value) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_SS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_SS].Size; /* The OPSIZE prefix toggles the size */ - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) Size = !Size; + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) Size = !Size; if (Size) { /* 32-bit size */ /* Check if ESP is between 1 and 3 */ - if (State->GeneralRegs[SOFT386_REG_ESP].Long >= 1 - && State->GeneralRegs[SOFT386_REG_ESP].Long <= 3) + if (State->GeneralRegs[FAST486_REG_ESP].Long >= 1 + && State->GeneralRegs[FAST486_REG_ESP].Long <= 3) { - Soft386Exception(State, SOFT386_EXCEPTION_SS); + Fast486Exception(State, FAST486_EXCEPTION_SS); return FALSE; } /* Subtract ESP by 4 */ - State->GeneralRegs[SOFT386_REG_ESP].Long -= 4; + State->GeneralRegs[FAST486_REG_ESP].Long -= 4; /* Store the value in SS:ESP */ - return Soft386WriteMemory(State, - SOFT386_REG_SS, - State->GeneralRegs[SOFT386_REG_ESP].Long, + return Fast486WriteMemory(State, + FAST486_REG_SS, + State->GeneralRegs[FAST486_REG_ESP].Long, &Value, sizeof(ULONG)); } @@ -68,19 +68,19 @@ Soft386StackPush(PSOFT386_STATE State, USHORT ShortValue = LOWORD(Value); /* Check if SP is 1 */ - if (State->GeneralRegs[SOFT386_REG_ESP].Long == 1) + if (State->GeneralRegs[FAST486_REG_ESP].Long == 1) { - Soft386Exception(State, SOFT386_EXCEPTION_SS); + Fast486Exception(State, FAST486_EXCEPTION_SS); return FALSE; } /* Subtract SP by 2 */ - State->GeneralRegs[SOFT386_REG_ESP].LowWord -= 2; + State->GeneralRegs[FAST486_REG_ESP].LowWord -= 2; /* Store the value in SS:SP */ - return Soft386WriteMemory(State, - SOFT386_REG_SS, - State->GeneralRegs[SOFT386_REG_ESP].LowWord, + return Fast486WriteMemory(State, + FAST486_REG_SS, + State->GeneralRegs[FAST486_REG_ESP].LowWord, &ShortValue, sizeof(USHORT)); } @@ -88,31 +88,31 @@ Soft386StackPush(PSOFT386_STATE State, FORCEINLINE BOOLEAN -Soft386StackPop(PSOFT386_STATE State, +Fast486StackPop(PFAST486_STATE State, PULONG Value) { ULONG LongValue; USHORT ShortValue; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_SS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_SS].Size; /* The OPSIZE prefix toggles the size */ - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) Size = !Size; + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) Size = !Size; if (Size) { /* 32-bit size */ /* Check if ESP is 0xFFFFFFFF */ - if (State->GeneralRegs[SOFT386_REG_ESP].Long == 0xFFFFFFFF) + if (State->GeneralRegs[FAST486_REG_ESP].Long == 0xFFFFFFFF) { - Soft386Exception(State, SOFT386_EXCEPTION_SS); + Fast486Exception(State, FAST486_EXCEPTION_SS); return FALSE; } /* Read the value from SS:ESP */ - if (!Soft386ReadMemory(State, - SOFT386_REG_SS, - State->GeneralRegs[SOFT386_REG_ESP].Long, + if (!Fast486ReadMemory(State, + FAST486_REG_SS, + State->GeneralRegs[FAST486_REG_ESP].Long, FALSE, &LongValue, sizeof(LongValue))) @@ -122,7 +122,7 @@ Soft386StackPop(PSOFT386_STATE State, } /* Increment ESP by 4 */ - State->GeneralRegs[SOFT386_REG_ESP].Long += 4; + State->GeneralRegs[FAST486_REG_ESP].Long += 4; /* Store the value in the result */ *Value = LongValue; @@ -132,16 +132,16 @@ Soft386StackPop(PSOFT386_STATE State, /* 16-bit size */ /* Check if SP is 0xFFFF */ - if (State->GeneralRegs[SOFT386_REG_ESP].LowWord == 0xFFFF) + if (State->GeneralRegs[FAST486_REG_ESP].LowWord == 0xFFFF) { - Soft386Exception(State, SOFT386_EXCEPTION_SS); + Fast486Exception(State, FAST486_EXCEPTION_SS); return FALSE; } /* Read the value from SS:SP */ - if (!Soft386ReadMemory(State, - SOFT386_REG_SS, - State->GeneralRegs[SOFT386_REG_ESP].LowWord, + if (!Fast486ReadMemory(State, + FAST486_REG_SS, + State->GeneralRegs[FAST486_REG_ESP].LowWord, FALSE, &ShortValue, sizeof(ShortValue))) @@ -151,7 +151,7 @@ Soft386StackPop(PSOFT386_STATE State, } /* Increment SP by 2 */ - State->GeneralRegs[SOFT386_REG_ESP].Long += 2; + State->GeneralRegs[FAST486_REG_ESP].Long += 2; /* Store the value in the result */ *Value = ShortValue; @@ -162,25 +162,25 @@ Soft386StackPop(PSOFT386_STATE State, FORCEINLINE BOOLEAN -Soft386LoadSegment(PSOFT386_STATE State, +Fast486LoadSegment(PFAST486_STATE State, INT Segment, USHORT Selector) { - PSOFT386_SEG_REG CachedDescriptor; - SOFT386_GDT_ENTRY GdtEntry; + PFAST486_SEG_REG CachedDescriptor; + FAST486_GDT_ENTRY GdtEntry; - ASSERT(Segment < SOFT386_NUM_SEG_REGS); + ASSERT(Segment < FAST486_NUM_SEG_REGS); /* Get the cached descriptor */ CachedDescriptor = &State->SegmentRegs[Segment]; /* Check for protected mode */ - if ((State->ControlRegisters[SOFT386_REG_CR0] & SOFT386_CR0_PE) && !State->Flags.Vm) + if ((State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE) && !State->Flags.Vm) { /* Make sure the GDT contains the entry */ if (GET_SEGMENT_INDEX(Selector) >= (State->Gdtr.Size + 1)) { - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } @@ -202,43 +202,43 @@ Soft386LoadSegment(PSOFT386_STATE State, sizeof(GdtEntry)); } - if (Segment == SOFT386_REG_SS) + if (Segment == FAST486_REG_SS) { /* Loading the stack segment */ if (GET_SEGMENT_INDEX(Selector) == 0) { - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } if (!GdtEntry.SystemType) { /* This is a special descriptor */ - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } if (GdtEntry.Executable || !GdtEntry.ReadWrite) { - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } - if ((GET_SEGMENT_RPL(Selector) != Soft386GetCurrentPrivLevel(State)) + if ((GET_SEGMENT_RPL(Selector) != Fast486GetCurrentPrivLevel(State)) || (GET_SEGMENT_RPL(Selector) != GdtEntry.Dpl)) { - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } if (!GdtEntry.Present) { - Soft386Exception(State, SOFT386_EXCEPTION_SS); + Fast486Exception(State, FAST486_EXCEPTION_SS); return FALSE; } } - else if (Segment == SOFT386_REG_CS) + else if (Segment == FAST486_REG_CS) { /* Loading the code segment */ // TODO: NOT IMPLEMENTED @@ -250,20 +250,20 @@ Soft386LoadSegment(PSOFT386_STATE State, if (!GdtEntry.SystemType) { /* This is a special descriptor */ - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } if ((GET_SEGMENT_RPL(Selector) > GdtEntry.Dpl) - && (Soft386GetCurrentPrivLevel(State) > GdtEntry.Dpl)) + && (Fast486GetCurrentPrivLevel(State) > GdtEntry.Dpl)) { - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } if (!GdtEntry.Present) { - Soft386Exception(State, SOFT386_EXCEPTION_NP); + Fast486Exception(State, FAST486_EXCEPTION_NP); return FALSE; } } @@ -296,17 +296,17 @@ Soft386LoadSegment(PSOFT386_STATE State, FORCEINLINE BOOLEAN -Soft386FetchByte(PSOFT386_STATE State, +Fast486FetchByte(PFAST486_STATE State, PUCHAR Data) { - PSOFT386_SEG_REG CachedDescriptor; + PFAST486_SEG_REG CachedDescriptor; /* Get the cached descriptor of CS */ - CachedDescriptor = &State->SegmentRegs[SOFT386_REG_CS]; + CachedDescriptor = &State->SegmentRegs[FAST486_REG_CS]; /* Read from memory */ - if (!Soft386ReadMemory(State, - SOFT386_REG_CS, + if (!Fast486ReadMemory(State, + FAST486_REG_CS, (CachedDescriptor->Size) ? State->InstPtr.Long : State->InstPtr.LowWord, TRUE, @@ -326,18 +326,18 @@ Soft386FetchByte(PSOFT386_STATE State, FORCEINLINE BOOLEAN -Soft386FetchWord(PSOFT386_STATE State, +Fast486FetchWord(PFAST486_STATE State, PUSHORT Data) { - PSOFT386_SEG_REG CachedDescriptor; + PFAST486_SEG_REG CachedDescriptor; /* Get the cached descriptor of CS */ - CachedDescriptor = &State->SegmentRegs[SOFT386_REG_CS]; + CachedDescriptor = &State->SegmentRegs[FAST486_REG_CS]; /* Read from memory */ // FIXME: Fix byte order on big-endian machines - if (!Soft386ReadMemory(State, - SOFT386_REG_CS, + if (!Fast486ReadMemory(State, + FAST486_REG_CS, (CachedDescriptor->Size) ? State->InstPtr.Long : State->InstPtr.LowWord, TRUE, @@ -357,18 +357,18 @@ Soft386FetchWord(PSOFT386_STATE State, FORCEINLINE BOOLEAN -Soft386FetchDword(PSOFT386_STATE State, +Fast486FetchDword(PFAST486_STATE State, PULONG Data) { - PSOFT386_SEG_REG CachedDescriptor; + PFAST486_SEG_REG CachedDescriptor; /* Get the cached descriptor of CS */ - CachedDescriptor = &State->SegmentRegs[SOFT386_REG_CS]; + CachedDescriptor = &State->SegmentRegs[FAST486_REG_CS]; /* Read from memory */ // FIXME: Fix byte order on big-endian machines - if (!Soft386ReadMemory(State, - SOFT386_REG_CS, + if (!Fast486ReadMemory(State, + FAST486_REG_CS, (CachedDescriptor->Size) ? State->InstPtr.Long : State->InstPtr.LowWord, TRUE, @@ -388,14 +388,14 @@ Soft386FetchDword(PSOFT386_STATE State, FORCEINLINE BOOLEAN -Soft386GetIntVector(PSOFT386_STATE State, +Fast486GetIntVector(PFAST486_STATE State, UCHAR Number, - PSOFT386_IDT_ENTRY IdtEntry) + PFAST486_IDT_ENTRY IdtEntry) { ULONG FarPointer; /* Check for protected mode */ - if (State->ControlRegisters[SOFT386_REG_CR0] & SOFT386_CR0_PE) + if (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE) { /* Read from the IDT */ // FIXME: This code is only correct when paging is disabled!!! @@ -440,7 +440,7 @@ Soft386GetIntVector(PSOFT386_STATE State, IdtEntry->Offset = LOWORD(FarPointer); IdtEntry->Selector = HIWORD(FarPointer); IdtEntry->Zero = 0; - IdtEntry->Type = SOFT386_IDT_INT_GATE; + IdtEntry->Type = FAST486_IDT_INT_GATE; IdtEntry->Storage = FALSE; IdtEntry->Dpl = 0; IdtEntry->Present = TRUE; @@ -456,21 +456,21 @@ Soft386GetIntVector(PSOFT386_STATE State, FORCEINLINE BOOLEAN -Soft386CalculateParity(UCHAR Number) +Fast486CalculateParity(UCHAR Number) { return (0x9669 >> ((Number & 0x0F) ^ (Number >> 4))) & 1; } FORCEINLINE BOOLEAN -Soft386ParseModRegRm(PSOFT386_STATE State, +Fast486ParseModRegRm(PFAST486_STATE State, BOOLEAN AddressSize, - PSOFT386_MOD_REG_RM ModRegRm) + PFAST486_MOD_REG_RM ModRegRm) { UCHAR ModRmByte, Mode, RegMem; /* Fetch the MOD REG R/M byte */ - if (!Soft386FetchByte(State, &ModRmByte)) + if (!Fast486FetchByte(State, &ModRmByte)) { /* Exception occurred */ return FALSE; @@ -499,13 +499,13 @@ Soft386ParseModRegRm(PSOFT386_STATE State, if (AddressSize) { - if (RegMem == SOFT386_REG_ESP) + if (RegMem == FAST486_REG_ESP) { UCHAR SibByte; ULONG Scale, Index, Base; /* Fetch the SIB byte */ - if (!Soft386FetchByte(State, &SibByte)) + if (!Fast486FetchByte(State, &SibByte)) { /* Exception occurred */ return FALSE; @@ -514,16 +514,16 @@ Soft386ParseModRegRm(PSOFT386_STATE State, /* Unpack the scale, index and base */ Scale = 1 << (SibByte >> 6); Index = (SibByte >> 3) & 0x07; - if (Index != SOFT386_REG_ESP) Index = State->GeneralRegs[Index].Long; + if (Index != FAST486_REG_ESP) Index = State->GeneralRegs[Index].Long; else Index = 0; Base = State->GeneralRegs[SibByte & 0x07].Long; /* Calculate the address */ ModRegRm->MemoryAddress = Base + Index * Scale; } - else if (RegMem == SOFT386_REG_EBP) + else if (RegMem == FAST486_REG_EBP) { - if (Mode) ModRegRm->MemoryAddress = State->GeneralRegs[SOFT386_REG_EBP].Long; + if (Mode) ModRegRm->MemoryAddress = State->GeneralRegs[FAST486_REG_EBP].Long; else ModRegRm->MemoryAddress = 0; } else @@ -533,14 +533,14 @@ Soft386ParseModRegRm(PSOFT386_STATE State, } /* Check if there is no segment override */ - if (!(State->PrefixFlags & SOFT386_PREFIX_SEG)) + if (!(State->PrefixFlags & FAST486_PREFIX_SEG)) { /* Check if the default segment should be SS */ - if ((RegMem == SOFT386_REG_EBP) && Mode) + if ((RegMem == FAST486_REG_EBP) && Mode) { /* Add a SS: prefix */ - State->PrefixFlags |= SOFT386_PREFIX_SEG; - State->SegmentOverride = SOFT386_REG_SS; + State->PrefixFlags |= FAST486_PREFIX_SEG; + State->SegmentOverride = FAST486_REG_SS; } } @@ -549,7 +549,7 @@ Soft386ParseModRegRm(PSOFT386_STATE State, CHAR Offset; /* Fetch the byte */ - if (!Soft386FetchByte(State, (PUCHAR)&Offset)) + if (!Fast486FetchByte(State, (PUCHAR)&Offset)) { /* Exception occurred */ return FALSE; @@ -558,12 +558,12 @@ Soft386ParseModRegRm(PSOFT386_STATE State, /* Add the signed offset to the address */ ModRegRm->MemoryAddress += (LONG)Offset; } - else if ((Mode == 2) || ((Mode == 0) && (RegMem == SOFT386_REG_EBP))) + else if ((Mode == 2) || ((Mode == 0) && (RegMem == FAST486_REG_EBP))) { LONG Offset; /* Fetch the dword */ - if (!Soft386FetchDword(State, (PULONG)&Offset)) + if (!Fast486FetchDword(State, (PULONG)&Offset)) { /* Exception occurred */ return FALSE; @@ -582,8 +582,8 @@ Soft386ParseModRegRm(PSOFT386_STATE State, case 2: { /* (SS:)[BX + SI] */ - ModRegRm->MemoryAddress = State->GeneralRegs[SOFT386_REG_EBX].LowWord - + State->GeneralRegs[SOFT386_REG_ESI].LowWord; + ModRegRm->MemoryAddress = State->GeneralRegs[FAST486_REG_EBX].LowWord + + State->GeneralRegs[FAST486_REG_ESI].LowWord; break; } @@ -592,8 +592,8 @@ Soft386ParseModRegRm(PSOFT386_STATE State, case 3: { /* (SS:)[BX + DI] */ - ModRegRm->MemoryAddress = State->GeneralRegs[SOFT386_REG_EBX].LowWord - + State->GeneralRegs[SOFT386_REG_EDI].LowWord; + ModRegRm->MemoryAddress = State->GeneralRegs[FAST486_REG_EBX].LowWord + + State->GeneralRegs[FAST486_REG_EDI].LowWord; break; } @@ -601,7 +601,7 @@ Soft386ParseModRegRm(PSOFT386_STATE State, case 4: { /* [SI] */ - ModRegRm->MemoryAddress = State->GeneralRegs[SOFT386_REG_ESI].LowWord; + ModRegRm->MemoryAddress = State->GeneralRegs[FAST486_REG_ESI].LowWord; break; } @@ -609,7 +609,7 @@ Soft386ParseModRegRm(PSOFT386_STATE State, case 5: { /* [DI] */ - ModRegRm->MemoryAddress = State->GeneralRegs[SOFT386_REG_EDI].LowWord; + ModRegRm->MemoryAddress = State->GeneralRegs[FAST486_REG_EDI].LowWord; break; } @@ -619,7 +619,7 @@ Soft386ParseModRegRm(PSOFT386_STATE State, if (Mode) { /* [BP] */ - ModRegRm->MemoryAddress = State->GeneralRegs[SOFT386_REG_EBP].LowWord; + ModRegRm->MemoryAddress = State->GeneralRegs[FAST486_REG_EBP].LowWord; } else { @@ -633,21 +633,21 @@ Soft386ParseModRegRm(PSOFT386_STATE State, case 7: { /* [BX] */ - ModRegRm->MemoryAddress = State->GeneralRegs[SOFT386_REG_EBX].LowWord; + ModRegRm->MemoryAddress = State->GeneralRegs[FAST486_REG_EBX].LowWord; break; } } /* Check if there is no segment override */ - if (!(State->PrefixFlags & SOFT386_PREFIX_SEG)) + if (!(State->PrefixFlags & FAST486_PREFIX_SEG)) { /* Check if the default segment should be SS */ if ((RegMem == 2) || (RegMem == 3) || ((RegMem == 6) && Mode)) { /* Add a SS: prefix */ - State->PrefixFlags |= SOFT386_PREFIX_SEG; - State->SegmentOverride = SOFT386_REG_SS; + State->PrefixFlags |= FAST486_PREFIX_SEG; + State->SegmentOverride = FAST486_REG_SS; } } @@ -656,7 +656,7 @@ Soft386ParseModRegRm(PSOFT386_STATE State, CHAR Offset; /* Fetch the byte */ - if (!Soft386FetchByte(State, (PUCHAR)&Offset)) + if (!Fast486FetchByte(State, (PUCHAR)&Offset)) { /* Exception occurred */ return FALSE; @@ -670,7 +670,7 @@ Soft386ParseModRegRm(PSOFT386_STATE State, SHORT Offset; /* Fetch the word */ - if (!Soft386FetchWord(State, (PUSHORT)&Offset)) + if (!Fast486FetchWord(State, (PUSHORT)&Offset)) { /* Exception occurred */ return FALSE; @@ -689,12 +689,12 @@ Soft386ParseModRegRm(PSOFT386_STATE State, FORCEINLINE BOOLEAN -Soft386ReadModrmByteOperands(PSOFT386_STATE State, - PSOFT386_MOD_REG_RM ModRegRm, +Fast486ReadModrmByteOperands(PFAST486_STATE State, + PFAST486_MOD_REG_RM ModRegRm, PUCHAR RegValue, PUCHAR RmValue) { - SOFT386_SEG_REGS Segment = SOFT386_REG_DS; + FAST486_SEG_REGS Segment = FAST486_REG_DS; /* Get the register value */ if (ModRegRm->Register & 0x04) @@ -725,14 +725,14 @@ Soft386ReadModrmByteOperands(PSOFT386_STATE State, else { /* Check for the segment override */ - if (State->PrefixFlags & SOFT386_PREFIX_SEG) + if (State->PrefixFlags & FAST486_PREFIX_SEG) { /* Use the override segment instead */ Segment = State->SegmentOverride; } /* Read memory */ - if (!Soft386ReadMemory(State, + if (!Fast486ReadMemory(State, Segment, ModRegRm->MemoryAddress, FALSE, @@ -749,12 +749,12 @@ Soft386ReadModrmByteOperands(PSOFT386_STATE State, FORCEINLINE BOOLEAN -Soft386ReadModrmWordOperands(PSOFT386_STATE State, - PSOFT386_MOD_REG_RM ModRegRm, +Fast486ReadModrmWordOperands(PFAST486_STATE State, + PFAST486_MOD_REG_RM ModRegRm, PUSHORT RegValue, PUSHORT RmValue) { - SOFT386_SEG_REGS Segment = SOFT386_REG_DS; + FAST486_SEG_REGS Segment = FAST486_REG_DS; /* Get the register value */ *RegValue = State->GeneralRegs[ModRegRm->Register].LowWord; @@ -767,14 +767,14 @@ Soft386ReadModrmWordOperands(PSOFT386_STATE State, else { /* Check for the segment override */ - if (State->PrefixFlags & SOFT386_PREFIX_SEG) + if (State->PrefixFlags & FAST486_PREFIX_SEG) { /* Use the override segment instead */ Segment = State->SegmentOverride; } /* Read memory */ - if (!Soft386ReadMemory(State, + if (!Fast486ReadMemory(State, Segment, ModRegRm->MemoryAddress, FALSE, @@ -791,12 +791,12 @@ Soft386ReadModrmWordOperands(PSOFT386_STATE State, FORCEINLINE BOOLEAN -Soft386ReadModrmDwordOperands(PSOFT386_STATE State, - PSOFT386_MOD_REG_RM ModRegRm, +Fast486ReadModrmDwordOperands(PFAST486_STATE State, + PFAST486_MOD_REG_RM ModRegRm, PULONG RegValue, PULONG RmValue) { - SOFT386_SEG_REGS Segment = SOFT386_REG_DS; + FAST486_SEG_REGS Segment = FAST486_REG_DS; /* Get the register value */ *RegValue = State->GeneralRegs[ModRegRm->Register].Long; @@ -809,14 +809,14 @@ Soft386ReadModrmDwordOperands(PSOFT386_STATE State, else { /* Check for the segment override */ - if (State->PrefixFlags & SOFT386_PREFIX_SEG) + if (State->PrefixFlags & FAST486_PREFIX_SEG) { /* Use the override segment instead */ Segment = State->SegmentOverride; } /* Read memory */ - if (!Soft386ReadMemory(State, + if (!Fast486ReadMemory(State, Segment, ModRegRm->MemoryAddress, FALSE, @@ -833,12 +833,12 @@ Soft386ReadModrmDwordOperands(PSOFT386_STATE State, FORCEINLINE BOOLEAN -Soft386WriteModrmByteOperands(PSOFT386_STATE State, - PSOFT386_MOD_REG_RM ModRegRm, +Fast486WriteModrmByteOperands(PFAST486_STATE State, + PFAST486_MOD_REG_RM ModRegRm, BOOLEAN WriteRegister, UCHAR Value) { - SOFT386_SEG_REGS Segment = SOFT386_REG_DS; + FAST486_SEG_REGS Segment = FAST486_REG_DS; if (WriteRegister) { @@ -873,14 +873,14 @@ Soft386WriteModrmByteOperands(PSOFT386_STATE State, else { /* Check for the segment override */ - if (State->PrefixFlags & SOFT386_PREFIX_SEG) + if (State->PrefixFlags & FAST486_PREFIX_SEG) { /* Use the override segment instead */ Segment = State->SegmentOverride; } /* Write memory */ - if (!Soft386WriteMemory(State, + if (!Fast486WriteMemory(State, Segment, ModRegRm->MemoryAddress, &Value, @@ -897,12 +897,12 @@ Soft386WriteModrmByteOperands(PSOFT386_STATE State, FORCEINLINE BOOLEAN -Soft386WriteModrmWordOperands(PSOFT386_STATE State, - PSOFT386_MOD_REG_RM ModRegRm, +Fast486WriteModrmWordOperands(PFAST486_STATE State, + PFAST486_MOD_REG_RM ModRegRm, BOOLEAN WriteRegister, USHORT Value) { - SOFT386_SEG_REGS Segment = SOFT386_REG_DS; + FAST486_SEG_REGS Segment = FAST486_REG_DS; if (WriteRegister) { @@ -919,14 +919,14 @@ Soft386WriteModrmWordOperands(PSOFT386_STATE State, else { /* Check for the segment override */ - if (State->PrefixFlags & SOFT386_PREFIX_SEG) + if (State->PrefixFlags & FAST486_PREFIX_SEG) { /* Use the override segment instead */ Segment = State->SegmentOverride; } /* Write memory */ - if (!Soft386WriteMemory(State, + if (!Fast486WriteMemory(State, Segment, ModRegRm->MemoryAddress, &Value, @@ -943,12 +943,12 @@ Soft386WriteModrmWordOperands(PSOFT386_STATE State, FORCEINLINE BOOLEAN -Soft386WriteModrmDwordOperands(PSOFT386_STATE State, - PSOFT386_MOD_REG_RM ModRegRm, +Fast486WriteModrmDwordOperands(PFAST486_STATE State, + PFAST486_MOD_REG_RM ModRegRm, BOOLEAN WriteRegister, ULONG Value) { - SOFT386_SEG_REGS Segment = SOFT386_REG_DS; + FAST486_SEG_REGS Segment = FAST486_REG_DS; if (WriteRegister) { @@ -965,14 +965,14 @@ Soft386WriteModrmDwordOperands(PSOFT386_STATE State, else { /* Check for the segment override */ - if (State->PrefixFlags & SOFT386_PREFIX_SEG) + if (State->PrefixFlags & FAST486_PREFIX_SEG) { /* Use the override segment instead */ Segment = State->SegmentOverride; } /* Write memory */ - if (!Soft386WriteMemory(State, + if (!Fast486WriteMemory(State, Segment, ModRegRm->MemoryAddress, &Value, diff --git a/lib/soft386/extraops.c b/lib/fast486/extraops.c similarity index 91% rename from lib/soft386/extraops.c rename to lib/fast486/extraops.c index b57a643ec2f..b9382b12c59 100644 --- a/lib/soft386/extraops.c +++ b/lib/fast486/extraops.c @@ -1,5 +1,5 @@ /* - * Soft386 386/486 CPU Emulation Library + * Fast486 386/486 CPU Emulation Library * extraops.c * * Copyright (C) 2013 Aleksandar Andrejevic @@ -28,15 +28,15 @@ // #define NDEBUG #include -#include +#include #include "opcodes.h" #include "common.h" #include "extraops.h" /* PUBLIC VARIABLES ***********************************************************/ -SOFT386_OPCODE_HANDLER_PROC -Soft386ExtendedHandlers[SOFT386_NUM_OPCODE_HANDLERS] = +FAST486_OPCODE_HANDLER_PROC +Fast486ExtendedHandlers[FAST486_NUM_OPCODE_HANDLERS] = { NULL, // TODO: OPCODE 0x00 NOT IMPLEMENTED NULL, // TODO: OPCODE 0x01 NOT IMPLEMENTED @@ -166,22 +166,22 @@ Soft386ExtendedHandlers[SOFT386_NUM_OPCODE_HANDLERS] = NULL, // TODO: OPCODE 0x7D NOT IMPLEMENTED NULL, // TODO: OPCODE 0x7E NOT IMPLEMENTED NULL, // TODO: OPCODE 0x7F NOT IMPLEMENTED - Soft386ExtOpcodeConditionalJmp, - Soft386ExtOpcodeConditionalJmp, - Soft386ExtOpcodeConditionalJmp, - Soft386ExtOpcodeConditionalJmp, - Soft386ExtOpcodeConditionalJmp, - Soft386ExtOpcodeConditionalJmp, - Soft386ExtOpcodeConditionalJmp, - Soft386ExtOpcodeConditionalJmp, - Soft386ExtOpcodeConditionalJmp, - Soft386ExtOpcodeConditionalJmp, - Soft386ExtOpcodeConditionalJmp, - Soft386ExtOpcodeConditionalJmp, - Soft386ExtOpcodeConditionalJmp, - Soft386ExtOpcodeConditionalJmp, - Soft386ExtOpcodeConditionalJmp, - Soft386ExtOpcodeConditionalJmp, + Fast486ExtOpcodeConditionalJmp, + Fast486ExtOpcodeConditionalJmp, + Fast486ExtOpcodeConditionalJmp, + Fast486ExtOpcodeConditionalJmp, + Fast486ExtOpcodeConditionalJmp, + Fast486ExtOpcodeConditionalJmp, + Fast486ExtOpcodeConditionalJmp, + Fast486ExtOpcodeConditionalJmp, + Fast486ExtOpcodeConditionalJmp, + Fast486ExtOpcodeConditionalJmp, + Fast486ExtOpcodeConditionalJmp, + Fast486ExtOpcodeConditionalJmp, + Fast486ExtOpcodeConditionalJmp, + Fast486ExtOpcodeConditionalJmp, + Fast486ExtOpcodeConditionalJmp, + Fast486ExtOpcodeConditionalJmp, NULL, // TODO: OPCODE 0x90 NOT IMPLEMENTED NULL, // TODO: OPCODE 0x91 NOT IMPLEMENTED NULL, // TODO: OPCODE 0x92 NOT IMPLEMENTED @@ -298,22 +298,22 @@ Soft386ExtendedHandlers[SOFT386_NUM_OPCODE_HANDLERS] = /* PUBLIC FUNCTIONS ***********************************************************/ -SOFT386_OPCODE_HANDLER(Soft386ExtOpcodeConditionalJmp) +FAST486_OPCODE_HANDLER(Fast486ExtOpcodeConditionalJmp) { BOOLEAN Jump = FALSE; LONG Offset = 0; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -323,7 +323,7 @@ SOFT386_OPCODE_HANDLER(Soft386ExtOpcodeConditionalJmp) /* Fetch the offset */ if (Size) { - if (!Soft386FetchDword(State, (PULONG)&Offset)) + if (!Fast486FetchDword(State, (PULONG)&Offset)) { /* Exception occurred */ return FALSE; @@ -333,7 +333,7 @@ SOFT386_OPCODE_HANDLER(Soft386ExtOpcodeConditionalJmp) { SHORT Value; - if (!Soft386FetchWord(State, (PUSHORT)&Value)) + if (!Fast486FetchWord(State, (PUSHORT)&Value)) { /* Exception occurred */ return FALSE; @@ -419,26 +419,26 @@ SOFT386_OPCODE_HANDLER(Soft386ExtOpcodeConditionalJmp) } -SOFT386_OPCODE_HANDLER(Soft386OpcodeExtended) +FAST486_OPCODE_HANDLER(Fast486OpcodeExtended) { UCHAR SecondOpcode; /* Fetch the second operation code */ - if (!Soft386FetchByte(State, &SecondOpcode)) + if (!Fast486FetchByte(State, &SecondOpcode)) { /* Exception occurred */ return FALSE; } - if (Soft386ExtendedHandlers[SecondOpcode] != NULL) + if (Fast486ExtendedHandlers[SecondOpcode] != NULL) { /* Call the extended opcode handler */ - return Soft386ExtendedHandlers[SecondOpcode](State, SecondOpcode); + return Fast486ExtendedHandlers[SecondOpcode](State, SecondOpcode); } else { /* This is not a valid opcode */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } } diff --git a/lib/soft386/extraops.h b/lib/fast486/extraops.h similarity index 87% rename from lib/soft386/extraops.h rename to lib/fast486/extraops.h index 3f5409d42ff..708abc6ccb5 100644 --- a/lib/soft386/extraops.h +++ b/lib/fast486/extraops.h @@ -1,5 +1,5 @@ /* - * Soft386 386/486 CPU Emulation Library + * Fast486 386/486 CPU Emulation Library * extraops.h * * Copyright (C) 2013 Aleksandar Andrejevic @@ -23,8 +23,8 @@ #define _EXTRAOPS_H_ /* DEFINES ********************************************************************/ -SOFT386_OPCODE_HANDLER(Soft386ExtOpcodeConditionalJmp); -SOFT386_OPCODE_HANDLER(Soft386OpcodeExtended); +FAST486_OPCODE_HANDLER(Fast486ExtOpcodeConditionalJmp); +FAST486_OPCODE_HANDLER(Fast486OpcodeExtended); #endif // _EXTRAOPS_H_ diff --git a/lib/soft386/soft386.c b/lib/fast486/fast486.c similarity index 55% rename from lib/soft386/soft386.c rename to lib/fast486/fast486.c index feca57917d7..44caf9cab7b 100644 --- a/lib/soft386/soft386.c +++ b/lib/fast486/fast486.c @@ -1,6 +1,6 @@ /* - * Soft386 386/486 CPU Emulation Library - * soft386.c + * Fast486 386/486 CPU Emulation Library + * fast486.c * * Copyright (C) 2013 Aleksandar Andrejevic * @@ -28,7 +28,7 @@ // #define NDEBUG #include -#include +#include #include "common.h" #include "opcodes.h" @@ -36,11 +36,11 @@ typedef enum { - SOFT386_STEP_INTO, - SOFT386_STEP_OVER, - SOFT386_STEP_OUT, - SOFT386_CONTINUE -} SOFT386_EXEC_CMD; + FAST486_STEP_INTO, + FAST486_STEP_OVER, + FAST486_STEP_OUT, + FAST486_CONTINUE +} FAST486_EXEC_CMD; /* PRIVATE FUNCTIONS **********************************************************/ @@ -48,7 +48,7 @@ static inline VOID NTAPI -Soft386ExecutionControl(PSOFT386_STATE State, INT Command) +Fast486ExecutionControl(PFAST486_STATE State, INT Command) { UCHAR Opcode; INT ProcedureCallCount = 0; @@ -64,13 +64,13 @@ Soft386ExecutionControl(PSOFT386_STATE State, INT Command) /* Check if interrupts are enabled and there is an interrupt pending */ if (State->Flags.If && State->HardwareInt) { - SOFT386_IDT_ENTRY IdtEntry; + FAST486_IDT_ENTRY IdtEntry; /* Get the interrupt vector */ - if (Soft386GetIntVector(State, State->PendingIntNum, &IdtEntry)) + if (Fast486GetIntVector(State, State->PendingIntNum, &IdtEntry)) { /* Perform the interrupt */ - Soft386InterruptInternal(State, + Fast486InterruptInternal(State, IdtEntry.Selector, MAKELONG(IdtEntry.Offset, IdtEntry.OffsetHigh), IdtEntry.Type); @@ -82,22 +82,22 @@ Soft386ExecutionControl(PSOFT386_STATE State, INT Command) } /* Perform an instruction fetch */ - if (!Soft386FetchByte(State, &Opcode)) continue; + if (!Fast486FetchByte(State, &Opcode)) continue; // TODO: Check for CALL/RET to update ProcedureCallCount. - if (Soft386OpcodeHandlers[Opcode] != NULL) + if (Fast486OpcodeHandlers[Opcode] != NULL) { /* Call the opcode handler */ - Soft386OpcodeHandlers[Opcode](State, Opcode); + Fast486OpcodeHandlers[Opcode](State, Opcode); } else { /* This is not a valid opcode */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); } - if (Soft386OpcodeHandlers[Opcode] != Soft386OpcodePrefix) + if (Fast486OpcodeHandlers[Opcode] != Fast486OpcodePrefix) { /* A non-prefix opcode has been executed, reset the prefix flags */ State->PrefixFlags = 0; @@ -111,67 +111,67 @@ Soft386ExecutionControl(PSOFT386_STATE State, INT Command) /* Increment the time stamp counter */ State->TimeStampCounter++; } - while ((Command == SOFT386_CONTINUE) - || (Command == SOFT386_STEP_OVER && ProcedureCallCount > 0) - || (Command == SOFT386_STEP_OUT && ProcedureCallCount >= 0) - || (Soft386OpcodeHandlers[Opcode] == Soft386OpcodePrefix)); + while ((Command == FAST486_CONTINUE) + || (Command == FAST486_STEP_OVER && ProcedureCallCount > 0) + || (Command == FAST486_STEP_OUT && ProcedureCallCount >= 0) + || (Fast486OpcodeHandlers[Opcode] == Fast486OpcodePrefix)); } /* PUBLIC FUNCTIONS ***********************************************************/ VOID NTAPI -Soft386Continue(PSOFT386_STATE State) +Fast486Continue(PFAST486_STATE State) { /* Call the internal function */ - Soft386ExecutionControl(State, SOFT386_CONTINUE); + Fast486ExecutionControl(State, FAST486_CONTINUE); } VOID NTAPI -Soft386StepInto(PSOFT386_STATE State) +Fast486StepInto(PFAST486_STATE State) { /* Call the internal function */ - Soft386ExecutionControl(State, SOFT386_STEP_INTO); + Fast486ExecutionControl(State, FAST486_STEP_INTO); } VOID NTAPI -Soft386StepOver(PSOFT386_STATE State) +Fast486StepOver(PFAST486_STATE State) { /* Call the internal function */ - Soft386ExecutionControl(State, SOFT386_STEP_OVER); + Fast486ExecutionControl(State, FAST486_STEP_OVER); } VOID NTAPI -Soft386StepOut(PSOFT386_STATE State) +Fast486StepOut(PFAST486_STATE State) { /* Call the internal function */ - Soft386ExecutionControl(State, SOFT386_STEP_OUT); + Fast486ExecutionControl(State, FAST486_STEP_OUT); } VOID NTAPI -Soft386DumpState(PSOFT386_STATE State) +Fast486DumpState(PFAST486_STATE State) { DPRINT1("\nCPU currently executing in %s mode at %04X:%08X\n" "Time Stamp Counter = %016X\n", - (State->ControlRegisters[0] & SOFT386_CR0_PE) ? "protected" : "real", - State->SegmentRegs[SOFT386_REG_CS].Selector, + (State->ControlRegisters[0] & FAST486_CR0_PE) ? "protected" : "real", + State->SegmentRegs[FAST486_REG_CS].Selector, State->InstPtr.Long, State->TimeStampCounter); DPRINT1("\nGeneral purpose registers:\n" "EAX = %08X\tECX = %08X\tEDX = %08X\tEBX = %08X\n" "ESP = %08X\tEBP = %08X\tESI = %08X\tEDI = %08X\n", - State->GeneralRegs[SOFT386_REG_EAX].Long, - State->GeneralRegs[SOFT386_REG_ECX].Long, - State->GeneralRegs[SOFT386_REG_EDX].Long, - State->GeneralRegs[SOFT386_REG_EBX].Long, - State->GeneralRegs[SOFT386_REG_ESP].Long, - State->GeneralRegs[SOFT386_REG_EBP].Long, - State->GeneralRegs[SOFT386_REG_ESI].Long, - State->GeneralRegs[SOFT386_REG_EDI].Long); + State->GeneralRegs[FAST486_REG_EAX].Long, + State->GeneralRegs[FAST486_REG_ECX].Long, + State->GeneralRegs[FAST486_REG_EDX].Long, + State->GeneralRegs[FAST486_REG_EBX].Long, + State->GeneralRegs[FAST486_REG_ESP].Long, + State->GeneralRegs[FAST486_REG_EBP].Long, + State->GeneralRegs[FAST486_REG_ESI].Long, + State->GeneralRegs[FAST486_REG_EDI].Long); DPRINT1("\nSegment registers:\n" "ES = %04X (Base: %08X, Limit: %08X, Dpl: %u)\n" "CS = %04X (Base: %08X, Limit: %08X, Dpl: %u)\n" @@ -179,30 +179,30 @@ Soft386DumpState(PSOFT386_STATE State) "DS = %04X (Base: %08X, Limit: %08X, Dpl: %u)\n" "FS = %04X (Base: %08X, Limit: %08X, Dpl: %u)\n" "GS = %04X (Base: %08X, Limit: %08X, Dpl: %u)\n", - State->SegmentRegs[SOFT386_REG_ES].Selector, - State->SegmentRegs[SOFT386_REG_ES].Base, - State->SegmentRegs[SOFT386_REG_ES].Limit, - State->SegmentRegs[SOFT386_REG_ES].Dpl, - State->SegmentRegs[SOFT386_REG_CS].Selector, - State->SegmentRegs[SOFT386_REG_CS].Base, - State->SegmentRegs[SOFT386_REG_CS].Limit, - State->SegmentRegs[SOFT386_REG_CS].Dpl, - State->SegmentRegs[SOFT386_REG_SS].Selector, - State->SegmentRegs[SOFT386_REG_SS].Base, - State->SegmentRegs[SOFT386_REG_SS].Limit, - State->SegmentRegs[SOFT386_REG_SS].Dpl, - State->SegmentRegs[SOFT386_REG_DS].Selector, - State->SegmentRegs[SOFT386_REG_DS].Base, - State->SegmentRegs[SOFT386_REG_DS].Limit, - State->SegmentRegs[SOFT386_REG_DS].Dpl, - State->SegmentRegs[SOFT386_REG_FS].Selector, - State->SegmentRegs[SOFT386_REG_FS].Base, - State->SegmentRegs[SOFT386_REG_FS].Limit, - State->SegmentRegs[SOFT386_REG_FS].Dpl, - State->SegmentRegs[SOFT386_REG_GS].Selector, - State->SegmentRegs[SOFT386_REG_GS].Base, - State->SegmentRegs[SOFT386_REG_GS].Limit, - State->SegmentRegs[SOFT386_REG_GS].Dpl); + State->SegmentRegs[FAST486_REG_ES].Selector, + State->SegmentRegs[FAST486_REG_ES].Base, + State->SegmentRegs[FAST486_REG_ES].Limit, + State->SegmentRegs[FAST486_REG_ES].Dpl, + State->SegmentRegs[FAST486_REG_CS].Selector, + State->SegmentRegs[FAST486_REG_CS].Base, + State->SegmentRegs[FAST486_REG_CS].Limit, + State->SegmentRegs[FAST486_REG_CS].Dpl, + State->SegmentRegs[FAST486_REG_SS].Selector, + State->SegmentRegs[FAST486_REG_SS].Base, + State->SegmentRegs[FAST486_REG_SS].Limit, + State->SegmentRegs[FAST486_REG_SS].Dpl, + State->SegmentRegs[FAST486_REG_DS].Selector, + State->SegmentRegs[FAST486_REG_DS].Base, + State->SegmentRegs[FAST486_REG_DS].Limit, + State->SegmentRegs[FAST486_REG_DS].Dpl, + State->SegmentRegs[FAST486_REG_FS].Selector, + State->SegmentRegs[FAST486_REG_FS].Base, + State->SegmentRegs[FAST486_REG_FS].Limit, + State->SegmentRegs[FAST486_REG_FS].Dpl, + State->SegmentRegs[FAST486_REG_GS].Selector, + State->SegmentRegs[FAST486_REG_GS].Base, + State->SegmentRegs[FAST486_REG_GS].Limit, + State->SegmentRegs[FAST486_REG_GS].Dpl); DPRINT1("\nFlags: %08X (%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s) Iopl: %u\n", State->Flags.Long, State->Flags.Cf ? "CF" : "cf", @@ -224,38 +224,38 @@ Soft386DumpState(PSOFT386_STATE State) DPRINT1("\nControl Registers:\n" "CR0 = %08X\tCR1 = %08X\tCR2 = %08X\tCR3 = %08X\n" "CR4 = %08X\tCR5 = %08X\tCR6 = %08X\tCR7 = %08X\n", - State->ControlRegisters[SOFT386_REG_CR0], - State->ControlRegisters[SOFT386_REG_CR1], - State->ControlRegisters[SOFT386_REG_CR2], - State->ControlRegisters[SOFT386_REG_CR3], - State->ControlRegisters[SOFT386_REG_CR4], - State->ControlRegisters[SOFT386_REG_CR5], - State->ControlRegisters[SOFT386_REG_CR6], - State->ControlRegisters[SOFT386_REG_CR7]); + State->ControlRegisters[FAST486_REG_CR0], + State->ControlRegisters[FAST486_REG_CR1], + State->ControlRegisters[FAST486_REG_CR2], + State->ControlRegisters[FAST486_REG_CR3], + State->ControlRegisters[FAST486_REG_CR4], + State->ControlRegisters[FAST486_REG_CR5], + State->ControlRegisters[FAST486_REG_CR6], + State->ControlRegisters[FAST486_REG_CR7]); DPRINT1("\nDebug Registers:\n" "DR0 = %08X\tDR1 = %08X\tDR2 = %08X\tDR3 = %08X\n" "DR4 = %08X\tDR5 = %08X\tDR6 = %08X\tDR7 = %08X\n", - State->DebugRegisters[SOFT386_REG_DR0], - State->DebugRegisters[SOFT386_REG_DR1], - State->DebugRegisters[SOFT386_REG_DR2], - State->DebugRegisters[SOFT386_REG_DR3], - State->DebugRegisters[SOFT386_REG_DR4], - State->DebugRegisters[SOFT386_REG_DR5], - State->DebugRegisters[SOFT386_REG_DR6], - State->DebugRegisters[SOFT386_REG_DR7]); + State->DebugRegisters[FAST486_REG_DR0], + State->DebugRegisters[FAST486_REG_DR1], + State->DebugRegisters[FAST486_REG_DR2], + State->DebugRegisters[FAST486_REG_DR3], + State->DebugRegisters[FAST486_REG_DR4], + State->DebugRegisters[FAST486_REG_DR5], + State->DebugRegisters[FAST486_REG_DR6], + State->DebugRegisters[FAST486_REG_DR7]); } VOID NTAPI -Soft386Reset(PSOFT386_STATE State) +Fast486Reset(PFAST486_STATE State) { INT i; - SOFT386_MEM_READ_PROC MemReadCallback = State->MemReadCallback; - SOFT386_MEM_WRITE_PROC MemWriteCallback = State->MemWriteCallback; - SOFT386_IO_READ_PROC IoReadCallback = State->IoReadCallback; - SOFT386_IO_WRITE_PROC IoWriteCallback = State->IoWriteCallback; - SOFT386_IDLE_PROC IdleCallback = State->IdleCallback; - SOFT386_BOP_PROC BopCallback = State->BopCallback; + FAST486_MEM_READ_PROC MemReadCallback = State->MemReadCallback; + FAST486_MEM_WRITE_PROC MemWriteCallback = State->MemWriteCallback; + FAST486_IO_READ_PROC IoReadCallback = State->IoReadCallback; + FAST486_IO_WRITE_PROC IoWriteCallback = State->IoWriteCallback; + FAST486_IDLE_PROC IdleCallback = State->IdleCallback; + FAST486_BOP_PROC BopCallback = State->BopCallback; /* Clear the entire structure */ RtlZeroMemory(State, sizeof(*State)); @@ -265,7 +265,7 @@ Soft386Reset(PSOFT386_STATE State) State->InstPtr.LowWord = 0xFFF0; /* Initialize segments */ - for (i = 0; i < SOFT386_NUM_SEG_REGS; i++) + for (i = 0; i < FAST486_NUM_SEG_REGS; i++) { /* Set the selector, base and limit, other values don't apply in real mode */ State->SegmentRegs[i].Selector = 0; @@ -274,15 +274,15 @@ Soft386Reset(PSOFT386_STATE State) } /* Initialize the code segment */ - State->SegmentRegs[SOFT386_REG_CS].Selector = 0xF000; - State->SegmentRegs[SOFT386_REG_CS].Base = 0xFFFF0000; + State->SegmentRegs[FAST486_REG_CS].Selector = 0xF000; + State->SegmentRegs[FAST486_REG_CS].Base = 0xFFFF0000; /* Initialize the IDT */ State->Idtr.Size = 0x3FF; State->Idtr.Address = 0; /* Initialize CR0 */ - State->ControlRegisters[SOFT386_REG_CR0] |= SOFT386_CR0_ET; + State->ControlRegisters[FAST486_REG_CR0] |= FAST486_CR0_ET; /* Restore the callbacks */ State->MemReadCallback = MemReadCallback; @@ -295,7 +295,7 @@ Soft386Reset(PSOFT386_STATE State) VOID NTAPI -Soft386Interrupt(PSOFT386_STATE State, UCHAR Number) +Fast486Interrupt(PFAST486_STATE State, UCHAR Number) { /* Set the hardware interrupt flag */ State->HardwareInt = TRUE; @@ -304,10 +304,10 @@ Soft386Interrupt(PSOFT386_STATE State, UCHAR Number) VOID NTAPI -Soft386ExecuteAt(PSOFT386_STATE State, USHORT Segment, ULONG Offset) +Fast486ExecuteAt(PFAST486_STATE State, USHORT Segment, ULONG Offset) { /* Load the new CS */ - if (!Soft386LoadSegment(State, SOFT386_REG_CS, Segment)) + if (!Fast486LoadSegment(State, FAST486_REG_CS, Segment)) { /* An exception occurred, let the handler execute instead */ return; @@ -319,27 +319,27 @@ Soft386ExecuteAt(PSOFT386_STATE State, USHORT Segment, ULONG Offset) VOID NTAPI -Soft386SetStack(PSOFT386_STATE State, USHORT Segment, ULONG Offset) +Fast486SetStack(PFAST486_STATE State, USHORT Segment, ULONG Offset) { /* Load the new SS */ - if (!Soft386LoadSegment(State, SOFT386_REG_SS, Segment)) + if (!Fast486LoadSegment(State, FAST486_REG_SS, Segment)) { /* An exception occurred, let the handler execute instead */ return; } /* Set the new SP */ - State->GeneralRegs[SOFT386_REG_ESP].Long = Offset; + State->GeneralRegs[FAST486_REG_ESP].Long = Offset; } VOID NTAPI -Soft386SetSegment(PSOFT386_STATE State, - SOFT386_SEG_REGS Segment, +Fast486SetSegment(PFAST486_STATE State, + FAST486_SEG_REGS Segment, USHORT Selector) { /* Call the internal function */ - Soft386LoadSegment(State, Segment, Selector); + Fast486LoadSegment(State, Segment, Selector); } /* EOF */ diff --git a/lib/soft386/opcodes.c b/lib/fast486/opcodes.c similarity index 64% rename from lib/soft386/opcodes.c rename to lib/fast486/opcodes.c index 5acac3d2e85..00f4b5fd0b8 100644 --- a/lib/soft386/opcodes.c +++ b/lib/fast486/opcodes.c @@ -1,5 +1,5 @@ /* - * Soft386 386/486 CPU Emulation Library + * Fast486 386/486 CPU Emulation Library * opcodes.c * * Copyright (C) 2013 Aleksandar Andrejevic @@ -29,7 +29,7 @@ // #define NDEBUG #include -#include +#include #include "opcodes.h" #include "opgroups.h" #include "extraops.h" @@ -37,225 +37,225 @@ /* PUBLIC VARIABLES ***********************************************************/ -SOFT386_OPCODE_HANDLER_PROC -Soft386OpcodeHandlers[SOFT386_NUM_OPCODE_HANDLERS] = +FAST486_OPCODE_HANDLER_PROC +Fast486OpcodeHandlers[FAST486_NUM_OPCODE_HANDLERS] = { - Soft386OpcodeAddByteModrm, - Soft386OpcodeAddModrm, - Soft386OpcodeAddByteModrm, - Soft386OpcodeAddModrm, - Soft386OpcodeAddAl, - Soft386OpcodeAddEax, - Soft386OpcodePushEs, - Soft386OpcodePopEs, - Soft386OpcodeOrByteModrm, - Soft386OpcodeOrModrm, - Soft386OpcodeOrByteModrm, - Soft386OpcodeOrModrm, - Soft386OpcodeOrAl, - Soft386OpcodeOrEax, - Soft386OpcodePushCs, - Soft386OpcodeExtended, - Soft386OpcodeAdcByteModrm, - Soft386OpcodeAdcModrm, - Soft386OpcodeAdcByteModrm, - Soft386OpcodeAdcModrm, - Soft386OpcodeAdcAl, - Soft386OpcodeAdcEax, - Soft386OpcodePushSs, - Soft386OpcodePopSs, - Soft386OpcodeSbbByteModrm, - Soft386OpcodeSbbModrm, - Soft386OpcodeSbbByteModrm, - Soft386OpcodeSbbModrm, - Soft386OpcodeSbbAl, - Soft386OpcodeSbbEax, - Soft386OpcodePushDs, - Soft386OpcodePopDs, - Soft386OpcodeAndByteModrm, - Soft386OpcodeAndModrm, - Soft386OpcodeAndByteModrm, - Soft386OpcodeAndModrm, - Soft386OpcodeAndAl, - Soft386OpcodeAndEax, - Soft386OpcodePrefix, - Soft386OpcodeDaa, - Soft386OpcodeCmpSubByteModrm, - Soft386OpcodeCmpSubModrm, - Soft386OpcodeCmpSubByteModrm, - Soft386OpcodeCmpSubModrm, - Soft386OpcodeCmpSubAl, - Soft386OpcodeCmpSubEax, - Soft386OpcodePrefix, - Soft386OpcodeDas, - Soft386OpcodeXorByteModrm, - Soft386OpcodeXorModrm, - Soft386OpcodeXorByteModrm, - Soft386OpcodeXorModrm, - Soft386OpcodeXorAl, - Soft386OpcodeXorEax, - Soft386OpcodePrefix, - Soft386OpcodeAaa, - Soft386OpcodeCmpSubByteModrm, - Soft386OpcodeCmpSubModrm, - Soft386OpcodeCmpSubByteModrm, - Soft386OpcodeCmpSubModrm, - Soft386OpcodeCmpSubAl, - Soft386OpcodeCmpSubEax, - Soft386OpcodePrefix, - Soft386OpcodeAas, - Soft386OpcodeIncrement, - Soft386OpcodeIncrement, - Soft386OpcodeIncrement, - Soft386OpcodeIncrement, - Soft386OpcodeIncrement, - Soft386OpcodeIncrement, - Soft386OpcodeIncrement, - Soft386OpcodeIncrement, - Soft386OpcodeDecrement, - Soft386OpcodeDecrement, - Soft386OpcodeDecrement, - Soft386OpcodeDecrement, - Soft386OpcodeDecrement, - Soft386OpcodeDecrement, - Soft386OpcodeDecrement, - Soft386OpcodeDecrement, - Soft386OpcodePushReg, - Soft386OpcodePushReg, - Soft386OpcodePushReg, - Soft386OpcodePushReg, - Soft386OpcodePushReg, - Soft386OpcodePushReg, - Soft386OpcodePushReg, - Soft386OpcodePushReg, - Soft386OpcodePopReg, - Soft386OpcodePopReg, - Soft386OpcodePopReg, - Soft386OpcodePopReg, - Soft386OpcodePopReg, - Soft386OpcodePopReg, - Soft386OpcodePopReg, - Soft386OpcodePopReg, - Soft386OpcodePushAll, - Soft386OpcodePopAll, - Soft386OpcodeBound, - Soft386OpcodeArpl, - Soft386OpcodePrefix, - Soft386OpcodePrefix, - Soft386OpcodePrefix, - Soft386OpcodePrefix, - Soft386OpcodePushImm, - Soft386OpcodeImulModrmImm, - Soft386OpcodePushByteImm, - Soft386OpcodeImulModrmImm, - Soft386OpcodeIns, - Soft386OpcodeIns, - Soft386OpcodeOuts, - Soft386OpcodeOuts, - Soft386OpcodeShortConditionalJmp, - Soft386OpcodeShortConditionalJmp, - Soft386OpcodeShortConditionalJmp, - Soft386OpcodeShortConditionalJmp, - Soft386OpcodeShortConditionalJmp, - Soft386OpcodeShortConditionalJmp, - Soft386OpcodeShortConditionalJmp, - Soft386OpcodeShortConditionalJmp, - Soft386OpcodeShortConditionalJmp, - Soft386OpcodeShortConditionalJmp, - Soft386OpcodeShortConditionalJmp, - Soft386OpcodeShortConditionalJmp, - Soft386OpcodeShortConditionalJmp, - Soft386OpcodeShortConditionalJmp, - Soft386OpcodeShortConditionalJmp, - Soft386OpcodeShortConditionalJmp, - Soft386OpcodeGroup8082, - Soft386OpcodeGroup81, - Soft386OpcodeGroup8082, - Soft386OpcodeGroup83, - Soft386OpcodeTestByteModrm, - Soft386OpcodeTestModrm, - Soft386OpcodeXchgByteModrm, - Soft386OpcodeXchgModrm, - Soft386OpcodeMovByteModrm, - Soft386OpcodeMovModrm, - Soft386OpcodeMovByteModrm, - Soft386OpcodeMovModrm, - Soft386OpcodeMovStoreSeg, - Soft386OpcodeLea, - Soft386OpcodeMovLoadSeg, - Soft386OpcodeGroup8F, - Soft386OpcodeNop, - Soft386OpcodeExchangeEax, - Soft386OpcodeExchangeEax, - Soft386OpcodeExchangeEax, - Soft386OpcodeExchangeEax, - Soft386OpcodeExchangeEax, - Soft386OpcodeExchangeEax, - Soft386OpcodeExchangeEax, - Soft386OpcodeCwde, - Soft386OpcodeCdq, - Soft386OpcodeCallAbs, - Soft386OpcodeWait, - Soft386OpcodePushFlags, - Soft386OpcodePopFlags, - Soft386OpcodeSahf, - Soft386OpcodeLahf, - Soft386OpcodeMovAlOffset, - Soft386OpcodeMovEaxOffset, - Soft386OpcodeMovOffsetAl, - Soft386OpcodeMovOffsetEax, - Soft386OpcodeMovs, - Soft386OpcodeMovs, - Soft386OpcodeCmps, - Soft386OpcodeCmps, - Soft386OpcodeTestAl, - Soft386OpcodeTestEax, - Soft386OpcodeStos, - Soft386OpcodeStos, - Soft386OpcodeLods, - Soft386OpcodeLods, - Soft386OpcodeScas, - Soft386OpcodeScas, - Soft386OpcodeMovByteRegImm, - Soft386OpcodeMovByteRegImm, - Soft386OpcodeMovByteRegImm, - Soft386OpcodeMovByteRegImm, - Soft386OpcodeMovByteRegImm, - Soft386OpcodeMovByteRegImm, - Soft386OpcodeMovByteRegImm, - Soft386OpcodeMovByteRegImm, - Soft386OpcodeMovRegImm, - Soft386OpcodeMovRegImm, - Soft386OpcodeMovRegImm, - Soft386OpcodeMovRegImm, - Soft386OpcodeMovRegImm, - Soft386OpcodeMovRegImm, - Soft386OpcodeMovRegImm, - Soft386OpcodeMovRegImm, - Soft386OpcodeGroupC0, - Soft386OpcodeGroupC1, - Soft386OpcodeRet, - Soft386OpcodeRet, - Soft386OpcodeLdsLes, - Soft386OpcodeLdsLes, - Soft386OpcodeGroupC6, - Soft386OpcodeGroupC7, - Soft386OpcodeEnter, - Soft386OpcodeLeave, - Soft386OpcodeRetFar, - Soft386OpcodeRetFar, - Soft386OpcodeInt, - Soft386OpcodeInt, - Soft386OpcodeInt, - Soft386OpcodeIret, - Soft386OpcodeGroupD0, - Soft386OpcodeGroupD1, - Soft386OpcodeGroupD2, - Soft386OpcodeGroupD3, - Soft386OpcodeAam, - Soft386OpcodeAad, - Soft386OpcodeSalc, - Soft386OpcodeXlat, + Fast486OpcodeAddByteModrm, + Fast486OpcodeAddModrm, + Fast486OpcodeAddByteModrm, + Fast486OpcodeAddModrm, + Fast486OpcodeAddAl, + Fast486OpcodeAddEax, + Fast486OpcodePushEs, + Fast486OpcodePopEs, + Fast486OpcodeOrByteModrm, + Fast486OpcodeOrModrm, + Fast486OpcodeOrByteModrm, + Fast486OpcodeOrModrm, + Fast486OpcodeOrAl, + Fast486OpcodeOrEax, + Fast486OpcodePushCs, + Fast486OpcodeExtended, + Fast486OpcodeAdcByteModrm, + Fast486OpcodeAdcModrm, + Fast486OpcodeAdcByteModrm, + Fast486OpcodeAdcModrm, + Fast486OpcodeAdcAl, + Fast486OpcodeAdcEax, + Fast486OpcodePushSs, + Fast486OpcodePopSs, + Fast486OpcodeSbbByteModrm, + Fast486OpcodeSbbModrm, + Fast486OpcodeSbbByteModrm, + Fast486OpcodeSbbModrm, + Fast486OpcodeSbbAl, + Fast486OpcodeSbbEax, + Fast486OpcodePushDs, + Fast486OpcodePopDs, + Fast486OpcodeAndByteModrm, + Fast486OpcodeAndModrm, + Fast486OpcodeAndByteModrm, + Fast486OpcodeAndModrm, + Fast486OpcodeAndAl, + Fast486OpcodeAndEax, + Fast486OpcodePrefix, + Fast486OpcodeDaa, + Fast486OpcodeCmpSubByteModrm, + Fast486OpcodeCmpSubModrm, + Fast486OpcodeCmpSubByteModrm, + Fast486OpcodeCmpSubModrm, + Fast486OpcodeCmpSubAl, + Fast486OpcodeCmpSubEax, + Fast486OpcodePrefix, + Fast486OpcodeDas, + Fast486OpcodeXorByteModrm, + Fast486OpcodeXorModrm, + Fast486OpcodeXorByteModrm, + Fast486OpcodeXorModrm, + Fast486OpcodeXorAl, + Fast486OpcodeXorEax, + Fast486OpcodePrefix, + Fast486OpcodeAaa, + Fast486OpcodeCmpSubByteModrm, + Fast486OpcodeCmpSubModrm, + Fast486OpcodeCmpSubByteModrm, + Fast486OpcodeCmpSubModrm, + Fast486OpcodeCmpSubAl, + Fast486OpcodeCmpSubEax, + Fast486OpcodePrefix, + Fast486OpcodeAas, + Fast486OpcodeIncrement, + Fast486OpcodeIncrement, + Fast486OpcodeIncrement, + Fast486OpcodeIncrement, + Fast486OpcodeIncrement, + Fast486OpcodeIncrement, + Fast486OpcodeIncrement, + Fast486OpcodeIncrement, + Fast486OpcodeDecrement, + Fast486OpcodeDecrement, + Fast486OpcodeDecrement, + Fast486OpcodeDecrement, + Fast486OpcodeDecrement, + Fast486OpcodeDecrement, + Fast486OpcodeDecrement, + Fast486OpcodeDecrement, + Fast486OpcodePushReg, + Fast486OpcodePushReg, + Fast486OpcodePushReg, + Fast486OpcodePushReg, + Fast486OpcodePushReg, + Fast486OpcodePushReg, + Fast486OpcodePushReg, + Fast486OpcodePushReg, + Fast486OpcodePopReg, + Fast486OpcodePopReg, + Fast486OpcodePopReg, + Fast486OpcodePopReg, + Fast486OpcodePopReg, + Fast486OpcodePopReg, + Fast486OpcodePopReg, + Fast486OpcodePopReg, + Fast486OpcodePushAll, + Fast486OpcodePopAll, + Fast486OpcodeBound, + Fast486OpcodeArpl, + Fast486OpcodePrefix, + Fast486OpcodePrefix, + Fast486OpcodePrefix, + Fast486OpcodePrefix, + Fast486OpcodePushImm, + Fast486OpcodeImulModrmImm, + Fast486OpcodePushByteImm, + Fast486OpcodeImulModrmImm, + Fast486OpcodeIns, + Fast486OpcodeIns, + Fast486OpcodeOuts, + Fast486OpcodeOuts, + Fast486OpcodeShortConditionalJmp, + Fast486OpcodeShortConditionalJmp, + Fast486OpcodeShortConditionalJmp, + Fast486OpcodeShortConditionalJmp, + Fast486OpcodeShortConditionalJmp, + Fast486OpcodeShortConditionalJmp, + Fast486OpcodeShortConditionalJmp, + Fast486OpcodeShortConditionalJmp, + Fast486OpcodeShortConditionalJmp, + Fast486OpcodeShortConditionalJmp, + Fast486OpcodeShortConditionalJmp, + Fast486OpcodeShortConditionalJmp, + Fast486OpcodeShortConditionalJmp, + Fast486OpcodeShortConditionalJmp, + Fast486OpcodeShortConditionalJmp, + Fast486OpcodeShortConditionalJmp, + Fast486OpcodeGroup8082, + Fast486OpcodeGroup81, + Fast486OpcodeGroup8082, + Fast486OpcodeGroup83, + Fast486OpcodeTestByteModrm, + Fast486OpcodeTestModrm, + Fast486OpcodeXchgByteModrm, + Fast486OpcodeXchgModrm, + Fast486OpcodeMovByteModrm, + Fast486OpcodeMovModrm, + Fast486OpcodeMovByteModrm, + Fast486OpcodeMovModrm, + Fast486OpcodeMovStoreSeg, + Fast486OpcodeLea, + Fast486OpcodeMovLoadSeg, + Fast486OpcodeGroup8F, + Fast486OpcodeNop, + Fast486OpcodeExchangeEax, + Fast486OpcodeExchangeEax, + Fast486OpcodeExchangeEax, + Fast486OpcodeExchangeEax, + Fast486OpcodeExchangeEax, + Fast486OpcodeExchangeEax, + Fast486OpcodeExchangeEax, + Fast486OpcodeCwde, + Fast486OpcodeCdq, + Fast486OpcodeCallAbs, + Fast486OpcodeWait, + Fast486OpcodePushFlags, + Fast486OpcodePopFlags, + Fast486OpcodeSahf, + Fast486OpcodeLahf, + Fast486OpcodeMovAlOffset, + Fast486OpcodeMovEaxOffset, + Fast486OpcodeMovOffsetAl, + Fast486OpcodeMovOffsetEax, + Fast486OpcodeMovs, + Fast486OpcodeMovs, + Fast486OpcodeCmps, + Fast486OpcodeCmps, + Fast486OpcodeTestAl, + Fast486OpcodeTestEax, + Fast486OpcodeStos, + Fast486OpcodeStos, + Fast486OpcodeLods, + Fast486OpcodeLods, + Fast486OpcodeScas, + Fast486OpcodeScas, + Fast486OpcodeMovByteRegImm, + Fast486OpcodeMovByteRegImm, + Fast486OpcodeMovByteRegImm, + Fast486OpcodeMovByteRegImm, + Fast486OpcodeMovByteRegImm, + Fast486OpcodeMovByteRegImm, + Fast486OpcodeMovByteRegImm, + Fast486OpcodeMovByteRegImm, + Fast486OpcodeMovRegImm, + Fast486OpcodeMovRegImm, + Fast486OpcodeMovRegImm, + Fast486OpcodeMovRegImm, + Fast486OpcodeMovRegImm, + Fast486OpcodeMovRegImm, + Fast486OpcodeMovRegImm, + Fast486OpcodeMovRegImm, + Fast486OpcodeGroupC0, + Fast486OpcodeGroupC1, + Fast486OpcodeRet, + Fast486OpcodeRet, + Fast486OpcodeLdsLes, + Fast486OpcodeLdsLes, + Fast486OpcodeGroupC6, + Fast486OpcodeGroupC7, + Fast486OpcodeEnter, + Fast486OpcodeLeave, + Fast486OpcodeRetFar, + Fast486OpcodeRetFar, + Fast486OpcodeInt, + Fast486OpcodeInt, + Fast486OpcodeInt, + Fast486OpcodeIret, + Fast486OpcodeGroupD0, + Fast486OpcodeGroupD1, + Fast486OpcodeGroupD2, + Fast486OpcodeGroupD3, + Fast486OpcodeAam, + Fast486OpcodeAad, + Fast486OpcodeSalc, + Fast486OpcodeXlat, NULL, // TODO: OPCODE 0xD8 NOT SUPPORTED NULL, // TODO: OPCODE 0xD9 NOT SUPPORTED NULL, // TODO: OPCODE 0xDA NOT SUPPORTED @@ -264,43 +264,43 @@ Soft386OpcodeHandlers[SOFT386_NUM_OPCODE_HANDLERS] = NULL, // TODO: OPCODE 0xDD NOT SUPPORTED NULL, // TODO: OPCODE 0xDE NOT SUPPORTED NULL, // TODO: OPCODE 0xDF NOT SUPPORTED - Soft386OpcodeLoop, - Soft386OpcodeLoop, - Soft386OpcodeLoop, - Soft386OpcodeJecxz, - Soft386OpcodeInByte, - Soft386OpcodeIn, - Soft386OpcodeOutByte, - Soft386OpcodeOut, - Soft386OpcodeCall, - Soft386OpcodeJmp, - Soft386OpcodeJmpAbs, - Soft386OpcodeShortJump, - Soft386OpcodeInByte, - Soft386OpcodeIn, - Soft386OpcodeOutByte, - Soft386OpcodeOut, - Soft386OpcodePrefix, + Fast486OpcodeLoop, + Fast486OpcodeLoop, + Fast486OpcodeLoop, + Fast486OpcodeJecxz, + Fast486OpcodeInByte, + Fast486OpcodeIn, + Fast486OpcodeOutByte, + Fast486OpcodeOut, + Fast486OpcodeCall, + Fast486OpcodeJmp, + Fast486OpcodeJmpAbs, + Fast486OpcodeShortJump, + Fast486OpcodeInByte, + Fast486OpcodeIn, + Fast486OpcodeOutByte, + Fast486OpcodeOut, + Fast486OpcodePrefix, NULL, // Invalid - Soft386OpcodePrefix, - Soft386OpcodePrefix, - Soft386OpcodeHalt, - Soft386OpcodeComplCarry, - Soft386OpcodeGroupF6, - Soft386OpcodeGroupF7, - Soft386OpcodeClearCarry, - Soft386OpcodeSetCarry, - Soft386OpcodeClearInt, - Soft386OpcodeSetInt, - Soft386OpcodeClearDir, - Soft386OpcodeSetDir, - Soft386OpcodeGroupFE, - Soft386OpcodeGroupFF, + Fast486OpcodePrefix, + Fast486OpcodePrefix, + Fast486OpcodeHalt, + Fast486OpcodeComplCarry, + Fast486OpcodeGroupF6, + Fast486OpcodeGroupF7, + Fast486OpcodeClearCarry, + Fast486OpcodeSetCarry, + Fast486OpcodeClearInt, + Fast486OpcodeSetInt, + Fast486OpcodeClearDir, + Fast486OpcodeSetDir, + Fast486OpcodeGroupFE, + Fast486OpcodeGroupFF, }; /* PUBLIC FUNCTIONS ***********************************************************/ -SOFT386_OPCODE_HANDLER(Soft386OpcodePrefix) +FAST486_OPCODE_HANDLER(Fast486OpcodePrefix) { BOOLEAN Valid = FALSE; @@ -309,10 +309,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePrefix) /* ES: */ case 0x26: { - if (!(State->PrefixFlags & SOFT386_PREFIX_SEG)) + if (!(State->PrefixFlags & FAST486_PREFIX_SEG)) { - State->PrefixFlags |= SOFT386_PREFIX_SEG; - State->SegmentOverride = SOFT386_REG_ES; + State->PrefixFlags |= FAST486_PREFIX_SEG; + State->SegmentOverride = FAST486_REG_ES; Valid = TRUE; } @@ -322,10 +322,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePrefix) /* CS: */ case 0x2E: { - if (!(State->PrefixFlags & SOFT386_PREFIX_SEG)) + if (!(State->PrefixFlags & FAST486_PREFIX_SEG)) { - State->PrefixFlags |= SOFT386_PREFIX_SEG; - State->SegmentOverride = SOFT386_REG_CS; + State->PrefixFlags |= FAST486_PREFIX_SEG; + State->SegmentOverride = FAST486_REG_CS; Valid = TRUE; } @@ -335,10 +335,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePrefix) /* SS: */ case 0x36: { - if (!(State->PrefixFlags & SOFT386_PREFIX_SEG)) + if (!(State->PrefixFlags & FAST486_PREFIX_SEG)) { - State->PrefixFlags |= SOFT386_PREFIX_SEG; - State->SegmentOverride = SOFT386_REG_SS; + State->PrefixFlags |= FAST486_PREFIX_SEG; + State->SegmentOverride = FAST486_REG_SS; Valid = TRUE; } @@ -348,10 +348,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePrefix) /* DS: */ case 0x3E: { - if (!(State->PrefixFlags & SOFT386_PREFIX_SEG)) + if (!(State->PrefixFlags & FAST486_PREFIX_SEG)) { - State->PrefixFlags |= SOFT386_PREFIX_SEG; - State->SegmentOverride = SOFT386_REG_DS; + State->PrefixFlags |= FAST486_PREFIX_SEG; + State->SegmentOverride = FAST486_REG_DS; Valid = TRUE; } @@ -361,10 +361,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePrefix) /* FS: */ case 0x64: { - if (!(State->PrefixFlags & SOFT386_PREFIX_SEG)) + if (!(State->PrefixFlags & FAST486_PREFIX_SEG)) { - State->PrefixFlags |= SOFT386_PREFIX_SEG; - State->SegmentOverride = SOFT386_REG_FS; + State->PrefixFlags |= FAST486_PREFIX_SEG; + State->SegmentOverride = FAST486_REG_FS; Valid = TRUE; } @@ -374,10 +374,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePrefix) /* GS: */ case 0x65: { - if (!(State->PrefixFlags & SOFT386_PREFIX_SEG)) + if (!(State->PrefixFlags & FAST486_PREFIX_SEG)) { - State->PrefixFlags |= SOFT386_PREFIX_SEG; - State->SegmentOverride = SOFT386_REG_GS; + State->PrefixFlags |= FAST486_PREFIX_SEG; + State->SegmentOverride = FAST486_REG_GS; Valid = TRUE; } @@ -387,9 +387,9 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePrefix) /* OPSIZE */ case 0x66: { - if (!(State->PrefixFlags & SOFT386_PREFIX_OPSIZE)) + if (!(State->PrefixFlags & FAST486_PREFIX_OPSIZE)) { - State->PrefixFlags |= SOFT386_PREFIX_OPSIZE; + State->PrefixFlags |= FAST486_PREFIX_OPSIZE; Valid = TRUE; } @@ -399,9 +399,9 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePrefix) /* ADSIZE */ case 0x67: { - if (!(State->PrefixFlags & SOFT386_PREFIX_ADSIZE)) + if (!(State->PrefixFlags & FAST486_PREFIX_ADSIZE)) { - State->PrefixFlags |= SOFT386_PREFIX_ADSIZE; + State->PrefixFlags |= FAST486_PREFIX_ADSIZE; Valid = TRUE; } break; @@ -410,9 +410,9 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePrefix) /* LOCK */ case 0xF0: { - if (!(State->PrefixFlags & SOFT386_PREFIX_LOCK)) + if (!(State->PrefixFlags & FAST486_PREFIX_LOCK)) { - State->PrefixFlags |= SOFT386_PREFIX_LOCK; + State->PrefixFlags |= FAST486_PREFIX_LOCK; Valid = TRUE; } @@ -424,9 +424,9 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePrefix) { /* Mutually exclusive with REP */ if (!(State->PrefixFlags - & (SOFT386_PREFIX_REPNZ | SOFT386_PREFIX_REP))) + & (FAST486_PREFIX_REPNZ | FAST486_PREFIX_REP))) { - State->PrefixFlags |= SOFT386_PREFIX_REPNZ; + State->PrefixFlags |= FAST486_PREFIX_REPNZ; Valid = TRUE; } @@ -438,9 +438,9 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePrefix) { /* Mutually exclusive with REPNZ */ if (!(State->PrefixFlags - & (SOFT386_PREFIX_REPNZ | SOFT386_PREFIX_REP))) + & (FAST486_PREFIX_REPNZ | FAST486_PREFIX_REP))) { - State->PrefixFlags |= SOFT386_PREFIX_REP; + State->PrefixFlags |= FAST486_PREFIX_REP; Valid = TRUE; } @@ -454,28 +454,28 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePrefix) State->PrefixFlags = 0; /* Throw an exception */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeIncrement) +FAST486_OPCODE_HANDLER(Fast486OpcodeIncrement) { ULONG Value; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -499,27 +499,27 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIncrement) State->Flags.Zf = (Value == 0) ? TRUE : FALSE; State->Flags.Af = ((Value & 0x0F) == 0) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(LOBYTE(Value)); + State->Flags.Pf = Fast486CalculateParity(LOBYTE(Value)); /* Return success */ return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeDecrement) +FAST486_OPCODE_HANDLER(Fast486OpcodeDecrement) { ULONG Value; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -543,18 +543,18 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeDecrement) State->Flags.Zf = (Value == 0) ? TRUE : FALSE; State->Flags.Af = ((Value & 0x0F) == 0x0F) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(LOBYTE(Value)); + State->Flags.Pf = Fast486CalculateParity(LOBYTE(Value)); /* Return success */ return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodePushReg) +FAST486_OPCODE_HANDLER(Fast486OpcodePushReg) { - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -562,24 +562,24 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePushReg) ASSERT((Opcode & 0xF8) == 0x50); /* Call the internal function */ - return Soft386StackPush(State, State->GeneralRegs[Opcode & 0x07].Long); + return Fast486StackPush(State, State->GeneralRegs[Opcode & 0x07].Long); } -SOFT386_OPCODE_HANDLER(Soft386OpcodePopReg) +FAST486_OPCODE_HANDLER(Fast486OpcodePopReg) { ULONG Value; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_SS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_SS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -587,7 +587,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePopReg) ASSERT((Opcode & 0xF8) == 0x58); /* Call the internal function */ - if (!Soft386StackPop(State, &Value)) return FALSE; + if (!Fast486StackPop(State, &Value)) return FALSE; /* Store the value */ if (Size) State->GeneralRegs[Opcode & 0x07].Long = Value; @@ -597,16 +597,16 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePopReg) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeNop) +FAST486_OPCODE_HANDLER(Fast486OpcodeNop) { - if (State->PrefixFlags & ~(SOFT386_PREFIX_OPSIZE | SOFT386_PREFIX_REP)) + if (State->PrefixFlags & ~(FAST486_PREFIX_OPSIZE | FAST486_PREFIX_REP)) { /* Allowed prefixes are REP and OPSIZE */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_REP) + if (State->PrefixFlags & FAST486_PREFIX_REP) { /* Idle cycle */ State->IdleCallback(State); @@ -615,21 +615,21 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeNop) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeExchangeEax) +FAST486_OPCODE_HANDLER(Fast486OpcodeExchangeEax) { INT Reg = Opcode & 0x07; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -642,22 +642,22 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeExchangeEax) ULONG Value; Value = State->GeneralRegs[Reg].Long; - State->GeneralRegs[Reg].Long = State->GeneralRegs[SOFT386_REG_EAX].Long; - State->GeneralRegs[SOFT386_REG_EAX].Long = Value; + State->GeneralRegs[Reg].Long = State->GeneralRegs[FAST486_REG_EAX].Long; + State->GeneralRegs[FAST486_REG_EAX].Long = Value; } else { USHORT Value; Value = State->GeneralRegs[Reg].LowWord; - State->GeneralRegs[Reg].LowWord = State->GeneralRegs[SOFT386_REG_EAX].LowWord; - State->GeneralRegs[SOFT386_REG_EAX].LowWord = Value; + State->GeneralRegs[Reg].LowWord = State->GeneralRegs[FAST486_REG_EAX].LowWord; + State->GeneralRegs[FAST486_REG_EAX].LowWord = Value; } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeShortConditionalJmp) +FAST486_OPCODE_HANDLER(Fast486OpcodeShortConditionalJmp) { BOOLEAN Jump = FALSE; CHAR Offset = 0; @@ -666,7 +666,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeShortConditionalJmp) ASSERT((Opcode & 0xF0) == 0x70); /* Fetch the offset */ - if (!Soft386FetchByte(State, (PUCHAR)&Offset)) + if (!Fast486FetchByte(State, (PUCHAR)&Offset)) { /* An exception occurred */ return FALSE; @@ -747,7 +747,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeShortConditionalJmp) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeClearCarry) +FAST486_OPCODE_HANDLER(Fast486OpcodeClearCarry) { /* Make sure this is the right instruction */ ASSERT(Opcode == 0xF8); @@ -755,7 +755,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeClearCarry) /* No prefixes allowed */ if (State->PrefixFlags) { - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -764,7 +764,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeClearCarry) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeSetCarry) +FAST486_OPCODE_HANDLER(Fast486OpcodeSetCarry) { /* Make sure this is the right instruction */ ASSERT(Opcode == 0xF9); @@ -772,7 +772,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSetCarry) /* No prefixes allowed */ if (State->PrefixFlags) { - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -781,7 +781,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSetCarry) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeComplCarry) +FAST486_OPCODE_HANDLER(Fast486OpcodeComplCarry) { /* Make sure this is the right instruction */ ASSERT(Opcode == 0xF5); @@ -789,7 +789,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeComplCarry) /* No prefixes allowed */ if (State->PrefixFlags) { - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -798,7 +798,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeComplCarry) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeClearInt) +FAST486_OPCODE_HANDLER(Fast486OpcodeClearInt) { /* Make sure this is the right instruction */ ASSERT(Opcode == 0xFA); @@ -806,15 +806,15 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeClearInt) /* No prefixes allowed */ if (State->PrefixFlags) { - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Check for protected mode */ - if (State->ControlRegisters[SOFT386_REG_CR0] & SOFT386_CR0_PE) + if (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE) { /* Check IOPL */ - if (State->Flags.Iopl >= State->SegmentRegs[SOFT386_REG_CS].Dpl) + if (State->Flags.Iopl >= State->SegmentRegs[FAST486_REG_CS].Dpl) { /* Clear the interrupt flag */ State->Flags.If = FALSE; @@ -822,7 +822,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeClearInt) else { /* General Protection Fault */ - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } } @@ -836,7 +836,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeClearInt) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeSetInt) +FAST486_OPCODE_HANDLER(Fast486OpcodeSetInt) { /* Make sure this is the right instruction */ ASSERT(Opcode == 0xFB); @@ -844,15 +844,15 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSetInt) /* No prefixes allowed */ if (State->PrefixFlags) { - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Check for protected mode */ - if (State->ControlRegisters[SOFT386_REG_CR0] & SOFT386_CR0_PE) + if (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE) { /* Check IOPL */ - if (State->Flags.Iopl >= State->SegmentRegs[SOFT386_REG_CS].Dpl) + if (State->Flags.Iopl >= State->SegmentRegs[FAST486_REG_CS].Dpl) { /* Set the interrupt flag */ State->Flags.If = TRUE; @@ -860,7 +860,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSetInt) else { /* General Protection Fault */ - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } } @@ -874,7 +874,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSetInt) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeClearDir) +FAST486_OPCODE_HANDLER(Fast486OpcodeClearDir) { /* Make sure this is the right instruction */ ASSERT(Opcode == 0xFC); @@ -882,7 +882,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeClearDir) /* No prefixes allowed */ if (State->PrefixFlags) { - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -891,7 +891,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeClearDir) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeSetDir) +FAST486_OPCODE_HANDLER(Fast486OpcodeSetDir) { /* Make sure this is the right instruction */ ASSERT(Opcode == 0xFD); @@ -899,7 +899,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSetDir) /* No prefixes allowed */ if (State->PrefixFlags) { - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -908,7 +908,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSetDir) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeHalt) +FAST486_OPCODE_HANDLER(Fast486OpcodeHalt) { /* Make sure this is the right instruction */ ASSERT(Opcode == 0xF4); @@ -916,14 +916,14 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeHalt) /* No prefixes allowed */ if (State->PrefixFlags) { - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Privileged instructions can only be executed under CPL = 0 */ - if (State->SegmentRegs[SOFT386_REG_CS].Dpl != 0) + if (State->SegmentRegs[FAST486_REG_CS].Dpl != 0) { - Soft386Exception(State, SOFT386_EXCEPTION_GP); + Fast486Exception(State, FAST486_EXCEPTION_GP); return FALSE; } @@ -934,7 +934,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeHalt) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeInByte) +FAST486_OPCODE_HANDLER(Fast486OpcodeInByte) { UCHAR Data; ULONG Port; @@ -945,7 +945,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeInByte) if (Opcode == 0xE4) { /* Fetch the parameter */ - if (!Soft386FetchByte(State, &Data)) + if (!Fast486FetchByte(State, &Data)) { /* Exception occurred */ return FALSE; @@ -957,36 +957,36 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeInByte) else { /* The port number is in DX */ - Port = State->GeneralRegs[SOFT386_REG_EDX].LowWord; + Port = State->GeneralRegs[FAST486_REG_EDX].LowWord; } /* Read a byte from the I/O port */ State->IoReadCallback(State, Port, &Data, sizeof(UCHAR)); /* Store the result in AL */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte = Data; + State->GeneralRegs[FAST486_REG_EAX].LowByte = Data; return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeIn) +FAST486_OPCODE_HANDLER(Fast486OpcodeIn) { ULONG Port; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xF7) == 0xE5); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -995,7 +995,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIn) UCHAR Data; /* Fetch the parameter */ - if (!Soft386FetchByte(State, &Data)) + if (!Fast486FetchByte(State, &Data)) { /* Exception occurred */ return FALSE; @@ -1007,7 +1007,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIn) else { /* The port number is in DX */ - Port = State->GeneralRegs[SOFT386_REG_EDX].LowWord; + Port = State->GeneralRegs[FAST486_REG_EDX].LowWord; } if (Size) @@ -1018,7 +1018,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIn) State->IoReadCallback(State, Port, &Data, sizeof(ULONG)); /* Store the value in EAX */ - State->GeneralRegs[SOFT386_REG_EAX].Long = Data; + State->GeneralRegs[FAST486_REG_EAX].Long = Data; } else { @@ -1028,13 +1028,13 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIn) State->IoReadCallback(State, Port, &Data, sizeof(USHORT)); /* Store the value in AX */ - State->GeneralRegs[SOFT386_REG_EAX].LowWord = Data; + State->GeneralRegs[FAST486_REG_EAX].LowWord = Data; } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeOutByte) +FAST486_OPCODE_HANDLER(Fast486OpcodeOutByte) { UCHAR Data; ULONG Port; @@ -1045,7 +1045,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOutByte) if (Opcode == 0xE6) { /* Fetch the parameter */ - if (!Soft386FetchByte(State, &Data)) + if (!Fast486FetchByte(State, &Data)) { /* Exception occurred */ return FALSE; @@ -1057,11 +1057,11 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOutByte) else { /* The port number is in DX */ - Port = State->GeneralRegs[SOFT386_REG_EDX].LowWord; + Port = State->GeneralRegs[FAST486_REG_EDX].LowWord; } /* Read the value from AL */ - Data = State->GeneralRegs[SOFT386_REG_EAX].LowByte; + Data = State->GeneralRegs[FAST486_REG_EAX].LowByte; /* Write the byte to the I/O port */ State->IoWriteCallback(State, Port, &Data, sizeof(UCHAR)); @@ -1069,24 +1069,24 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOutByte) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeOut) +FAST486_OPCODE_HANDLER(Fast486OpcodeOut) { ULONG Port; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xF7) == 0xE7); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -1095,7 +1095,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOut) UCHAR Data; /* Fetch the parameter */ - if (!Soft386FetchByte(State, &Data)) + if (!Fast486FetchByte(State, &Data)) { /* Exception occurred */ return FALSE; @@ -1107,13 +1107,13 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOut) else { /* The port number is in DX */ - Port = State->GeneralRegs[SOFT386_REG_EDX].LowWord; + Port = State->GeneralRegs[FAST486_REG_EDX].LowWord; } if (Size) { /* Get the value from EAX */ - ULONG Data = State->GeneralRegs[SOFT386_REG_EAX].Long; + ULONG Data = State->GeneralRegs[FAST486_REG_EAX].Long; /* Write a dword to the I/O port */ State->IoReadCallback(State, Port, &Data, sizeof(ULONG)); @@ -1121,7 +1121,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOut) else { /* Get the value from AX */ - USHORT Data = State->GeneralRegs[SOFT386_REG_EAX].LowWord; + USHORT Data = State->GeneralRegs[FAST486_REG_EAX].LowWord; /* Write a word to the I/O port */ State->IoWriteCallback(State, Port, &Data, sizeof(USHORT)); @@ -1130,7 +1130,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOut) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeShortJump) +FAST486_OPCODE_HANDLER(Fast486OpcodeShortJump) { CHAR Offset = 0; @@ -1138,7 +1138,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeShortJump) ASSERT(Opcode == 0xEB); /* Fetch the offset */ - if (!Soft386FetchByte(State, (PUCHAR)&Offset)) + if (!Fast486FetchByte(State, (PUCHAR)&Offset)) { /* An exception occurred */ return FALSE; @@ -1150,23 +1150,23 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeShortJump) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovRegImm) +FAST486_OPCODE_HANDLER(Fast486OpcodeMovRegImm) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xF8) == 0xB8); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -1175,7 +1175,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovRegImm) ULONG Value; /* Fetch the dword */ - if (!Soft386FetchDword(State, &Value)) + if (!Fast486FetchDword(State, &Value)) { /* Exception occurred */ return FALSE; @@ -1189,7 +1189,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovRegImm) USHORT Value; /* Fetch the word */ - if (!Soft386FetchWord(State, &Value)) + if (!Fast486FetchWord(State, &Value)) { /* Exception occurred */ return FALSE; @@ -1202,7 +1202,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovRegImm) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovByteRegImm) +FAST486_OPCODE_HANDLER(Fast486OpcodeMovByteRegImm) { UCHAR Value; @@ -1212,12 +1212,12 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovByteRegImm) if (State->PrefixFlags != 0) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Fetch the byte */ - if (!Soft386FetchByte(State, &Value)) + if (!Fast486FetchByte(State, &Value)) { /* Exception occurred */ return FALSE; @@ -1237,38 +1237,38 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovByteRegImm) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeAddByteModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeAddByteModrm) { UCHAR FirstValue, SecondValue, Result; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFD) == 0x00); - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } else if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } - if (!Soft386ReadModrmByteOperands(State, + if (!Fast486ReadModrmByteOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -1287,50 +1287,50 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAddByteModrm) State->Flags.Af = (((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) ? TRUE : FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmByteOperands(State, + return Fast486WriteModrmByteOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeAddModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeAddModrm) { - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFD) == 0x01); - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the address size */ AddressSize = !AddressSize; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the operand size */ OperandSize = !OperandSize; } if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_OPSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_OPSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -1341,7 +1341,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAddModrm) { ULONG FirstValue, SecondValue, Result; - if (!Soft386ReadModrmDwordOperands(State, + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -1360,19 +1360,19 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAddModrm) State->Flags.Af = (((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) ? TRUE : FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_LONG) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmDwordOperands(State, + return Fast486WriteModrmDwordOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } else { USHORT FirstValue, SecondValue, Result; - if (!Soft386ReadModrmWordOperands(State, + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -1391,19 +1391,19 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAddModrm) State->Flags.Af = (((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) ? TRUE : FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_WORD) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmWordOperands(State, + return Fast486WriteModrmWordOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeAddAl) +FAST486_OPCODE_HANDLER(Fast486OpcodeAddAl) { - UCHAR FirstValue = State->GeneralRegs[SOFT386_REG_EAX].LowByte; + UCHAR FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowByte; UCHAR SecondValue, Result; /* Make sure this is the right instruction */ @@ -1412,11 +1412,11 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAddAl) if (State->PrefixFlags) { /* This opcode doesn't take any prefixes */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (!Soft386FetchByte(State, &SecondValue)) + if (!Fast486FetchByte(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -1432,29 +1432,29 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAddAl) State->Flags.Af = (((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) ? TRUE : FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte = Result; + State->GeneralRegs[FAST486_REG_EAX].LowByte = Result; return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeAddEax) +FAST486_OPCODE_HANDLER(Fast486OpcodeAddEax) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x05); - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; @@ -1462,10 +1462,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAddEax) if (Size) { - ULONG FirstValue = State->GeneralRegs[SOFT386_REG_EAX].Long; + ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long; ULONG SecondValue, Result; - if (!Soft386FetchDword(State, &SecondValue)) + if (!Fast486FetchDword(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -1481,17 +1481,17 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAddEax) State->Flags.Af = (((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) ? TRUE : FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_LONG) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].Long = Result; + State->GeneralRegs[FAST486_REG_EAX].Long = Result; } else { - USHORT FirstValue = State->GeneralRegs[SOFT386_REG_EAX].LowWord; + USHORT FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowWord; USHORT SecondValue, Result; - if (!Soft386FetchWord(State, &SecondValue)) + if (!Fast486FetchWord(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -1507,47 +1507,47 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAddEax) State->Flags.Af = (((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) ? TRUE : FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_WORD) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowWord = Result; + State->GeneralRegs[FAST486_REG_EAX].LowWord = Result; } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeOrByteModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeOrByteModrm) { UCHAR FirstValue, SecondValue, Result; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFD) == 0x08); - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } else if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } - if (!Soft386ReadModrmByteOperands(State, + if (!Fast486ReadModrmByteOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -1564,50 +1564,50 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOrByteModrm) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmByteOperands(State, + return Fast486WriteModrmByteOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeOrModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeOrModrm) { - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFD) == 0x09); - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the address size */ AddressSize = !AddressSize; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the operand size */ OperandSize = !OperandSize; } if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_OPSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_OPSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -1618,7 +1618,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOrModrm) { ULONG FirstValue, SecondValue, Result; - if (!Soft386ReadModrmDwordOperands(State, + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -1635,19 +1635,19 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOrModrm) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_LONG) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmDwordOperands(State, + return Fast486WriteModrmDwordOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } else { USHORT FirstValue, SecondValue, Result; - if (!Soft386ReadModrmWordOperands(State, + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -1664,19 +1664,19 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOrModrm) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_WORD) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmWordOperands(State, + return Fast486WriteModrmWordOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeOrAl) +FAST486_OPCODE_HANDLER(Fast486OpcodeOrAl) { - UCHAR FirstValue = State->GeneralRegs[SOFT386_REG_EAX].LowByte; + UCHAR FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowByte; UCHAR SecondValue, Result; /* Make sure this is the right instruction */ @@ -1685,11 +1685,11 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOrAl) if (State->PrefixFlags) { /* This opcode doesn't take any prefixes */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (!Soft386FetchByte(State, &SecondValue)) + if (!Fast486FetchByte(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -1703,29 +1703,29 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOrAl) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte = Result; + State->GeneralRegs[FAST486_REG_EAX].LowByte = Result; return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeOrEax) +FAST486_OPCODE_HANDLER(Fast486OpcodeOrEax) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x0D); - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; @@ -1733,10 +1733,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOrEax) if (Size) { - ULONG FirstValue = State->GeneralRegs[SOFT386_REG_EAX].Long; + ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long; ULONG SecondValue, Result; - if (!Soft386FetchDword(State, &SecondValue)) + if (!Fast486FetchDword(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -1750,17 +1750,17 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOrEax) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_LONG) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].Long = Result; + State->GeneralRegs[FAST486_REG_EAX].Long = Result; } else { - USHORT FirstValue = State->GeneralRegs[SOFT386_REG_EAX].LowWord; + USHORT FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowWord; USHORT SecondValue, Result; - if (!Soft386FetchWord(State, &SecondValue)) + if (!Fast486FetchWord(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -1774,47 +1774,47 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOrEax) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_WORD) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowWord = Result; + State->GeneralRegs[FAST486_REG_EAX].LowWord = Result; } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeAndByteModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeAndByteModrm) { UCHAR FirstValue, SecondValue, Result; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFD) == 0x20); - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } else if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } - if (!Soft386ReadModrmByteOperands(State, + if (!Fast486ReadModrmByteOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -1831,50 +1831,50 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAndByteModrm) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmByteOperands(State, + return Fast486WriteModrmByteOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeAndModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeAndModrm) { - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFD) == 0x21); - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the address size */ AddressSize = !AddressSize; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the operand size */ OperandSize = !OperandSize; } if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_OPSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_OPSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -1885,7 +1885,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAndModrm) { ULONG FirstValue, SecondValue, Result; - if (!Soft386ReadModrmDwordOperands(State, + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -1902,19 +1902,19 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAndModrm) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_LONG) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmDwordOperands(State, + return Fast486WriteModrmDwordOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } else { USHORT FirstValue, SecondValue, Result; - if (!Soft386ReadModrmWordOperands(State, + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -1931,32 +1931,32 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAndModrm) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_WORD) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmWordOperands(State, + return Fast486WriteModrmWordOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeAndAl) +FAST486_OPCODE_HANDLER(Fast486OpcodeAndAl) { - UCHAR FirstValue = State->GeneralRegs[SOFT386_REG_EAX].LowByte; + UCHAR FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowByte; UCHAR SecondValue, Result; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x24); - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (!Soft386FetchByte(State, &SecondValue)) + if (!Fast486FetchByte(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -1970,29 +1970,29 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAndAl) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte = Result; + State->GeneralRegs[FAST486_REG_EAX].LowByte = Result; return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeAndEax) +FAST486_OPCODE_HANDLER(Fast486OpcodeAndEax) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x25); - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; @@ -2000,10 +2000,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAndEax) if (Size) { - ULONG FirstValue = State->GeneralRegs[SOFT386_REG_EAX].Long; + ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long; ULONG SecondValue, Result; - if (!Soft386FetchDword(State, &SecondValue)) + if (!Fast486FetchDword(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -2017,17 +2017,17 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAndEax) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_LONG) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].Long = Result; + State->GeneralRegs[FAST486_REG_EAX].Long = Result; } else { - USHORT FirstValue = State->GeneralRegs[SOFT386_REG_EAX].LowWord; + USHORT FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowWord; USHORT SecondValue, Result; - if (!Soft386FetchWord(State, &SecondValue)) + if (!Fast486FetchWord(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -2041,47 +2041,47 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAndEax) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_WORD) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowWord = Result; + State->GeneralRegs[FAST486_REG_EAX].LowWord = Result; } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeXorByteModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeXorByteModrm) { UCHAR FirstValue, SecondValue, Result; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFD) == 0x30); - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } else if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } - if (!Soft386ReadModrmByteOperands(State, + if (!Fast486ReadModrmByteOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -2098,50 +2098,50 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXorByteModrm) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmByteOperands(State, + return Fast486WriteModrmByteOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeXorModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeXorModrm) { - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFD) == 0x31); - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the address size */ AddressSize = !AddressSize; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the operand size */ OperandSize = !OperandSize; } if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_OPSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_OPSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -2152,7 +2152,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXorModrm) { ULONG FirstValue, SecondValue, Result; - if (!Soft386ReadModrmDwordOperands(State, + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -2169,19 +2169,19 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXorModrm) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_LONG) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmDwordOperands(State, + return Fast486WriteModrmDwordOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } else { USHORT FirstValue, SecondValue, Result; - if (!Soft386ReadModrmWordOperands(State, + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -2198,19 +2198,19 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXorModrm) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_WORD) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmWordOperands(State, + return Fast486WriteModrmWordOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeXorAl) +FAST486_OPCODE_HANDLER(Fast486OpcodeXorAl) { - UCHAR FirstValue = State->GeneralRegs[SOFT386_REG_EAX].LowByte; + UCHAR FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowByte; UCHAR SecondValue, Result; /* Make sure this is the right instruction */ @@ -2219,11 +2219,11 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXorAl) if (State->PrefixFlags) { /* This opcode doesn't take any prefixes */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (!Soft386FetchByte(State, &SecondValue)) + if (!Fast486FetchByte(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -2237,29 +2237,29 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXorAl) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte = Result; + State->GeneralRegs[FAST486_REG_EAX].LowByte = Result; return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeXorEax) +FAST486_OPCODE_HANDLER(Fast486OpcodeXorEax) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x35); - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; @@ -2267,10 +2267,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXorEax) if (Size) { - ULONG FirstValue = State->GeneralRegs[SOFT386_REG_EAX].Long; + ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long; ULONG SecondValue, Result; - if (!Soft386FetchDword(State, &SecondValue)) + if (!Fast486FetchDword(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -2284,17 +2284,17 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXorEax) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_LONG) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].Long = Result; + State->GeneralRegs[FAST486_REG_EAX].Long = Result; } else { - USHORT FirstValue = State->GeneralRegs[SOFT386_REG_EAX].LowWord; + USHORT FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowWord; USHORT SecondValue, Result; - if (!Soft386FetchWord(State, &SecondValue)) + if (!Fast486FetchWord(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -2308,47 +2308,47 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXorEax) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_WORD) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowWord = Result; + State->GeneralRegs[FAST486_REG_EAX].LowWord = Result; } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeTestByteModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeTestByteModrm) { UCHAR FirstValue, SecondValue, Result; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x84); - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } else if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } - if (!Soft386ReadModrmByteOperands(State, + if (!Fast486ReadModrmByteOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -2364,47 +2364,47 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeTestByteModrm) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* The result is discarded */ return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeTestModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeTestModrm) { - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x85); - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the address size */ AddressSize = !AddressSize; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the operand size */ OperandSize = !OperandSize; } if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_OPSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_OPSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -2415,7 +2415,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeTestModrm) { ULONG FirstValue, SecondValue, Result; - if (!Soft386ReadModrmDwordOperands(State, + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -2432,13 +2432,13 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeTestModrm) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_LONG) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); } else { USHORT FirstValue, SecondValue, Result; - if (!Soft386ReadModrmWordOperands(State, + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -2455,16 +2455,16 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeTestModrm) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_WORD) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); } /* The result is discarded */ return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeTestAl) +FAST486_OPCODE_HANDLER(Fast486OpcodeTestAl) { - UCHAR FirstValue = State->GeneralRegs[SOFT386_REG_EAX].LowByte; + UCHAR FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowByte; UCHAR SecondValue, Result; /* Make sure this is the right instruction */ @@ -2473,11 +2473,11 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeTestAl) if (State->PrefixFlags) { /* This opcode doesn't take any prefixes */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (!Soft386FetchByte(State, &SecondValue)) + if (!Fast486FetchByte(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -2491,27 +2491,27 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeTestAl) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* The result is discarded */ return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeTestEax) +FAST486_OPCODE_HANDLER(Fast486OpcodeTestEax) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0xA9); - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; @@ -2519,10 +2519,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeTestEax) if (Size) { - ULONG FirstValue = State->GeneralRegs[SOFT386_REG_EAX].Long; + ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long; ULONG SecondValue, Result; - if (!Soft386FetchDword(State, &SecondValue)) + if (!Fast486FetchDword(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -2536,14 +2536,14 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeTestEax) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_LONG) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); } else { - USHORT FirstValue = State->GeneralRegs[SOFT386_REG_EAX].LowWord; + USHORT FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowWord; USHORT SecondValue, Result; - if (!Soft386FetchWord(State, &SecondValue)) + if (!Fast486FetchWord(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -2557,45 +2557,45 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeTestEax) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_WORD) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); } /* The result is discarded */ return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeXchgByteModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeXchgByteModrm) { UCHAR FirstValue, SecondValue; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x86); - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } else if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } - if (!Soft386ReadModrmByteOperands(State, + if (!Fast486ReadModrmByteOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -2605,7 +2605,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXchgByteModrm) } /* Write the value from the register to the R/M */ - if (!Soft386WriteModrmByteOperands(State, + if (!Fast486WriteModrmByteOperands(State, &ModRegRm, FALSE, FirstValue)) @@ -2615,7 +2615,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXchgByteModrm) } /* Write the value from the R/M to the register */ - if (!Soft386WriteModrmByteOperands(State, + if (!Fast486WriteModrmByteOperands(State, &ModRegRm, TRUE, SecondValue)) @@ -2627,41 +2627,41 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXchgByteModrm) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeXchgModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeXchgModrm) { - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x87); - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the address size */ AddressSize = !AddressSize; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the operand size */ OperandSize = !OperandSize; } if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_OPSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_OPSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -2672,7 +2672,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXchgModrm) { ULONG FirstValue, SecondValue; - if (!Soft386ReadModrmDwordOperands(State, + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -2682,7 +2682,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXchgModrm) } /* Write the value from the register to the R/M */ - if (!Soft386WriteModrmDwordOperands(State, + if (!Fast486WriteModrmDwordOperands(State, &ModRegRm, FALSE, FirstValue)) @@ -2692,7 +2692,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXchgModrm) } /* Write the value from the R/M to the register */ - if (!Soft386WriteModrmDwordOperands(State, + if (!Fast486WriteModrmDwordOperands(State, &ModRegRm, TRUE, SecondValue)) @@ -2705,7 +2705,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXchgModrm) { USHORT FirstValue, SecondValue; - if (!Soft386ReadModrmWordOperands(State, + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -2715,7 +2715,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXchgModrm) } /* Write the value from the register to the R/M */ - if (!Soft386WriteModrmWordOperands(State, + if (!Fast486WriteModrmWordOperands(State, &ModRegRm, FALSE, FirstValue)) @@ -2725,7 +2725,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXchgModrm) } /* Write the value from the R/M to the register */ - if (!Soft386WriteModrmWordOperands(State, + if (!Fast486WriteModrmWordOperands(State, &ModRegRm, TRUE, SecondValue)) @@ -2739,64 +2739,64 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXchgModrm) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodePushEs) +FAST486_OPCODE_HANDLER(Fast486OpcodePushEs) { /* Call the internal API */ - return Soft386StackPush(State, State->SegmentRegs[SOFT386_REG_ES].Selector); + return Fast486StackPush(State, State->SegmentRegs[FAST486_REG_ES].Selector); } -SOFT386_OPCODE_HANDLER(Soft386OpcodePopEs) +FAST486_OPCODE_HANDLER(Fast486OpcodePopEs) { ULONG NewSelector; - if (!Soft386StackPop(State, &NewSelector)) + if (!Fast486StackPop(State, &NewSelector)) { /* Exception occurred */ return FALSE; } /* Call the internal API */ - return Soft386LoadSegment(State, SOFT386_REG_ES, LOWORD(NewSelector)); + return Fast486LoadSegment(State, FAST486_REG_ES, LOWORD(NewSelector)); } -SOFT386_OPCODE_HANDLER(Soft386OpcodePushCs) +FAST486_OPCODE_HANDLER(Fast486OpcodePushCs) { /* Call the internal API */ - return Soft386StackPush(State, State->SegmentRegs[SOFT386_REG_CS].Selector); + return Fast486StackPush(State, State->SegmentRegs[FAST486_REG_CS].Selector); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeAdcByteModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeAdcByteModrm) { UCHAR FirstValue, SecondValue, Result; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFD) == 0x10); - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } else if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } - if (!Soft386ReadModrmByteOperands(State, + if (!Fast486ReadModrmByteOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -2819,50 +2819,50 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAdcByteModrm) State->Flags.Af = (((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) ? TRUE : FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmByteOperands(State, + return Fast486WriteModrmByteOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeAdcModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeAdcModrm) { - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFD) == 0x11); - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the address size */ AddressSize = !AddressSize; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the operand size */ OperandSize = !OperandSize; } if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_OPSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_OPSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -2873,7 +2873,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAdcModrm) { ULONG FirstValue, SecondValue, Result; - if (!Soft386ReadModrmDwordOperands(State, + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -2896,19 +2896,19 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAdcModrm) State->Flags.Af = (((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) ? TRUE : FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_LONG) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmDwordOperands(State, + return Fast486WriteModrmDwordOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } else { USHORT FirstValue, SecondValue, Result; - if (!Soft386ReadModrmWordOperands(State, + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -2931,20 +2931,20 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAdcModrm) State->Flags.Af = (((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) ? TRUE : FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_WORD) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmWordOperands(State, + return Fast486WriteModrmWordOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeAdcAl) +FAST486_OPCODE_HANDLER(Fast486OpcodeAdcAl) { - UCHAR FirstValue = State->GeneralRegs[SOFT386_REG_EAX].LowByte; + UCHAR FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowByte; UCHAR SecondValue, Result; /* Make sure this is the right instruction */ @@ -2953,11 +2953,11 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAdcAl) if (State->PrefixFlags) { /* This opcode doesn't take any prefixes */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (!Soft386FetchByte(State, &SecondValue)) + if (!Fast486FetchByte(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -2977,29 +2977,29 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAdcAl) State->Flags.Af = (((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) ? TRUE : FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte = Result; + State->GeneralRegs[FAST486_REG_EAX].LowByte = Result; return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeAdcEax) +FAST486_OPCODE_HANDLER(Fast486OpcodeAdcEax) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x15); - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; @@ -3007,10 +3007,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAdcEax) if (Size) { - ULONG FirstValue = State->GeneralRegs[SOFT386_REG_EAX].Long; + ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long; ULONG SecondValue, Result; - if (!Soft386FetchDword(State, &SecondValue)) + if (!Fast486FetchDword(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -3030,17 +3030,17 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAdcEax) State->Flags.Af = (((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) ? TRUE : FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_LONG) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].Long = Result; + State->GeneralRegs[FAST486_REG_EAX].Long = Result; } else { - USHORT FirstValue = State->GeneralRegs[SOFT386_REG_EAX].LowWord; + USHORT FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowWord; USHORT SecondValue, Result; - if (!Soft386FetchWord(State, &SecondValue)) + if (!Fast486FetchWord(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -3060,59 +3060,59 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAdcEax) State->Flags.Af = (((FirstValue & 0x0F) + (SecondValue & 0x0F)) & 0x10) ? TRUE : FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_WORD) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowWord = Result; + State->GeneralRegs[FAST486_REG_EAX].LowWord = Result; } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodePushSs) +FAST486_OPCODE_HANDLER(Fast486OpcodePushSs) { /* Call the internal API */ - return Soft386StackPush(State, State->SegmentRegs[SOFT386_REG_SS].Selector); + return Fast486StackPush(State, State->SegmentRegs[FAST486_REG_SS].Selector); } -SOFT386_OPCODE_HANDLER(Soft386OpcodePopSs) +FAST486_OPCODE_HANDLER(Fast486OpcodePopSs) { ULONG NewSelector; - if (!Soft386StackPop(State, &NewSelector)) + if (!Fast486StackPop(State, &NewSelector)) { /* Exception occurred */ return FALSE; } /* Call the internal API */ - return Soft386LoadSegment(State, SOFT386_REG_SS, LOWORD(NewSelector)); + return Fast486LoadSegment(State, FAST486_REG_SS, LOWORD(NewSelector)); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbByteModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeSbbByteModrm) { UCHAR FirstValue, SecondValue, Result; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; INT Carry = State->Flags.Cf ? 1 : 0; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFD) == 0x18); - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } - if (!Soft386ReadModrmByteOperands(State, + if (!Fast486ReadModrmByteOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -3122,7 +3122,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbByteModrm) } /* Check if this is the instruction that writes to R/M */ - if (!(Opcode & SOFT386_OPCODE_WRITE_REG)) + if (!(Opcode & FAST486_OPCODE_WRITE_REG)) { /* Swap the order */ FirstValue ^= SecondValue; @@ -3140,40 +3140,40 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbByteModrm) State->Flags.Af = (FirstValue & 0x0F) < ((SecondValue + 1) & 0x0F); State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmByteOperands(State, + return Fast486WriteModrmByteOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeSbbModrm) { - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; INT Carry = State->Flags.Cf ? 1 : 0; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFD) == 0x19); - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the address size */ AddressSize = !AddressSize; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the operand size */ OperandSize = !OperandSize; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -3184,7 +3184,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbModrm) { ULONG FirstValue, SecondValue, Result; - if (!Soft386ReadModrmDwordOperands(State, + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -3194,7 +3194,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbModrm) } /* Check if this is the instruction that writes to R/M */ - if (!(Opcode & SOFT386_OPCODE_WRITE_REG)) + if (!(Opcode & FAST486_OPCODE_WRITE_REG)) { /* Swap the order */ FirstValue ^= SecondValue; @@ -3212,19 +3212,19 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbModrm) State->Flags.Af = (FirstValue & 0x0F) < ((SecondValue + 1) & 0x0F); State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_LONG) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmDwordOperands(State, + return Fast486WriteModrmDwordOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } else { USHORT FirstValue, SecondValue, Result; - if (!Soft386ReadModrmWordOperands(State, + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -3234,7 +3234,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbModrm) } /* Check if this is the instruction that writes to R/M */ - if (!(Opcode & SOFT386_OPCODE_WRITE_REG)) + if (!(Opcode & FAST486_OPCODE_WRITE_REG)) { /* Swap the order */ FirstValue ^= SecondValue; @@ -3252,19 +3252,19 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbModrm) State->Flags.Af = (FirstValue & 0x0F) < ((SecondValue + 1) & 0x0F); State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_WORD) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmWordOperands(State, + return Fast486WriteModrmWordOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbAl) +FAST486_OPCODE_HANDLER(Fast486OpcodeSbbAl) { - UCHAR FirstValue = State->GeneralRegs[SOFT386_REG_EAX].LowByte; + UCHAR FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowByte; UCHAR SecondValue, Result; INT Carry = State->Flags.Cf ? 1 : 0; @@ -3274,11 +3274,11 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbAl) if (State->PrefixFlags) { /* This opcode doesn't take any prefixes */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (!Soft386FetchByte(State, &SecondValue)) + if (!Fast486FetchByte(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -3294,31 +3294,31 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbAl) State->Flags.Af = (FirstValue & 0x0F) < ((SecondValue + 1) & 0x0F); State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte = Result; + State->GeneralRegs[FAST486_REG_EAX].LowByte = Result; return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbEax) +FAST486_OPCODE_HANDLER(Fast486OpcodeSbbEax) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; INT Carry = State->Flags.Cf ? 1 : 0; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x1D); - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; @@ -3326,10 +3326,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbEax) if (Size) { - ULONG FirstValue = State->GeneralRegs[SOFT386_REG_EAX].Long; + ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long; ULONG SecondValue, Result; - if (!Soft386FetchDword(State, &SecondValue)) + if (!Fast486FetchDword(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -3345,17 +3345,17 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbEax) State->Flags.Af = (FirstValue & 0x0F) < ((SecondValue + Carry) & 0x0F); State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_LONG) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].Long = Result; + State->GeneralRegs[FAST486_REG_EAX].Long = Result; } else { - USHORT FirstValue = State->GeneralRegs[SOFT386_REG_EAX].LowWord; + USHORT FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowWord; USHORT SecondValue, Result; - if (!Soft386FetchWord(State, &SecondValue)) + if (!Fast486FetchWord(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -3371,39 +3371,39 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbEax) State->Flags.Af = (FirstValue & 0x0F) < ((SecondValue + Carry) & 0x0F); State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_WORD) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowWord = Result; + State->GeneralRegs[FAST486_REG_EAX].LowWord = Result; } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodePushDs) +FAST486_OPCODE_HANDLER(Fast486OpcodePushDs) { /* Call the internal API */ - return Soft386StackPush(State, State->SegmentRegs[SOFT386_REG_DS].Selector); + return Fast486StackPush(State, State->SegmentRegs[FAST486_REG_DS].Selector); } -SOFT386_OPCODE_HANDLER(Soft386OpcodePopDs) +FAST486_OPCODE_HANDLER(Fast486OpcodePopDs) { ULONG NewSelector; - if (!Soft386StackPop(State, &NewSelector)) + if (!Fast486StackPop(State, &NewSelector)) { /* Exception occurred */ return FALSE; } /* Call the internal API */ - return Soft386LoadSegment(State, SOFT386_REG_DS, LOWORD(NewSelector)); + return Fast486LoadSegment(State, FAST486_REG_DS, LOWORD(NewSelector)); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeDaa) +FAST486_OPCODE_HANDLER(Fast486OpcodeDaa) { - UCHAR Value = State->GeneralRegs[SOFT386_REG_EAX].LowByte; + UCHAR Value = State->GeneralRegs[FAST486_REG_EAX].LowByte; BOOLEAN Carry = State->Flags.Cf; /* Clear the carry flag */ @@ -3413,8 +3413,8 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeDaa) if (((Value & 0x0F) > 9) || State->Flags.Af) { /* Correct it */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte += 0x06; - if (State->GeneralRegs[SOFT386_REG_EAX].LowByte < 0x06) + State->GeneralRegs[FAST486_REG_EAX].LowByte += 0x06; + if (State->GeneralRegs[FAST486_REG_EAX].LowByte < 0x06) { /* A carry occurred */ State->Flags.Cf = TRUE; @@ -3428,7 +3428,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeDaa) if ((Value > 0x99) || Carry) { /* Correct it */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte += 0x60; + State->GeneralRegs[FAST486_REG_EAX].LowByte += 0x60; /* There was a carry */ State->Flags.Cf = TRUE; @@ -3437,38 +3437,38 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeDaa) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubByteModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeCmpSubByteModrm) { UCHAR FirstValue, SecondValue, Result; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xED) == 0x28); - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } else if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } - if (!Soft386ReadModrmByteOperands(State, + if (!Fast486ReadModrmByteOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -3478,7 +3478,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubByteModrm) } /* Check if this is the instruction that writes to R/M */ - if (!(Opcode & SOFT386_OPCODE_WRITE_REG)) + if (!(Opcode & FAST486_OPCODE_WRITE_REG)) { /* Swap the order */ FirstValue ^= SecondValue; @@ -3496,15 +3496,15 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubByteModrm) State->Flags.Af = (FirstValue & 0x0F) < (SecondValue & 0x0F); State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Check if this is not a CMP */ if (!(Opcode & 0x10)) { /* Write back the result */ - return Soft386WriteModrmByteOperands(State, + return Fast486WriteModrmByteOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } else @@ -3514,41 +3514,41 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubByteModrm) } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeCmpSubModrm) { - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xED) == 0x29); - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the address size */ AddressSize = !AddressSize; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the operand size */ OperandSize = !OperandSize; } if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_OPSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_OPSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -3559,7 +3559,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubModrm) { ULONG FirstValue, SecondValue, Result; - if (!Soft386ReadModrmDwordOperands(State, + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -3569,7 +3569,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubModrm) } /* Check if this is the instruction that writes to R/M */ - if (!(Opcode & SOFT386_OPCODE_WRITE_REG)) + if (!(Opcode & FAST486_OPCODE_WRITE_REG)) { /* Swap the order */ FirstValue ^= SecondValue; @@ -3587,15 +3587,15 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubModrm) State->Flags.Af = (FirstValue & 0x0F) < (SecondValue & 0x0F); State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_LONG) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Check if this is not a CMP */ if (!(Opcode & 0x10)) { /* Write back the result */ - return Soft386WriteModrmDwordOperands(State, + return Fast486WriteModrmDwordOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } else @@ -3608,7 +3608,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubModrm) { USHORT FirstValue, SecondValue, Result; - if (!Soft386ReadModrmWordOperands(State, + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -3618,7 +3618,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubModrm) } /* Check if this is the instruction that writes to R/M */ - if (!(Opcode & SOFT386_OPCODE_WRITE_REG)) + if (!(Opcode & FAST486_OPCODE_WRITE_REG)) { /* Swap the order */ FirstValue ^= SecondValue; @@ -3636,15 +3636,15 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubModrm) State->Flags.Af = (FirstValue & 0x0F) < (SecondValue & 0x0F); State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_WORD) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Check if this is not a CMP */ if (!(Opcode & 0x10)) { /* Write back the result */ - return Soft386WriteModrmWordOperands(State, + return Fast486WriteModrmWordOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } else @@ -3655,9 +3655,9 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubModrm) } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubAl) +FAST486_OPCODE_HANDLER(Fast486OpcodeCmpSubAl) { - UCHAR FirstValue = State->GeneralRegs[SOFT386_REG_EAX].LowByte; + UCHAR FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowByte; UCHAR SecondValue, Result; /* Make sure this is the right instruction */ @@ -3666,11 +3666,11 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubAl) if (State->PrefixFlags) { /* This opcode doesn't take any prefixes */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (!Soft386FetchByte(State, &SecondValue)) + if (!Fast486FetchByte(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -3686,33 +3686,33 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubAl) State->Flags.Af = (FirstValue & 0x0F) < (SecondValue & 0x0F); State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Check if this is not a CMP */ if (!(Opcode & 0x10)) { /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte = Result; + State->GeneralRegs[FAST486_REG_EAX].LowByte = Result; } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubEax) +FAST486_OPCODE_HANDLER(Fast486OpcodeCmpSubEax) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xEF) == 0x2D); - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; @@ -3720,10 +3720,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubEax) if (Size) { - ULONG FirstValue = State->GeneralRegs[SOFT386_REG_EAX].Long; + ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long; ULONG SecondValue, Result; - if (!Soft386FetchDword(State, &SecondValue)) + if (!Fast486FetchDword(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -3739,21 +3739,21 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubEax) State->Flags.Af = (FirstValue & 0x0F) < (SecondValue & 0x0F); State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_LONG) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Check if this is not a CMP */ if (!(Opcode & 0x10)) { /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].Long = Result; + State->GeneralRegs[FAST486_REG_EAX].Long = Result; } } else { - USHORT FirstValue = State->GeneralRegs[SOFT386_REG_EAX].LowWord; + USHORT FirstValue = State->GeneralRegs[FAST486_REG_EAX].LowWord; USHORT SecondValue, Result; - if (!Soft386FetchWord(State, &SecondValue)) + if (!Fast486FetchWord(State, &SecondValue)) { /* Exception occurred */ return FALSE; @@ -3769,22 +3769,22 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubEax) State->Flags.Af = (FirstValue & 0x0F) < (SecondValue & 0x0F); State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_WORD) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Check if this is not a CMP */ if (!(Opcode & 0x10)) { /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowWord = Result; + State->GeneralRegs[FAST486_REG_EAX].LowWord = Result; } } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeDas) +FAST486_OPCODE_HANDLER(Fast486OpcodeDas) { - UCHAR Value = State->GeneralRegs[SOFT386_REG_EAX].LowByte; + UCHAR Value = State->GeneralRegs[FAST486_REG_EAX].LowByte; BOOLEAN Carry = State->Flags.Cf; /* Clear the carry flag */ @@ -3794,8 +3794,8 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeDas) if (((Value & 0x0F) > 9) || State->Flags.Af) { /* Correct it */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte -= 0x06; - if (State->GeneralRegs[SOFT386_REG_EAX].LowByte > 0xFB) + State->GeneralRegs[FAST486_REG_EAX].LowByte -= 0x06; + if (State->GeneralRegs[FAST486_REG_EAX].LowByte > 0xFB) { /* A borrow occurred */ State->Flags.Cf = TRUE; @@ -3809,7 +3809,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeDas) if ((Value > 0x99) || Carry) { /* Correct it */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte -= 0x60; + State->GeneralRegs[FAST486_REG_EAX].LowByte -= 0x60; /* There was a borrow */ State->Flags.Cf = TRUE; @@ -3818,9 +3818,9 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeDas) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeAaa) +FAST486_OPCODE_HANDLER(Fast486OpcodeAaa) { - UCHAR Value = State->GeneralRegs[SOFT386_REG_EAX].LowByte; + UCHAR Value = State->GeneralRegs[FAST486_REG_EAX].LowByte; /* * Check if the value in AL is not a valid BCD digit, @@ -3829,8 +3829,8 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAaa) if (((Value & 0x0F) > 9) || State->Flags.Af) { /* Correct it */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte += 0x06; - State->GeneralRegs[SOFT386_REG_EAX].HighByte++; + State->GeneralRegs[FAST486_REG_EAX].LowByte += 0x06; + State->GeneralRegs[FAST486_REG_EAX].HighByte++; /* Set CF and AF */ State->Flags.Cf = State->Flags.Af = TRUE; @@ -3842,14 +3842,14 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAaa) } /* Keep only the lowest 4 bits of AL */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte &= 0x0F; + State->GeneralRegs[FAST486_REG_EAX].LowByte &= 0x0F; return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeAas) +FAST486_OPCODE_HANDLER(Fast486OpcodeAas) { - UCHAR Value = State->GeneralRegs[SOFT386_REG_EAX].LowByte; + UCHAR Value = State->GeneralRegs[FAST486_REG_EAX].LowByte; /* * Check if the value in AL is not a valid BCD digit, @@ -3858,8 +3858,8 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAas) if (((Value & 0x0F) > 9) || State->Flags.Af) { /* Correct it */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte -= 0x06; - State->GeneralRegs[SOFT386_REG_EAX].HighByte--; + State->GeneralRegs[FAST486_REG_EAX].LowByte -= 0x06; + State->GeneralRegs[FAST486_REG_EAX].HighByte--; /* Set CF and AF */ State->Flags.Cf = State->Flags.Af = TRUE; @@ -3871,40 +3871,40 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAas) } /* Keep only the lowest 4 bits of AL */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte &= 0x0F; + State->GeneralRegs[FAST486_REG_EAX].LowByte &= 0x0F; return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodePushAll) +FAST486_OPCODE_HANDLER(Fast486OpcodePushAll) { INT i; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; - SOFT386_REG SavedEsp = State->GeneralRegs[SOFT386_REG_ESP]; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; + FAST486_REG SavedEsp = State->GeneralRegs[FAST486_REG_ESP]; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x60); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Push all the registers in order */ - for (i = 0; i < SOFT386_NUM_GEN_REGS; i++) + for (i = 0; i < FAST486_NUM_GEN_REGS; i++) { - if (i == SOFT386_REG_ESP) + if (i == FAST486_REG_ESP) { /* Use the saved ESP instead */ - if (!Soft386StackPush(State, Size ? SavedEsp.Long : SavedEsp.LowWord)) + if (!Fast486StackPush(State, Size ? SavedEsp.Long : SavedEsp.LowWord)) { /* Exception occurred */ return FALSE; @@ -3913,7 +3913,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePushAll) else { /* Push the register */ - if (!Soft386StackPush(State, Size ? State->GeneralRegs[i].Long + if (!Fast486StackPush(State, Size ? State->GeneralRegs[i].Long : State->GeneralRegs[i].LowWord)) { /* Exception occurred */ @@ -3925,40 +3925,40 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePushAll) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodePopAll) +FAST486_OPCODE_HANDLER(Fast486OpcodePopAll) { INT i; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; ULONG Value; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x61); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Pop all the registers in reverse order */ - for (i = SOFT386_NUM_GEN_REGS - 1; i >= 0; i--) + for (i = FAST486_NUM_GEN_REGS - 1; i >= 0; i--) { /* Pop the value */ - if (!Soft386StackPop(State, &Value)) + if (!Fast486StackPop(State, &Value)) { /* Exception occurred */ return FALSE; } /* Don't modify ESP */ - if (i != SOFT386_REG_ESP) + if (i != FAST486_REG_ESP) { if (Size) State->GeneralRegs[i].Long = Value; else State->GeneralRegs[i].LowWord = LOWORD(Value); @@ -3968,7 +3968,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePopAll) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeBound) +FAST486_OPCODE_HANDLER(Fast486OpcodeBound) { // TODO: NOT IMPLEMENTED UNIMPLEMENTED; @@ -3976,36 +3976,36 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeBound) return FALSE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeArpl) +FAST486_OPCODE_HANDLER(Fast486OpcodeArpl) { USHORT FirstValue, SecondValue; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (!(State->ControlRegisters[SOFT386_REG_CR0] & SOFT386_CR0_PE) + if (!(State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE) || State->Flags.Vm - || (State->PrefixFlags & SOFT386_PREFIX_LOCK)) + || (State->PrefixFlags & FAST486_PREFIX_LOCK)) { /* Cannot be used in real mode or with a LOCK prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } /* Read the operands */ - if (!Soft386ReadModrmWordOperands(State, + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -4025,7 +4025,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeArpl) State->Flags.Zf = TRUE; /* Write back the result */ - return Soft386WriteModrmWordOperands(State, &ModRegRm, FALSE, SecondValue); + return Fast486WriteModrmWordOperands(State, &ModRegRm, FALSE, SecondValue); } else { @@ -4035,21 +4035,21 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeArpl) } } -SOFT386_OPCODE_HANDLER(Soft386OpcodePushImm) +FAST486_OPCODE_HANDLER(Fast486OpcodePushImm) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x68); - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; @@ -4059,56 +4059,56 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePushImm) { ULONG Data; - if (!Soft386FetchDword(State, &Data)) + if (!Fast486FetchDword(State, &Data)) { /* Exception occurred */ return FALSE; } /* Call the internal API */ - return Soft386StackPush(State, Data); + return Fast486StackPush(State, Data); } else { USHORT Data; - if (!Soft386FetchWord(State, &Data)) + if (!Fast486FetchWord(State, &Data)) { /* Exception occurred */ return FALSE; } /* Call the internal API */ - return Soft386StackPush(State, Data); + return Fast486StackPush(State, Data); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeImulModrmImm) +FAST486_OPCODE_HANDLER(Fast486OpcodeImulModrmImm) { BOOLEAN OperandSize, AddressSize; - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; LONG Multiplier; LONGLONG Product; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFD) == 0x69); - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the address size */ AddressSize = !AddressSize; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the operand size */ OperandSize = !OperandSize; } /* Fetch the parameters */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -4119,7 +4119,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeImulModrmImm) CHAR Byte; /* Fetch the immediate operand */ - if (!Soft386FetchByte(State, (PUCHAR)&Byte)) + if (!Fast486FetchByte(State, (PUCHAR)&Byte)) { /* Exception occurred */ return FALSE; @@ -4134,7 +4134,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeImulModrmImm) LONG Dword; /* Fetch the immediate operand */ - if (!Soft386FetchDword(State, (PULONG)&Dword)) + if (!Fast486FetchDword(State, (PULONG)&Dword)) { /* Exception occurred */ return FALSE; @@ -4147,7 +4147,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeImulModrmImm) SHORT Word; /* Fetch the immediate operand */ - if (!Soft386FetchWord(State, (PUSHORT)&Word)) + if (!Fast486FetchWord(State, (PUSHORT)&Word)) { /* Exception occurred */ return FALSE; @@ -4162,7 +4162,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeImulModrmImm) LONG RegValue, Multiplicand; /* Read the operands */ - if (!Soft386ReadModrmDwordOperands(State, + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, (PULONG)&RegValue, (PULONG)&Multiplicand)) @@ -4179,7 +4179,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeImulModrmImm) SHORT RegValue, Multiplicand; /* Read the operands */ - if (!Soft386ReadModrmWordOperands(State, + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, (PUSHORT)&RegValue, (PUSHORT)&Multiplicand)) @@ -4200,61 +4200,61 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeImulModrmImm) else State->Flags.Cf = State->Flags.Of = FALSE; /* Write-back the result */ - return Soft386WriteModrmDwordOperands(State, + return Fast486WriteModrmDwordOperands(State, &ModRegRm, TRUE, (ULONG)((LONG)Product)); } -SOFT386_OPCODE_HANDLER(Soft386OpcodePushByteImm) +FAST486_OPCODE_HANDLER(Fast486OpcodePushByteImm) { UCHAR Data; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x6A); - if (!Soft386FetchByte(State, &Data)) + if (!Fast486FetchByte(State, &Data)) { /* Exception occurred */ return FALSE; } /* Call the internal API */ - return Soft386StackPush(State, Data); + return Fast486StackPush(State, Data); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovByteModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeMovByteModrm) { UCHAR FirstValue, SecondValue, Result; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFD) == 0x88); - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } else if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } - if (!Soft386ReadModrmByteOperands(State, + if (!Fast486ReadModrmByteOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -4263,52 +4263,52 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovByteModrm) return FALSE; } - if (Opcode & SOFT386_OPCODE_WRITE_REG) Result = SecondValue; + if (Opcode & FAST486_OPCODE_WRITE_REG) Result = SecondValue; else Result = FirstValue; /* Write back the result */ - return Soft386WriteModrmByteOperands(State, + return Fast486WriteModrmByteOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovModrm) +FAST486_OPCODE_HANDLER(Fast486OpcodeMovModrm) { - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFD) == 0x89); - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the address size */ AddressSize = !AddressSize; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the operand size */ OperandSize = !OperandSize; } if (State->PrefixFlags - & ~(SOFT386_PREFIX_ADSIZE - | SOFT386_PREFIX_OPSIZE - | SOFT386_PREFIX_SEG - | SOFT386_PREFIX_LOCK)) + & ~(FAST486_PREFIX_ADSIZE + | FAST486_PREFIX_OPSIZE + | FAST486_PREFIX_SEG + | FAST486_PREFIX_LOCK)) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -4319,7 +4319,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovModrm) { ULONG FirstValue, SecondValue, Result; - if (!Soft386ReadModrmDwordOperands(State, + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -4328,20 +4328,20 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovModrm) return FALSE; } - if (Opcode & SOFT386_OPCODE_WRITE_REG) Result = SecondValue; + if (Opcode & FAST486_OPCODE_WRITE_REG) Result = SecondValue; else Result = FirstValue; /* Write back the result */ - return Soft386WriteModrmDwordOperands(State, + return Fast486WriteModrmDwordOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } else { USHORT FirstValue, SecondValue, Result; - if (!Soft386ReadModrmWordOperands(State, + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &FirstValue, &SecondValue)) @@ -4350,93 +4350,93 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovModrm) return FALSE; } - if (Opcode & SOFT386_OPCODE_WRITE_REG) Result = SecondValue; + if (Opcode & FAST486_OPCODE_WRITE_REG) Result = SecondValue; else Result = FirstValue; /* Write back the result */ - return Soft386WriteModrmWordOperands(State, + return Fast486WriteModrmWordOperands(State, &ModRegRm, - Opcode & SOFT386_OPCODE_WRITE_REG, + Opcode & FAST486_OPCODE_WRITE_REG, Result); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovStoreSeg) +FAST486_OPCODE_HANDLER(Fast486OpcodeMovStoreSeg) { BOOLEAN OperandSize, AddressSize; - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x8C); - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the address size */ AddressSize = !AddressSize; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the operand size */ OperandSize = !OperandSize; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } - if (ModRegRm.Register >= SOFT386_NUM_SEG_REGS) + if (ModRegRm.Register >= FAST486_NUM_SEG_REGS) { /* Invalid */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } if (OperandSize) { - return Soft386WriteModrmDwordOperands(State, + return Fast486WriteModrmDwordOperands(State, &ModRegRm, FALSE, State->SegmentRegs[ModRegRm.Register].Selector); } else { - return Soft386WriteModrmWordOperands(State, + return Fast486WriteModrmWordOperands(State, &ModRegRm, FALSE, State->SegmentRegs[ModRegRm.Register].Selector); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeLea) +FAST486_OPCODE_HANDLER(Fast486OpcodeLea) { - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x8D); - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the address size */ AddressSize = !AddressSize; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the operand size */ OperandSize = !OperandSize; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -4446,21 +4446,21 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeLea) if (!ModRegRm.Memory) { /* Invalid */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Write the address to the register */ if (OperandSize) { - return Soft386WriteModrmDwordOperands(State, + return Fast486WriteModrmDwordOperands(State, &ModRegRm, TRUE, ModRegRm.MemoryAddress); } else { - return Soft386WriteModrmWordOperands(State, + return Fast486WriteModrmWordOperands(State, &ModRegRm, TRUE, ModRegRm.MemoryAddress); @@ -4468,40 +4468,40 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeLea) } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovLoadSeg) +FAST486_OPCODE_HANDLER(Fast486OpcodeMovLoadSeg) { BOOLEAN OperandSize, AddressSize; - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x8E); - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the address size */ AddressSize = !AddressSize; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the operand size */ OperandSize = !OperandSize; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } - if ((ModRegRm.Register >= SOFT386_NUM_SEG_REGS) - || ((SOFT386_SEG_REGS)ModRegRm.Register == SOFT386_REG_CS)) + if ((ModRegRm.Register >= FAST486_NUM_SEG_REGS) + || ((FAST486_SEG_REGS)ModRegRm.Register == FAST486_REG_CS)) { /* Invalid */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -4509,133 +4509,133 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovLoadSeg) { ULONG Dummy, Selector; - if (!Soft386ReadModrmDwordOperands(State, &ModRegRm, &Dummy, &Selector)) + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &Dummy, &Selector)) { /* Exception occurred */ return FALSE; } - return Soft386LoadSegment(State, ModRegRm.Register, LOWORD(Selector)); + return Fast486LoadSegment(State, ModRegRm.Register, LOWORD(Selector)); } else { USHORT Dummy, Selector; - if (!Soft386ReadModrmWordOperands(State, &ModRegRm, &Dummy, &Selector)) + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &Dummy, &Selector)) { /* Exception occurred */ return FALSE; } - return Soft386LoadSegment(State, ModRegRm.Register, Selector); + return Fast486LoadSegment(State, ModRegRm.Register, Selector); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeCwde) +FAST486_OPCODE_HANDLER(Fast486OpcodeCwde) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x98); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } if (Size) { /* Sign extend AX to EAX */ - State->GeneralRegs[SOFT386_REG_EAX].Long = MAKELONG + State->GeneralRegs[FAST486_REG_EAX].Long = MAKELONG ( - State->GeneralRegs[SOFT386_REG_EAX].LowWord, - (State->GeneralRegs[SOFT386_REG_EAX].LowWord & SIGN_FLAG_WORD) + State->GeneralRegs[FAST486_REG_EAX].LowWord, + (State->GeneralRegs[FAST486_REG_EAX].LowWord & SIGN_FLAG_WORD) ? 0xFFFF : 0x0000 ); } else { /* Sign extend AL to AX */ - State->GeneralRegs[SOFT386_REG_EAX].HighByte = - (State->GeneralRegs[SOFT386_REG_EAX].LowByte & SIGN_FLAG_BYTE) + State->GeneralRegs[FAST486_REG_EAX].HighByte = + (State->GeneralRegs[FAST486_REG_EAX].LowByte & SIGN_FLAG_BYTE) ? 0xFF : 0x00; } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeCdq) +FAST486_OPCODE_HANDLER(Fast486OpcodeCdq) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x99); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } if (Size) { /* Sign extend EAX to EDX:EAX */ - State->GeneralRegs[SOFT386_REG_EDX].Long = - (State->GeneralRegs[SOFT386_REG_EAX].Long & SIGN_FLAG_LONG) + State->GeneralRegs[FAST486_REG_EDX].Long = + (State->GeneralRegs[FAST486_REG_EAX].Long & SIGN_FLAG_LONG) ? 0xFFFFFFFF : 0x00000000; } else { /* Sign extend AX to DX:AX */ - State->GeneralRegs[SOFT386_REG_EDX].LowWord = - (State->GeneralRegs[SOFT386_REG_EAX].LowWord & SIGN_FLAG_WORD) + State->GeneralRegs[FAST486_REG_EDX].LowWord = + (State->GeneralRegs[FAST486_REG_EAX].LowWord & SIGN_FLAG_WORD) ? 0xFFFF : 0x0000; } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeCallAbs) +FAST486_OPCODE_HANDLER(Fast486OpcodeCallAbs) { USHORT Segment = 0; ULONG Offset = 0; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0x9A); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Fetch the offset */ if (Size) { - if (!Soft386FetchDword(State, &Offset)) + if (!Fast486FetchDword(State, &Offset)) { /* Exception occurred */ return FALSE; @@ -4643,7 +4643,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCallAbs) } else { - if (!Soft386FetchWord(State, (PUSHORT)&Offset)) + if (!Fast486FetchWord(State, (PUSHORT)&Offset)) { /* Exception occurred */ return FALSE; @@ -4651,28 +4651,28 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCallAbs) } /* Fetch the segment */ - if (!Soft386FetchWord(State, &Segment)) + if (!Fast486FetchWord(State, &Segment)) { /* Exception occurred */ return FALSE; } /* Push the current code segment selector */ - if (!Soft386StackPush(State, State->SegmentRegs[SOFT386_REG_CS].Selector)) + if (!Fast486StackPush(State, State->SegmentRegs[FAST486_REG_CS].Selector)) { /* Exception occurred */ return FALSE; } /* Push the current value of the instruction pointer */ - if (!Soft386StackPush(State, State->InstPtr.Long)) + if (!Fast486StackPush(State, State->InstPtr.Long)) { /* Exception occurred */ return FALSE; } /* Load the new CS */ - if (!Soft386LoadSegment(State, SOFT386_REG_CS, Segment)) + if (!Fast486LoadSegment(State, FAST486_REG_CS, Segment)) { /* Exception occurred */ return FALSE; @@ -4685,7 +4685,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCallAbs) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeWait) +FAST486_OPCODE_HANDLER(Fast486OpcodeWait) { // TODO: NOT IMPLEMENTED UNIMPLEMENTED; @@ -4693,18 +4693,18 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeWait) return FALSE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodePushFlags) +FAST486_OPCODE_HANDLER(Fast486OpcodePushFlags) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* This OPSIZE prefix toggles the size */ Size = !Size; @@ -4714,36 +4714,36 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePushFlags) if (State->Flags.Vm && (State->Flags.Iopl != 3)) { /* Call the VM86 monitor */ - Soft386ExceptionWithErrorCode(State, SOFT386_EXCEPTION_GP, 0); + Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_GP, 0); return FALSE; } /* Push the flags */ - if (Size) return Soft386StackPush(State, State->Flags.Long); - else return Soft386StackPush(State, LOWORD(State->Flags.Long)); + if (Size) return Fast486StackPush(State, State->Flags.Long); + else return Fast486StackPush(State, LOWORD(State->Flags.Long)); } -SOFT386_OPCODE_HANDLER(Soft386OpcodePopFlags) +FAST486_OPCODE_HANDLER(Fast486OpcodePopFlags) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; - INT Cpl = Soft386GetCurrentPrivLevel(State); + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; + INT Cpl = Fast486GetCurrentPrivLevel(State); ULONG NewFlags; - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* This OPSIZE prefix toggles the size */ Size = !Size; } /* Pop the new flags */ - if (!Soft386StackPop(State, &NewFlags)) + if (!Fast486StackPop(State, &NewFlags)) { /* Exception occurred */ return FALSE; @@ -4848,7 +4848,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePopFlags) else { /* Call the VM86 monitor */ - Soft386ExceptionWithErrorCode(State, SOFT386_EXCEPTION_GP, 0); + Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_GP, 0); } } @@ -4856,14 +4856,14 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodePopFlags) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeSahf) +FAST486_OPCODE_HANDLER(Fast486OpcodeSahf) { /* Make sure this is the right instruction */ ASSERT(Opcode == 0x9E); /* Set the low-order byte of FLAGS to AH */ State->Flags.Long &= 0xFFFFFF00; - State->Flags.Long |= State->GeneralRegs[SOFT386_REG_EAX].HighByte; + State->Flags.Long |= State->GeneralRegs[FAST486_REG_EAX].HighByte; /* Restore the reserved bits of FLAGS */ State->Flags.AlwaysSet = TRUE; @@ -4872,34 +4872,34 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeSahf) return FALSE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeLahf) +FAST486_OPCODE_HANDLER(Fast486OpcodeLahf) { /* Make sure this is the right instruction */ ASSERT(Opcode == 0x9F); /* Set AH to the low-order byte of FLAGS */ - State->GeneralRegs[SOFT386_REG_EAX].HighByte = LOBYTE(State->Flags.Long); + State->GeneralRegs[FAST486_REG_EAX].HighByte = LOBYTE(State->Flags.Long); return FALSE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeRet) +FAST486_OPCODE_HANDLER(Fast486OpcodeRet) { ULONG ReturnAddress; USHORT BytesToPop = 0; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFE) == 0xC2); - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; @@ -4908,46 +4908,46 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeRet) if (Opcode == 0xC2) { /* Fetch the number of bytes to pop after the return */ - if (!Soft386FetchWord(State, &BytesToPop)) return FALSE; + if (!Fast486FetchWord(State, &BytesToPop)) return FALSE; } /* Pop the return address */ - if (!Soft386StackPop(State, &ReturnAddress)) return FALSE; + if (!Fast486StackPop(State, &ReturnAddress)) return FALSE; /* Return to the calling procedure, and if necessary, pop the parameters */ if (Size) { State->InstPtr.Long = ReturnAddress; - State->GeneralRegs[SOFT386_REG_ESP].Long += BytesToPop; + State->GeneralRegs[FAST486_REG_ESP].Long += BytesToPop; } else { State->InstPtr.LowWord = LOWORD(ReturnAddress); - State->GeneralRegs[SOFT386_REG_ESP].LowWord += BytesToPop; + State->GeneralRegs[FAST486_REG_ESP].LowWord += BytesToPop; } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeLdsLes) +FAST486_OPCODE_HANDLER(Fast486OpcodeLdsLes) { UCHAR FarPointer[6]; BOOLEAN OperandSize, AddressSize; - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFE) == 0xC4); - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } /* Get the operands */ - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -4957,14 +4957,14 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeLdsLes) { /* Check if this is a BOP and the host supports BOPs */ if ((Opcode == 0xC4) - && (ModRegRm.Register == SOFT386_REG_EAX) - && (ModRegRm.SecondRegister == SOFT386_REG_ESP) + && (ModRegRm.Register == FAST486_REG_EAX) + && (ModRegRm.SecondRegister == FAST486_REG_ESP) && (State->BopCallback != NULL)) { USHORT BopCode; /* Fetch the BOP code */ - if (!Soft386FetchWord(State, &BopCode)) + if (!Fast486FetchWord(State, &BopCode)) { /* Exception occurred */ return FALSE; @@ -4978,13 +4978,13 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeLdsLes) } /* Invalid */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (!Soft386ReadMemory(State, - (State->PrefixFlags & SOFT386_PREFIX_SEG) - ? State->SegmentOverride : SOFT386_REG_DS, + if (!Fast486ReadMemory(State, + (State->PrefixFlags & FAST486_PREFIX_SEG) + ? State->SegmentOverride : FAST486_REG_DS, ModRegRm.MemoryAddress, FALSE, FarPointer, @@ -5003,9 +5003,9 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeLdsLes) State->GeneralRegs[ModRegRm.Register].Long = Offset; /* Load the segment */ - return Soft386LoadSegment(State, + return Fast486LoadSegment(State, (Opcode == 0xC4) - ? SOFT386_REG_ES : SOFT386_REG_DS, + ? FAST486_REG_ES : FAST486_REG_DS, Segment); } else @@ -5017,101 +5017,101 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeLdsLes) State->GeneralRegs[ModRegRm.Register].LowWord = Offset; /* Load the segment */ - return Soft386LoadSegment(State, + return Fast486LoadSegment(State, (Opcode == 0xC4) - ? SOFT386_REG_ES : SOFT386_REG_DS, + ? FAST486_REG_ES : FAST486_REG_DS, Segment); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeEnter) +FAST486_OPCODE_HANDLER(Fast486OpcodeEnter) { INT i; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; USHORT FrameSize; UCHAR NestingLevel; - SOFT386_REG FramePointer; + FAST486_REG FramePointer; /* Make sure this is the right instruction */ ASSERT(Opcode == 0xC8); - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (!Soft386FetchWord(State, &FrameSize)) + if (!Fast486FetchWord(State, &FrameSize)) { /* Exception occurred */ return FALSE; } - if (!Soft386FetchByte(State, &NestingLevel)) + if (!Fast486FetchByte(State, &NestingLevel)) { /* Exception occurred */ return FALSE; } /* Push EBP */ - if (!Soft386StackPush(State, State->GeneralRegs[SOFT386_REG_EBP].Long)) + if (!Fast486StackPush(State, State->GeneralRegs[FAST486_REG_EBP].Long)) { /* Exception occurred */ return FALSE; } /* Save ESP */ - FramePointer = State->GeneralRegs[SOFT386_REG_ESP]; + FramePointer = State->GeneralRegs[FAST486_REG_ESP]; /* Set up the nested procedure stacks */ for (i = 1; i < NestingLevel; i++) { if (Size) { - State->GeneralRegs[SOFT386_REG_EBP].Long -= 4; - Soft386StackPush(State, State->GeneralRegs[SOFT386_REG_EBP].Long); + State->GeneralRegs[FAST486_REG_EBP].Long -= 4; + Fast486StackPush(State, State->GeneralRegs[FAST486_REG_EBP].Long); } else { - State->GeneralRegs[SOFT386_REG_EBP].LowWord -= 2; - Soft386StackPush(State, State->GeneralRegs[SOFT386_REG_EBP].LowWord); + State->GeneralRegs[FAST486_REG_EBP].LowWord -= 2; + Fast486StackPush(State, State->GeneralRegs[FAST486_REG_EBP].LowWord); } } - if (NestingLevel > 0) Soft386StackPush(State, FramePointer.Long); + if (NestingLevel > 0) Fast486StackPush(State, FramePointer.Long); /* Set EBP to the frame pointer */ - State->GeneralRegs[SOFT386_REG_EBP] = FramePointer; + State->GeneralRegs[FAST486_REG_EBP] = FramePointer; /* Reserve space for the frame */ - if (Size) State->GeneralRegs[SOFT386_REG_ESP].Long -= (ULONG)FrameSize; - else State->GeneralRegs[SOFT386_REG_ESP].LowWord -= FrameSize; + if (Size) State->GeneralRegs[FAST486_REG_ESP].Long -= (ULONG)FrameSize; + else State->GeneralRegs[FAST486_REG_ESP].LowWord -= FrameSize; return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeLeave) +FAST486_OPCODE_HANDLER(Fast486OpcodeLeave) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0xC9); - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; @@ -5120,73 +5120,73 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeLeave) if (Size) { /* Set the stack pointer (ESP) to the base pointer (EBP) */ - State->GeneralRegs[SOFT386_REG_ESP].Long = State->GeneralRegs[SOFT386_REG_EBP].Long; + State->GeneralRegs[FAST486_REG_ESP].Long = State->GeneralRegs[FAST486_REG_EBP].Long; /* Pop the saved base pointer from the stack */ - return Soft386StackPop(State, &State->GeneralRegs[SOFT386_REG_EBP].Long); + return Fast486StackPop(State, &State->GeneralRegs[FAST486_REG_EBP].Long); } else { ULONG Value; /* Set the stack pointer (SP) to the base pointer (BP) */ - State->GeneralRegs[SOFT386_REG_ESP].LowWord = State->GeneralRegs[SOFT386_REG_EBP].LowWord; + State->GeneralRegs[FAST486_REG_ESP].LowWord = State->GeneralRegs[FAST486_REG_EBP].LowWord; /* Pop the saved base pointer from the stack */ - if (Soft386StackPop(State, &Value)) + if (Fast486StackPop(State, &Value)) { - State->GeneralRegs[SOFT386_REG_EBP].LowWord = LOWORD(Value); + State->GeneralRegs[FAST486_REG_EBP].LowWord = LOWORD(Value); return TRUE; } else return FALSE; } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeRetFar) +FAST486_OPCODE_HANDLER(Fast486OpcodeRetFar) { ULONG Segment = 0; ULONG Offset = 0; USHORT BytesToPop = 0; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFE) == 0xCA); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } if (Opcode == 0xCA) { /* Fetch the number of bytes to pop after the return */ - if (!Soft386FetchWord(State, &BytesToPop)) return FALSE; + if (!Fast486FetchWord(State, &BytesToPop)) return FALSE; } /* Pop the offset */ - if (!Soft386StackPop(State, &Offset)) + if (!Fast486StackPop(State, &Offset)) { /* Exception occurred */ return FALSE; } /* Pop the segment */ - if (!Soft386StackPop(State, &Segment)) + if (!Fast486StackPop(State, &Segment)) { /* Exception occurred */ return FALSE; } /* Load the new CS */ - if (!Soft386LoadSegment(State, SOFT386_REG_CS, Segment)) + if (!Fast486LoadSegment(State, FAST486_REG_CS, Segment)) { /* Exception occurred */ return FALSE; @@ -5196,21 +5196,21 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeRetFar) if (Size) { State->InstPtr.Long = Offset; - State->GeneralRegs[SOFT386_REG_ESP].Long += BytesToPop; + State->GeneralRegs[FAST486_REG_ESP].Long += BytesToPop; } else { State->InstPtr.LowWord = LOWORD(Offset); - State->GeneralRegs[SOFT386_REG_ESP].LowWord += BytesToPop; + State->GeneralRegs[FAST486_REG_ESP].LowWord += BytesToPop; } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeInt) +FAST486_OPCODE_HANDLER(Fast486OpcodeInt) { UCHAR IntNum; - SOFT386_IDT_ENTRY IdtEntry; + FAST486_IDT_ENTRY IdtEntry; switch (Opcode) { @@ -5224,7 +5224,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeInt) case 0xCD: { /* Fetch the interrupt number */ - if (!Soft386FetchByte(State, &IntNum)) + if (!Fast486FetchByte(State, &IntNum)) { /* Exception occurred */ return FALSE; @@ -5239,7 +5239,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeInt) if (!State->Flags.Of) return TRUE; /* Exception #OF */ - IntNum = SOFT386_EXCEPTION_OF; + IntNum = FAST486_EXCEPTION_OF; break; } @@ -5252,14 +5252,14 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeInt) } /* Get the interrupt vector */ - if (!Soft386GetIntVector(State, IntNum, &IdtEntry)) + if (!Fast486GetIntVector(State, IntNum, &IdtEntry)) { /* Exception occurred */ return FALSE; } /* Perform the interrupt */ - if (!Soft386InterruptInternal(State, + if (!Fast486InterruptInternal(State, IdtEntry.Selector, MAKELONG(IdtEntry.Offset, IdtEntry.OffsetHigh), IdtEntry.Type)) @@ -5271,54 +5271,54 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeInt) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeIret) +FAST486_OPCODE_HANDLER(Fast486OpcodeIret) { INT i; ULONG InstPtr, CodeSel, StackPtr, StackSel; - SOFT386_FLAGS_REG NewFlags; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_FLAGS_REG NewFlags; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0xCF); - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } /* Pop EIP */ - if (!Soft386StackPop(State, &InstPtr)) + if (!Fast486StackPop(State, &InstPtr)) { /* Exception occurred */ return FALSE; } /* Pop CS */ - if (!Soft386StackPop(State, &CodeSel)) + if (!Fast486StackPop(State, &CodeSel)) { /* Exception occurred */ return FALSE; } /* Pop EFLAGS */ - if (!Soft386StackPop(State, &NewFlags.Long)) + if (!Fast486StackPop(State, &NewFlags.Long)) { /* Exception occurred */ return FALSE; } /* Check for protected mode */ - if (State->ControlRegisters[SOFT386_REG_CR0] & SOFT386_CR0_PE) + if (State->ControlRegisters[FAST486_REG_CR0] & FAST486_CR0_PE) { - INT Cpl = Soft386GetCurrentPrivLevel(State); + INT Cpl = Fast486GetCurrentPrivLevel(State); if (State->Flags.Vm) { @@ -5331,7 +5331,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIret) State->InstPtr.Long = LOWORD(InstPtr); /* Load new CS */ - if (!Soft386LoadSegment(State, SOFT386_REG_CS, CodeSel)) + if (!Fast486LoadSegment(State, FAST486_REG_CS, CodeSel)) { /* Exception occurred */ return FALSE; @@ -5346,7 +5346,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIret) else { /* Call the VM86 monitor */ - Soft386ExceptionWithErrorCode(State, SOFT386_EXCEPTION_GP, 0); + Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_GP, 0); return FALSE; } @@ -5367,12 +5367,12 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIret) ULONG Es, Ds, Fs, Gs; /* Pop ESP, SS, ES, FS, GS */ - if (!Soft386StackPop(State, &StackPtr)) return FALSE; - if (!Soft386StackPop(State, &StackSel)) return FALSE; - if (!Soft386StackPop(State, &Es)) return FALSE; - if (!Soft386StackPop(State, &Ds)) return FALSE; - if (!Soft386StackPop(State, &Fs)) return FALSE; - if (!Soft386StackPop(State, &Gs)) return FALSE; + if (!Fast486StackPop(State, &StackPtr)) return FALSE; + if (!Fast486StackPop(State, &StackSel)) return FALSE; + if (!Fast486StackPop(State, &Es)) return FALSE; + if (!Fast486StackPop(State, &Ds)) return FALSE; + if (!Fast486StackPop(State, &Fs)) return FALSE; + if (!Fast486StackPop(State, &Gs)) return FALSE; /* Set the new IP */ State->InstPtr.Long = LOWORD(InstPtr); @@ -5383,18 +5383,18 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIret) State->Flags.AlwaysSet = State->Flags.Vm = TRUE; /* Load the new segments */ - if (!Soft386LoadSegment(State, SOFT386_REG_CS, CodeSel)) return FALSE; - if (!Soft386LoadSegment(State, SOFT386_REG_SS, StackSel)) return FALSE; - if (!Soft386LoadSegment(State, SOFT386_REG_ES, Es)) return FALSE; - if (!Soft386LoadSegment(State, SOFT386_REG_DS, Ds)) return FALSE; - if (!Soft386LoadSegment(State, SOFT386_REG_FS, Fs)) return FALSE; - if (!Soft386LoadSegment(State, SOFT386_REG_GS, Gs)) return FALSE; + if (!Fast486LoadSegment(State, FAST486_REG_CS, CodeSel)) return FALSE; + if (!Fast486LoadSegment(State, FAST486_REG_SS, StackSel)) return FALSE; + if (!Fast486LoadSegment(State, FAST486_REG_ES, Es)) return FALSE; + if (!Fast486LoadSegment(State, FAST486_REG_DS, Ds)) return FALSE; + if (!Fast486LoadSegment(State, FAST486_REG_FS, Fs)) return FALSE; + if (!Fast486LoadSegment(State, FAST486_REG_GS, Gs)) return FALSE; return TRUE; } /* Load the new CS */ - if (!Soft386LoadSegment(State, SOFT386_REG_CS, CodeSel)) + if (!Fast486LoadSegment(State, FAST486_REG_CS, CodeSel)) { /* Exception occurred */ return FALSE; @@ -5407,29 +5407,29 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIret) if (GET_SEGMENT_RPL(CodeSel) > Cpl) { /* Pop ESP */ - if (!Soft386StackPop(State, &StackPtr)) + if (!Fast486StackPop(State, &StackPtr)) { /* Exception */ return FALSE; } /* Pop SS */ - if (!Soft386StackPop(State, &StackSel)) + if (!Fast486StackPop(State, &StackSel)) { /* Exception */ return FALSE; } /* Load new SS */ - if (!Soft386LoadSegment(State, SOFT386_REG_SS, StackSel)) + if (!Fast486LoadSegment(State, FAST486_REG_SS, StackSel)) { /* Exception */ return FALSE; } /* Set ESP */ - if (Size) State->GeneralRegs[SOFT386_REG_ESP].Long = StackPtr; - else State->GeneralRegs[SOFT386_REG_ESP].LowWord = LOWORD(StackPtr); + if (Size) State->GeneralRegs[FAST486_REG_ESP].Long = StackPtr; + else State->GeneralRegs[FAST486_REG_ESP].LowWord = LOWORD(StackPtr); } /* Set the new flags */ @@ -5444,20 +5444,20 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIret) if (GET_SEGMENT_RPL(CodeSel) > Cpl) { /* Update the CPL */ - Cpl = Soft386GetCurrentPrivLevel(State); + Cpl = Fast486GetCurrentPrivLevel(State); /* Check segment security */ - for (i = 0; i <= SOFT386_NUM_SEG_REGS; i++) + for (i = 0; i <= FAST486_NUM_SEG_REGS; i++) { /* Don't check CS or SS */ - if ((i == SOFT386_REG_CS) || (i == SOFT386_REG_SS)) continue; + if ((i == FAST486_REG_CS) || (i == FAST486_REG_SS)) continue; if ((Cpl > State->SegmentRegs[i].Dpl) && (!State->SegmentRegs[i].Executable || !State->SegmentRegs[i].DirConf)) { /* Load the NULL descriptor in the segment */ - if (!Soft386LoadSegment(State, i, 0)) return FALSE; + if (!Fast486LoadSegment(State, i, 0)) return FALSE; } } } @@ -5467,7 +5467,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIret) if (Size && (InstPtr & 0xFFFF0000)) { /* Invalid */ - Soft386ExceptionWithErrorCode(State, SOFT386_EXCEPTION_GP, 0); + Fast486ExceptionWithErrorCode(State, FAST486_EXCEPTION_GP, 0); return FALSE; } @@ -5475,7 +5475,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIret) State->InstPtr.Long = InstPtr; /* Load new CS */ - if (!Soft386LoadSegment(State, SOFT386_REG_CS, CodeSel)) + if (!Fast486LoadSegment(State, FAST486_REG_CS, CodeSel)) { /* Exception occurred */ return FALSE; @@ -5490,20 +5490,20 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIret) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeAam) +FAST486_OPCODE_HANDLER(Fast486OpcodeAam) { UCHAR Base; - UCHAR Value = State->GeneralRegs[SOFT386_REG_EAX].LowByte; + UCHAR Value = State->GeneralRegs[FAST486_REG_EAX].LowByte; - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Fetch the base */ - if (!Soft386FetchByte(State, &Base)) + if (!Fast486FetchByte(State, &Base)) { /* Exception occurred */ return FALSE; @@ -5513,70 +5513,70 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeAam) if (Base == 0) { /* Divide error */ - Soft386Exception(State, SOFT386_EXCEPTION_DE); + Fast486Exception(State, FAST486_EXCEPTION_DE); return FALSE; } /* Adjust */ - State->GeneralRegs[SOFT386_REG_EAX].HighByte = Value / Base; - State->GeneralRegs[SOFT386_REG_EAX].LowByte = Value %= Base; + State->GeneralRegs[FAST486_REG_EAX].HighByte = Value / Base; + State->GeneralRegs[FAST486_REG_EAX].LowByte = Value %= Base; /* Update flags */ State->Flags.Zf = (Value == 0) ? TRUE : FALSE; State->Flags.Sf = (Value & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Value); + State->Flags.Pf = Fast486CalculateParity(Value); return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeAad) +FAST486_OPCODE_HANDLER(Fast486OpcodeAad) { UCHAR Base; - UCHAR Value = State->GeneralRegs[SOFT386_REG_EAX].LowByte; + UCHAR Value = State->GeneralRegs[FAST486_REG_EAX].LowByte; - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Fetch the base */ - if (!Soft386FetchByte(State, &Base)) + if (!Fast486FetchByte(State, &Base)) { /* Exception occurred */ return FALSE; } /* Adjust */ - Value += State->GeneralRegs[SOFT386_REG_EAX].HighByte * Base; - State->GeneralRegs[SOFT386_REG_EAX].LowByte = Value; + Value += State->GeneralRegs[FAST486_REG_EAX].HighByte * Base; + State->GeneralRegs[FAST486_REG_EAX].LowByte = Value; /* Update flags */ State->Flags.Zf = (Value == 0) ? TRUE : FALSE; State->Flags.Sf = (Value & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Value); + State->Flags.Pf = Fast486CalculateParity(Value); return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeXlat) +FAST486_OPCODE_HANDLER(Fast486OpcodeXlat) { UCHAR Value; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } /* Read a byte from DS:[(E)BX + AL] */ - if (!Soft386ReadMemory(State, - SOFT386_REG_DS, - AddressSize ? State->GeneralRegs[SOFT386_REG_EBX].Long - : State->GeneralRegs[SOFT386_REG_EBX].LowWord - + State->GeneralRegs[SOFT386_REG_EAX].LowByte, + if (!Fast486ReadMemory(State, + FAST486_REG_DS, + AddressSize ? State->GeneralRegs[FAST486_REG_EBX].Long + : State->GeneralRegs[FAST486_REG_EBX].LowWord + + State->GeneralRegs[FAST486_REG_EAX].LowByte, FALSE, &Value, sizeof(UCHAR))) @@ -5586,36 +5586,36 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeXlat) } /* Set AL to the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte = Value; + State->GeneralRegs[FAST486_REG_EAX].LowByte = Value; /* Return success */ return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeLoop) +FAST486_OPCODE_HANDLER(Fast486OpcodeLoop) { BOOLEAN Condition; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; CHAR Offset = 0; /* Make sure this is the right instruction */ ASSERT((Opcode >= 0xE0) && (Opcode <= 0xE2)); - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (Size) Condition = ((--State->GeneralRegs[SOFT386_REG_ECX].Long) != 0); - else Condition = ((--State->GeneralRegs[SOFT386_REG_ECX].LowWord) != 0); + if (Size) Condition = ((--State->GeneralRegs[FAST486_REG_ECX].Long) != 0); + else Condition = ((--State->GeneralRegs[FAST486_REG_ECX].LowWord) != 0); if (Opcode == 0xE0) { @@ -5630,7 +5630,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeLoop) } /* Fetch the offset */ - if (!Soft386FetchByte(State, (PUCHAR)&Offset)) + if (!Fast486FetchByte(State, (PUCHAR)&Offset)) { /* An exception occurred */ return FALSE; @@ -5645,33 +5645,33 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeLoop) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeJecxz) +FAST486_OPCODE_HANDLER(Fast486OpcodeJecxz) { BOOLEAN Condition; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; CHAR Offset = 0; /* Make sure this is the right instruction */ ASSERT(Opcode == 0xE3); - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (Size) Condition = (State->GeneralRegs[SOFT386_REG_ECX].Long == 0); - else Condition = (State->GeneralRegs[SOFT386_REG_ECX].LowWord == 0); + if (Size) Condition = (State->GeneralRegs[FAST486_REG_ECX].Long == 0); + else Condition = (State->GeneralRegs[FAST486_REG_ECX].LowWord == 0); /* Fetch the offset */ - if (!Soft386FetchByte(State, (PUCHAR)&Offset)) + if (!Fast486FetchByte(State, (PUCHAR)&Offset)) { /* An exception occurred */ return FALSE; @@ -5686,23 +5686,23 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeJecxz) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeCall) +FAST486_OPCODE_HANDLER(Fast486OpcodeCall) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0xE8); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -5711,14 +5711,14 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCall) LONG Offset = 0; /* Fetch the offset */ - if (!Soft386FetchDword(State, (PULONG)&Offset)) + if (!Fast486FetchDword(State, (PULONG)&Offset)) { /* An exception occurred */ return FALSE; } /* Push the current value of the instruction pointer */ - if (!Soft386StackPush(State, State->InstPtr.Long)) + if (!Fast486StackPush(State, State->InstPtr.Long)) { /* Exception occurred */ return FALSE; @@ -5732,14 +5732,14 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCall) SHORT Offset = 0; /* Fetch the offset */ - if (!Soft386FetchWord(State, (PUSHORT)&Offset)) + if (!Fast486FetchWord(State, (PUSHORT)&Offset)) { /* An exception occurred */ return FALSE; } /* Push the current value of the instruction pointer */ - if (!Soft386StackPush(State, State->InstPtr.Long)) + if (!Fast486StackPush(State, State->InstPtr.Long)) { /* Exception occurred */ return FALSE; @@ -5752,23 +5752,23 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCall) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeJmp) +FAST486_OPCODE_HANDLER(Fast486OpcodeJmp) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0xE9); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -5777,7 +5777,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeJmp) LONG Offset = 0; /* Fetch the offset */ - if (!Soft386FetchDword(State, (PULONG)&Offset)) + if (!Fast486FetchDword(State, (PULONG)&Offset)) { /* An exception occurred */ return FALSE; @@ -5791,7 +5791,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeJmp) SHORT Offset = 0; /* Fetch the offset */ - if (!Soft386FetchWord(State, (PUSHORT)&Offset)) + if (!Fast486FetchWord(State, (PUSHORT)&Offset)) { /* An exception occurred */ return FALSE; @@ -5804,32 +5804,32 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeJmp) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeJmpAbs) +FAST486_OPCODE_HANDLER(Fast486OpcodeJmpAbs) { USHORT Segment = 0; ULONG Offset = 0; - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0xEA); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; } - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Fetch the offset */ if (Size) { - if (!Soft386FetchDword(State, &Offset)) + if (!Fast486FetchDword(State, &Offset)) { /* Exception occurred */ return FALSE; @@ -5837,7 +5837,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeJmpAbs) } else { - if (!Soft386FetchWord(State, (PUSHORT)&Offset)) + if (!Fast486FetchWord(State, (PUSHORT)&Offset)) { /* Exception occurred */ return FALSE; @@ -5845,14 +5845,14 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeJmpAbs) } /* Fetch the segment */ - if (!Soft386FetchWord(State, &Segment)) + if (!Fast486FetchWord(State, &Segment)) { /* Exception occurred */ return FALSE; } /* Load the new CS */ - if (!Soft386LoadSegment(State, SOFT386_REG_CS, Segment)) + if (!Fast486LoadSegment(State, FAST486_REG_CS, Segment)) { /* Exception occurred */ return FALSE; @@ -5865,15 +5865,15 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeJmpAbs) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovAlOffset) +FAST486_OPCODE_HANDLER(Fast486OpcodeMovAlOffset) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; ULONG Offset; /* Make sure this is the right instruction */ ASSERT(Opcode == 0xA0); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; @@ -5881,7 +5881,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovAlOffset) if (Size) { - if (!Soft386FetchDword(State, &Offset)) + if (!Fast486FetchDword(State, &Offset)) { /* Exception occurred */ return FALSE; @@ -5891,7 +5891,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovAlOffset) { USHORT WordOffset; - if (!Soft386FetchWord(State, &WordOffset)) + if (!Fast486FetchWord(State, &WordOffset)) { /* Exception occurred */ return FALSE; @@ -5901,23 +5901,23 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovAlOffset) } /* Read from memory */ - return Soft386ReadMemory(State, - (State->PrefixFlags & SOFT386_PREFIX_SEG) ? - State->SegmentOverride : SOFT386_REG_DS, + return Fast486ReadMemory(State, + (State->PrefixFlags & FAST486_PREFIX_SEG) ? + State->SegmentOverride : FAST486_REG_DS, Offset, FALSE, - &State->GeneralRegs[SOFT386_REG_EAX].LowByte, + &State->GeneralRegs[FAST486_REG_EAX].LowByte, sizeof(UCHAR)); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovEaxOffset) +FAST486_OPCODE_HANDLER(Fast486OpcodeMovEaxOffset) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0xA1); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; @@ -5927,51 +5927,51 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovEaxOffset) { ULONG Offset; - if (!Soft386FetchDword(State, &Offset)) + if (!Fast486FetchDword(State, &Offset)) { /* Exception occurred */ return FALSE; } /* Read from memory */ - return Soft386ReadMemory(State, - (State->PrefixFlags & SOFT386_PREFIX_SEG) ? - State->SegmentOverride : SOFT386_REG_DS, + return Fast486ReadMemory(State, + (State->PrefixFlags & FAST486_PREFIX_SEG) ? + State->SegmentOverride : FAST486_REG_DS, Offset, FALSE, - &State->GeneralRegs[SOFT386_REG_EAX].Long, + &State->GeneralRegs[FAST486_REG_EAX].Long, sizeof(ULONG)); } else { USHORT Offset; - if (!Soft386FetchWord(State, &Offset)) + if (!Fast486FetchWord(State, &Offset)) { /* Exception occurred */ return FALSE; } /* Read from memory */ - return Soft386ReadMemory(State, - (State->PrefixFlags & SOFT386_PREFIX_SEG) ? - State->SegmentOverride : SOFT386_REG_DS, + return Fast486ReadMemory(State, + (State->PrefixFlags & FAST486_PREFIX_SEG) ? + State->SegmentOverride : FAST486_REG_DS, Offset, FALSE, - &State->GeneralRegs[SOFT386_REG_EAX].LowWord, + &State->GeneralRegs[FAST486_REG_EAX].LowWord, sizeof(USHORT)); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovOffsetAl) +FAST486_OPCODE_HANDLER(Fast486OpcodeMovOffsetAl) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; ULONG Offset; /* Make sure this is the right instruction */ ASSERT(Opcode == 0xA2); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; @@ -5979,7 +5979,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovOffsetAl) if (Size) { - if (!Soft386FetchDword(State, &Offset)) + if (!Fast486FetchDword(State, &Offset)) { /* Exception occurred */ return FALSE; @@ -5989,7 +5989,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovOffsetAl) { USHORT WordOffset; - if (!Soft386FetchWord(State, &WordOffset)) + if (!Fast486FetchWord(State, &WordOffset)) { /* Exception occurred */ return FALSE; @@ -5999,22 +5999,22 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovOffsetAl) } /* Write to memory */ - return Soft386WriteMemory(State, - (State->PrefixFlags & SOFT386_PREFIX_SEG) ? - State->SegmentOverride : SOFT386_REG_DS, + return Fast486WriteMemory(State, + (State->PrefixFlags & FAST486_PREFIX_SEG) ? + State->SegmentOverride : FAST486_REG_DS, Offset, - &State->GeneralRegs[SOFT386_REG_EAX].LowByte, + &State->GeneralRegs[FAST486_REG_EAX].LowByte, sizeof(UCHAR)); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovOffsetEax) +FAST486_OPCODE_HANDLER(Fast486OpcodeMovOffsetEax) { - BOOLEAN Size = State->SegmentRegs[SOFT386_REG_CS].Size; + BOOLEAN Size = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT(Opcode == 0xA3); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ Size = !Size; @@ -6024,82 +6024,82 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovOffsetEax) { ULONG Offset; - if (!Soft386FetchDword(State, &Offset)) + if (!Fast486FetchDword(State, &Offset)) { /* Exception occurred */ return FALSE; } /* Write to memory */ - return Soft386WriteMemory(State, - (State->PrefixFlags & SOFT386_PREFIX_SEG) ? - State->SegmentOverride : SOFT386_REG_DS, + return Fast486WriteMemory(State, + (State->PrefixFlags & FAST486_PREFIX_SEG) ? + State->SegmentOverride : FAST486_REG_DS, Offset, - &State->GeneralRegs[SOFT386_REG_EAX].Long, + &State->GeneralRegs[FAST486_REG_EAX].Long, sizeof(ULONG)); } else { USHORT Offset; - if (!Soft386FetchWord(State, &Offset)) + if (!Fast486FetchWord(State, &Offset)) { /* Exception occurred */ return FALSE; } /* Write to memory */ - return Soft386WriteMemory(State, - (State->PrefixFlags & SOFT386_PREFIX_SEG) ? - State->SegmentOverride : SOFT386_REG_DS, + return Fast486WriteMemory(State, + (State->PrefixFlags & FAST486_PREFIX_SEG) ? + State->SegmentOverride : FAST486_REG_DS, Offset, - &State->GeneralRegs[SOFT386_REG_EAX].LowWord, + &State->GeneralRegs[FAST486_REG_EAX].LowWord, sizeof(USHORT)); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeSalc) +FAST486_OPCODE_HANDLER(Fast486OpcodeSalc) { /* Make sure this is the right instruction */ ASSERT(Opcode == 0xD6); - if (State->PrefixFlags & SOFT386_PREFIX_LOCK) + if (State->PrefixFlags & FAST486_PREFIX_LOCK) { /* Invalid prefix */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Set all the bits of AL to CF */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte = State->Flags.Cf ? 0xFF : 0x00; + State->GeneralRegs[FAST486_REG_EAX].LowByte = State->Flags.Cf ? 0xFF : 0x00; return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovs) +FAST486_OPCODE_HANDLER(Fast486OpcodeMovs) { ULONG Data, DataSize; BOOLEAN OperandSize, AddressSize; - SOFT386_SEG_REGS Segment = SOFT386_REG_DS; + FAST486_SEG_REGS Segment = FAST486_REG_DS; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFE) == 0xA4); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ OperandSize = !OperandSize; } - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (State->PrefixFlags & SOFT386_PREFIX_SEG) + if (State->PrefixFlags & FAST486_PREFIX_SEG) { /* Use the override segment instead of DS */ Segment = State->SegmentOverride; @@ -6109,11 +6109,11 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovs) if (Opcode == 0xA4) DataSize = sizeof(UCHAR); else DataSize = OperandSize ? sizeof(ULONG) : sizeof(USHORT); - if (State->PrefixFlags & SOFT386_PREFIX_REP) + if (State->PrefixFlags & FAST486_PREFIX_REP) { UCHAR Block[STRING_BLOCK_SIZE]; - ULONG Count = OperandSize ? State->GeneralRegs[SOFT386_REG_ECX].Long - : State->GeneralRegs[SOFT386_REG_ECX].LowWord; + ULONG Count = OperandSize ? State->GeneralRegs[FAST486_REG_ECX].Long + : State->GeneralRegs[FAST486_REG_ECX].LowWord; /* Clear the memory block */ RtlZeroMemory(Block, sizeof(Block)); @@ -6127,11 +6127,11 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovs) if (!AddressSize) { ULONG MaxBytesSrc = State->Flags.Df - ? (ULONG)State->GeneralRegs[SOFT386_REG_ESI].LowWord - : (0x10000 - (ULONG)State->GeneralRegs[SOFT386_REG_ESI].LowWord); + ? (ULONG)State->GeneralRegs[FAST486_REG_ESI].LowWord + : (0x10000 - (ULONG)State->GeneralRegs[FAST486_REG_ESI].LowWord); ULONG MaxBytesDest = State->Flags.Df - ? (ULONG)State->GeneralRegs[SOFT386_REG_EDI].LowWord - : (0x10000 - (ULONG)State->GeneralRegs[SOFT386_REG_EDI].LowWord); + ? (ULONG)State->GeneralRegs[FAST486_REG_EDI].LowWord + : (0x10000 - (ULONG)State->GeneralRegs[FAST486_REG_EDI].LowWord); Processed = min(Processed, min(MaxBytesSrc, MaxBytesDest) / DataSize); @@ -6143,44 +6143,44 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovs) /* Reduce ESI and EDI by the number of bytes to transfer */ if (AddressSize) { - State->GeneralRegs[SOFT386_REG_ESI].Long -= Processed * DataSize; - State->GeneralRegs[SOFT386_REG_EDI].Long -= Processed * DataSize; + State->GeneralRegs[FAST486_REG_ESI].Long -= Processed * DataSize; + State->GeneralRegs[FAST486_REG_EDI].Long -= Processed * DataSize; } else { - State->GeneralRegs[SOFT386_REG_ESI].LowWord -= Processed * DataSize; - State->GeneralRegs[SOFT386_REG_EDI].LowWord -= Processed * DataSize; + State->GeneralRegs[FAST486_REG_ESI].LowWord -= Processed * DataSize; + State->GeneralRegs[FAST486_REG_EDI].LowWord -= Processed * DataSize; } } /* Read from memory */ - if (!Soft386ReadMemory(State, + if (!Fast486ReadMemory(State, Segment, - AddressSize ? State->GeneralRegs[SOFT386_REG_ESI].Long - : State->GeneralRegs[SOFT386_REG_ESI].LowWord, + AddressSize ? State->GeneralRegs[FAST486_REG_ESI].Long + : State->GeneralRegs[FAST486_REG_ESI].LowWord, FALSE, Block, Processed * DataSize)) { /* Set ECX */ - if (OperandSize) State->GeneralRegs[SOFT386_REG_ECX].Long = Count; - else State->GeneralRegs[SOFT386_REG_ECX].LowWord = LOWORD(Count); + if (OperandSize) State->GeneralRegs[FAST486_REG_ECX].Long = Count; + else State->GeneralRegs[FAST486_REG_ECX].LowWord = LOWORD(Count); /* Exception occurred */ return FALSE; } /* Write to memory */ - if (!Soft386WriteMemory(State, - SOFT386_REG_ES, - AddressSize ? State->GeneralRegs[SOFT386_REG_EDI].Long - : State->GeneralRegs[SOFT386_REG_EDI].LowWord, + if (!Fast486WriteMemory(State, + FAST486_REG_ES, + AddressSize ? State->GeneralRegs[FAST486_REG_EDI].Long + : State->GeneralRegs[FAST486_REG_EDI].LowWord, Block, Processed * DataSize)) { /* Set ECX */ - if (OperandSize) State->GeneralRegs[SOFT386_REG_ECX].Long = Count; - else State->GeneralRegs[SOFT386_REG_ECX].LowWord = LOWORD(Count); + if (OperandSize) State->GeneralRegs[FAST486_REG_ECX].Long = Count; + else State->GeneralRegs[FAST486_REG_ECX].LowWord = LOWORD(Count); /* Exception occurred */ return FALSE; @@ -6191,13 +6191,13 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovs) /* Increase ESI and EDI by the number of bytes transfered */ if (AddressSize) { - State->GeneralRegs[SOFT386_REG_ESI].Long += Processed * DataSize; - State->GeneralRegs[SOFT386_REG_EDI].Long += Processed * DataSize; + State->GeneralRegs[FAST486_REG_ESI].Long += Processed * DataSize; + State->GeneralRegs[FAST486_REG_EDI].Long += Processed * DataSize; } else { - State->GeneralRegs[SOFT386_REG_ESI].LowWord += Processed * DataSize; - State->GeneralRegs[SOFT386_REG_EDI].LowWord += Processed * DataSize; + State->GeneralRegs[FAST486_REG_ESI].LowWord += Processed * DataSize; + State->GeneralRegs[FAST486_REG_EDI].LowWord += Processed * DataSize; } } @@ -6206,16 +6206,16 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovs) } /* Clear ECX */ - if (OperandSize) State->GeneralRegs[SOFT386_REG_ECX].Long = 0; - else State->GeneralRegs[SOFT386_REG_ECX].LowWord = 0; + if (OperandSize) State->GeneralRegs[FAST486_REG_ECX].Long = 0; + else State->GeneralRegs[FAST486_REG_ECX].LowWord = 0; } else { /* Read from the source operand */ - if (!Soft386ReadMemory(State, - SOFT386_REG_DS, - AddressSize ? State->GeneralRegs[SOFT386_REG_ESI].Long - : State->GeneralRegs[SOFT386_REG_ESI].LowWord, + if (!Fast486ReadMemory(State, + FAST486_REG_DS, + AddressSize ? State->GeneralRegs[FAST486_REG_ESI].Long + : State->GeneralRegs[FAST486_REG_ESI].LowWord, FALSE, &Data, DataSize)) @@ -6225,10 +6225,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovs) } /* Write to the destination operand */ - if (!Soft386WriteMemory(State, - SOFT386_REG_ES, - AddressSize ? State->GeneralRegs[SOFT386_REG_EDI].Long - : State->GeneralRegs[SOFT386_REG_EDI].LowWord, + if (!Fast486WriteMemory(State, + FAST486_REG_ES, + AddressSize ? State->GeneralRegs[FAST486_REG_EDI].Long + : State->GeneralRegs[FAST486_REG_EDI].LowWord, &Data, DataSize)) { @@ -6241,26 +6241,26 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovs) { if (!State->Flags.Df) { - State->GeneralRegs[SOFT386_REG_ESI].Long += DataSize; - State->GeneralRegs[SOFT386_REG_EDI].Long += DataSize; + State->GeneralRegs[FAST486_REG_ESI].Long += DataSize; + State->GeneralRegs[FAST486_REG_EDI].Long += DataSize; } else { - State->GeneralRegs[SOFT386_REG_ESI].Long -= DataSize; - State->GeneralRegs[SOFT386_REG_EDI].Long -= DataSize; + State->GeneralRegs[FAST486_REG_ESI].Long -= DataSize; + State->GeneralRegs[FAST486_REG_EDI].Long -= DataSize; } } else { if (!State->Flags.Df) { - State->GeneralRegs[SOFT386_REG_ESI].LowWord += DataSize; - State->GeneralRegs[SOFT386_REG_EDI].LowWord += DataSize; + State->GeneralRegs[FAST486_REG_ESI].LowWord += DataSize; + State->GeneralRegs[FAST486_REG_EDI].LowWord += DataSize; } else { - State->GeneralRegs[SOFT386_REG_ESI].LowWord -= DataSize; - State->GeneralRegs[SOFT386_REG_EDI].LowWord -= DataSize; + State->GeneralRegs[FAST486_REG_ESI].LowWord -= DataSize; + State->GeneralRegs[FAST486_REG_EDI].LowWord -= DataSize; } } } @@ -6269,31 +6269,31 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeMovs) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeCmps) +FAST486_OPCODE_HANDLER(Fast486OpcodeCmps) { ULONG FirstValue = 0, SecondValue = 0, Result; ULONG DataSize, DataMask, SignFlag; BOOLEAN OperandSize, AddressSize; - SOFT386_SEG_REGS Segment = SOFT386_REG_DS; + FAST486_SEG_REGS Segment = FAST486_REG_DS; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFE) == 0xA6); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ OperandSize = !OperandSize; } - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (State->PrefixFlags & SOFT386_PREFIX_SEG) + if (State->PrefixFlags & FAST486_PREFIX_SEG) { /* Use the override segment instead of DS */ Segment = State->SegmentOverride; @@ -6308,10 +6308,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmps) SignFlag = 1 << ((DataSize * 8) - 1); /* Read from the first source operand */ - if (!Soft386ReadMemory(State, + if (!Fast486ReadMemory(State, Segment, - AddressSize ? State->GeneralRegs[SOFT386_REG_ESI].Long - : State->GeneralRegs[SOFT386_REG_ESI].LowWord, + AddressSize ? State->GeneralRegs[FAST486_REG_ESI].Long + : State->GeneralRegs[FAST486_REG_ESI].LowWord, FALSE, &FirstValue, DataSize)) @@ -6321,10 +6321,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmps) } /* Read from the second source operand */ - if (!Soft386ReadMemory(State, - SOFT386_REG_ES, - AddressSize ? State->GeneralRegs[SOFT386_REG_EDI].Long - : State->GeneralRegs[SOFT386_REG_EDI].LowWord, + if (!Fast486ReadMemory(State, + FAST486_REG_ES, + AddressSize ? State->GeneralRegs[FAST486_REG_EDI].Long + : State->GeneralRegs[FAST486_REG_EDI].LowWord, FALSE, &SecondValue, DataSize)) @@ -6345,45 +6345,45 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmps) State->Flags.Af = (FirstValue & 0x0F) < (SecondValue & 0x0F); State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SignFlag) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Increment/decrement ESI and EDI */ if (OperandSize) { if (!State->Flags.Df) { - State->GeneralRegs[SOFT386_REG_ESI].Long += DataSize; - State->GeneralRegs[SOFT386_REG_EDI].Long += DataSize; + State->GeneralRegs[FAST486_REG_ESI].Long += DataSize; + State->GeneralRegs[FAST486_REG_EDI].Long += DataSize; } else { - State->GeneralRegs[SOFT386_REG_ESI].Long -= DataSize; - State->GeneralRegs[SOFT386_REG_EDI].Long -= DataSize; + State->GeneralRegs[FAST486_REG_ESI].Long -= DataSize; + State->GeneralRegs[FAST486_REG_EDI].Long -= DataSize; } } else { if (!State->Flags.Df) { - State->GeneralRegs[SOFT386_REG_ESI].LowWord += DataSize; - State->GeneralRegs[SOFT386_REG_EDI].LowWord += DataSize; + State->GeneralRegs[FAST486_REG_ESI].LowWord += DataSize; + State->GeneralRegs[FAST486_REG_EDI].LowWord += DataSize; } else { - State->GeneralRegs[SOFT386_REG_ESI].LowWord -= DataSize; - State->GeneralRegs[SOFT386_REG_EDI].LowWord -= DataSize; + State->GeneralRegs[FAST486_REG_ESI].LowWord -= DataSize; + State->GeneralRegs[FAST486_REG_EDI].LowWord -= DataSize; } } // FIXME: This method is slow! - if ((State->PrefixFlags & SOFT386_PREFIX_REP) - || (State->PrefixFlags & SOFT386_PREFIX_REPNZ)) + if ((State->PrefixFlags & FAST486_PREFIX_REP) + || (State->PrefixFlags & FAST486_PREFIX_REPNZ)) { BOOLEAN Repeat = TRUE; if (OperandSize) { - if ((--State->GeneralRegs[SOFT386_REG_ECX].Long) == 0) + if ((--State->GeneralRegs[FAST486_REG_ECX].Long) == 0) { /* ECX is 0 */ Repeat = FALSE; @@ -6391,15 +6391,15 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmps) } else { - if ((--State->GeneralRegs[SOFT386_REG_ECX].LowWord) == 0) + if ((--State->GeneralRegs[FAST486_REG_ECX].LowWord) == 0) { /* CX is 0 */ Repeat = FALSE; } } - if (((State->PrefixFlags & SOFT386_PREFIX_REP) && !State->Flags.Zf) - || ((State->PrefixFlags & SOFT386_PREFIX_REPNZ) && State->Flags.Zf)) + if (((State->PrefixFlags & FAST486_PREFIX_REP) && !State->Flags.Zf) + || ((State->PrefixFlags & FAST486_PREFIX_REPNZ) && State->Flags.Zf)) { /* REPZ with ZF = 0 or REPNZ with ZF = 1 */ Repeat = FALSE; @@ -6416,23 +6416,23 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeCmps) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeStos) +FAST486_OPCODE_HANDLER(Fast486OpcodeStos) { ULONG DataSize; BOOLEAN OperandSize, AddressSize; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFE) == 0xAA); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ OperandSize = !OperandSize; } - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; @@ -6442,16 +6442,16 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeStos) if (Opcode == 0xAA) DataSize = sizeof(UCHAR); else DataSize = OperandSize ? sizeof(ULONG) : sizeof(USHORT); - if (State->PrefixFlags & SOFT386_PREFIX_REP) + if (State->PrefixFlags & FAST486_PREFIX_REP) { UCHAR Block[STRING_BLOCK_SIZE]; - ULONG Count = OperandSize ? State->GeneralRegs[SOFT386_REG_ECX].Long - : State->GeneralRegs[SOFT386_REG_ECX].LowWord; + ULONG Count = OperandSize ? State->GeneralRegs[FAST486_REG_ECX].Long + : State->GeneralRegs[FAST486_REG_ECX].LowWord; /* Fill the memory block with the data */ if (DataSize == sizeof(UCHAR)) { - RtlFillMemory(Block, sizeof(Block), State->GeneralRegs[SOFT386_REG_EAX].LowByte); + RtlFillMemory(Block, sizeof(Block), State->GeneralRegs[FAST486_REG_EAX].LowByte); } else { @@ -6461,11 +6461,11 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeStos) { if (DataSize == sizeof(USHORT)) { - ((PUSHORT)Block)[i] = State->GeneralRegs[SOFT386_REG_EAX].LowWord; + ((PUSHORT)Block)[i] = State->GeneralRegs[FAST486_REG_EAX].LowWord; } else { - ((PULONG)Block)[i] = State->GeneralRegs[SOFT386_REG_EAX].Long; + ((PULONG)Block)[i] = State->GeneralRegs[FAST486_REG_EAX].Long; } } } @@ -6479,8 +6479,8 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeStos) if (!AddressSize) { ULONG MaxBytes = State->Flags.Df - ? (ULONG)State->GeneralRegs[SOFT386_REG_EDI].LowWord - : (0x10000 - (ULONG)State->GeneralRegs[SOFT386_REG_EDI].LowWord); + ? (ULONG)State->GeneralRegs[FAST486_REG_EDI].LowWord + : (0x10000 - (ULONG)State->GeneralRegs[FAST486_REG_EDI].LowWord); Processed = min(Processed, MaxBytes / DataSize); if (Processed == 0) Processed = 1; @@ -6489,21 +6489,21 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeStos) if (State->Flags.Df) { /* Reduce EDI by the number of bytes to transfer */ - if (AddressSize) State->GeneralRegs[SOFT386_REG_EDI].Long -= Processed * DataSize; - else State->GeneralRegs[SOFT386_REG_EDI].LowWord -= Processed * DataSize; + if (AddressSize) State->GeneralRegs[FAST486_REG_EDI].Long -= Processed * DataSize; + else State->GeneralRegs[FAST486_REG_EDI].LowWord -= Processed * DataSize; } /* Write to memory */ - if (!Soft386WriteMemory(State, - SOFT386_REG_ES, - AddressSize ? State->GeneralRegs[SOFT386_REG_EDI].Long - : State->GeneralRegs[SOFT386_REG_EDI].LowWord, + if (!Fast486WriteMemory(State, + FAST486_REG_ES, + AddressSize ? State->GeneralRegs[FAST486_REG_EDI].Long + : State->GeneralRegs[FAST486_REG_EDI].LowWord, Block, Processed * DataSize)) { /* Set ECX */ - if (OperandSize) State->GeneralRegs[SOFT386_REG_ECX].Long = Count; - else State->GeneralRegs[SOFT386_REG_ECX].LowWord = LOWORD(Count); + if (OperandSize) State->GeneralRegs[FAST486_REG_ECX].Long = Count; + else State->GeneralRegs[FAST486_REG_ECX].LowWord = LOWORD(Count); /* Exception occurred */ return FALSE; @@ -6512,8 +6512,8 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeStos) if (!State->Flags.Df) { /* Increase EDI by the number of bytes transfered */ - if (AddressSize) State->GeneralRegs[SOFT386_REG_EDI].Long += Processed * DataSize; - else State->GeneralRegs[SOFT386_REG_EDI].LowWord += Processed * DataSize; + if (AddressSize) State->GeneralRegs[FAST486_REG_EDI].Long += Processed * DataSize; + else State->GeneralRegs[FAST486_REG_EDI].LowWord += Processed * DataSize; } /* Reduce the total count by the number processed in this run */ @@ -6521,17 +6521,17 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeStos) } /* Clear ECX */ - if (OperandSize) State->GeneralRegs[SOFT386_REG_ECX].Long = 0; - else State->GeneralRegs[SOFT386_REG_ECX].LowWord = 0; + if (OperandSize) State->GeneralRegs[FAST486_REG_ECX].Long = 0; + else State->GeneralRegs[FAST486_REG_ECX].LowWord = 0; } else { /* Write to the destination operand */ - if (!Soft386WriteMemory(State, - SOFT386_REG_ES, - AddressSize ? State->GeneralRegs[SOFT386_REG_EDI].Long - : State->GeneralRegs[SOFT386_REG_EDI].LowWord, - &State->GeneralRegs[SOFT386_REG_EAX].Long, + if (!Fast486WriteMemory(State, + FAST486_REG_ES, + AddressSize ? State->GeneralRegs[FAST486_REG_EDI].Long + : State->GeneralRegs[FAST486_REG_EDI].LowWord, + &State->GeneralRegs[FAST486_REG_EAX].Long, DataSize)) { /* Exception occurred */ @@ -6541,13 +6541,13 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeStos) /* Increment/decrement EDI */ if (OperandSize) { - if (!State->Flags.Df) State->GeneralRegs[SOFT386_REG_EDI].Long += DataSize; - else State->GeneralRegs[SOFT386_REG_EDI].Long -= DataSize; + if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_EDI].Long += DataSize; + else State->GeneralRegs[FAST486_REG_EDI].Long -= DataSize; } else { - if (!State->Flags.Df) State->GeneralRegs[SOFT386_REG_EDI].LowWord += DataSize; - else State->GeneralRegs[SOFT386_REG_EDI].LowWord -= DataSize; + if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_EDI].LowWord += DataSize; + else State->GeneralRegs[FAST486_REG_EDI].LowWord -= DataSize; } } @@ -6555,30 +6555,30 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeStos) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeLods) +FAST486_OPCODE_HANDLER(Fast486OpcodeLods) { ULONG DataSize; BOOLEAN OperandSize, AddressSize; - SOFT386_SEG_REGS Segment = SOFT386_REG_DS; + FAST486_SEG_REGS Segment = FAST486_REG_DS; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFE) == 0xAC); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ OperandSize = !OperandSize; } - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (State->PrefixFlags & SOFT386_PREFIX_SEG) + if (State->PrefixFlags & FAST486_PREFIX_SEG) { /* Use the override segment instead of DS */ Segment = State->SegmentOverride; @@ -6588,10 +6588,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeLods) if (Opcode == 0xAC) DataSize = sizeof(UCHAR); else DataSize = OperandSize ? sizeof(ULONG) : sizeof(USHORT); - if (State->PrefixFlags & SOFT386_PREFIX_REP) + if (State->PrefixFlags & FAST486_PREFIX_REP) { - ULONG Count = OperandSize ? State->GeneralRegs[SOFT386_REG_ECX].Long - : State->GeneralRegs[SOFT386_REG_ECX].LowWord; + ULONG Count = OperandSize ? State->GeneralRegs[FAST486_REG_ECX].Long + : State->GeneralRegs[FAST486_REG_ECX].LowWord; /* If the count is 0, do nothing */ if (Count == 0) return TRUE; @@ -6599,23 +6599,23 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeLods) /* Only the last entry will be loaded */ if (!State->Flags.Df) { - if (AddressSize) State->GeneralRegs[SOFT386_REG_ESI].Long += (Count - 1) * DataSize; - else State->GeneralRegs[SOFT386_REG_ESI].LowWord += (Count - 1) * DataSize; + if (AddressSize) State->GeneralRegs[FAST486_REG_ESI].Long += (Count - 1) * DataSize; + else State->GeneralRegs[FAST486_REG_ESI].LowWord += (Count - 1) * DataSize; } else { - if (AddressSize) State->GeneralRegs[SOFT386_REG_ESI].Long -= (Count - 1) * DataSize; - else State->GeneralRegs[SOFT386_REG_ESI].LowWord -= (Count - 1) * DataSize; + if (AddressSize) State->GeneralRegs[FAST486_REG_ESI].Long -= (Count - 1) * DataSize; + else State->GeneralRegs[FAST486_REG_ESI].LowWord -= (Count - 1) * DataSize; } } /* Read from the source operand */ - if (!Soft386ReadMemory(State, + if (!Fast486ReadMemory(State, Segment, - AddressSize ? State->GeneralRegs[SOFT386_REG_ESI].Long - : State->GeneralRegs[SOFT386_REG_ESI].LowWord, + AddressSize ? State->GeneralRegs[FAST486_REG_ESI].Long + : State->GeneralRegs[FAST486_REG_ESI].LowWord, FALSE, - &State->GeneralRegs[SOFT386_REG_EAX].Long, + &State->GeneralRegs[FAST486_REG_EAX].Long, DataSize)) { /* Exception occurred */ @@ -6625,39 +6625,39 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeLods) /* Increment/decrement ESI */ if (OperandSize) { - if (!State->Flags.Df) State->GeneralRegs[SOFT386_REG_ESI].Long += DataSize; - else State->GeneralRegs[SOFT386_REG_ESI].Long -= DataSize; + if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_ESI].Long += DataSize; + else State->GeneralRegs[FAST486_REG_ESI].Long -= DataSize; } else { - if (!State->Flags.Df) State->GeneralRegs[SOFT386_REG_ESI].LowWord += DataSize; - else State->GeneralRegs[SOFT386_REG_ESI].LowWord -= DataSize; + if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_ESI].LowWord += DataSize; + else State->GeneralRegs[FAST486_REG_ESI].LowWord -= DataSize; } /* Return success */ return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeScas) +FAST486_OPCODE_HANDLER(Fast486OpcodeScas) { - ULONG FirstValue = State->GeneralRegs[SOFT386_REG_EAX].Long; + ULONG FirstValue = State->GeneralRegs[FAST486_REG_EAX].Long; ULONG SecondValue = 0; ULONG Result; ULONG DataSize, DataMask, SignFlag; BOOLEAN OperandSize, AddressSize; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFE) == 0xAE); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ OperandSize = !OperandSize; } - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; @@ -6672,10 +6672,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeScas) SignFlag = 1 << ((DataSize * 8) - 1); /* Read from the source operand */ - if (!Soft386ReadMemory(State, - SOFT386_REG_ES, - AddressSize ? State->GeneralRegs[SOFT386_REG_EDI].Long - : State->GeneralRegs[SOFT386_REG_EDI].LowWord, + if (!Fast486ReadMemory(State, + FAST486_REG_ES, + AddressSize ? State->GeneralRegs[FAST486_REG_EDI].Long + : State->GeneralRegs[FAST486_REG_EDI].LowWord, FALSE, &SecondValue, DataSize)) @@ -6696,29 +6696,29 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeScas) State->Flags.Af = (FirstValue & 0x0F) < (SecondValue & 0x0F); State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SignFlag) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Increment/decrement EDI */ if (OperandSize) { - if (!State->Flags.Df) State->GeneralRegs[SOFT386_REG_EDI].Long += DataSize; - else State->GeneralRegs[SOFT386_REG_EDI].Long -= DataSize; + if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_EDI].Long += DataSize; + else State->GeneralRegs[FAST486_REG_EDI].Long -= DataSize; } else { - if (!State->Flags.Df) State->GeneralRegs[SOFT386_REG_EDI].LowWord += DataSize; - else State->GeneralRegs[SOFT386_REG_EDI].LowWord -= DataSize; + if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_EDI].LowWord += DataSize; + else State->GeneralRegs[FAST486_REG_EDI].LowWord -= DataSize; } // FIXME: This method is slow! - if ((State->PrefixFlags & SOFT386_PREFIX_REP) - || (State->PrefixFlags & SOFT386_PREFIX_REPNZ)) + if ((State->PrefixFlags & FAST486_PREFIX_REP) + || (State->PrefixFlags & FAST486_PREFIX_REPNZ)) { BOOLEAN Repeat = TRUE; if (OperandSize) { - if ((--State->GeneralRegs[SOFT386_REG_ECX].Long) == 0) + if ((--State->GeneralRegs[FAST486_REG_ECX].Long) == 0) { /* ECX is 0 */ Repeat = FALSE; @@ -6726,15 +6726,15 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeScas) } else { - if ((--State->GeneralRegs[SOFT386_REG_ECX].LowWord) == 0) + if ((--State->GeneralRegs[FAST486_REG_ECX].LowWord) == 0) { /* CX is 0 */ Repeat = FALSE; } } - if (((State->PrefixFlags & SOFT386_PREFIX_REP) && !State->Flags.Zf) - || ((State->PrefixFlags & SOFT386_PREFIX_REPNZ) && State->Flags.Zf)) + if (((State->PrefixFlags & FAST486_PREFIX_REP) && !State->Flags.Zf) + || ((State->PrefixFlags & FAST486_PREFIX_REPNZ) && State->Flags.Zf)) { /* REPZ with ZF = 0 or REPNZ with ZF = 1 */ Repeat = FALSE; @@ -6751,23 +6751,23 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeScas) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeIns) +FAST486_OPCODE_HANDLER(Fast486OpcodeIns) { ULONG DataSize; BOOLEAN OperandSize, AddressSize; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFE) == 0x6C); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ OperandSize = !OperandSize; } - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; @@ -6777,11 +6777,11 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIns) if (Opcode == 0x6C) DataSize = sizeof(UCHAR); else DataSize = OperandSize ? sizeof(ULONG) : sizeof(USHORT); - if (State->PrefixFlags & SOFT386_PREFIX_REP) + if (State->PrefixFlags & FAST486_PREFIX_REP) { UCHAR Block[STRING_BLOCK_SIZE]; - ULONG Count = OperandSize ? State->GeneralRegs[SOFT386_REG_ECX].Long - : State->GeneralRegs[SOFT386_REG_ECX].LowWord; + ULONG Count = OperandSize ? State->GeneralRegs[FAST486_REG_ECX].Long + : State->GeneralRegs[FAST486_REG_ECX].LowWord; /* Clear the memory block */ RtlZeroMemory(Block, sizeof(Block)); @@ -6795,8 +6795,8 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIns) if (!AddressSize) { ULONG MaxBytes = State->Flags.Df - ? (ULONG)State->GeneralRegs[SOFT386_REG_EDI].LowWord - : (0x10000 - (ULONG)State->GeneralRegs[SOFT386_REG_EDI].LowWord); + ? (ULONG)State->GeneralRegs[FAST486_REG_EDI].LowWord + : (0x10000 - (ULONG)State->GeneralRegs[FAST486_REG_EDI].LowWord); Processed = min(Processed, MaxBytes / DataSize); if (Processed == 0) Processed = 1; @@ -6804,7 +6804,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIns) /* Read from the I/O port */ State->IoReadCallback(State, - State->GeneralRegs[SOFT386_REG_EDX].LowWord, + State->GeneralRegs[FAST486_REG_EDX].LowWord, Block, Processed * DataSize); @@ -6813,8 +6813,8 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIns) ULONG i, j; /* Reduce EDI by the number of bytes to transfer */ - if (AddressSize) State->GeneralRegs[SOFT386_REG_EDI].Long -= Processed * DataSize; - else State->GeneralRegs[SOFT386_REG_EDI].LowWord -= Processed * DataSize; + if (AddressSize) State->GeneralRegs[FAST486_REG_EDI].Long -= Processed * DataSize; + else State->GeneralRegs[FAST486_REG_EDI].LowWord -= Processed * DataSize; /* Reverse the block data */ for (i = 0; i < Processed / 2; i++) @@ -6830,16 +6830,16 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIns) } /* Write to memory */ - if (!Soft386WriteMemory(State, - SOFT386_REG_ES, - AddressSize ? State->GeneralRegs[SOFT386_REG_EDI].Long - : State->GeneralRegs[SOFT386_REG_EDI].LowWord, + if (!Fast486WriteMemory(State, + FAST486_REG_ES, + AddressSize ? State->GeneralRegs[FAST486_REG_EDI].Long + : State->GeneralRegs[FAST486_REG_EDI].LowWord, Block, Processed * DataSize)) { /* Set ECX */ - if (OperandSize) State->GeneralRegs[SOFT386_REG_ECX].Long = Count; - else State->GeneralRegs[SOFT386_REG_ECX].LowWord = LOWORD(Count); + if (OperandSize) State->GeneralRegs[FAST486_REG_ECX].Long = Count; + else State->GeneralRegs[FAST486_REG_ECX].LowWord = LOWORD(Count); /* Exception occurred */ return FALSE; @@ -6848,8 +6848,8 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIns) if (!State->Flags.Df) { /* Increase EDI by the number of bytes transfered */ - if (AddressSize) State->GeneralRegs[SOFT386_REG_EDI].Long += Processed * DataSize; - else State->GeneralRegs[SOFT386_REG_EDI].LowWord += Processed * DataSize; + if (AddressSize) State->GeneralRegs[FAST486_REG_EDI].Long += Processed * DataSize; + else State->GeneralRegs[FAST486_REG_EDI].LowWord += Processed * DataSize; } /* Reduce the total count by the number processed in this run */ @@ -6857,8 +6857,8 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIns) } /* Clear ECX */ - if (OperandSize) State->GeneralRegs[SOFT386_REG_ECX].Long = 0; - else State->GeneralRegs[SOFT386_REG_ECX].LowWord = 0; + if (OperandSize) State->GeneralRegs[FAST486_REG_ECX].Long = 0; + else State->GeneralRegs[FAST486_REG_ECX].LowWord = 0; } else { @@ -6866,15 +6866,15 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIns) /* Read from the I/O port */ State->IoReadCallback(State, - State->GeneralRegs[SOFT386_REG_EDX].LowWord, + State->GeneralRegs[FAST486_REG_EDX].LowWord, &Data, DataSize); /* Write to the destination operand */ - if (!Soft386WriteMemory(State, - SOFT386_REG_ES, - AddressSize ? State->GeneralRegs[SOFT386_REG_EDI].Long - : State->GeneralRegs[SOFT386_REG_EDI].LowWord, + if (!Fast486WriteMemory(State, + FAST486_REG_ES, + AddressSize ? State->GeneralRegs[FAST486_REG_EDI].Long + : State->GeneralRegs[FAST486_REG_EDI].LowWord, &Data, DataSize)) { @@ -6885,13 +6885,13 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIns) /* Increment/decrement EDI */ if (OperandSize) { - if (!State->Flags.Df) State->GeneralRegs[SOFT386_REG_EDI].Long += DataSize; - else State->GeneralRegs[SOFT386_REG_EDI].Long -= DataSize; + if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_EDI].Long += DataSize; + else State->GeneralRegs[FAST486_REG_EDI].Long -= DataSize; } else { - if (!State->Flags.Df) State->GeneralRegs[SOFT386_REG_EDI].LowWord += DataSize; - else State->GeneralRegs[SOFT386_REG_EDI].LowWord -= DataSize; + if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_EDI].LowWord += DataSize; + else State->GeneralRegs[FAST486_REG_EDI].LowWord -= DataSize; } } @@ -6899,23 +6899,23 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeIns) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeOuts) +FAST486_OPCODE_HANDLER(Fast486OpcodeOuts) { ULONG DataSize; BOOLEAN OperandSize, AddressSize; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; /* Make sure this is the right instruction */ ASSERT((Opcode & 0xFE) == 0x6E); - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ OperandSize = !OperandSize; } - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; @@ -6925,11 +6925,11 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOuts) if (Opcode == 0x6E) DataSize = sizeof(UCHAR); else DataSize = OperandSize ? sizeof(ULONG) : sizeof(USHORT); - if (State->PrefixFlags & SOFT386_PREFIX_REP) + if (State->PrefixFlags & FAST486_PREFIX_REP) { UCHAR Block[STRING_BLOCK_SIZE]; - ULONG Count = OperandSize ? State->GeneralRegs[SOFT386_REG_ECX].Long - : State->GeneralRegs[SOFT386_REG_ECX].LowWord; + ULONG Count = OperandSize ? State->GeneralRegs[FAST486_REG_ECX].Long + : State->GeneralRegs[FAST486_REG_ECX].LowWord; /* Clear the memory block */ RtlZeroMemory(Block, sizeof(Block)); @@ -6943,25 +6943,25 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOuts) if (!AddressSize) { ULONG MaxBytes = State->Flags.Df - ? (ULONG)State->GeneralRegs[SOFT386_REG_EDI].LowWord - : (0x10000 - (ULONG)State->GeneralRegs[SOFT386_REG_EDI].LowWord); + ? (ULONG)State->GeneralRegs[FAST486_REG_EDI].LowWord + : (0x10000 - (ULONG)State->GeneralRegs[FAST486_REG_EDI].LowWord); Processed = min(Processed, MaxBytes / DataSize); if (Processed == 0) Processed = 1; } /* Read from memory */ - if (!Soft386ReadMemory(State, - SOFT386_REG_ES, - AddressSize ? State->GeneralRegs[SOFT386_REG_EDI].Long - : State->GeneralRegs[SOFT386_REG_EDI].LowWord, + if (!Fast486ReadMemory(State, + FAST486_REG_ES, + AddressSize ? State->GeneralRegs[FAST486_REG_EDI].Long + : State->GeneralRegs[FAST486_REG_EDI].LowWord, FALSE, Block, Processed * DataSize)) { /* Set ECX */ - if (OperandSize) State->GeneralRegs[SOFT386_REG_ECX].Long = Count; - else State->GeneralRegs[SOFT386_REG_ECX].LowWord = LOWORD(Count); + if (OperandSize) State->GeneralRegs[FAST486_REG_ECX].Long = Count; + else State->GeneralRegs[FAST486_REG_ECX].LowWord = LOWORD(Count); /* Exception occurred */ return FALSE; @@ -6972,8 +6972,8 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOuts) ULONG i, j; /* Reduce EDI by the number of bytes to transfer */ - if (AddressSize) State->GeneralRegs[SOFT386_REG_EDI].Long -= Processed * DataSize; - else State->GeneralRegs[SOFT386_REG_EDI].LowWord -= Processed * DataSize; + if (AddressSize) State->GeneralRegs[FAST486_REG_EDI].Long -= Processed * DataSize; + else State->GeneralRegs[FAST486_REG_EDI].LowWord -= Processed * DataSize; /* Reverse the block data */ for (i = 0; i < Processed / 2; i++) @@ -6990,15 +6990,15 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOuts) /* Write to the I/O port */ State->IoWriteCallback(State, - State->GeneralRegs[SOFT386_REG_EDX].LowWord, + State->GeneralRegs[FAST486_REG_EDX].LowWord, Block, Processed * DataSize); if (!State->Flags.Df) { /* Increase EDI by the number of bytes transfered */ - if (AddressSize) State->GeneralRegs[SOFT386_REG_EDI].Long += Processed * DataSize; - else State->GeneralRegs[SOFT386_REG_EDI].LowWord += Processed * DataSize; + if (AddressSize) State->GeneralRegs[FAST486_REG_EDI].Long += Processed * DataSize; + else State->GeneralRegs[FAST486_REG_EDI].LowWord += Processed * DataSize; } /* Reduce the total count by the number processed in this run */ @@ -7006,18 +7006,18 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOuts) } /* Clear ECX */ - if (OperandSize) State->GeneralRegs[SOFT386_REG_ECX].Long = 0; - else State->GeneralRegs[SOFT386_REG_ECX].LowWord = 0; + if (OperandSize) State->GeneralRegs[FAST486_REG_ECX].Long = 0; + else State->GeneralRegs[FAST486_REG_ECX].LowWord = 0; } else { ULONG Data = 0; /* Read from the source operand */ - if (!Soft386ReadMemory(State, - SOFT386_REG_DS, - AddressSize ? State->GeneralRegs[SOFT386_REG_ESI].Long - : State->GeneralRegs[SOFT386_REG_ESI].LowWord, + if (!Fast486ReadMemory(State, + FAST486_REG_DS, + AddressSize ? State->GeneralRegs[FAST486_REG_ESI].Long + : State->GeneralRegs[FAST486_REG_ESI].LowWord, FALSE, &Data, DataSize)) @@ -7028,20 +7028,20 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeOuts) /* Write to the I/O port */ State->IoWriteCallback(State, - State->GeneralRegs[SOFT386_REG_EDX].LowWord, + State->GeneralRegs[FAST486_REG_EDX].LowWord, &Data, DataSize); /* Increment/decrement ESI */ if (OperandSize) { - if (!State->Flags.Df) State->GeneralRegs[SOFT386_REG_ESI].Long += DataSize; - else State->GeneralRegs[SOFT386_REG_ESI].Long -= DataSize; + if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_ESI].Long += DataSize; + else State->GeneralRegs[FAST486_REG_ESI].Long -= DataSize; } else { - if (!State->Flags.Df) State->GeneralRegs[SOFT386_REG_ESI].LowWord += DataSize; - else State->GeneralRegs[SOFT386_REG_ESI].LowWord -= DataSize; + if (!State->Flags.Df) State->GeneralRegs[FAST486_REG_ESI].LowWord += DataSize; + else State->GeneralRegs[FAST486_REG_ESI].LowWord -= DataSize; } } diff --git a/lib/fast486/opcodes.h b/lib/fast486/opcodes.h new file mode 100644 index 00000000000..8a35dcfc84b --- /dev/null +++ b/lib/fast486/opcodes.h @@ -0,0 +1,159 @@ +/* + * Fast486 386/486 CPU Emulation Library + * opcodes.h + * + * Copyright (C) 2013 Aleksandar Andrejevic + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef _OPCODES_H_ +#define _OPCODES_H_ + +/* DEFINES ********************************************************************/ + +#ifndef FASTCALL +#define FASTCALL __fastcall +#endif + +#define FAST486_NUM_OPCODE_HANDLERS 256 +#define FAST486_OPCODE_WRITE_REG (1 << 1) +#define FAST486_OPCODE_HANDLER(x) \ + BOOLEAN FASTCALL x(PFAST486_STATE State, UCHAR Opcode) + +typedef BOOLEAN (FASTCALL *FAST486_OPCODE_HANDLER_PROC)(PFAST486_STATE, UCHAR); + +extern +FAST486_OPCODE_HANDLER_PROC +Fast486OpcodeHandlers[FAST486_NUM_OPCODE_HANDLERS]; + +FAST486_OPCODE_HANDLER(Fast486OpcodePrefix); +FAST486_OPCODE_HANDLER(Fast486OpcodeIncrement); +FAST486_OPCODE_HANDLER(Fast486OpcodeDecrement); +FAST486_OPCODE_HANDLER(Fast486OpcodePushReg); +FAST486_OPCODE_HANDLER(Fast486OpcodePopReg); +FAST486_OPCODE_HANDLER(Fast486OpcodeNop); +FAST486_OPCODE_HANDLER(Fast486OpcodeExchangeEax); +FAST486_OPCODE_HANDLER(Fast486OpcodeShortConditionalJmp); +FAST486_OPCODE_HANDLER(Fast486OpcodeClearCarry); +FAST486_OPCODE_HANDLER(Fast486OpcodeSetCarry); +FAST486_OPCODE_HANDLER(Fast486OpcodeComplCarry); +FAST486_OPCODE_HANDLER(Fast486OpcodeClearInt); +FAST486_OPCODE_HANDLER(Fast486OpcodeSetInt); +FAST486_OPCODE_HANDLER(Fast486OpcodeClearDir); +FAST486_OPCODE_HANDLER(Fast486OpcodeSetDir); +FAST486_OPCODE_HANDLER(Fast486OpcodeHalt); +FAST486_OPCODE_HANDLER(Fast486OpcodeInByte); +FAST486_OPCODE_HANDLER(Fast486OpcodeIn); +FAST486_OPCODE_HANDLER(Fast486OpcodeOutByte); +FAST486_OPCODE_HANDLER(Fast486OpcodeOut); +FAST486_OPCODE_HANDLER(Fast486OpcodeShortJump); +FAST486_OPCODE_HANDLER(Fast486OpcodeMovRegImm); +FAST486_OPCODE_HANDLER(Fast486OpcodeMovByteRegImm); +FAST486_OPCODE_HANDLER(Fast486OpcodeAddByteModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeAddModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeAddAl); +FAST486_OPCODE_HANDLER(Fast486OpcodeAddEax); +FAST486_OPCODE_HANDLER(Fast486OpcodeOrByteModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeOrModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeOrAl); +FAST486_OPCODE_HANDLER(Fast486OpcodeOrEax); +FAST486_OPCODE_HANDLER(Fast486OpcodeAndByteModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeAndModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeAndAl); +FAST486_OPCODE_HANDLER(Fast486OpcodeAndEax); +FAST486_OPCODE_HANDLER(Fast486OpcodeXorByteModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeXorModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeXorAl); +FAST486_OPCODE_HANDLER(Fast486OpcodeXorEax); +FAST486_OPCODE_HANDLER(Fast486OpcodeTestByteModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeTestModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeTestAl); +FAST486_OPCODE_HANDLER(Fast486OpcodeTestEax); +FAST486_OPCODE_HANDLER(Fast486OpcodeXchgByteModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeXchgModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodePushEs); +FAST486_OPCODE_HANDLER(Fast486OpcodePopEs); +FAST486_OPCODE_HANDLER(Fast486OpcodePushCs); +FAST486_OPCODE_HANDLER(Fast486OpcodeAdcByteModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeAdcModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeAdcAl); +FAST486_OPCODE_HANDLER(Fast486OpcodeAdcEax); +FAST486_OPCODE_HANDLER(Fast486OpcodePushSs); +FAST486_OPCODE_HANDLER(Fast486OpcodePopSs); +FAST486_OPCODE_HANDLER(Fast486OpcodeSbbByteModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeSbbModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeSbbAl); +FAST486_OPCODE_HANDLER(Fast486OpcodeSbbEax); +FAST486_OPCODE_HANDLER(Fast486OpcodePushDs); +FAST486_OPCODE_HANDLER(Fast486OpcodePopDs); +FAST486_OPCODE_HANDLER(Fast486OpcodeDaa); +FAST486_OPCODE_HANDLER(Fast486OpcodeCmpSubByteModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeCmpSubModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeCmpSubAl); +FAST486_OPCODE_HANDLER(Fast486OpcodeCmpSubEax); +FAST486_OPCODE_HANDLER(Fast486OpcodeDas); +FAST486_OPCODE_HANDLER(Fast486OpcodeAaa); +FAST486_OPCODE_HANDLER(Fast486OpcodeAas); +FAST486_OPCODE_HANDLER(Fast486OpcodePushAll); +FAST486_OPCODE_HANDLER(Fast486OpcodePopAll); +FAST486_OPCODE_HANDLER(Fast486OpcodeBound); +FAST486_OPCODE_HANDLER(Fast486OpcodeArpl); +FAST486_OPCODE_HANDLER(Fast486OpcodePushImm); +FAST486_OPCODE_HANDLER(Fast486OpcodeImulModrmImm); +FAST486_OPCODE_HANDLER(Fast486OpcodePushByteImm); +FAST486_OPCODE_HANDLER(Fast486OpcodeMovByteModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeMovModrm); +FAST486_OPCODE_HANDLER(Fast486OpcodeMovStoreSeg); +FAST486_OPCODE_HANDLER(Fast486OpcodeLea); +FAST486_OPCODE_HANDLER(Fast486OpcodeMovLoadSeg); +FAST486_OPCODE_HANDLER(Fast486OpcodeCwde); +FAST486_OPCODE_HANDLER(Fast486OpcodeCdq); +FAST486_OPCODE_HANDLER(Fast486OpcodeCallAbs); +FAST486_OPCODE_HANDLER(Fast486OpcodeWait); +FAST486_OPCODE_HANDLER(Fast486OpcodePushFlags); +FAST486_OPCODE_HANDLER(Fast486OpcodePopFlags); +FAST486_OPCODE_HANDLER(Fast486OpcodeSahf); +FAST486_OPCODE_HANDLER(Fast486OpcodeLahf); +FAST486_OPCODE_HANDLER(Fast486OpcodeRet); +FAST486_OPCODE_HANDLER(Fast486OpcodeLdsLes); +FAST486_OPCODE_HANDLER(Fast486OpcodeEnter); +FAST486_OPCODE_HANDLER(Fast486OpcodeLeave); +FAST486_OPCODE_HANDLER(Fast486OpcodeRetFarImm); +FAST486_OPCODE_HANDLER(Fast486OpcodeRetFar); +FAST486_OPCODE_HANDLER(Fast486OpcodeInt); +FAST486_OPCODE_HANDLER(Fast486OpcodeIret); +FAST486_OPCODE_HANDLER(Fast486OpcodeAam); +FAST486_OPCODE_HANDLER(Fast486OpcodeAad); +FAST486_OPCODE_HANDLER(Fast486OpcodeXlat); +FAST486_OPCODE_HANDLER(Fast486OpcodeLoop); +FAST486_OPCODE_HANDLER(Fast486OpcodeJecxz); +FAST486_OPCODE_HANDLER(Fast486OpcodeCall); +FAST486_OPCODE_HANDLER(Fast486OpcodeJmp); +FAST486_OPCODE_HANDLER(Fast486OpcodeJmpAbs); +FAST486_OPCODE_HANDLER(Fast486OpcodeMovAlOffset); +FAST486_OPCODE_HANDLER(Fast486OpcodeMovEaxOffset); +FAST486_OPCODE_HANDLER(Fast486OpcodeMovOffsetAl); +FAST486_OPCODE_HANDLER(Fast486OpcodeMovOffsetEax); +FAST486_OPCODE_HANDLER(Fast486OpcodeSalc); +FAST486_OPCODE_HANDLER(Fast486OpcodeMovs); +FAST486_OPCODE_HANDLER(Fast486OpcodeCmps); +FAST486_OPCODE_HANDLER(Fast486OpcodeStos); +FAST486_OPCODE_HANDLER(Fast486OpcodeLods); +FAST486_OPCODE_HANDLER(Fast486OpcodeScas); +FAST486_OPCODE_HANDLER(Fast486OpcodeIns); +FAST486_OPCODE_HANDLER(Fast486OpcodeOuts); + +#endif // _OPCODES_H_ diff --git a/lib/soft386/opgroups.c b/lib/fast486/opgroups.c similarity index 73% rename from lib/soft386/opgroups.c rename to lib/fast486/opgroups.c index ac59a393c11..5738406204b 100644 --- a/lib/soft386/opgroups.c +++ b/lib/fast486/opgroups.c @@ -1,5 +1,5 @@ /* - * Soft386 386/486 CPU Emulation Library + * Fast486 386/486 CPU Emulation Library * opgroups.c * * Copyright (C) 2013 Aleksandar Andrejevic @@ -28,7 +28,7 @@ // #define NDEBUG #include -#include +#include #include "opcodes.h" #include "common.h" @@ -37,7 +37,7 @@ inline static ULONG -Soft386ArithmeticOperation(PSOFT386_STATE State, +Fast486ArithmeticOperation(PFAST486_STATE State, INT Operation, ULONG FirstValue, ULONG SecondValue, @@ -148,7 +148,7 @@ Soft386ArithmeticOperation(PSOFT386_STATE State, /* Update ZF, SF and PF */ State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SignFlag) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(LOBYTE(Result)); + State->Flags.Pf = Fast486CalculateParity(LOBYTE(Result)); /* Return the result */ return Result; @@ -157,7 +157,7 @@ Soft386ArithmeticOperation(PSOFT386_STATE State, static inline ULONG -Soft386RotateOperation(PSOFT386_STATE State, +Fast486RotateOperation(PFAST486_STATE State, INT Operation, ULONG Value, UCHAR Bits, @@ -283,7 +283,7 @@ Soft386RotateOperation(PSOFT386_STATE State, /* Update ZF, SF and PF */ State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & HighestBit) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Return the result */ return Result; @@ -291,70 +291,70 @@ Soft386RotateOperation(PSOFT386_STATE State, /* PUBLIC FUNCTIONS ***********************************************************/ -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroup8082) +FAST486_OPCODE_HANDLER(Fast486OpcodeGroup8082) { UCHAR Immediate, Dummy, Value; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } /* Fetch the immediate operand */ - if (!Soft386FetchByte(State, &Immediate)) + if (!Fast486FetchByte(State, &Immediate)) { /* Exception occurred */ return FALSE; } /* Read the operands */ - if (!Soft386ReadModrmByteOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmByteOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; } /* Calculate the result */ - Value = Soft386ArithmeticOperation(State, ModRegRm.Register, Value, Immediate, 8); + Value = Fast486ArithmeticOperation(State, ModRegRm.Register, Value, Immediate, 8); /* Unless this is CMP, write back the result */ if (ModRegRm.Register != 7) { - return Soft386WriteModrmByteOperands(State, &ModRegRm, FALSE, Value); + return Fast486WriteModrmByteOperands(State, &ModRegRm, FALSE, Value); } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroup81) +FAST486_OPCODE_HANDLER(Fast486OpcodeGroup81) { - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ OperandSize = !OperandSize; } - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -365,26 +365,26 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroup81) ULONG Immediate, Value, Dummy; /* Fetch the immediate operand */ - if (!Soft386FetchDword(State, &Immediate)) + if (!Fast486FetchDword(State, &Immediate)) { /* Exception occurred */ return FALSE; } /* Read the operands */ - if (!Soft386ReadModrmDwordOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; } /* Calculate the result */ - Value = Soft386ArithmeticOperation(State, ModRegRm.Register, Value, Immediate, 32); + Value = Fast486ArithmeticOperation(State, ModRegRm.Register, Value, Immediate, 32); /* Unless this is CMP, write back the result */ if (ModRegRm.Register != 7) { - return Soft386WriteModrmDwordOperands(State, &ModRegRm, FALSE, Value); + return Fast486WriteModrmDwordOperands(State, &ModRegRm, FALSE, Value); } } else @@ -392,60 +392,60 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroup81) USHORT Immediate, Value, Dummy; /* Fetch the immediate operand */ - if (!Soft386FetchWord(State, &Immediate)) + if (!Fast486FetchWord(State, &Immediate)) { /* Exception occurred */ return FALSE; } /* Read the operands */ - if (!Soft386ReadModrmWordOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; } /* Calculate the result */ - Value = Soft386ArithmeticOperation(State, ModRegRm.Register, Value, Immediate, 16); + Value = Fast486ArithmeticOperation(State, ModRegRm.Register, Value, Immediate, 16); /* Unless this is CMP, write back the result */ if (ModRegRm.Register != 7) { - return Soft386WriteModrmWordOperands(State, &ModRegRm, FALSE, Value); + return Fast486WriteModrmWordOperands(State, &ModRegRm, FALSE, Value); } } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroup83) +FAST486_OPCODE_HANDLER(Fast486OpcodeGroup83) { CHAR ImmByte; - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ OperandSize = !OperandSize; } - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } /* Fetch the immediate operand */ - if (!Soft386FetchByte(State, (PUCHAR)&ImmByte)) + if (!Fast486FetchByte(State, (PUCHAR)&ImmByte)) { /* Exception occurred */ return FALSE; @@ -457,19 +457,19 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroup83) ULONG Value, Dummy; /* Read the operands */ - if (!Soft386ReadModrmDwordOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; } /* Calculate the result */ - Value = Soft386ArithmeticOperation(State, ModRegRm.Register, Value, Immediate, 32); + Value = Fast486ArithmeticOperation(State, ModRegRm.Register, Value, Immediate, 32); /* Unless this is CMP, write back the result */ if (ModRegRm.Register != 7) { - return Soft386WriteModrmDwordOperands(State, &ModRegRm, FALSE, Value); + return Fast486WriteModrmDwordOperands(State, &ModRegRm, FALSE, Value); } } else @@ -478,46 +478,46 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroup83) USHORT Value, Dummy; /* Read the operands */ - if (!Soft386ReadModrmWordOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; } /* Calculate the result */ - Value = Soft386ArithmeticOperation(State, ModRegRm.Register, Value, Immediate, 16); + Value = Fast486ArithmeticOperation(State, ModRegRm.Register, Value, Immediate, 16); /* Unless this is CMP, write back the result */ if (ModRegRm.Register != 7) { - return Soft386WriteModrmWordOperands(State, &ModRegRm, FALSE, Value); + return Fast486WriteModrmWordOperands(State, &ModRegRm, FALSE, Value); } } return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroup8F) +FAST486_OPCODE_HANDLER(Fast486OpcodeGroup8F) { ULONG Value; - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ OperandSize = !OperandSize; } - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -526,12 +526,12 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroup8F) if (ModRegRm.Register != 0) { /* Invalid */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Pop a value from the stack */ - if (!Soft386StackPop(State, &Value)) + if (!Fast486StackPop(State, &Value)) { /* Exception occurred */ return FALSE; @@ -539,94 +539,94 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroup8F) if (OperandSize) { - return Soft386WriteModrmDwordOperands(State, + return Fast486WriteModrmDwordOperands(State, &ModRegRm, FALSE, Value); } else { - return Soft386WriteModrmWordOperands(State, + return Fast486WriteModrmWordOperands(State, &ModRegRm, FALSE, LOWORD(Value)); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupC0) +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupC0) { UCHAR Dummy, Value, Count; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } /* Fetch the count */ - if (!Soft386FetchByte(State, &Count)) + if (!Fast486FetchByte(State, &Count)) { /* Exception occurred */ return FALSE; } /* Read the operands */ - if (!Soft386ReadModrmByteOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmByteOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; } /* Calculate the result */ - Value = LOBYTE(Soft386RotateOperation(State, + Value = LOBYTE(Fast486RotateOperation(State, ModRegRm.Register, Value, 8, Count)); /* Write back the result */ - return Soft386WriteModrmByteOperands(State, + return Fast486WriteModrmByteOperands(State, &ModRegRm, FALSE, Value); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupC1) +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupC1) { UCHAR Count; - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ OperandSize = !OperandSize; } - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } /* Fetch the count */ - if (!Soft386FetchByte(State, &Count)) + if (!Fast486FetchByte(State, &Count)) { /* Exception occurred */ return FALSE; @@ -637,58 +637,58 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupC1) ULONG Dummy, Value; /* Read the operands */ - if (!Soft386ReadModrmDwordOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; } /* Calculate the result */ - Value = Soft386RotateOperation(State, + Value = Fast486RotateOperation(State, ModRegRm.Register, Value, 32, Count); /* Write back the result */ - return Soft386WriteModrmDwordOperands(State, &ModRegRm, FALSE, Value); + return Fast486WriteModrmDwordOperands(State, &ModRegRm, FALSE, Value); } else { USHORT Dummy, Value; /* Read the operands */ - if (!Soft386ReadModrmWordOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; } /* Calculate the result */ - Value = LOWORD(Soft386RotateOperation(State, + Value = LOWORD(Fast486RotateOperation(State, ModRegRm.Register, Value, 16, Count)); /* Write back the result */ - return Soft386WriteModrmWordOperands(State, &ModRegRm, FALSE, Value); + return Fast486WriteModrmWordOperands(State, &ModRegRm, FALSE, Value); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupC6) +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupC6) { UCHAR Immediate; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -697,43 +697,43 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupC6) if (ModRegRm.Register != 0) { /* Invalid */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Get the immediate operand */ - if (!Soft386FetchByte(State, &Immediate)) + if (!Fast486FetchByte(State, &Immediate)) { /* Exception occurred */ return FALSE; } - return Soft386WriteModrmByteOperands(State, + return Fast486WriteModrmByteOperands(State, &ModRegRm, FALSE, Immediate); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupC7) +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupC7) { - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ OperandSize = !OperandSize; } - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -742,7 +742,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupC7) if (ModRegRm.Register != 0) { /* Invalid */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -751,13 +751,13 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupC7) ULONG Immediate; /* Get the immediate operand */ - if (!Soft386FetchDword(State, &Immediate)) + if (!Fast486FetchDword(State, &Immediate)) { /* Exception occurred */ return FALSE; } - return Soft386WriteModrmDwordOperands(State, + return Fast486WriteModrmDwordOperands(State, &ModRegRm, FALSE, Immediate); @@ -767,76 +767,76 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupC7) USHORT Immediate; /* Get the immediate operand */ - if (!Soft386FetchWord(State, &Immediate)) + if (!Fast486FetchWord(State, &Immediate)) { /* Exception occurred */ return FALSE; } - return Soft386WriteModrmWordOperands(State, + return Fast486WriteModrmWordOperands(State, &ModRegRm, FALSE, Immediate); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupD0) +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupD0) { UCHAR Dummy, Value; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } /* Read the operands */ - if (!Soft386ReadModrmByteOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmByteOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; } /* Calculate the result */ - Value = LOBYTE(Soft386RotateOperation(State, ModRegRm.Register, Value, 8, 1)); + Value = LOBYTE(Fast486RotateOperation(State, ModRegRm.Register, Value, 8, 1)); /* Write back the result */ - return Soft386WriteModrmByteOperands(State, + return Fast486WriteModrmByteOperands(State, &ModRegRm, FALSE, Value); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupD1) +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupD1) { - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ OperandSize = !OperandSize; } - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -847,96 +847,96 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupD1) ULONG Dummy, Value; /* Read the operands */ - if (!Soft386ReadModrmDwordOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; } /* Calculate the result */ - Value = Soft386RotateOperation(State, ModRegRm.Register, Value, 32, 1); + Value = Fast486RotateOperation(State, ModRegRm.Register, Value, 32, 1); /* Write back the result */ - return Soft386WriteModrmDwordOperands(State, &ModRegRm, FALSE, Value); + return Fast486WriteModrmDwordOperands(State, &ModRegRm, FALSE, Value); } else { USHORT Dummy, Value; /* Read the operands */ - if (!Soft386ReadModrmWordOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; } /* Calculate the result */ - Value = LOWORD(Soft386RotateOperation(State, ModRegRm.Register, Value, 16, 1)); + Value = LOWORD(Fast486RotateOperation(State, ModRegRm.Register, Value, 16, 1)); /* Write back the result */ - return Soft386WriteModrmWordOperands(State, &ModRegRm, FALSE, Value); + return Fast486WriteModrmWordOperands(State, &ModRegRm, FALSE, Value); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupD2) +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupD2) { UCHAR Dummy, Value; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } /* Read the operands */ - if (!Soft386ReadModrmByteOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmByteOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; } /* Calculate the result */ - Value = LOBYTE(Soft386RotateOperation(State, + Value = LOBYTE(Fast486RotateOperation(State, ModRegRm.Register, Value, 8, - State->GeneralRegs[SOFT386_REG_ECX].LowByte)); + State->GeneralRegs[FAST486_REG_ECX].LowByte)); /* Write back the result */ - return Soft386WriteModrmByteOperands(State, + return Fast486WriteModrmByteOperands(State, &ModRegRm, FALSE, Value); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupD3) +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupD3) { - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ OperandSize = !OperandSize; } - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -947,65 +947,65 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupD3) ULONG Dummy, Value; /* Read the operands */ - if (!Soft386ReadModrmDwordOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; } /* Calculate the result */ - Value = Soft386RotateOperation(State, + Value = Fast486RotateOperation(State, ModRegRm.Register, Value, 32, - State->GeneralRegs[SOFT386_REG_ECX].LowByte); + State->GeneralRegs[FAST486_REG_ECX].LowByte); /* Write back the result */ - return Soft386WriteModrmDwordOperands(State, &ModRegRm, FALSE, Value); + return Fast486WriteModrmDwordOperands(State, &ModRegRm, FALSE, Value); } else { USHORT Dummy, Value; /* Read the operands */ - if (!Soft386ReadModrmWordOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; } /* Calculate the result */ - Value = LOWORD(Soft386RotateOperation(State, + Value = LOWORD(Fast486RotateOperation(State, ModRegRm.Register, Value, 16, - State->GeneralRegs[SOFT386_REG_ECX].LowByte)); + State->GeneralRegs[FAST486_REG_ECX].LowByte)); /* Write back the result */ - return Soft386WriteModrmWordOperands(State, &ModRegRm, FALSE, Value); + return Fast486WriteModrmWordOperands(State, &ModRegRm, FALSE, Value); } } -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF6) +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupF6) { UCHAR Dummy, Value = 0; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; } /* Read the operands */ - if (!Soft386ReadModrmByteOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmByteOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; @@ -1020,7 +1020,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF6) UCHAR Immediate, Result; /* Fetch the immediate byte */ - if (!Soft386FetchByte(State, &Immediate)) + if (!Fast486FetchByte(State, &Immediate)) { /* Exception occurred */ return FALSE; @@ -1034,7 +1034,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF6) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); break; } @@ -1043,7 +1043,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF6) case 2: { /* Write back the result */ - return Soft386WriteModrmByteOperands(State, &ModRegRm, FALSE, ~Value); + return Fast486WriteModrmByteOperands(State, &ModRegRm, FALSE, ~Value); } /* NEG */ @@ -1058,22 +1058,22 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF6) State->Flags.Af = ((Value & 0x0F) != 0) ? TRUE : FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SIGN_FLAG_BYTE) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ - return Soft386WriteModrmByteOperands(State, &ModRegRm, FALSE, Result); + return Fast486WriteModrmByteOperands(State, &ModRegRm, FALSE, Result); } /* MUL */ case 4: { - USHORT Result = (USHORT)Value * (USHORT)State->GeneralRegs[SOFT386_REG_EAX].LowByte; + USHORT Result = (USHORT)Value * (USHORT)State->GeneralRegs[FAST486_REG_EAX].LowByte; /* Update the flags */ State->Flags.Cf = State->Flags.Of = HIBYTE(Result) ? TRUE : FALSE; /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowWord = Result; + State->GeneralRegs[FAST486_REG_EAX].LowWord = Result; break; } @@ -1081,14 +1081,14 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF6) /* IMUL */ case 5: { - SHORT Result = (SHORT)((CHAR)Value) * (SHORT)((CHAR)State->GeneralRegs[SOFT386_REG_EAX].LowByte); + SHORT Result = (SHORT)((CHAR)Value) * (SHORT)((CHAR)State->GeneralRegs[FAST486_REG_EAX].LowByte); /* Update the flags */ State->Flags.Cf = State->Flags.Of = ((Result < -128) || (Result > 127)) ? TRUE : FALSE; /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowWord = (USHORT)Result; + State->GeneralRegs[FAST486_REG_EAX].LowWord = (USHORT)Result; break; } @@ -1096,12 +1096,12 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF6) /* DIV */ case 6: { - UCHAR Quotient = State->GeneralRegs[SOFT386_REG_EAX].LowWord / Value; - UCHAR Remainder = State->GeneralRegs[SOFT386_REG_EAX].LowWord % Value; + UCHAR Quotient = State->GeneralRegs[FAST486_REG_EAX].LowWord / Value; + UCHAR Remainder = State->GeneralRegs[FAST486_REG_EAX].LowWord % Value; /* Write back the results */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte = Quotient; - State->GeneralRegs[SOFT386_REG_EAX].HighByte = Remainder; + State->GeneralRegs[FAST486_REG_EAX].LowByte = Quotient; + State->GeneralRegs[FAST486_REG_EAX].HighByte = Remainder; break; } @@ -1109,12 +1109,12 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF6) /* IDIV */ case 7: { - CHAR Quotient = (SHORT)State->GeneralRegs[SOFT386_REG_EAX].LowWord / (CHAR)Value; - CHAR Remainder = (SHORT)State->GeneralRegs[SOFT386_REG_EAX].LowWord % (CHAR)Value; + CHAR Quotient = (SHORT)State->GeneralRegs[FAST486_REG_EAX].LowWord / (CHAR)Value; + CHAR Remainder = (SHORT)State->GeneralRegs[FAST486_REG_EAX].LowWord % (CHAR)Value; /* Write back the results */ - State->GeneralRegs[SOFT386_REG_EAX].LowByte = (UCHAR)Quotient; - State->GeneralRegs[SOFT386_REG_EAX].HighByte = (UCHAR)Remainder; + State->GeneralRegs[FAST486_REG_EAX].LowByte = (UCHAR)Quotient; + State->GeneralRegs[FAST486_REG_EAX].HighByte = (UCHAR)Remainder; break; } @@ -1123,27 +1123,27 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF6) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF7) +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupF7) { ULONG Dummy, Value = 0, SignFlag; - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ OperandSize = !OperandSize; } - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -1157,7 +1157,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF7) if (OperandSize) { /* 32-bit */ - if (!Soft386ReadModrmDwordOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; @@ -1166,7 +1166,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF7) else { /* 16-bit */ - if (!Soft386ReadModrmWordOperands(State, &ModRegRm, (PUSHORT)&Dummy, (PUSHORT)&Value)) + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, (PUSHORT)&Dummy, (PUSHORT)&Value)) { /* Exception occurred */ return FALSE; @@ -1184,7 +1184,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF7) if (OperandSize) { /* Fetch the immediate dword */ - if (!Soft386FetchDword(State, &Immediate)) + if (!Fast486FetchDword(State, &Immediate)) { /* Exception occurred */ return FALSE; @@ -1193,7 +1193,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF7) else { /* Fetch the immediate word */ - if (!Soft386FetchWord(State, (PUSHORT)&Immediate)) + if (!Fast486FetchWord(State, (PUSHORT)&Immediate)) { /* Exception occurred */ return FALSE; @@ -1208,7 +1208,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF7) State->Flags.Of = FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SignFlag) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); break; } @@ -1220,12 +1220,12 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF7) if (OperandSize) { /* 32-bit */ - return Soft386WriteModrmDwordOperands(State, &ModRegRm, FALSE, ~Value); + return Fast486WriteModrmDwordOperands(State, &ModRegRm, FALSE, ~Value); } else { /* 16-bit */ - return Soft386WriteModrmWordOperands(State, &ModRegRm, FALSE, LOWORD(~Value)); + return Fast486WriteModrmWordOperands(State, &ModRegRm, FALSE, LOWORD(~Value)); } } @@ -1242,18 +1242,18 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF7) State->Flags.Af = ((Value & 0x0F) != 0) ? TRUE : FALSE; State->Flags.Zf = (Result == 0) ? TRUE : FALSE; State->Flags.Sf = (Result & SignFlag) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Result); + State->Flags.Pf = Fast486CalculateParity(Result); /* Write back the result */ if (OperandSize) { /* 32-bit */ - return Soft386WriteModrmDwordOperands(State, &ModRegRm, FALSE, Result); + return Fast486WriteModrmDwordOperands(State, &ModRegRm, FALSE, Result); } else { /* 16-bit */ - return Soft386WriteModrmWordOperands(State, &ModRegRm, FALSE, LOWORD(Result)); + return Fast486WriteModrmWordOperands(State, &ModRegRm, FALSE, LOWORD(Result)); } } @@ -1262,26 +1262,26 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF7) { if (OperandSize) { - ULONGLONG Result = (ULONGLONG)Value * (ULONGLONG)State->GeneralRegs[SOFT386_REG_EAX].Long; + ULONGLONG Result = (ULONGLONG)Value * (ULONGLONG)State->GeneralRegs[FAST486_REG_EAX].Long; /* Update the flags */ State->Flags.Cf = State->Flags.Of = (Result & 0xFFFFFFFF00000000ULL) ? TRUE : FALSE; /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].Long = Result & 0xFFFFFFFFULL; - State->GeneralRegs[SOFT386_REG_EDX].Long = Result >> 32; + State->GeneralRegs[FAST486_REG_EAX].Long = Result & 0xFFFFFFFFULL; + State->GeneralRegs[FAST486_REG_EDX].Long = Result >> 32; } else { - ULONG Result = (ULONG)Value * (ULONG)State->GeneralRegs[SOFT386_REG_EAX].LowWord; + ULONG Result = (ULONG)Value * (ULONG)State->GeneralRegs[FAST486_REG_EAX].LowWord; /* Update the flags */ State->Flags.Cf = State->Flags.Of = HIWORD(Result) ? TRUE : FALSE; /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowWord = LOWORD(Result); - State->GeneralRegs[SOFT386_REG_EDX].LowWord = HIWORD(Result); + State->GeneralRegs[FAST486_REG_EAX].LowWord = LOWORD(Result); + State->GeneralRegs[FAST486_REG_EDX].LowWord = HIWORD(Result); } break; @@ -1292,27 +1292,27 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF7) { if (OperandSize) { - LONGLONG Result = (LONGLONG)((LONG)Value) * (LONGLONG)((LONG)State->GeneralRegs[SOFT386_REG_EAX].Long); + LONGLONG Result = (LONGLONG)((LONG)Value) * (LONGLONG)((LONG)State->GeneralRegs[FAST486_REG_EAX].Long); /* Update the flags */ State->Flags.Cf = State->Flags.Of = ((Result < -2147483648LL) || (Result > 2147483647LL)) ? TRUE : FALSE; /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].Long = Result & 0xFFFFFFFFULL; - State->GeneralRegs[SOFT386_REG_EDX].Long = Result >> 32; + State->GeneralRegs[FAST486_REG_EAX].Long = Result & 0xFFFFFFFFULL; + State->GeneralRegs[FAST486_REG_EDX].Long = Result >> 32; } else { - LONG Result = (LONG)((SHORT)Value) * (LONG)((SHORT)State->GeneralRegs[SOFT386_REG_EAX].LowWord); + LONG Result = (LONG)((SHORT)Value) * (LONG)((SHORT)State->GeneralRegs[FAST486_REG_EAX].LowWord); /* Update the flags */ State->Flags.Cf = State->Flags.Of = ((Result < -32768) || (Result > 32767)) ? TRUE : FALSE; /* Write back the result */ - State->GeneralRegs[SOFT386_REG_EAX].LowWord = LOWORD(Result); - State->GeneralRegs[SOFT386_REG_EDX].LowWord = HIWORD(Result); + State->GeneralRegs[FAST486_REG_EAX].LowWord = LOWORD(Result); + State->GeneralRegs[FAST486_REG_EDX].LowWord = HIWORD(Result); } break; @@ -1323,25 +1323,25 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF7) { if (OperandSize) { - ULONGLONG Dividend = (ULONGLONG)State->GeneralRegs[SOFT386_REG_EAX].Long - | ((ULONGLONG)State->GeneralRegs[SOFT386_REG_EDX].Long << 32); + ULONGLONG Dividend = (ULONGLONG)State->GeneralRegs[FAST486_REG_EAX].Long + | ((ULONGLONG)State->GeneralRegs[FAST486_REG_EDX].Long << 32); ULONG Quotient = Dividend / Value; ULONG Remainder = Dividend % Value; /* Write back the results */ - State->GeneralRegs[SOFT386_REG_EAX].Long = Quotient; - State->GeneralRegs[SOFT386_REG_EDX].Long = Remainder; + State->GeneralRegs[FAST486_REG_EAX].Long = Quotient; + State->GeneralRegs[FAST486_REG_EDX].Long = Remainder; } else { - ULONG Dividend = (ULONG)State->GeneralRegs[SOFT386_REG_EAX].LowWord - | ((ULONG)State->GeneralRegs[SOFT386_REG_EDX].LowWord << 16); + ULONG Dividend = (ULONG)State->GeneralRegs[FAST486_REG_EAX].LowWord + | ((ULONG)State->GeneralRegs[FAST486_REG_EDX].LowWord << 16); USHORT Quotient = Dividend / Value; USHORT Remainder = Dividend % Value; /* Write back the results */ - State->GeneralRegs[SOFT386_REG_EAX].LowWord = Quotient; - State->GeneralRegs[SOFT386_REG_EDX].LowWord = Remainder; + State->GeneralRegs[FAST486_REG_EAX].LowWord = Quotient; + State->GeneralRegs[FAST486_REG_EDX].LowWord = Remainder; } break; @@ -1352,25 +1352,25 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF7) { if (OperandSize) { - LONGLONG Dividend = (LONGLONG)State->GeneralRegs[SOFT386_REG_EAX].Long - | ((LONGLONG)State->GeneralRegs[SOFT386_REG_EDX].Long << 32); + LONGLONG Dividend = (LONGLONG)State->GeneralRegs[FAST486_REG_EAX].Long + | ((LONGLONG)State->GeneralRegs[FAST486_REG_EDX].Long << 32); LONG Quotient = Dividend / (LONG)Value; LONG Remainder = Dividend % (LONG)Value; /* Write back the results */ - State->GeneralRegs[SOFT386_REG_EAX].Long = (ULONG)Quotient; - State->GeneralRegs[SOFT386_REG_EDX].Long = (ULONG)Remainder; + State->GeneralRegs[FAST486_REG_EAX].Long = (ULONG)Quotient; + State->GeneralRegs[FAST486_REG_EDX].Long = (ULONG)Remainder; } else { - LONG Dividend = (LONG)State->GeneralRegs[SOFT386_REG_EAX].LowWord - | ((LONG)State->GeneralRegs[SOFT386_REG_EDX].LowWord << 16); + LONG Dividend = (LONG)State->GeneralRegs[FAST486_REG_EAX].LowWord + | ((LONG)State->GeneralRegs[FAST486_REG_EDX].LowWord << 16); SHORT Quotient = Dividend / (SHORT)LOWORD(Value); SHORT Remainder = Dividend % (SHORT)LOWORD(Value); /* Write back the results */ - State->GeneralRegs[SOFT386_REG_EAX].LowWord = (USHORT)Quotient; - State->GeneralRegs[SOFT386_REG_EDX].LowWord = (USHORT)Remainder; + State->GeneralRegs[FAST486_REG_EAX].LowWord = (USHORT)Quotient; + State->GeneralRegs[FAST486_REG_EDX].LowWord = (USHORT)Remainder; } break; @@ -1380,19 +1380,19 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF7) return TRUE; } -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFE) +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupFE) { UCHAR Dummy, Value; - SOFT386_MOD_REG_RM ModRegRm; - BOOLEAN AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + FAST486_MOD_REG_RM ModRegRm; + BOOLEAN AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -1401,12 +1401,12 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFE) if (ModRegRm.Register > 1) { /* Invalid */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } /* Read the operands */ - if (!Soft386ReadModrmByteOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmByteOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; @@ -1430,35 +1430,35 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFE) /* Update flags */ State->Flags.Sf = (Value & SIGN_FLAG_BYTE) ? TRUE : FALSE; State->Flags.Zf = (Value == 0) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Value); + State->Flags.Pf = Fast486CalculateParity(Value); /* Write back the result */ - return Soft386WriteModrmByteOperands(State, + return Fast486WriteModrmByteOperands(State, &ModRegRm, FALSE, Value); } -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupFF) { - SOFT386_MOD_REG_RM ModRegRm; + FAST486_MOD_REG_RM ModRegRm; BOOLEAN OperandSize, AddressSize; - OperandSize = AddressSize = State->SegmentRegs[SOFT386_REG_CS].Size; + OperandSize = AddressSize = State->SegmentRegs[FAST486_REG_CS].Size; - if (State->PrefixFlags & SOFT386_PREFIX_OPSIZE) + if (State->PrefixFlags & FAST486_PREFIX_OPSIZE) { /* The OPSIZE prefix toggles the size */ OperandSize = !OperandSize; } - if (State->PrefixFlags & SOFT386_PREFIX_ADSIZE) + if (State->PrefixFlags & FAST486_PREFIX_ADSIZE) { /* The ADSIZE prefix toggles the size */ AddressSize = !AddressSize; } - if (!Soft386ParseModRegRm(State, AddressSize, &ModRegRm)) + if (!Fast486ParseModRegRm(State, AddressSize, &ModRegRm)) { /* Exception occurred */ return FALSE; @@ -1467,7 +1467,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) if (ModRegRm.Register == 7) { /* Invalid */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -1476,7 +1476,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) { ULONG Dummy, Value; - if (!Soft386ReadModrmDwordOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmDwordOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; @@ -1499,7 +1499,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) else if (ModRegRm.Register == 2) { /* Push the current value of EIP */ - if (!Soft386StackPush(State, State->InstPtr.Long)) + if (!Fast486StackPush(State, State->InstPtr.Long)) { /* Exception occurred */ return FALSE; @@ -1511,17 +1511,17 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) else if (ModRegRm.Register == 3) { USHORT Selector; - INT Segment = SOFT386_REG_DS; + INT Segment = FAST486_REG_DS; /* Check for the segment override */ - if (State->PrefixFlags & SOFT386_PREFIX_SEG) + if (State->PrefixFlags & FAST486_PREFIX_SEG) { /* Use the override segment instead */ Segment = State->SegmentOverride; } /* Read the selector */ - if (!Soft386ReadMemory(State, + if (!Fast486ReadMemory(State, Segment, ModRegRm.MemoryAddress + sizeof(ULONG), FALSE, @@ -1533,21 +1533,21 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) } /* Push the current value of CS */ - if (!Soft386StackPush(State, State->SegmentRegs[SOFT386_REG_CS].Selector)) + if (!Fast486StackPush(State, State->SegmentRegs[FAST486_REG_CS].Selector)) { /* Exception occurred */ return FALSE; } /* Push the current value of EIP */ - if (!Soft386StackPush(State, State->InstPtr.Long)) + if (!Fast486StackPush(State, State->InstPtr.Long)) { /* Exception occurred */ return FALSE; } /* Load the new code segment */ - if (!Soft386LoadSegment(State, SOFT386_REG_CS, Selector)) + if (!Fast486LoadSegment(State, FAST486_REG_CS, Selector)) { /* Exception occurred */ return FALSE; @@ -1564,17 +1564,17 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) else if (ModRegRm.Register == 5) { USHORT Selector; - INT Segment = SOFT386_REG_DS; + INT Segment = FAST486_REG_DS; /* Check for the segment override */ - if (State->PrefixFlags & SOFT386_PREFIX_SEG) + if (State->PrefixFlags & FAST486_PREFIX_SEG) { /* Use the override segment instead */ Segment = State->SegmentOverride; } /* Read the selector */ - if (!Soft386ReadMemory(State, + if (!Fast486ReadMemory(State, Segment, ModRegRm.MemoryAddress + sizeof(ULONG), FALSE, @@ -1586,7 +1586,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) } /* Load the new code segment */ - if (!Soft386LoadSegment(State, SOFT386_REG_CS, Selector)) + if (!Fast486LoadSegment(State, FAST486_REG_CS, Selector)) { /* Exception occurred */ return FALSE; @@ -1598,7 +1598,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) else if (ModRegRm.Register == 6) { /* Push the value on to the stack */ - return Soft386StackPush(State, Value); + return Fast486StackPush(State, Value); } if (ModRegRm.Register <= 1) @@ -1606,10 +1606,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) /* Update flags */ State->Flags.Sf = (Value & SIGN_FLAG_LONG) ? TRUE : FALSE; State->Flags.Zf = (Value == 0) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Value); + State->Flags.Pf = Fast486CalculateParity(Value); /* Write back the result */ - return Soft386WriteModrmDwordOperands(State, + return Fast486WriteModrmDwordOperands(State, &ModRegRm, FALSE, Value); @@ -1619,7 +1619,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) { USHORT Dummy, Value; - if (!Soft386ReadModrmWordOperands(State, &ModRegRm, &Dummy, &Value)) + if (!Fast486ReadModrmWordOperands(State, &ModRegRm, &Dummy, &Value)) { /* Exception occurred */ return FALSE; @@ -1642,7 +1642,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) else if (ModRegRm.Register == 2) { /* Push the current value of IP */ - if (!Soft386StackPush(State, State->InstPtr.LowWord)) + if (!Fast486StackPush(State, State->InstPtr.LowWord)) { /* Exception occurred */ return FALSE; @@ -1654,17 +1654,17 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) else if (ModRegRm.Register == 3) { USHORT Selector; - INT Segment = SOFT386_REG_DS; + INT Segment = FAST486_REG_DS; /* Check for the segment override */ - if (State->PrefixFlags & SOFT386_PREFIX_SEG) + if (State->PrefixFlags & FAST486_PREFIX_SEG) { /* Use the override segment instead */ Segment = State->SegmentOverride; } /* Read the selector */ - if (!Soft386ReadMemory(State, + if (!Fast486ReadMemory(State, Segment, ModRegRm.MemoryAddress + sizeof(USHORT), FALSE, @@ -1676,21 +1676,21 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) } /* Push the current value of CS */ - if (!Soft386StackPush(State, State->SegmentRegs[SOFT386_REG_CS].Selector)) + if (!Fast486StackPush(State, State->SegmentRegs[FAST486_REG_CS].Selector)) { /* Exception occurred */ return FALSE; } /* Push the current value of IP */ - if (!Soft386StackPush(State, State->InstPtr.LowWord)) + if (!Fast486StackPush(State, State->InstPtr.LowWord)) { /* Exception occurred */ return FALSE; } /* Load the new code segment */ - if (!Soft386LoadSegment(State, SOFT386_REG_CS, Selector)) + if (!Fast486LoadSegment(State, FAST486_REG_CS, Selector)) { /* Exception occurred */ return FALSE; @@ -1708,17 +1708,17 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) else if (ModRegRm.Register == 5) { USHORT Selector; - INT Segment = SOFT386_REG_DS; + INT Segment = FAST486_REG_DS; /* Check for the segment override */ - if (State->PrefixFlags & SOFT386_PREFIX_SEG) + if (State->PrefixFlags & FAST486_PREFIX_SEG) { /* Use the override segment instead */ Segment = State->SegmentOverride; } /* Read the selector */ - if (!Soft386ReadMemory(State, + if (!Fast486ReadMemory(State, Segment, ModRegRm.MemoryAddress + sizeof(USHORT), FALSE, @@ -1730,7 +1730,7 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) } /* Load the new code segment */ - if (!Soft386LoadSegment(State, SOFT386_REG_CS, Selector)) + if (!Fast486LoadSegment(State, FAST486_REG_CS, Selector)) { /* Exception occurred */ return FALSE; @@ -1742,12 +1742,12 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) else if (ModRegRm.Register == 6) { /* Push the value on to the stack */ - return Soft386StackPush(State, Value); + return Fast486StackPush(State, Value); } else { /* Invalid */ - Soft386Exception(State, SOFT386_EXCEPTION_UD); + Fast486Exception(State, FAST486_EXCEPTION_UD); return FALSE; } @@ -1756,10 +1756,10 @@ SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF) /* Update flags */ State->Flags.Sf = (Value & SIGN_FLAG_WORD) ? TRUE : FALSE; State->Flags.Zf = (Value == 0) ? TRUE : FALSE; - State->Flags.Pf = Soft386CalculateParity(Value); + State->Flags.Pf = Fast486CalculateParity(Value); /* Write back the result */ - return Soft386WriteModrmWordOperands(State, + return Fast486WriteModrmWordOperands(State, &ModRegRm, FALSE, Value); diff --git a/lib/soft386/opgroups.h b/lib/fast486/opgroups.h similarity index 55% rename from lib/soft386/opgroups.h rename to lib/fast486/opgroups.h index 71b6d4b4a68..fb7dcd40c34 100644 --- a/lib/soft386/opgroups.h +++ b/lib/fast486/opgroups.h @@ -1,5 +1,5 @@ /* - * Soft386 386/486 CPU Emulation Library + * Fast486 386/486 CPU Emulation Library * opgroups.h * * Copyright (C) 2013 Aleksandar Andrejevic @@ -24,22 +24,22 @@ /* DEFINES ********************************************************************/ -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroup8082); -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroup81); -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroup83); -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroup8F); -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupC0); -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupC1); -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupC6); -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupC7); -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupD0); -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupD1); -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupD2); -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupD3); -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF6); -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupF7); -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFE); -SOFT386_OPCODE_HANDLER(Soft386OpcodeGroupFF); +FAST486_OPCODE_HANDLER(Fast486OpcodeGroup8082); +FAST486_OPCODE_HANDLER(Fast486OpcodeGroup81); +FAST486_OPCODE_HANDLER(Fast486OpcodeGroup83); +FAST486_OPCODE_HANDLER(Fast486OpcodeGroup8F); +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupC0); +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupC1); +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupC6); +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupC7); +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupD0); +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupD1); +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupD2); +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupD3); +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupF6); +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupF7); +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupFE); +FAST486_OPCODE_HANDLER(Fast486OpcodeGroupFF); #endif // _OPGROUPS_H_ diff --git a/lib/soft386/CMakeLists.txt b/lib/soft386/CMakeLists.txt deleted file mode 100644 index 36d94c0abee..00000000000 --- a/lib/soft386/CMakeLists.txt +++ /dev/null @@ -1,11 +0,0 @@ - -include_directories(${REACTOS_SOURCE_DIR}/include/reactos/libs/soft386) - -list(APPEND SOURCE - soft386.c - opcodes.c - opgroups.c - extraops.c - common.c) - -add_library(soft386 ${SOURCE}) diff --git a/lib/soft386/opcodes.h b/lib/soft386/opcodes.h deleted file mode 100644 index a889df78190..00000000000 --- a/lib/soft386/opcodes.h +++ /dev/null @@ -1,159 +0,0 @@ -/* - * Soft386 386/486 CPU Emulation Library - * opcodes.h - * - * Copyright (C) 2013 Aleksandar Andrejevic - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -#ifndef _OPCODES_H_ -#define _OPCODES_H_ - -/* DEFINES ********************************************************************/ - -#ifndef FASTCALL -#define FASTCALL __fastcall -#endif - -#define SOFT386_NUM_OPCODE_HANDLERS 256 -#define SOFT386_OPCODE_WRITE_REG (1 << 1) -#define SOFT386_OPCODE_HANDLER(x) \ - BOOLEAN FASTCALL x(PSOFT386_STATE State, UCHAR Opcode) - -typedef BOOLEAN (FASTCALL *SOFT386_OPCODE_HANDLER_PROC)(PSOFT386_STATE, UCHAR); - -extern -SOFT386_OPCODE_HANDLER_PROC -Soft386OpcodeHandlers[SOFT386_NUM_OPCODE_HANDLERS]; - -SOFT386_OPCODE_HANDLER(Soft386OpcodePrefix); -SOFT386_OPCODE_HANDLER(Soft386OpcodeIncrement); -SOFT386_OPCODE_HANDLER(Soft386OpcodeDecrement); -SOFT386_OPCODE_HANDLER(Soft386OpcodePushReg); -SOFT386_OPCODE_HANDLER(Soft386OpcodePopReg); -SOFT386_OPCODE_HANDLER(Soft386OpcodeNop); -SOFT386_OPCODE_HANDLER(Soft386OpcodeExchangeEax); -SOFT386_OPCODE_HANDLER(Soft386OpcodeShortConditionalJmp); -SOFT386_OPCODE_HANDLER(Soft386OpcodeClearCarry); -SOFT386_OPCODE_HANDLER(Soft386OpcodeSetCarry); -SOFT386_OPCODE_HANDLER(Soft386OpcodeComplCarry); -SOFT386_OPCODE_HANDLER(Soft386OpcodeClearInt); -SOFT386_OPCODE_HANDLER(Soft386OpcodeSetInt); -SOFT386_OPCODE_HANDLER(Soft386OpcodeClearDir); -SOFT386_OPCODE_HANDLER(Soft386OpcodeSetDir); -SOFT386_OPCODE_HANDLER(Soft386OpcodeHalt); -SOFT386_OPCODE_HANDLER(Soft386OpcodeInByte); -SOFT386_OPCODE_HANDLER(Soft386OpcodeIn); -SOFT386_OPCODE_HANDLER(Soft386OpcodeOutByte); -SOFT386_OPCODE_HANDLER(Soft386OpcodeOut); -SOFT386_OPCODE_HANDLER(Soft386OpcodeShortJump); -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovRegImm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovByteRegImm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeAddByteModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeAddModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeAddAl); -SOFT386_OPCODE_HANDLER(Soft386OpcodeAddEax); -SOFT386_OPCODE_HANDLER(Soft386OpcodeOrByteModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeOrModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeOrAl); -SOFT386_OPCODE_HANDLER(Soft386OpcodeOrEax); -SOFT386_OPCODE_HANDLER(Soft386OpcodeAndByteModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeAndModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeAndAl); -SOFT386_OPCODE_HANDLER(Soft386OpcodeAndEax); -SOFT386_OPCODE_HANDLER(Soft386OpcodeXorByteModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeXorModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeXorAl); -SOFT386_OPCODE_HANDLER(Soft386OpcodeXorEax); -SOFT386_OPCODE_HANDLER(Soft386OpcodeTestByteModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeTestModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeTestAl); -SOFT386_OPCODE_HANDLER(Soft386OpcodeTestEax); -SOFT386_OPCODE_HANDLER(Soft386OpcodeXchgByteModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeXchgModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodePushEs); -SOFT386_OPCODE_HANDLER(Soft386OpcodePopEs); -SOFT386_OPCODE_HANDLER(Soft386OpcodePushCs); -SOFT386_OPCODE_HANDLER(Soft386OpcodeAdcByteModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeAdcModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeAdcAl); -SOFT386_OPCODE_HANDLER(Soft386OpcodeAdcEax); -SOFT386_OPCODE_HANDLER(Soft386OpcodePushSs); -SOFT386_OPCODE_HANDLER(Soft386OpcodePopSs); -SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbByteModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbAl); -SOFT386_OPCODE_HANDLER(Soft386OpcodeSbbEax); -SOFT386_OPCODE_HANDLER(Soft386OpcodePushDs); -SOFT386_OPCODE_HANDLER(Soft386OpcodePopDs); -SOFT386_OPCODE_HANDLER(Soft386OpcodeDaa); -SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubByteModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubAl); -SOFT386_OPCODE_HANDLER(Soft386OpcodeCmpSubEax); -SOFT386_OPCODE_HANDLER(Soft386OpcodeDas); -SOFT386_OPCODE_HANDLER(Soft386OpcodeAaa); -SOFT386_OPCODE_HANDLER(Soft386OpcodeAas); -SOFT386_OPCODE_HANDLER(Soft386OpcodePushAll); -SOFT386_OPCODE_HANDLER(Soft386OpcodePopAll); -SOFT386_OPCODE_HANDLER(Soft386OpcodeBound); -SOFT386_OPCODE_HANDLER(Soft386OpcodeArpl); -SOFT386_OPCODE_HANDLER(Soft386OpcodePushImm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeImulModrmImm); -SOFT386_OPCODE_HANDLER(Soft386OpcodePushByteImm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovByteModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovModrm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovStoreSeg); -SOFT386_OPCODE_HANDLER(Soft386OpcodeLea); -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovLoadSeg); -SOFT386_OPCODE_HANDLER(Soft386OpcodeCwde); -SOFT386_OPCODE_HANDLER(Soft386OpcodeCdq); -SOFT386_OPCODE_HANDLER(Soft386OpcodeCallAbs); -SOFT386_OPCODE_HANDLER(Soft386OpcodeWait); -SOFT386_OPCODE_HANDLER(Soft386OpcodePushFlags); -SOFT386_OPCODE_HANDLER(Soft386OpcodePopFlags); -SOFT386_OPCODE_HANDLER(Soft386OpcodeSahf); -SOFT386_OPCODE_HANDLER(Soft386OpcodeLahf); -SOFT386_OPCODE_HANDLER(Soft386OpcodeRet); -SOFT386_OPCODE_HANDLER(Soft386OpcodeLdsLes); -SOFT386_OPCODE_HANDLER(Soft386OpcodeEnter); -SOFT386_OPCODE_HANDLER(Soft386OpcodeLeave); -SOFT386_OPCODE_HANDLER(Soft386OpcodeRetFarImm); -SOFT386_OPCODE_HANDLER(Soft386OpcodeRetFar); -SOFT386_OPCODE_HANDLER(Soft386OpcodeInt); -SOFT386_OPCODE_HANDLER(Soft386OpcodeIret); -SOFT386_OPCODE_HANDLER(Soft386OpcodeAam); -SOFT386_OPCODE_HANDLER(Soft386OpcodeAad); -SOFT386_OPCODE_HANDLER(Soft386OpcodeXlat); -SOFT386_OPCODE_HANDLER(Soft386OpcodeLoop); -SOFT386_OPCODE_HANDLER(Soft386OpcodeJecxz); -SOFT386_OPCODE_HANDLER(Soft386OpcodeCall); -SOFT386_OPCODE_HANDLER(Soft386OpcodeJmp); -SOFT386_OPCODE_HANDLER(Soft386OpcodeJmpAbs); -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovAlOffset); -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovEaxOffset); -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovOffsetAl); -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovOffsetEax); -SOFT386_OPCODE_HANDLER(Soft386OpcodeSalc); -SOFT386_OPCODE_HANDLER(Soft386OpcodeMovs); -SOFT386_OPCODE_HANDLER(Soft386OpcodeCmps); -SOFT386_OPCODE_HANDLER(Soft386OpcodeStos); -SOFT386_OPCODE_HANDLER(Soft386OpcodeLods); -SOFT386_OPCODE_HANDLER(Soft386OpcodeScas); -SOFT386_OPCODE_HANDLER(Soft386OpcodeIns); -SOFT386_OPCODE_HANDLER(Soft386OpcodeOuts); - -#endif // _OPCODES_H_ diff --git a/subsystems/ntvdm/CMakeLists.txt b/subsystems/ntvdm/CMakeLists.txt index 2c992d5dc01..0b0113f8864 100644 --- a/subsystems/ntvdm/CMakeLists.txt +++ b/subsystems/ntvdm/CMakeLists.txt @@ -1,6 +1,6 @@ include_directories(${REACTOS_SOURCE_DIR}/include/reactos/libs/softx86) -include_directories(${REACTOS_SOURCE_DIR}/include/reactos/libs/soft386) +include_directories(${REACTOS_SOURCE_DIR}/include/reactos/libs/fast486) spec2def(ntvdm.exe ntvdm.spec) @@ -19,7 +19,7 @@ list(APPEND SOURCE add_executable(ntvdm ${SOURCE}) set_module_type(ntvdm win32cui UNICODE) -target_link_libraries(ntvdm softx86 softx87 soft386) +target_link_libraries(ntvdm softx86 softx87 fast486) add_importlibs(ntvdm msvcrt user32 gdi32 kernel32 ntdll) add_dependencies(ntvdm softx86 softx87) add_cd_file(TARGET ntvdm DESTINATION reactos/system32 FOR all) diff --git a/subsystems/ntvdm/emulator.c b/subsystems/ntvdm/emulator.c index 1c99b574047..42d709f502e 100644 --- a/subsystems/ntvdm/emulator.c +++ b/subsystems/ntvdm/emulator.c @@ -24,7 +24,7 @@ softx86_ctx EmulatorContext; softx87_ctx FpuEmulatorContext; #else -SOFT386_STATE EmulatorContext; +FAST486_STATE EmulatorContext; #endif static BOOLEAN A20Line = FALSE; @@ -239,8 +239,8 @@ static VOID EmulatorBop(WORD Code) StackSegment = EmulatorContext.state->segment_reg[SX86_SREG_SS].val; StackPointer = EmulatorContext.state->general_reg[SX86_REG_SP].val; #else - StackSegment = EmulatorContext.SegmentRegs[SOFT386_REG_SS].Selector; - StackPointer = EmulatorContext.GeneralRegs[SOFT386_REG_ESP].LowWord; + StackSegment = EmulatorContext.SegmentRegs[FAST486_REG_SS].Selector; + StackPointer = EmulatorContext.GeneralRegs[FAST486_REG_ESP].LowWord; #endif /* Get the stack */ @@ -340,7 +340,7 @@ static VOID EmulatorBop(WORD Code) } #ifdef NEW_EMULATOR -static VOID WINAPI EmulatorBiosOperation(PSOFT386_STATE State, WORD Code) +static VOID WINAPI EmulatorBiosOperation(PFAST486_STATE State, WORD Code) { /* * HACK: To maintain softx86 compatbility, just call the old EmulatorBop here. @@ -421,14 +421,14 @@ BOOLEAN EmulatorInitialize() softx87_connect_to_CPU(&EmulatorContext, &FpuEmulatorContext); #else /* Set the callbacks */ - EmulatorContext.MemReadCallback = (SOFT386_MEM_READ_PROC)EmulatorReadMemory; - EmulatorContext.MemWriteCallback = (SOFT386_MEM_WRITE_PROC)EmulatorWriteMemory; - EmulatorContext.IoReadCallback = (SOFT386_IO_READ_PROC)EmulatorReadIo; - EmulatorContext.IoWriteCallback = (SOFT386_IO_WRITE_PROC)EmulatorWriteIo; - EmulatorContext.BopCallback = (SOFT386_BOP_PROC)EmulatorBiosOperation; + EmulatorContext.MemReadCallback = (FAST486_MEM_READ_PROC)EmulatorReadMemory; + EmulatorContext.MemWriteCallback = (FAST486_MEM_WRITE_PROC)EmulatorWriteMemory; + EmulatorContext.IoReadCallback = (FAST486_IO_READ_PROC)EmulatorReadIo; + EmulatorContext.IoWriteCallback = (FAST486_IO_WRITE_PROC)EmulatorWriteIo; + EmulatorContext.BopCallback = (FAST486_BOP_PROC)EmulatorBiosOperation; /* Reset the CPU */ - Soft386Reset(&EmulatorContext); + Fast486Reset(&EmulatorContext); #endif /* Enable interrupts */ @@ -443,7 +443,7 @@ VOID EmulatorSetStack(WORD Segment, DWORD Offset) /* Call the softx86 API */ softx86_set_stack_ptr(&EmulatorContext, Segment, Offset); #else - Soft386SetStack(&EmulatorContext, Segment, Offset); + Fast486SetStack(&EmulatorContext, Segment, Offset); #endif } @@ -454,8 +454,8 @@ VOID EmulatorExecute(WORD Segment, WORD Offset) /* Call the softx86 API */ softx86_set_instruction_ptr(&EmulatorContext, Segment, Offset); #else - /* Tell Soft386 to move the instruction pointer */ - Soft386ExecuteAt(&EmulatorContext, Segment, Offset); + /* Tell Fast486 to move the instruction pointer */ + Fast486ExecuteAt(&EmulatorContext, Segment, Offset); #endif } @@ -472,8 +472,8 @@ VOID EmulatorInterrupt(BYTE Number) /* Call the softx86 API */ softx86_make_simple_interrupt_call(&EmulatorContext, &Segment, &Offset); #else - /* Call the Soft386 API */ - Soft386Interrupt(&EmulatorContext, Number); + /* Call the Fast486 API */ + Fast486Interrupt(&EmulatorContext, Number); #endif } @@ -483,8 +483,8 @@ VOID EmulatorExternalInterrupt(BYTE Number) /* Call the softx86 API */ softx86_ext_hw_signal(&EmulatorContext, Number); #else - /* Call the Soft386 API */ - Soft386Interrupt(&EmulatorContext, Number); + /* Call the Fast486 API */ + Fast486Interrupt(&EmulatorContext, Number); #endif } @@ -538,7 +538,7 @@ VOID EmulatorSetRegister(ULONG Register, ULONG Value) } else { - Soft386SetSegment(&EmulatorContext, Register - EMULATOR_REG_ES, (USHORT)Value); + Fast486SetSegment(&EmulatorContext, Register - EMULATOR_REG_ES, (USHORT)Value); } #endif } @@ -605,10 +605,10 @@ VOID EmulatorStep(VOID) } #else /* Dump the state for debugging purposes */ - // Soft386DumpState(&EmulatorContext); + // Fast486DumpState(&EmulatorContext); /* Execute the next instruction */ - Soft386StepInto(&EmulatorContext); + Fast486StepInto(&EmulatorContext); #endif } diff --git a/subsystems/ntvdm/emulator.h b/subsystems/ntvdm/emulator.h index 34270500d7c..5b6ec6ba192 100644 --- a/subsystems/ntvdm/emulator.h +++ b/subsystems/ntvdm/emulator.h @@ -17,7 +17,7 @@ #include #include #else -#include +#include #endif /* DEFINES ********************************************************************/ @@ -94,7 +94,7 @@ extern softx87_ctx FpuEmulatorContext; #else #define NTVDMCALL __stdcall -extern SOFT386_STATE EmulatorContext; +extern FAST486_STATE EmulatorContext; #endif diff --git a/subsystems/ntvdm/ntvdm.h b/subsystems/ntvdm/ntvdm.h index 371604d9f35..479d938c314 100644 --- a/subsystems/ntvdm/ntvdm.h +++ b/subsystems/ntvdm/ntvdm.h @@ -27,8 +27,8 @@ #define FAR_POINTER(x) ((ULONG_PTR)BaseAddress + TO_LINEAR(HIWORD(x), LOWORD(x))) #define STEPS_PER_CYCLE 256 -// Uncomment the following to use the new Soft386 CPU emulator (EXPERIMENTAL) -// #define NEW_EMULATOR +// Uncomment the following to use the new Fast486 CPU emulator (EXPERIMENTAL) +#define NEW_EMULATOR /* FUNCTIONS ******************************************************************/ -- 2.17.1