c0f45e0b7f
BIOS execution is provided through the `v8086` module, which provides software emulation of an 8086 processor. It is not currently working with some BIOSes and may (read: probably will be) replaced with another emulator (x86emu comes to mind) at some point in the near future. In the meantime, the default video mode for QEMU works with this and it's enough to get us on real VESA instead of fake VBE. The `bochs` module will be renamed in a future commit. Userspace programs have been adjusted to work at bitrates other than 32 *POORLY*. If you write pixels left-to-right, they should work fine. They only work with 24-bpp otherwise, and then you need to be careful of what pixels you are writing when, or you will overwrite things in other pixels. You may pass a commandline argument like the following to set display modes: vid=vesa,1024,768 Or for stranger modes under QEMU or Bochs, use the bochs VBE initializer: vid=bochs,1280,720 Note that the address of the linear framebuffer is still found via hackish probing instead of PCI or trusting the VBE information, so if you have things in the wrong memory ranges (0xE0000000+), be prepared to have them get read. Once again, this entire commit is a massive hack. I am happy that it worked, and I will continue to make it less hacky, but in the meantime, this is what we've got. Happy holidays.
330 lines
7.2 KiB
C
330 lines
7.2 KiB
C
/*
|
|
* Realmode Emulator Plugin
|
|
* - By John Hodge (thePowersGang)
|
|
*
|
|
* This code is published under the FreeBSD licence
|
|
* (See the file COPYING for details)
|
|
*
|
|
* ---
|
|
* Core Emulator Include
|
|
*/
|
|
#ifndef _RME_H_
|
|
#define _RME_H_
|
|
|
|
/**
|
|
* \file rme.h
|
|
* \brief Realmode Emulator Header
|
|
* \author John Hodge (thePowersGang)
|
|
*
|
|
* \section using Using RME
|
|
*
|
|
*/
|
|
|
|
|
|
/**
|
|
* \brief Enable the use of size overrides
|
|
* \note Disabling this will speed up emulation, but may cause undefined
|
|
* behavior with some BIOSes.
|
|
*
|
|
* If set to -1, size overrides will cause a \#UD
|
|
*/
|
|
#define USE_SIZE_OVERRIDES 1
|
|
|
|
/**
|
|
* \brief Size of a memory block
|
|
* \note Feel free to edit this value, just make sure it stays a power
|
|
* of two.
|
|
*/
|
|
#define RME_BLOCK_SIZE 0x1000
|
|
|
|
/**
|
|
* \brief Magic return Instruction Pointer
|
|
*/
|
|
#define RME_MAGIC_IP 0xFFFF
|
|
/**
|
|
* \brief Magic return Code Segment
|
|
*/
|
|
#define RME_MAGIC_CS 0xFFFF
|
|
|
|
/**
|
|
* \brief Error codes returned by ::RME_Call and ::RME_CallInt
|
|
*/
|
|
enum eRME_Errors
|
|
{
|
|
RME_ERR_OK, //!< Exited successfully
|
|
RME_ERR_INVAL, //!< Bad paramater passed to emulator
|
|
RME_ERR_BADMEM, //!< Emulator accessed invalid memory
|
|
RME_ERR_UNDEFOPCODE, //!< Undefined opcode
|
|
RME_ERR_DIVERR, //!< Divide error
|
|
RME_ERR_BUG, //!< Bug in the emulator
|
|
|
|
RME_ERR_LAST //!< Last Error
|
|
};
|
|
|
|
typedef union uGPR
|
|
{
|
|
#if USE_SIZE_OVERRIDES == 1
|
|
uint32_t D;
|
|
#endif
|
|
uint16_t W;
|
|
struct {
|
|
uint8_t L;
|
|
uint8_t H;
|
|
} B;
|
|
} tGPR;
|
|
|
|
/**
|
|
* \brief Emulator state structure
|
|
*/
|
|
typedef struct sRME_State
|
|
{
|
|
//! \brief General Purpose Registers
|
|
//! \{
|
|
tGPR AX, CX, DX, BX, SP, BP, SI, DI;
|
|
|
|
//! \}
|
|
|
|
//! \brief Segment Registers
|
|
//! \{
|
|
uint16_t SS; //!< Stack Segment
|
|
uint16_t DS; //!< Data Segment
|
|
uint16_t ES; //!< Extra Segment
|
|
//! \}
|
|
|
|
//! \brief Program Counter
|
|
//! \{
|
|
uint16_t CS; //!< Code Segment
|
|
uint16_t IP; //!< Instruction Pointer
|
|
//! \}
|
|
|
|
uint16_t Flags; //!< State Flags
|
|
|
|
/**
|
|
* \brief Emulator's Memory
|
|
*
|
|
* The ~1MiB realmode address space is broken into blocks of
|
|
* ::RME_BLOCK_SIZE bytes that can each point to different areas
|
|
* of memory.
|
|
* NOTE: There is no write protection on these blocks
|
|
* \note A value of NULL in a block indicates that the block is invalid
|
|
* \note 0x110000 bytes is all that is accessable using the realmode
|
|
* segmentation scheme (true max is 0xFFFF0+0xFFFF = 0x10FFEF)
|
|
*/
|
|
uint8_t *Memory[0x110000/RME_BLOCK_SIZE]; // 1Mib,64KiB in 256 4 KiB blocks
|
|
|
|
/**
|
|
* \brief High-Level Emulation Callback
|
|
* \param State Emulation state at the interrupt
|
|
* \param IntNum Interrupt number
|
|
* \return 1 if the call was handled, 0 if it should be emulated
|
|
*
|
|
* Called on all in-emulator INT calls
|
|
*/
|
|
int (*HLECallbacks[256])(struct sRME_State *State, int IntNum);
|
|
|
|
int InstrNum; //!< Total executed instructions
|
|
|
|
// --- Decoder State ---
|
|
/**
|
|
* \brief Decoder State
|
|
* \note Should not be touched except by the emulator
|
|
*/
|
|
struct {
|
|
int OverrideSegment;
|
|
int bOverrideOperand;
|
|
int bOverrideAddress;
|
|
int IPOffset;
|
|
} Decoder;
|
|
} tRME_State;
|
|
|
|
|
|
/**
|
|
* \brief Creates a blank RME instance
|
|
*/
|
|
extern tRME_State *RME_CreateState(void);
|
|
|
|
/**
|
|
* \brief Calls an interrupt
|
|
* \param State State returned from ::RME_CreateState
|
|
* \param Num Interrupt number
|
|
*/
|
|
extern int RME_CallInt(tRME_State *State, int Num);
|
|
|
|
/**
|
|
* \brief Executes the emulator until RME_MAGIC_CS:RME_MAGIC_IP is reached
|
|
* \param State State returned from ::RME_CreateState
|
|
*/
|
|
extern int RME_Call(tRME_State *State);
|
|
|
|
/**
|
|
* \brief Prints contents of the state's registers to debug
|
|
* \param State State returned from ::RME_CreateState
|
|
*/
|
|
extern void RME_DumpRegs(tRME_State *State);
|
|
|
|
/*
|
|
* Definitions specific to the internals of the emulator
|
|
*/
|
|
#ifdef _RME_C_
|
|
|
|
/**
|
|
*/
|
|
enum gpRegs
|
|
{
|
|
AL, CL, DL, BL,
|
|
AH, CH, DH, BH
|
|
};
|
|
|
|
enum sRegs
|
|
{
|
|
SREG_ES,
|
|
SREG_CS,
|
|
SREG_SS,
|
|
SREG_DS
|
|
};
|
|
|
|
#define OPCODE_RI(name, code) name##_RI_AL = code|AL, name##_RI_BL = code|BL,\
|
|
name##_RI_CL = code|CL, name##_RI_DL = code|DL,\
|
|
name##_RI_AH = code|AH, name##_RI_BH = code|BH,\
|
|
name##_RI_CH = code|CH, name##_RI_DH = code|DH,\
|
|
name##_RI_AX = code|AL|8, name##_RI_BX = code|BL|8,\
|
|
name##_RI_CX = code|CL|8, name##_RI_DX = code|DL|8,\
|
|
name##_RI_SP = code|AH|8, name##_RI_BP = code|CH|8,\
|
|
name##_RI_SI = code|DH|8, name##_RI_DI = code|BH|8
|
|
|
|
enum opcodes {
|
|
ADD_MR = 0x00, ADD_MRX = 0x01,
|
|
ADD_RM = 0x02, ADD_RMX = 0x03,
|
|
ADD_AI = 0x04, ADD_AIX = 0x05,
|
|
|
|
OR_MR = 0x08, OR_MRX = 0x09,
|
|
OR_RM = 0x0A, OR_RMX = 0x0B,
|
|
OR_AI = 0x0C, OR_AIX = 0x0D,
|
|
|
|
AND_MR = 0x20, AND_MRX = 0x21,
|
|
AND_RM = 0x22, AND_RMX = 0x23,
|
|
AND_AI = 0x24, AND_AIX = 0x25,
|
|
|
|
SUB_MR = 0x28, SUB_MRX = 0x29,
|
|
SUB_RM = 0x2A, SUB_RMX = 0x2B,
|
|
SUB_AI = 0x2C, SUB_AIX = 0x2D,
|
|
|
|
XOR_MR = 0x30, XOR_MRX = 0x31,
|
|
XOR_RM = 0x32, XOR_RMX = 0x33,
|
|
XOR_AI = 0x34, XOR_AIX = 0x35,
|
|
|
|
CMP_MR = 0x38, CMP_MRX = 0x39,
|
|
CMP_RM = 0x3A, CMP_RMX = 0x3B,
|
|
CMP_AI = 0x3C, CMP_AIX = 0x3D,
|
|
|
|
DEC_A = 0x48|AL, DEC_B = 0x48|BL,
|
|
DEC_C = 0x48|CL, DEC_D = 0x48|DL,
|
|
DEC_Sp = 0x48|AH, DEC_Bp = 0x48|CH,
|
|
DEC_Si = 0x48|DH, DEC_Di = 0x48|BH,
|
|
|
|
INC_A = 0x40|AL, INC_B = 0x40|BL,
|
|
INC_C = 0x40|CL, INC_D = 0x40|DL,
|
|
INC_Sp = 0x40|AH, INC_Bp = 0x40|CH,
|
|
INC_Si = 0x40|DH, INC_Di = 0x40|BH,
|
|
|
|
DIV_R = 0xFA, DIV_RX = 0xFB,
|
|
DIV_M = 0xFA, DIV_MX = 0xFB,
|
|
|
|
|
|
INT3 = 0xCC, INT_I = 0xCD,
|
|
IRET = 0xCF,
|
|
|
|
MOV_MoA = 0xA2, MOV_MoAX = 0xA3,
|
|
MOV_AMo = 0xA0, MOV_AMoX = 0xA1,
|
|
OPCODE_RI(MOV, 0xB0),
|
|
MOV_MI = 0xC6, MOV_MIX = 0xC7,
|
|
MOV_MR = 0x88, MOV_MRX = 0x89,
|
|
MOV_RM = 0x8A, MOV_RMX = 0x8B,
|
|
MOV_RS = 0x8C, MOV_SR = 0x8E,
|
|
MOV_MS = 0x8C, MOV_SM = 0x8E,
|
|
|
|
MUL_R = 0xF6, MUL_RX = 0xF7,
|
|
MUL_M = 0xF6, MUL_MX = 0xF7,
|
|
|
|
NOP = 0x90,
|
|
XCHG_AA = 0x90, XCHG_AB = 0x90|BL,
|
|
XCHG_AC = 0x90|CL, XCHG_AD = 0x90|DL,
|
|
XCHG_ASp = 0x90|AH, XCHG_ABp = 0x90|CH,
|
|
XCHG_ASi = 0x90|DH, XCHG_ADi = 0x90|BH,
|
|
XCHG_RM = 0x86,
|
|
|
|
NOT_R = 0xF6, NOT_RX = 0xF7,
|
|
NOT_M = 0xF6, NOT_MX = 0xF7,
|
|
|
|
|
|
IN_AI = 0xE4, IN_AIX = 0xE5,
|
|
IN_ADx = 0xEC, IN_ADxX = 0xED,
|
|
OUT_IA = 0xE6, OUT_IAX = 0xE7,
|
|
OUT_DxA = 0xEE, OUT_DxAX = 0xEF,
|
|
|
|
POP_AX = 0x58|AL, POP_BX = 0x58|BL,
|
|
POP_CX = 0x58|CL, POP_DX = 0x58|DL,
|
|
POP_SP = 0x58|AH, POP_BP = 0x58|CH,
|
|
POP_SI = 0x58|DH, POP_DI = 0x58|BH,
|
|
POP_ES = 7|(SREG_ES<<3),
|
|
POP_SS = 7|(SREG_SS<<3), POP_DS = 7|(SREG_DS<<3),
|
|
POP_MX = 0x8F,
|
|
POPA = 0x61, POPF = 0x9D,
|
|
|
|
PUSH_AX = 0x50|AL, PUSH_BX = 0x50|BL,
|
|
PUSH_CX = 0x50|CL, PUSH_DX = 0x50|DL,
|
|
PUSH_SP = 0x50|AH, PUSH_BP = 0x50|CH,
|
|
PUSH_SI = 0x50|DH, PUSH_DI = 0x50|BH,
|
|
// PUSH_MX = 0xFF, // - TODO: Check (maybe 0x87)
|
|
PUSH_ES = 6|(SREG_ES<<3), PUSH_CS = 6|(SREG_CS<<3),
|
|
PUSH_SS = 6|(SREG_SS<<3), PUSH_DS = 6|(SREG_DS<<3),
|
|
PUSH_I8 = 0x6A, PUSH_I = 0x68,
|
|
PUSHA = 0x60, PUSHF = 0x9C,
|
|
|
|
RET_N = 0xC3, RET_iN = 0xC2,
|
|
RET_F = 0xCB, RET_iF = 0xCA,
|
|
|
|
CALL_MF = 0xFF, CALL_MN = 0xFF,
|
|
CALL_N = 0xE8, CALL_F = 0x9A,
|
|
CALL_R = 0xFF,
|
|
|
|
JMP_MF = 0xFF, JMP_N = 0xE9,
|
|
JMP_S = 0xEB, JMP_F = 0xEA,
|
|
|
|
LES = 0xC4,
|
|
LDS = 0xC5,
|
|
LEA = 0x8D,
|
|
|
|
CLC = 0xF8, STC = 0xF9,
|
|
CLI = 0xFA, STI = 0xFB,
|
|
CLD = 0xFC, STD = 0xFD,
|
|
|
|
TEST_RM = 0x84, TEST_RMX = 0x85,
|
|
TEST_AI = 0xA8, TEST_AIX = 0xA9,
|
|
|
|
MOVSB = 0xA4, MOVSW = 0xA5,
|
|
CMPSB = 0xA6, CMPSW = 0xA7,
|
|
STOSB = 0xAA, STOSW = 0xAB,
|
|
LODSB = 0xAC, LODSW = 0xAD,
|
|
SCASB = 0xAE, SCASW = 0xAF,
|
|
INSB = 0x6C, INSW = 0x6D,
|
|
OUTSB = 0x6E, OUTSW = 0x6F,
|
|
|
|
// --- Unimplementeds
|
|
FPU_ARITH = 0xDC,
|
|
|
|
// --- Overrides
|
|
OVR_ES = 0x26,
|
|
OVR_CS = 0x2E,
|
|
OVR_SS = 0x36,
|
|
OVR_DS = 0x3E,
|
|
|
|
REPNZ = 0xF2, REP = 0xF3,
|
|
LOOPNZ = 0xE0, LOOPZ = 0xE1,
|
|
LOOP = 0xE2
|
|
};
|
|
|
|
#endif
|
|
|
|
#endif
|