decode.h

简单的虚拟机

#include "enenv.h"
#include <stdbool.h>
#define		MAX_MNEMONIC_LEN		32
#define		MAX_OPERAND_LEN		32
#define		MAX_INSTRUCTION_LEN	128

/* linear address of current code */
#define LADDR (cpu.sreg.cs<<4)+cpu.ip

/* current instruction being decoding */
struct INSTRUCTION
{
	/* prefixes */
	char RepeatPrefix; /* rep, repz...*/
	char SegmentPrefix;
	char OperandPrefix; /* byte, word */
	char AddressPrefix; /* ptr word, ptr byte */

	unsigned int	Opcode;
	char	ModRM;
	char	SIB;
	unsigned int	Displacement;
	unsigned int	Immediate;

	unsigned int	LinearAddress;

	/* dFlag: direction flag, indicating source or destination operand */
	/* wFlag: bit width flag, indicating byte or word */
	/* sFlag: */
	char dFlag, wFlag, sFlag;
};

bool hlt; /* global halt flag */

#define REG8 0
#define REG16 1
#define MEM8 2
#define MEM16 3

struct Operand
{
	char RM; /* indicate operand type: REG8 | REG16 | MEM8 | MEM16 */
	int value;
};

/* macros to get and set values of operand */
#define get_memop_val(op) \
	((op).RM&1)?(*(word*)(cpu.ram+(op).value)):(*((byte*)(cpu.ram+op.value)))

#define get_regop_val(op) \
	((op).RM&1)?(*(word*)(op).value):(*(byte*)(op).value)

#define get_op_val(op) \
	((op).RM&2)?(get_memop_val(op)):(get_regop_val(op))

#define set_memop_val(op,val) \
	((op).RM&1)?(*(word*)(cpu.ram+(op).value)=(val)):(*(byte*)(cpu.ram+(op).value)=(val))

#define set_regop_val(op,val) \
	((op).RM&1)?(*(word*)(op).value=(val)):(*(byte*)(op).value=(val))

#define set_op_val(op,val) \
	(op.RM&2)?(set_memop_val(op,(val))):(set_regop_val(op,(val)))



bool decode(); /* the main decode engine */
inline word IndirectAddr(struct INSTRUCTION* Instruction,char RM); /* emulating the indirect-addressing of x86 */
unsigned char *ParseModRM(unsigned char *Code, struct INSTRUCTION* Instruction, struct Operand* operandRM);
unsigned char *ParseRegModRM(unsigned char *Code, struct INSTRUCTION* Instruction, struct Operand* operand1, struct Operand* operand2);
unsigned char *ParseImmediate(unsigned char *Code, struct INSTRUCTION* Instruction, word *Immediate);


/* some mnemonic table
   const char *RepeatPrefixes[] = 	{"lock", "rep", "repe", "repz", "repne", "repnz"};
   const char *AddressPrefixes[] = 	{"qword", "fword", "dword", "word", "byte"};
   const char *SegmentRegisters[] = 	{"es", "cs", "ss", "ds", "fs", "gs"};
   const char *Register32[] = 		{"eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi"};
   const char *Register16[] = 		{"ax", "cx", "dx", "bx", "sp", "bp", "si", "di"};
   const char *Register8[] = 		{"al", "cl", "dl", "bl", "ah", "ch", "dh", "bh"};
   const char *Address16[] = 		{"bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"};
   const char *ArithmeticMnemonic[] = {"add", "or", "adc", "sbb", "and", "sub", "xor", "cmp" };
   const char *BCDAdjustMnemonic[] = {"daa", "das", "aaa", "aas", "aam", "aad"};
   const char *JxxxMnemonic[] = 	{"jo", "jb", "jz", "jbe", "js", "jp", "jl", "jle"};
   const char *JnxxMnemonic[] = 	{"jno", "jnb", "jnz", "ja", "jns", "jnp", "jge", "jg"};
   const char *StrMnemonic[] = 	{"", "", "movs", "cmps", "", "stos", "lods", "scas"};
   const char *LogicalShiftMnemonic[] = {"rol", "ror", "rcl", "rcr", "shl", "shr", "sal", "sar"};
   const char *LoopMnemonic[] = 	{"loopnz", "loopz", "loop"};
   const char *LogicalArithmeticMnemonic[] = {"test", "???", "not", "neg", "mul", "imul", "div", "idiv"};
   const char *FlagMnemonic[] = 	{"clc", "stc", "cli", "sti", "cld", "std"};
   const char *FFOpcodeMnemonic[] = 	{"inc", "dec", "call", "call", "jmp", "jmp", "push"};
   const char *SetxxxMnemonic[] = 	{"seto", "setb", "sete", "setbe", "sets", "setpe", "setl", "setle"};
   const char *SetnxxMnemonic[] = 	{"setno", "setnb", "setne", "seta", "setns", "setpo", "setge", "setg"};
   const char *BTMnemonic[] = 		{"bt", "bts", "btr", "btc"};
   */