GNUBoot
/
coreboot-kgpe-d16
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

use Paulo's reduced version 

git-svn-id: svn://svn.coreboot.org/coreboot/trunk@1853 2b7e53f0-3cfb-0310-b3e9-8179ed1497e1
This commit is contained in:
Li-Ta Lo 2005-01-11 03:18:39 +00:00
parent 3678ad8e38
commit 8b0356c2c9
24 changed files with 10514 additions and 17195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
util/vgabios/helper_exec.c
View File

@ -50,8 +50,8 @@ int run_bios_int(int num)
X86_CS = MEM_RW((num << 2) + 2); X86_CS = MEM_RW((num << 2) + 2);
X86_IP = MEM_RW(num << 2); X86_IP = MEM_RW(num << 2);
//printf("%s: INT %x CS:IP = %x:%x\n", __FUNCTION__, printf("%s: INT %x CS:IP = %x:%x\n", __FUNCTION__,
// num, MEM_RW((num << 2) + 2), MEM_RW(num << 2)); num, MEM_RW((num << 2) + 2), MEM_RW(num << 2));
return 1; return 1;
} }
@ -128,7 +128,7 @@ u8 x_inb(u16 port)
val = inb(port); val = inb(port);
//printf("inb(0x%04x) = 0x%02x\n", port, val); printf("inb(0x%04x) = 0x%02x\n", port, val);
return val; return val;
} }
@ -139,7 +139,7 @@ u16 x_inw(u16 port)
val = inw(port); val = inw(port);
//printf("inw(0x%04x) = 0x%04x\n", port, val); printf("inw(0x%04x) = 0x%04x\n", port, val);
return val; return val;
} }
@ -149,25 +149,26 @@ u32 x_inl(u16 port)
val = inl(port); val = inl(port);
//printf("inl(0x%04x) = 0x%08x\n", port, val); printf("inl(0x%04x) = 0x%08x\n", port, val);
return val; return val;
} }
void x_outb(u16 port, u8 val) void x_outb(u16 port, u8 val)
{ {
//printf("outb(0x%02x, 0x%04x)\n", val, port); printf("outb(0x%02x, 0x%04x)\n",
val, port);
outb(val, port); outb(val, port);
} }
void x_outw(u16 port, u16 val) void x_outw(u16 port, u16 val)
{ {
//printf("outw(0x%04x, 0x%04x)\n", val, port); printf("outw(0x%04x, 0x%04x)\n", val, port);
outw(val, port); outw(val, port);
} }
void x_outl(u16 port, u32 val) void x_outl(u16 port, u32 val)
{ {
//printf("outl(0x%08x, 0x%04x)\n", val, port); printf("outl(0x%08x, 0x%04x)\n", val, port);
outl(val, port); outl(val, port);
} }

4
util/vgabios/int10.c
View File

@ -18,7 +18,7 @@ extern int verbose;
*/ */
int int42_handler() int int42_handler()
{ {
#if 0
if (verbose && X86_AH != 0x0e) { if (verbose && X86_AH != 0x0e) {
printf("int%x\n", current->num); printf("int%x\n", current->num);
x86emu_dump_xregs(); x86emu_dump_xregs();
@ -472,7 +472,7 @@ int int42_handler()
/* Ignored */ /* Ignored */
break; break;
} }
#endif
return 1; return 1;
} }
#endif #endif

2
util/vgabios/int15.c
View File

@ -6,7 +6,7 @@ void x86emu_dump_xregs();
int int15_handler(void) int int15_handler(void)
{ {
printf("\nint15 encountered.\n"); printf("\nint15 encountered.\n");
x86emu_dump_xregs(); //x86emu_dump_xregs();
X86_EAX = 0; X86_EAX = 0;
return 1; return 1;
} }

2
util/vgabios/int1a.c
View File

@ -19,7 +19,7 @@ int int1A_handler()
if (verbose) { if (verbose) {
printf("\nint1a encountered.\n"); printf("\nint1a encountered.\n");
x86emu_dump_xregs(); //x86emu_dump_xregs();
} }
switch (X86_AX) { switch (X86_AX) {

14
util/vgabios/pci-userspace.c
View File

@ -44,7 +44,7 @@ PCITAG findPci(unsigned short bx)
tag->slot = slot; tag->slot = slot;
tag->func = func; tag->func = func;
if (pci_get_dev(pacc, bus, slot, func)) if (pci_get_dev(pacc, 0, bus, slot, func))
return tag; return tag;
return NULL; return NULL;
@ -58,7 +58,7 @@ u32 pciSlotBX(PCITAG tag)
u8 pciReadByte(PCITAG tag, u32 idx) u8 pciReadByte(PCITAG tag, u32 idx)
{ {
struct pci_dev *d; struct pci_dev *d;
if ((d = pci_get_dev(pacc, tag->bus, tag->slot, tag->func))) if ((d = pci_get_dev(pacc, 0, tag->bus, tag->slot, tag->func)))
return pci_read_byte(d, idx); return pci_read_byte(d, idx);
#ifdef DEBUG_PCI #ifdef DEBUG_PCI
printf("PCI: device not found while read byte (%x:%x.%x)\n", printf("PCI: device not found while read byte (%x:%x.%x)\n",
@ -70,7 +70,7 @@ u8 pciReadByte(PCITAG tag, u32 idx)
u16 pciReadWord(PCITAG tag, u32 idx) u16 pciReadWord(PCITAG tag, u32 idx)
{ {
struct pci_dev *d; struct pci_dev *d;
if ((d = pci_get_dev(pacc, tag->bus, tag->slot, tag->func))) if ((d = pci_get_dev(pacc, 0, tag->bus, tag->slot, tag->func)))
return pci_read_word(d, idx); return pci_read_word(d, idx);
#ifdef DEBUG_PCI #ifdef DEBUG_PCI
printf("PCI: device not found while read word (%x:%x.%x)\n", printf("PCI: device not found while read word (%x:%x.%x)\n",
@ -82,7 +82,7 @@ u16 pciReadWord(PCITAG tag, u32 idx)
u32 pciReadLong(PCITAG tag, u32 idx) u32 pciReadLong(PCITAG tag, u32 idx)
{ {
struct pci_dev *d; struct pci_dev *d;
if ((d = pci_get_dev(pacc, tag->bus, tag->slot, tag->func))) if ((d = pci_get_dev(pacc, 0, tag->bus, tag->slot, tag->func)))
return pci_read_long(d, idx); return pci_read_long(d, idx);
#ifdef DEBUG_PCI #ifdef DEBUG_PCI
printf("PCI: device not found while read long (%x:%x.%x)\n", printf("PCI: device not found while read long (%x:%x.%x)\n",
@ -95,7 +95,7 @@ u32 pciReadLong(PCITAG tag, u32 idx)
void pciWriteLong(PCITAG tag, u32 idx, u32 data) void pciWriteLong(PCITAG tag, u32 idx, u32 data)
{ {
struct pci_dev *d; struct pci_dev *d;
if ((d = pci_get_dev(pacc, tag->bus, tag->slot, tag->func))) if ((d = pci_get_dev(pacc, 0, tag->bus, tag->slot, tag->func)))
pci_write_long(d, idx, data); pci_write_long(d, idx, data);
#ifdef DEBUG_PCI #ifdef DEBUG_PCI
else else
@ -107,7 +107,7 @@ void pciWriteLong(PCITAG tag, u32 idx, u32 data)
void pciWriteWord(PCITAG tag, u32 idx, u16 data) void pciWriteWord(PCITAG tag, u32 idx, u16 data)
{ {
struct pci_dev *d; struct pci_dev *d;
if ((d = pci_get_dev(pacc, tag->bus, tag->slot, tag->func))) if ((d = pci_get_dev(pacc, 0, tag->bus, tag->slot, tag->func)))
pci_write_word(d, idx, data); pci_write_word(d, idx, data);
#ifdef DEBUG_PCI #ifdef DEBUG_PCI
else else
@ -120,7 +120,7 @@ void pciWriteWord(PCITAG tag, u32 idx, u16 data)
void pciWriteByte(PCITAG tag, u32 idx, u8 data) void pciWriteByte(PCITAG tag, u32 idx, u8 data)
{ {
struct pci_dev *d; struct pci_dev *d;
if ((d = pci_get_dev(pacc, tag->bus, tag->slot, tag->func))) if ((d = pci_get_dev(pacc, 0, tag->bus, tag->slot, tag->func)))
pci_write_long(d, idx, data); pci_write_long(d, idx, data);
#ifdef DEBUG_PCI #ifdef DEBUG_PCI
else else

6
util/vgabios/testbios.c
View File

@ -76,7 +76,7 @@ void do_int(int num)
if (!ret) { if (!ret) {
printf("\nint%x: not implemented\n", num); printf("\nint%x: not implemented\n", num);
x86emu_dump_xregs(); //x86emu_dump_xregs();
} }
} }
@ -317,10 +317,10 @@ int main(int argc, char **argv)
if (trace) { if (trace) {
printf("Switching to single step mode.\n"); printf("Switching to single step mode.\n");
X86EMU_trace_on(); //X86EMU_trace_on();
} }
if (debugflag) { if (debugflag) {
X86EMU_set_debug(debugflag); //X86EMU_set_debug(debugflag);
} }
X86EMU_exec(); X86EMU_exec();
/* Cleaning up */ /* Cleaning up */

2
util/vgabios/x86emu/include/x86emu.h
View File

@ -181,6 +181,8 @@ void X86EMU_halt_sys(void);
#define DEBUG_TRACECALL_REGS_F 0x004000 #define DEBUG_TRACECALL_REGS_F 0x004000
#define DEBUG_DECODE_NOPRINT_F 0x008000 #define DEBUG_DECODE_NOPRINT_F 0x008000
#define DEBUG_SAVE_IP_CS_F 0x010000 #define DEBUG_SAVE_IP_CS_F 0x010000
#define DEBUG_EXIT 0x020000
#define DEBUG_SAVE_CS_IP 0x040000
#define DEBUG_SYS_F (DEBUG_SVC_F|DEBUG_FS_F|DEBUG_PROC_F) #define DEBUG_SYS_F (DEBUG_SVC_F|DEBUG_FS_F|DEBUG_PROC_F)
void X86EMU_trace_regs(void); void X86EMU_trace_regs(void);

288
util/vgabios/x86emu/src/x86emu/debug.c
View File

@ -2,7 +2,7 @@
* *
* Realmode X86 Emulator Library * Realmode X86 Emulator Library
* *
* Copyright (C) 1996-1999 SciTech Software, Inc. * Copyright (C) 1991-2004 SciTech Software, Inc.
* Copyright (C) David Mosberger-Tang * Copyright (C) David Mosberger-Tang
* Copyright (C) 1999 Egbert Eich * Copyright (C) 1999 Egbert Eich
* *
@ -36,56 +36,50 @@
* emulator. * emulator.
* *
****************************************************************************/ ****************************************************************************/
/* $XFree86: xc/extras/x86emu/src/x86emu/debug.c,v 1.4 2000/04/17 16:29:45 eich Exp $ */
#include "x86emu/x86emui.h" #include "x86emu/x86emui.h"
#ifdef IN_MODULE
#include "xf86_ansic.h"
#else
#include <stdarg.h> #include <stdarg.h>
#include <stdlib.h>
#endif
/*----------------------------- Implementation ----------------------------*/ /*----------------------------- Implementation ----------------------------*/
#ifdef DEBUG #ifdef DEBUG
static void print_encoded_bytes(u16 s, u16 o); static void print_encoded_bytes (u16 s, u16 o);
static void print_decoded_instruction(void); static void print_decoded_instruction (void);
static int parse_line(char *s, int *ps, int *n); static int parse_line (char *s, int *ps, int *n);
/* should look something like debug's output. */ /* should look something like debug's output. */
void X86EMU_trace_regs(void) void X86EMU_trace_regs (void)
{ {
if (DEBUG_TRACE()) { if (DEBUG_TRACE()) {
x86emu_dump_regs(); x86emu_dump_regs();
} }
if (DEBUG_DECODE() && !DEBUG_DECODE_NOPRINT()) { if (DEBUG_DECODE() && ! DEBUG_DECODE_NOPRINT()) {
printk("%04x:%04x ", M.x86.saved_cs, M.x86.saved_ip); printk("%04x:%04x ",M.x86.saved_cs, M.x86.saved_ip);
print_encoded_bytes(M.x86.saved_cs, M.x86.saved_ip); print_encoded_bytes( M.x86.saved_cs, M.x86.saved_ip);
print_decoded_instruction(); print_decoded_instruction();
} }
} }
void X86EMU_trace_xregs(void) void X86EMU_trace_xregs (void)
{ {
if (DEBUG_TRACE()) { if (DEBUG_TRACE()) {
x86emu_dump_xregs(); x86emu_dump_xregs();
} }
} }
void x86emu_just_disassemble(void) void x86emu_just_disassemble (void)
{ {
/* /*
* This routine called if the flag DEBUG_DISASSEMBLE is set kind * This routine called if the flag DEBUG_DISASSEMBLE is set kind
* of a hack! * of a hack!
*/ */
printk("%04x:%04x ", M.x86.saved_cs, M.x86.saved_ip); printk("%04x:%04x ",M.x86.saved_cs, M.x86.saved_ip);
print_encoded_bytes(M.x86.saved_cs, M.x86.saved_ip); print_encoded_bytes( M.x86.saved_cs, M.x86.saved_ip);
print_decoded_instruction(); print_decoded_instruction();
} }
static void disassemble_forward(u16 seg, u16 off, int n) static void disassemble_forward (u16 seg, u16 off, int n)
{ {
X86EMU_sysEnv tregs; X86EMU_sysEnv tregs;
int i; int i;
@ -133,104 +127,103 @@ static void disassemble_forward(u16 seg, u16 off, int n)
* the instruction. XXX --- CHECK THAT MEM IS NOT AFFECTED!!! * the instruction. XXX --- CHECK THAT MEM IS NOT AFFECTED!!!
* Note the use of a copy of the register structure... * Note the use of a copy of the register structure...
*/ */
for (i = 0; i < n; i++) { for (i=0; i<n; i++) {
op1 = (*sys_rdb) (((u32) M.x86.R_CS << 4) + (M.x86.R_IP++)); op1 = (*sys_rdb)(((u32)M.x86.R_CS<<4) + (M.x86.R_IP++));
(x86emu_optab[op1]) (op1); (x86emu_optab[op1])(op1);
} }
/* end major hack mode. */ /* end major hack mode. */
} }
void x86emu_check_ip_access(void) void x86emu_check_ip_access (void)
{ {
/* NULL as of now */ /* NULL as of now */
} }
void x86emu_check_sp_access(void) void x86emu_check_sp_access (void)
{ {
} }
void x86emu_check_mem_access(u32 dummy) void x86emu_check_mem_access (u32 dummy)
{ {
/* check bounds, etc */ /* check bounds, etc */
} }
void x86emu_check_data_access(uint dummy1, uint dummy2) void x86emu_check_data_access (uint dummy1, uint dummy2)
{ {
/* check bounds, etc */ /* check bounds, etc */
} }
void x86emu_inc_decoded_inst_len(int x) void x86emu_inc_decoded_inst_len (int x)
{ {
M.x86.enc_pos += x; M.x86.enc_pos += x;
} }
void x86emu_decode_printf(char *x) void x86emu_decode_printf (char *x)
{ {
sprintf(M.x86.decoded_buf + M.x86.enc_str_pos, "%s", x); sprintf(M.x86.decoded_buf+M.x86.enc_str_pos,"%s",x);
M.x86.enc_str_pos += strlen(x); M.x86.enc_str_pos += strlen(x);
} }
void x86emu_decode_printf2(char *x, int y) void x86emu_decode_printf2 (char *x, int y)
{ {
char temp[100]; char temp[100];
sprintf(temp, x, y); sprintf(temp,x,y);
sprintf(M.x86.decoded_buf + M.x86.enc_str_pos, "%s", temp); sprintf(M.x86.decoded_buf+M.x86.enc_str_pos,"%s",temp);
M.x86.enc_str_pos += strlen(temp); M.x86.enc_str_pos += strlen(temp);
} }
void x86emu_end_instr(void) void x86emu_end_instr (void)
{ {
M.x86.enc_str_pos = 0; M.x86.enc_str_pos = 0;
M.x86.enc_pos = 0; M.x86.enc_pos = 0;
} }
static void print_encoded_bytes(u16 s, u16 o) static void print_encoded_bytes (u16 s, u16 o)
{ {
int i; int i;
char buf1[64]; char buf1[64];
for (i = 0; i < M.x86.enc_pos; i++) { for (i=0; i< M.x86.enc_pos; i++) {
sprintf(buf1 + 2 * i, "%02x", fetch_data_byte_abs(s, o + i)); sprintf(buf1+2*i,"%02x", fetch_data_byte_abs(s,o+i));
} }
printk("%-20s", buf1); printk("%-20s",buf1);
} }
static void print_decoded_instruction(void) static void print_decoded_instruction (void)
{ {
printk("%s", M.x86.decoded_buf); printk("%s", M.x86.decoded_buf);
} }
void x86emu_print_int_vect(u16 iv) void x86emu_print_int_vect (u16 iv)
{ {
u16 seg, off; u16 seg,off;
if (iv > 256) if (iv > 256) return;
return; seg = fetch_data_word_abs(0,iv*4);
seg = fetch_data_word_abs(0, iv * 4); off = fetch_data_word_abs(0,iv*4+2);
off = fetch_data_word_abs(0, iv * 4 + 2);
printk("%04x:%04x ", seg, off); printk("%04x:%04x ", seg, off);
} }
void X86EMU_dump_memory(u16 seg, u16 off, u32 amt) void X86EMU_dump_memory (u16 seg, u16 off, u32 amt)
{ {
u32 start = off & 0xfffffff0; u32 start = off & 0xfffffff0;
u32 end = (off + 16) & 0xfffffff0; u32 end = (off+16) & 0xfffffff0;
u32 i; u32 i;
u32 current; u32 current;
current = start; current = start;
while (end <= off + amt) { while (end <= off + amt) {
printk("%04x:%04x ", seg, start); printk("%04x:%04x ", seg, start);
for (i = start; i < off; i++) for (i=start; i< off; i++)
printk(" "); printk(" ");
for (; i < end; i++) for ( ; i< end; i++)
printk("%02x ", fetch_data_byte_abs(seg, i)); printk("%02x ", fetch_data_byte_abs(seg,i));
printk("\n"); printk("\n");
start = end; start = end;
end = start + 16; end = start + 16;
} }
} }
void x86emu_single_step(void) void x86emu_single_step (void)
{ {
char s[1024]; char s[1024];
int ps[10]; int ps[10];
@ -251,34 +244,34 @@ void x86emu_single_step(void)
M.x86.debug &= ~DEBUG_DECODE_NOPRINT_F; M.x86.debug &= ~DEBUG_DECODE_NOPRINT_F;
M.x86.debug |= DEBUG_TRACE_F; M.x86.debug |= DEBUG_TRACE_F;
M.x86.debug &= ~DEBUG_BREAK_F; M.x86.debug &= ~DEBUG_BREAK_F;
print_decoded_instruction(); print_decoded_instruction ();
X86EMU_trace_regs(); X86EMU_trace_regs();
} }
} }
done = 0; done=0;
offset = M.x86.saved_ip; offset = M.x86.saved_ip;
while (!done) { while (!done) {
printk("%x:%x -", M.x86.saved_cs, offset); printk("-");
p = fgets(s, 1023, stdin); p = fgets(s, 1023, stdin);
cmd = parse_line(s, ps, &ntok); cmd = parse_line(s, ps, &ntok);
switch (cmd) { switch(cmd) {
case 'u': case 'u':
disassemble_forward(M.x86.saved_cs, (u16) offset, 10); disassemble_forward(M.x86.saved_cs,(u16)offset,10);
break; break;
case 'd': case 'd':
if (ntok == 2) { if (ntok == 2) {
segment = M.x86.saved_cs; segment = M.x86.saved_cs;
offset = ps[1]; offset = ps[1];
X86EMU_dump_memory(segment, (u16) offset, 16); X86EMU_dump_memory(segment,(u16)offset,16);
offset += 16; offset += 16;
} else if (ntok == 3) { } else if (ntok == 3) {
segment = ps[1]; segment = ps[1];
offset = ps[2]; offset = ps[2];
X86EMU_dump_memory(segment, (u16) offset, 16); X86EMU_dump_memory(segment,(u16)offset,16);
offset += 16; offset += 16;
} else { } else {
segment = M.x86.saved_cs; segment = M.x86.saved_cs;
X86EMU_dump_memory(segment, (u16) offset, 16); X86EMU_dump_memory(segment,(u16)offset,16);
offset += 16; offset += 16;
} }
break; break;
@ -308,10 +301,11 @@ void x86emu_single_step(void)
} }
break; break;
case 'q': case 'q':
exit(1); M.x86.debug |= DEBUG_EXIT;
return;
case 'P': case 'P':
noDecode = (noDecode) ? 0 : 1; noDecode = (noDecode)?0:1;
printk("Toggled decoding to %s\n", (noDecode) ? "FALSE" : "TRUE"); printk("Toggled decoding to %s\n",(noDecode)?"FALSE":"TRUE");
break; break;
case 't': case 't':
case 0: case 0:
@ -323,7 +317,7 @@ void x86emu_single_step(void)
int X86EMU_trace_on(void) int X86EMU_trace_on(void)
{ {
return M.x86.debug |= /*DEBUG_STEP_F | */ DEBUG_DECODE_F | DEBUG_TRACE_F; return M.x86.debug |= DEBUG_STEP_F | DEBUG_DECODE_F | DEBUG_TRACE_F;
} }
int X86EMU_trace_off(void) int X86EMU_trace_off(void)
@ -331,18 +325,12 @@ int X86EMU_trace_off(void)
return M.x86.debug &= ~(DEBUG_STEP_F | DEBUG_DECODE_F | DEBUG_TRACE_F); return M.x86.debug &= ~(DEBUG_STEP_F | DEBUG_DECODE_F | DEBUG_TRACE_F);
} }
int X86EMU_set_debug(int debug) static int parse_line (char *s, int *ps, int *n)
{
return M.x86.debug = debug;
}
static int parse_line(char *s, int *ps, int *n)
{ {
int cmd; int cmd;
*n = 0; *n = 0;
while (*s == ' ' || *s == '\t') while(*s == ' ' || *s == '\t') s++;
s++;
ps[*n] = *s; ps[*n] = *s;
switch (*s) { switch (*s) {
case '\n': case '\n':
@ -354,118 +342,84 @@ static int parse_line(char *s, int *ps, int *n)
} }
while (1) { while (1) {
while (*s != ' ' && *s != '\t' && *s != '\n') while (*s != ' ' && *s != '\t' && *s != '\n') s++;
s++;
if (*s == '\n') if (*s == '\n')
return cmd; return cmd;
while (*s == ' ' || *s == '\t') while(*s == ' ' || *s == '\t') s++;
s++;
sscanf(s, "%x", &ps[*n]); sscanf(s,"%x",&ps[*n]);
*n += 1; *n += 1;
} }
} }
#endif /* DEBUG */ #endif /* DEBUG */
void x86emu_dump_regs(void) void x86emu_dump_regs (void)
{ {
printk("\tAX=%04x ", M.x86.R_AX); printk("\tAX=%04x ", M.x86.R_AX );
printk("BX=%04x ", M.x86.R_BX); printk("BX=%04x ", M.x86.R_BX );
printk("CX=%04x ", M.x86.R_CX); printk("CX=%04x ", M.x86.R_CX );
printk("DX=%04x ", M.x86.R_DX); printk("DX=%04x ", M.x86.R_DX );
printk("SP=%04x ", M.x86.R_SP); printk("SP=%04x ", M.x86.R_SP );
printk("BP=%04x ", M.x86.R_BP); printk("BP=%04x ", M.x86.R_BP );
printk("SI=%04x ", M.x86.R_SI); printk("SI=%04x ", M.x86.R_SI );
printk("DI=%04x\n", M.x86.R_DI); printk("DI=%04x\n", M.x86.R_DI );
printk("\tDS=%04x ", M.x86.R_DS); printk("\tDS=%04x ", M.x86.R_DS );
printk("ES=%04x ", M.x86.R_ES); printk("ES=%04x ", M.x86.R_ES );
printk("SS=%04x ", M.x86.R_SS); printk("SS=%04x ", M.x86.R_SS );
printk("CS=%04x ", M.x86.R_CS); printk("CS=%04x ", M.x86.R_CS );
printk("IP=%04x ", M.x86.R_IP); printk("IP=%04x ", M.x86.R_IP );
if (ACCESS_FLAG(F_OF)) if (ACCESS_FLAG(F_OF)) printk("OV "); /* CHECKED... */
printk("OV "); /* CHECKED... */ else printk("NV ");
else if (ACCESS_FLAG(F_DF)) printk("DN ");
printk("NV "); else printk("UP ");
if (ACCESS_FLAG(F_DF)) if (ACCESS_FLAG(F_IF)) printk("EI ");
printk("DN "); else printk("DI ");
else if (ACCESS_FLAG(F_SF)) printk("NG ");
printk("UP "); else printk("PL ");
if (ACCESS_FLAG(F_IF)) if (ACCESS_FLAG(F_ZF)) printk("ZR ");
printk("EI "); else printk("NZ ");
else if (ACCESS_FLAG(F_AF)) printk("AC ");
printk("DI "); else printk("NA ");
if (ACCESS_FLAG(F_SF)) if (ACCESS_FLAG(F_PF)) printk("PE ");
printk("NG "); else printk("PO ");
else if (ACCESS_FLAG(F_CF)) printk("CY ");
printk("PL "); else printk("NC ");
if (ACCESS_FLAG(F_ZF))
printk("ZR ");
else
printk("NZ ");
if (ACCESS_FLAG(F_AF))
printk("AC ");
else
printk("NA ");
if (ACCESS_FLAG(F_PF))
printk("PE ");
else
printk("PO ");
if (ACCESS_FLAG(F_CF))
printk("CY ");
else
printk("NC ");
printk("\n"); printk("\n");
} }
void x86emu_dump_xregs(void) void x86emu_dump_xregs (void)
{ {
printk("\tEAX=%08x ", M.x86.R_EAX); printk("\tEAX=%08x ", M.x86.R_EAX );
printk("EBX=%08x ", M.x86.R_EBX); printk("EBX=%08x ", M.x86.R_EBX );
printk("ECX=%08x ", M.x86.R_ECX); printk("ECX=%08x ", M.x86.R_ECX );
printk("EDX=%08x \n", M.x86.R_EDX); printk("EDX=%08x \n", M.x86.R_EDX );
printk("\tESP=%08x ", M.x86.R_ESP); printk("\tESP=%08x ", M.x86.R_ESP );
printk("EBP=%08x ", M.x86.R_EBP); printk("EBP=%08x ", M.x86.R_EBP );
printk("ESI=%08x ", M.x86.R_ESI); printk("ESI=%08x ", M.x86.R_ESI );
printk("EDI=%08x\n", M.x86.R_EDI); printk("EDI=%08x\n", M.x86.R_EDI );
printk("\tDS=%04x ", M.x86.R_DS); printk("\tDS=%04x ", M.x86.R_DS );
printk("ES=%04x ", M.x86.R_ES); printk("ES=%04x ", M.x86.R_ES );
printk("SS=%04x ", M.x86.R_SS); printk("SS=%04x ", M.x86.R_SS );
printk("CS=%04x ", M.x86.R_CS); printk("CS=%04x ", M.x86.R_CS );
printk("EIP=%08x\n\t", M.x86.R_EIP); printk("EIP=%08x\n\t", M.x86.R_EIP );
if (ACCESS_FLAG(F_OF)) if (ACCESS_FLAG(F_OF)) printk("OV "); /* CHECKED... */
printk("OV "); /* CHECKED... */ else printk("NV ");
else if (ACCESS_FLAG(F_DF)) printk("DN ");
printk("NV "); else printk("UP ");
if (ACCESS_FLAG(F_DF)) if (ACCESS_FLAG(F_IF)) printk("EI ");
printk("DN "); else printk("DI ");
else if (ACCESS_FLAG(F_SF)) printk("NG ");
printk("UP "); else printk("PL ");
if (ACCESS_FLAG(F_IF)) if (ACCESS_FLAG(F_ZF)) printk("ZR ");
printk("EI "); else printk("NZ ");
else if (ACCESS_FLAG(F_AF)) printk("AC ");
printk("DI "); else printk("NA ");
if (ACCESS_FLAG(F_SF)) if (ACCESS_FLAG(F_PF)) printk("PE ");
printk("NG "); else printk("PO ");
else if (ACCESS_FLAG(F_CF)) printk("CY ");
printk("PL "); else printk("NC ");
if (ACCESS_FLAG(F_ZF))
printk("ZR ");
else
printk("NZ ");
if (ACCESS_FLAG(F_AF))
printk("AC ");
else
printk("NA ");
if (ACCESS_FLAG(F_PF))
printk("PE ");
else
printk("PO ");
if (ACCESS_FLAG(F_CF))
printk("CY ");
else
printk("NC ");
printk("\n"); printk("\n");
} }

509
util/vgabios/x86emu/src/x86emu/decode.c
View File

@ -2,7 +2,7 @@
* *
* Realmode X86 Emulator Library * Realmode X86 Emulator Library
* *
* Copyright (C) 1996-1999 SciTech Software, Inc. * Copyright (C) 1991-2004 SciTech Software, Inc.
* Copyright (C) David Mosberger-Tang * Copyright (C) David Mosberger-Tang
* Copyright (C) 1999 Egbert Eich * Copyright (C) 1999 Egbert Eich
* *
@ -37,8 +37,6 @@
* *
****************************************************************************/ ****************************************************************************/
/* $XFree86: xc/extras/x86emu/src/x86emu/decode.c,v 1.9 2001/01/06 20:19:03 tsi Exp $ */
#include "x86emu/x86emui.h" #include "x86emu/x86emui.h"
/*----------------------------- Implementation ----------------------------*/ /*----------------------------- Implementation ----------------------------*/
@ -54,9 +52,9 @@ static void x86emu_intr_handle(void)
if (M.x86.intr & INTR_SYNCH) { if (M.x86.intr & INTR_SYNCH) {
intno = M.x86.intno; intno = M.x86.intno;
if (_X86EMU_intrTab[intno]) { if (_X86EMU_intrTab[intno]) {
(*_X86EMU_intrTab[intno]) (intno); (*_X86EMU_intrTab[intno])(intno);
} else { } else {
push_word((u16) M.x86.R_FLG); push_word((u16)M.x86.R_FLG);
CLEAR_FLAG(F_IF); CLEAR_FLAG(F_IF);
CLEAR_FLAG(F_TF); CLEAR_FLAG(F_TF);
push_word(M.x86.R_CS); push_word(M.x86.R_CS);
@ -76,7 +74,8 @@ REMARKS:
Raise the specified interrupt to be handled before the execution of the Raise the specified interrupt to be handled before the execution of the
next instruction. next instruction.
****************************************************************************/ ****************************************************************************/
void x86emu_intr_raise(u8 intrnum) void x86emu_intr_raise(
u8 intrnum)
{ {
M.x86.intno = intrnum; M.x86.intno = intrnum;
M.x86.intr |= INTR_SYNCH; M.x86.intr |= INTR_SYNCH;
@ -93,29 +92,37 @@ void X86EMU_exec(void)
u8 op1; u8 op1;
M.x86.intr = 0; M.x86.intr = 0;
DB(x86emu_end_instr(); DB(x86emu_end_instr();)
)
for (;;) { for (;;) {
DB(if (CHECK_IP_FETCH()) DB( if (CHECK_IP_FETCH())
x86emu_check_ip_access();) x86emu_check_ip_access();)
/* If debugging, save the IP and CS values. */ /* If debugging, save the IP and CS values. */
SAVE_IP_CS(M.x86.R_CS, M.x86.R_IP); SAVE_IP_CS(M.x86.R_CS, M.x86.R_IP);
INC_DECODED_INST_LEN(1); INC_DECODED_INST_LEN(1);
if (M.x86.intr) { if (M.x86.intr) {
if (M.x86.intr & INTR_HALTED) { if (M.x86.intr & INTR_HALTED) {
DB(printk("halted\n"); X86EMU_trace_regs(); DB( if (M.x86.R_SP != 0) {
) printk("halted\n");
X86EMU_trace_regs();
}
else {
if (M.x86.debug)
printk("Service completed successfully\n");
})
return; return;
} }
if (((M.x86.intr & INTR_SYNCH) if (((M.x86.intr & INTR_SYNCH) && (M.x86.intno == 0 || M.x86.intno == 2)) ||
&& (M.x86.intno == 0 || M.x86.intno == 2)) !ACCESS_FLAG(F_IF)) {
|| !ACCESS_FLAG(F_IF)) {
x86emu_intr_handle(); x86emu_intr_handle();
} }
} }
op1 = (*sys_rdb) (((u32) M.x86.R_CS << 4) + (M.x86.R_IP++)); op1 = (*sys_rdb)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP++));
(*x86emu_optab[op1]) (op1); (*x86emu_optab[op1])(op1);
if (M.x86.debug & DEBUG_EXIT) {
M.x86.debug &= ~DEBUG_EXIT;
return;
}
} }
} }
@ -140,13 +147,16 @@ next instruction.
NOTE: Do not inline this function, as (*sys_rdb) is already inline! NOTE: Do not inline this function, as (*sys_rdb) is already inline!
****************************************************************************/ ****************************************************************************/
void fetch_decode_modrm(int *mod, int *regh, int *regl) void fetch_decode_modrm(
int *mod,
int *regh,
int *regl)
{ {
int fetched; int fetched;
DB(if (CHECK_IP_FETCH()) DB( if (CHECK_IP_FETCH())
x86emu_check_ip_access();) x86emu_check_ip_access();)
fetched = (*sys_rdb) (((u32) M.x86.R_CS << 4) + (M.x86.R_IP++)); fetched = (*sys_rdb)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP++));
INC_DECODED_INST_LEN(1); INC_DECODED_INST_LEN(1);
*mod = (fetched >> 6) & 0x03; *mod = (fetched >> 6) & 0x03;
*regh = (fetched >> 3) & 0x07; *regh = (fetched >> 3) & 0x07;
@ -167,9 +177,9 @@ u8 fetch_byte_imm(void)
{ {
u8 fetched; u8 fetched;
DB(if (CHECK_IP_FETCH()) DB( if (CHECK_IP_FETCH())
x86emu_check_ip_access();) x86emu_check_ip_access();)
fetched = (*sys_rdb) (((u32) M.x86.R_CS << 4) + (M.x86.R_IP++)); fetched = (*sys_rdb)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP++));
INC_DECODED_INST_LEN(1); INC_DECODED_INST_LEN(1);
return fetched; return fetched;
} }
@ -188,9 +198,9 @@ u16 fetch_word_imm(void)
{ {
u16 fetched; u16 fetched;
DB(if (CHECK_IP_FETCH()) DB( if (CHECK_IP_FETCH())
x86emu_check_ip_access();) x86emu_check_ip_access();)
fetched = (*sys_rdw) (((u32) M.x86.R_CS << 4) + (M.x86.R_IP)); fetched = (*sys_rdw)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP));
M.x86.R_IP += 2; M.x86.R_IP += 2;
INC_DECODED_INST_LEN(2); INC_DECODED_INST_LEN(2);
return fetched; return fetched;
@ -210,9 +220,9 @@ u32 fetch_long_imm(void)
{ {
u32 fetched; u32 fetched;
DB(if (CHECK_IP_FETCH()) DB( if (CHECK_IP_FETCH())
x86emu_check_ip_access();) x86emu_check_ip_access();)
fetched = (*sys_rdl) (((u32) M.x86.R_CS << 4) + (M.x86.R_IP)); fetched = (*sys_rdl)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP));
M.x86.R_IP += 4; M.x86.R_IP += 4;
INC_DECODED_INST_LEN(4); INC_DECODED_INST_LEN(4);
return fetched; return fetched;
@ -290,13 +300,14 @@ Byte value read from the absolute memory location.
NOTE: Do not inline this function as (*sys_rdX) is already inline! NOTE: Do not inline this function as (*sys_rdX) is already inline!
****************************************************************************/ ****************************************************************************/
u8 fetch_data_byte(uint offset) u8 fetch_data_byte(
uint offset)
{ {
#ifdef DEBUG #ifdef DEBUG
if (CHECK_DATA_ACCESS()) if (CHECK_DATA_ACCESS())
x86emu_check_data_access((u16) get_data_segment(), offset); x86emu_check_data_access((u16)get_data_segment(), offset);
#endif #endif
return (*sys_rdb) ((get_data_segment() << 4) + offset); return (*sys_rdb)((get_data_segment() << 4) + offset);
} }
/**************************************************************************** /****************************************************************************
@ -308,13 +319,14 @@ Word value read from the absolute memory location.
NOTE: Do not inline this function as (*sys_rdX) is already inline! NOTE: Do not inline this function as (*sys_rdX) is already inline!
****************************************************************************/ ****************************************************************************/
u16 fetch_data_word(uint offset) u16 fetch_data_word(
uint offset)
{ {
#ifdef DEBUG #ifdef DEBUG
if (CHECK_DATA_ACCESS()) if (CHECK_DATA_ACCESS())
x86emu_check_data_access((u16) get_data_segment(), offset); x86emu_check_data_access((u16)get_data_segment(), offset);
#endif #endif
return (*sys_rdw) ((get_data_segment() << 4) + offset); return (*sys_rdw)((get_data_segment() << 4) + offset);
} }
/**************************************************************************** /****************************************************************************
@ -326,13 +338,14 @@ Long value read from the absolute memory location.
NOTE: Do not inline this function as (*sys_rdX) is already inline! NOTE: Do not inline this function as (*sys_rdX) is already inline!
****************************************************************************/ ****************************************************************************/
u32 fetch_data_long(uint offset) u32 fetch_data_long(
uint offset)
{ {
#ifdef DEBUG #ifdef DEBUG
if (CHECK_DATA_ACCESS()) if (CHECK_DATA_ACCESS())
x86emu_check_data_access((u16) get_data_segment(), offset); x86emu_check_data_access((u16)get_data_segment(), offset);
#endif #endif
return (*sys_rdl) ((get_data_segment() << 4) + offset); return (*sys_rdl)((get_data_segment() << 4) + offset);
} }
/**************************************************************************** /****************************************************************************
@ -345,13 +358,15 @@ Byte value read from the absolute memory location.
NOTE: Do not inline this function as (*sys_rdX) is already inline! NOTE: Do not inline this function as (*sys_rdX) is already inline!
****************************************************************************/ ****************************************************************************/
u8 fetch_data_byte_abs(uint segment, uint offset) u8 fetch_data_byte_abs(
uint segment,
uint offset)
{ {
#ifdef DEBUG #ifdef DEBUG
if (CHECK_DATA_ACCESS()) if (CHECK_DATA_ACCESS())
x86emu_check_data_access(segment, offset); x86emu_check_data_access(segment, offset);
#endif #endif
return (*sys_rdb) (((u32) segment << 4) + offset); return (*sys_rdb)(((u32)segment << 4) + offset);
} }
/**************************************************************************** /****************************************************************************
@ -364,13 +379,15 @@ Word value read from the absolute memory location.
NOTE: Do not inline this function as (*sys_rdX) is already inline! NOTE: Do not inline this function as (*sys_rdX) is already inline!
****************************************************************************/ ****************************************************************************/
u16 fetch_data_word_abs(uint segment, uint offset) u16 fetch_data_word_abs(
uint segment,
uint offset)
{ {
#ifdef DEBUG #ifdef DEBUG
if (CHECK_DATA_ACCESS()) if (CHECK_DATA_ACCESS())
x86emu_check_data_access(segment, offset); x86emu_check_data_access(segment, offset);
#endif #endif
return (*sys_rdw) (((u32) segment << 4) + offset); return (*sys_rdw)(((u32)segment << 4) + offset);
} }
/**************************************************************************** /****************************************************************************
@ -383,13 +400,15 @@ Long value read from the absolute memory location.
NOTE: Do not inline this function as (*sys_rdX) is already inline! NOTE: Do not inline this function as (*sys_rdX) is already inline!
****************************************************************************/ ****************************************************************************/
u32 fetch_data_long_abs(uint segment, uint offset) u32 fetch_data_long_abs(
uint segment,
uint offset)
{ {
#ifdef DEBUG #ifdef DEBUG
if (CHECK_DATA_ACCESS()) if (CHECK_DATA_ACCESS())
x86emu_check_data_access(segment, offset); x86emu_check_data_access(segment, offset);
#endif #endif
return (*sys_rdl) (((u32) segment << 4) + offset); return (*sys_rdl)(((u32)segment << 4) + offset);
} }
/**************************************************************************** /****************************************************************************
@ -403,13 +422,15 @@ the current 'default' segment, which may have been overridden.
NOTE: Do not inline this function as (*sys_wrX) is already inline! NOTE: Do not inline this function as (*sys_wrX) is already inline!
****************************************************************************/ ****************************************************************************/
void store_data_byte(uint offset, u8 val) void store_data_byte(
uint offset,
u8 val)
{ {
#ifdef DEBUG #ifdef DEBUG
if (CHECK_DATA_ACCESS()) if (CHECK_DATA_ACCESS())
x86emu_check_data_access((u16) get_data_segment(), offset); x86emu_check_data_access((u16)get_data_segment(), offset);
#endif #endif
(*sys_wrb) ((get_data_segment() << 4) + offset, val); (*sys_wrb)((get_data_segment() << 4) + offset, val);
} }
/**************************************************************************** /****************************************************************************
@ -423,13 +444,15 @@ the current 'default' segment, which may have been overridden.
NOTE: Do not inline this function as (*sys_wrX) is already inline! NOTE: Do not inline this function as (*sys_wrX) is already inline!
****************************************************************************/ ****************************************************************************/
void store_data_word(uint offset, u16 val) void store_data_word(
uint offset,
u16 val)
{ {
#ifdef DEBUG #ifdef DEBUG
if (CHECK_DATA_ACCESS()) if (CHECK_DATA_ACCESS())
x86emu_check_data_access((u16) get_data_segment(), offset); x86emu_check_data_access((u16)get_data_segment(), offset);
#endif #endif
(*sys_wrw) ((get_data_segment() << 4) + offset, val); (*sys_wrw)((get_data_segment() << 4) + offset, val);
} }
/**************************************************************************** /****************************************************************************
@ -443,13 +466,15 @@ the current 'default' segment, which may have been overridden.
NOTE: Do not inline this function as (*sys_wrX) is already inline! NOTE: Do not inline this function as (*sys_wrX) is already inline!
****************************************************************************/ ****************************************************************************/
void store_data_long(uint offset, u32 val) void store_data_long(
uint offset,
u32 val)
{ {
#ifdef DEBUG #ifdef DEBUG
if (CHECK_DATA_ACCESS()) if (CHECK_DATA_ACCESS())
x86emu_check_data_access((u16) get_data_segment(), offset); x86emu_check_data_access((u16)get_data_segment(), offset);
#endif #endif
(*sys_wrl) ((get_data_segment() << 4) + offset, val); (*sys_wrl)((get_data_segment() << 4) + offset, val);
} }
/**************************************************************************** /****************************************************************************
@ -463,13 +488,16 @@ Writes a byte value to an absolute memory location.
NOTE: Do not inline this function as (*sys_wrX) is already inline! NOTE: Do not inline this function as (*sys_wrX) is already inline!
****************************************************************************/ ****************************************************************************/
void store_data_byte_abs(uint segment, uint offset, u8 val) void store_data_byte_abs(
uint segment,
uint offset,
u8 val)
{ {
#ifdef DEBUG #ifdef DEBUG
if (CHECK_DATA_ACCESS()) if (CHECK_DATA_ACCESS())
x86emu_check_data_access(segment, offset); x86emu_check_data_access(segment, offset);
#endif #endif
(*sys_wrb) (((u32) segment << 4) + offset, val); (*sys_wrb)(((u32)segment << 4) + offset, val);
} }
/**************************************************************************** /****************************************************************************
@ -483,13 +511,16 @@ Writes a word value to an absolute memory location.
NOTE: Do not inline this function as (*sys_wrX) is already inline! NOTE: Do not inline this function as (*sys_wrX) is already inline!
****************************************************************************/ ****************************************************************************/
void store_data_word_abs(uint segment, uint offset, u16 val) void store_data_word_abs(
uint segment,
uint offset,
u16 val)
{ {
#ifdef DEBUG #ifdef DEBUG
if (CHECK_DATA_ACCESS()) if (CHECK_DATA_ACCESS())
x86emu_check_data_access(segment, offset); x86emu_check_data_access(segment, offset);
#endif #endif
(*sys_wrw) (((u32) segment << 4) + offset, val); (*sys_wrw)(((u32)segment << 4) + offset, val);
} }
/**************************************************************************** /****************************************************************************
@ -503,13 +534,16 @@ Writes a long value to an absolute memory location.
NOTE: Do not inline this function as (*sys_wrX) is already inline! NOTE: Do not inline this function as (*sys_wrX) is already inline!
****************************************************************************/ ****************************************************************************/
void store_data_long_abs(uint segment, uint offset, u32 val) void store_data_long_abs(
uint segment,
uint offset,
u32 val)
{ {
#ifdef DEBUG #ifdef DEBUG
if (CHECK_DATA_ACCESS()) if (CHECK_DATA_ACCESS())
x86emu_check_data_access(segment, offset); x86emu_check_data_access(segment, offset);
#endif #endif
(*sys_wrl) (((u32) segment << 4) + offset, val); (*sys_wrl)(((u32)segment << 4) + offset, val);
} }
/**************************************************************************** /****************************************************************************
@ -523,7 +557,8 @@ REMARKS:
Return a pointer to the register given by the R/RM field of the Return a pointer to the register given by the R/RM field of the
modrm byte, for byte operands. Also enables the decoding of instructions. modrm byte, for byte operands. Also enables the decoding of instructions.
****************************************************************************/ ****************************************************************************/
u8 *decode_rm_byte_register(int reg) u8* decode_rm_byte_register(
int reg)
{ {
switch (reg) { switch (reg) {
case 0: case 0:
@ -566,7 +601,8 @@ REMARKS:
Return a pointer to the register given by the R/RM field of the Return a pointer to the register given by the R/RM field of the
modrm byte, for word operands. Also enables the decoding of instructions. modrm byte, for word operands. Also enables the decoding of instructions.
****************************************************************************/ ****************************************************************************/
u16 *decode_rm_word_register(int reg) u16* decode_rm_word_register(
int reg)
{ {
switch (reg) { switch (reg) {
case 0: case 0:
@ -609,7 +645,8 @@ REMARKS:
Return a pointer to the register given by the R/RM field of the Return a pointer to the register given by the R/RM field of the
modrm byte, for dword operands. Also enables the decoding of instructions. modrm byte, for dword operands. Also enables the decoding of instructions.
****************************************************************************/ ****************************************************************************/
u32 *decode_rm_long_register(int reg) u32* decode_rm_long_register(
int reg)
{ {
switch (reg) { switch (reg) {
case 0: case 0:
@ -653,7 +690,8 @@ Return a pointer to the register given by the R/RM field of the
modrm byte, for word operands, modified from above for the weirdo modrm byte, for word operands, modified from above for the weirdo
special case of segreg operands. Also enables the decoding of instructions. special case of segreg operands. Also enables the decoding of instructions.
****************************************************************************/ ****************************************************************************/
u16 *decode_rm_seg_register(int reg) u16* decode_rm_seg_register(
int reg)
{ {
switch (reg) { switch (reg) {
case 0: case 0:
@ -674,7 +712,6 @@ u16 *decode_rm_seg_register(int reg)
case 5: case 5:
DECODE_PRINTF("GS"); DECODE_PRINTF("GS");
return &M.x86.R_GS; return &M.x86.R_GS;
case 6: case 6:
case 7: case 7:
DECODE_PRINTF("ILLEGAL SEGREG"); DECODE_PRINTF("ILLEGAL SEGREG");
@ -684,6 +721,138 @@ u16 *decode_rm_seg_register(int reg)
return NULL; /* NOT REACHED OR REACHED ON ERROR */ return NULL; /* NOT REACHED OR REACHED ON ERROR */
} }
/****************************************************************************
PARAMETERS:
scale - scale value of SIB byte
index - index value of SIB byte
RETURNS:
Value of scale * index
REMARKS:
Decodes scale/index of SIB byte and returns relevant offset part of
effective address.
****************************************************************************/
unsigned decode_sib_si(
int scale,
int index)
{
scale = 1 << scale;
if (scale > 1) {
DECODE_PRINTF2("[%d*", scale);
} else {
DECODE_PRINTF("[");
}
switch (index) {
case 0:
DECODE_PRINTF("EAX]");
return M.x86.R_EAX * index;
case 1:
DECODE_PRINTF("ECX]");
return M.x86.R_ECX * index;
case 2:
DECODE_PRINTF("EDX]");
return M.x86.R_EDX * index;
case 3:
DECODE_PRINTF("EBX]");
return M.x86.R_EBX * index;
case 4:
DECODE_PRINTF("0]");
return 0;
case 5:
DECODE_PRINTF("EBP]");
return M.x86.R_EBP * index;
case 6:
DECODE_PRINTF("ESI]");
return M.x86.R_ESI * index;
case 7:
DECODE_PRINTF("EDI]");
return M.x86.R_EDI * index;
}
HALT_SYS();
return 0; /* NOT REACHED OR REACHED ON ERROR */
}
/****************************************************************************
PARAMETERS:
mod - MOD value of preceding ModR/M byte
RETURNS:
Offset in memory for the address decoding
REMARKS:
Decodes SIB addressing byte and returns calculated effective address.
****************************************************************************/
unsigned decode_sib_address(
int mod)
{
int sib = fetch_byte_imm();
int ss = (sib >> 6) & 0x03;
int index = (sib >> 3) & 0x07;
int base = sib & 0x07;
int offset = 0;
int displacement;
switch (base) {
case 0:
DECODE_PRINTF("[EAX]");
offset = M.x86.R_EAX;
break;
case 1:
DECODE_PRINTF("[ECX]");
offset = M.x86.R_ECX;
break;
case 2:
DECODE_PRINTF("[EDX]");
offset = M.x86.R_EDX;
break;
case 3:
DECODE_PRINTF("[EBX]");
offset = M.x86.R_EBX;
break;
case 4:
DECODE_PRINTF("[ESP]");
offset = M.x86.R_ESP;
break;
case 5:
switch (mod) {
case 0:
displacement = (s32)fetch_long_imm();
DECODE_PRINTF2("[%d]", displacement);
offset = displacement;
break;
case 1:
displacement = (s8)fetch_byte_imm();
DECODE_PRINTF2("[%d][EBP]", displacement);
offset = M.x86.R_EBP + displacement;
break;
case 2:
displacement = (s32)fetch_long_imm();
DECODE_PRINTF2("[%d][EBP]", displacement);
offset = M.x86.R_EBP + displacement;
break;
default:
HALT_SYS();
}
DECODE_PRINTF("[EAX]");
offset = M.x86.R_EAX;
break;
case 6:
DECODE_PRINTF("[ESI]");
offset = M.x86.R_ESI;
break;
case 7:
DECODE_PRINTF("[EDI]");
offset = M.x86.R_EDI;
break;
default:
HALT_SYS();
}
offset += decode_sib_si(ss, index);
return offset;
}
/**************************************************************************** /****************************************************************************
PARAMETERS: PARAMETERS:
rm - RM value to decode rm - RM value to decode
@ -704,25 +873,56 @@ NOTE: The code which specifies the corresponding segment (ds vs ss)
if a SS access is needed, set this bit. Otherwise, DS access if a SS access is needed, set this bit. Otherwise, DS access
occurs (unless any of the segment override bits are set). occurs (unless any of the segment override bits are set).
****************************************************************************/ ****************************************************************************/
unsigned decode_rm00_address(int rm) unsigned decode_rm00_address(
int rm)
{ {
unsigned offset; unsigned offset;
if (M.x86.mode & SYSMODE_PREFIX_ADDR) {
/* 32-bit addressing */
switch (rm) {
case 0:
DECODE_PRINTF("[EAX]");
return M.x86.R_EAX;
case 1:
DECODE_PRINTF("[ECX]");
return M.x86.R_ECX;
case 2:
DECODE_PRINTF("[EDX]");
return M.x86.R_EDX;
case 3:
DECODE_PRINTF("[EBX]");
return M.x86.R_EBX;
case 4:
return decode_sib_address(0);
case 5:
offset = fetch_long_imm();
DECODE_PRINTF2("[%08x]", offset);
return offset;
case 6:
DECODE_PRINTF("[ESI]");
return M.x86.R_ESI;
case 7:
DECODE_PRINTF("[EDI]");
return M.x86.R_EDI;
}
} else {
/* 16-bit addressing */
switch (rm) { switch (rm) {
case 0: case 0:
DECODE_PRINTF("[BX+SI]"); DECODE_PRINTF("[BX+SI]");
return M.x86.R_BX + M.x86.R_SI; return (M.x86.R_BX + M.x86.R_SI) & 0xffff;
case 1: case 1:
DECODE_PRINTF("[BX+DI]"); DECODE_PRINTF("[BX+DI]");
return M.x86.R_BX + M.x86.R_DI; return (M.x86.R_BX + M.x86.R_DI) & 0xffff;
case 2: case 2:
DECODE_PRINTF("[BP+SI]"); DECODE_PRINTF("[BP+SI]");
M.x86.mode |= SYSMODE_SEG_DS_SS; M.x86.mode |= SYSMODE_SEG_DS_SS;
return M.x86.R_BP + M.x86.R_SI; return (M.x86.R_BP + M.x86.R_SI) & 0xffff;
case 3: case 3:
DECODE_PRINTF("[BP+DI]"); DECODE_PRINTF("[BP+DI]");
M.x86.mode |= SYSMODE_SEG_DS_SS; M.x86.mode |= SYSMODE_SEG_DS_SS;
return M.x86.R_BP + M.x86.R_DI; return (M.x86.R_BP + M.x86.R_DI) & 0xffff;
case 4: case 4:
DECODE_PRINTF("[SI]"); DECODE_PRINTF("[SI]");
return M.x86.R_SI; return M.x86.R_SI;
@ -737,6 +937,7 @@ unsigned decode_rm00_address(int rm)
DECODE_PRINTF("[BX]"); DECODE_PRINTF("[BX]");
return M.x86.R_BX; return M.x86.R_BX;
} }
}
HALT_SYS(); HALT_SYS();
return 0; return 0;
} }
@ -752,37 +953,79 @@ REMARKS:
Return the offset given by mod=01 addressing. Also enables the Return the offset given by mod=01 addressing. Also enables the
decoding of instructions. decoding of instructions.
****************************************************************************/ ****************************************************************************/
unsigned decode_rm01_address(int rm) unsigned decode_rm01_address(
int rm)
{ {
int displacement = (s8) fetch_byte_imm(); int displacement;
if (M.x86.mode & SYSMODE_PREFIX_ADDR) {
/* 32-bit addressing */
if (rm != 4)
displacement = (s8)fetch_byte_imm();
else
displacement = 0;
switch (rm) {
case 0:
DECODE_PRINTF2("%d[EAX]", displacement);
return M.x86.R_EAX + displacement;
case 1:
DECODE_PRINTF2("%d[ECX]", displacement);
return M.x86.R_ECX + displacement;
case 2:
DECODE_PRINTF2("%d[EDX]", displacement);
return M.x86.R_EDX + displacement;
case 3:
DECODE_PRINTF2("%d[EBX]", displacement);
return M.x86.R_EBX + displacement;
case 4: {
int offset = decode_sib_address(1);
displacement = (s8)fetch_byte_imm();
DECODE_PRINTF2("[%d]", displacement);
return offset + displacement;
}
case 5:
DECODE_PRINTF2("%d[EBP]", displacement);
return M.x86.R_EBP + displacement;
case 6:
DECODE_PRINTF2("%d[ESI]", displacement);
return M.x86.R_ESI + displacement;
case 7:
DECODE_PRINTF2("%d[EDI]", displacement);
return M.x86.R_EDI + displacement;
}
} else {
/* 16-bit addressing */
displacement = (s8)fetch_byte_imm();
switch (rm) { switch (rm) {
case 0: case 0:
DECODE_PRINTF2("%d[BX+SI]", displacement); DECODE_PRINTF2("%d[BX+SI]", displacement);
return M.x86.R_BX + M.x86.R_SI + displacement; return (M.x86.R_BX + M.x86.R_SI + displacement) & 0xffff;
case 1: case 1:
DECODE_PRINTF2("%d[BX+DI]", displacement); DECODE_PRINTF2("%d[BX+DI]", displacement);
return M.x86.R_BX + M.x86.R_DI + displacement; return (M.x86.R_BX + M.x86.R_DI + displacement) & 0xffff;
case 2: case 2:
DECODE_PRINTF2("%d[BP+SI]", displacement); DECODE_PRINTF2("%d[BP+SI]", displacement);
M.x86.mode |= SYSMODE_SEG_DS_SS; M.x86.mode |= SYSMODE_SEG_DS_SS;
return M.x86.R_BP + M.x86.R_SI + displacement; return (M.x86.R_BP + M.x86.R_SI + displacement) & 0xffff;
case 3: case 3:
DECODE_PRINTF2("%d[BP+DI]", displacement); DECODE_PRINTF2("%d[BP+DI]", displacement);
M.x86.mode |= SYSMODE_SEG_DS_SS; M.x86.mode |= SYSMODE_SEG_DS_SS;
return M.x86.R_BP + M.x86.R_DI + displacement; return (M.x86.R_BP + M.x86.R_DI + displacement) & 0xffff;
case 4: case 4:
DECODE_PRINTF2("%d[SI]", displacement); DECODE_PRINTF2("%d[SI]", displacement);
return M.x86.R_SI + displacement; return (M.x86.R_SI + displacement) & 0xffff;
case 5: case 5:
DECODE_PRINTF2("%d[DI]", displacement); DECODE_PRINTF2("%d[DI]", displacement);
return M.x86.R_DI + displacement; return (M.x86.R_DI + displacement) & 0xffff;
case 6: case 6:
DECODE_PRINTF2("%d[BP]", displacement); DECODE_PRINTF2("%d[BP]", displacement);
M.x86.mode |= SYSMODE_SEG_DS_SS; M.x86.mode |= SYSMODE_SEG_DS_SS;
return M.x86.R_BP + displacement; return (M.x86.R_BP + displacement) & 0xffff;
case 7: case 7:
DECODE_PRINTF2("%d[BX]", displacement); DECODE_PRINTF2("%d[BX]", displacement);
return M.x86.R_BX + displacement; return (M.x86.R_BX + displacement) & 0xffff;
}
} }
HALT_SYS(); HALT_SYS();
return 0; /* SHOULD NOT HAPPEN */ return 0; /* SHOULD NOT HAPPEN */
@ -799,39 +1042,107 @@ REMARKS:
Return the offset given by mod=10 addressing. Also enables the Return the offset given by mod=10 addressing. Also enables the
decoding of instructions. decoding of instructions.
****************************************************************************/ ****************************************************************************/
unsigned decode_rm10_address(int rm) unsigned decode_rm10_address(
int rm)
{ {
unsigned displacement = (u16) fetch_word_imm(); if (M.x86.mode & SYSMODE_PREFIX_ADDR) {
int displacement;
/* 32-bit addressing */
if (rm != 4)
displacement = (s32)fetch_long_imm();
else
displacement = 0;
switch (rm) { switch (rm) {
case 0: case 0:
DECODE_PRINTF2("%04x[BX+SI]", displacement); DECODE_PRINTF2("%d[EAX]", displacement);
return M.x86.R_BX + M.x86.R_SI + displacement; return M.x86.R_EAX + displacement;
case 1: case 1:
DECODE_PRINTF2("%04x[BX+DI]", displacement); DECODE_PRINTF2("%d[ECX]", displacement);
return M.x86.R_BX + M.x86.R_DI + displacement; return M.x86.R_ECX + displacement;
case 2: case 2:
DECODE_PRINTF2("%04x[BP+SI]", displacement); DECODE_PRINTF2("%d[EDX]", displacement);
M.x86.mode |= SYSMODE_SEG_DS_SS; return M.x86.R_EDX + displacement;
return M.x86.R_BP + M.x86.R_SI + displacement;
case 3: case 3:
DECODE_PRINTF2("%04x[BP+DI]", displacement); DECODE_PRINTF2("%d[EBX]", displacement);
M.x86.mode |= SYSMODE_SEG_DS_SS; return M.x86.R_EBX + displacement;
return M.x86.R_BP + M.x86.R_DI + displacement; case 4: {
case 4: int offset = decode_sib_address(2);
DECODE_PRINTF2("%04x[SI]", displacement); displacement = (s32)fetch_long_imm();
return M.x86.R_SI + displacement; DECODE_PRINTF2("[%d]", displacement);
return offset + displacement;
}
case 5: case 5:
DECODE_PRINTF2("%04x[DI]", displacement); DECODE_PRINTF2("%d[EBP]", displacement);
return M.x86.R_DI + displacement; return M.x86.R_EBP + displacement;
case 6: case 6:
DECODE_PRINTF2("%04x[BP]", displacement); DECODE_PRINTF2("%d[ESI]", displacement);
M.x86.mode |= SYSMODE_SEG_DS_SS; return M.x86.R_ESI + displacement;
return M.x86.R_BP + displacement;
case 7: case 7:
DECODE_PRINTF2("%04x[BX]", displacement); DECODE_PRINTF2("%d[EDI]", displacement);
return M.x86.R_BX + displacement; return M.x86.R_EDI + displacement;
}
} else {
int displacement = (s16)fetch_word_imm();
/* 16-bit addressing */
switch (rm) {
case 0:
DECODE_PRINTF2("%d[BX+SI]", displacement);
return (M.x86.R_BX + M.x86.R_SI + displacement) & 0xffff;
case 1:
DECODE_PRINTF2("%d[BX+DI]", displacement);
return (M.x86.R_BX + M.x86.R_DI + displacement) & 0xffff;
case 2:
DECODE_PRINTF2("%d[BP+SI]", displacement);
M.x86.mode |= SYSMODE_SEG_DS_SS;
return (M.x86.R_BP + M.x86.R_SI + displacement) & 0xffff;
case 3:
DECODE_PRINTF2("%d[BP+DI]", displacement);
M.x86.mode |= SYSMODE_SEG_DS_SS;
return (M.x86.R_BP + M.x86.R_DI + displacement) & 0xffff;
case 4:
DECODE_PRINTF2("%d[SI]", displacement);
return (M.x86.R_SI + displacement) & 0xffff;
case 5:
DECODE_PRINTF2("%d[DI]", displacement);
return (M.x86.R_DI + displacement) & 0xffff;
case 6:
DECODE_PRINTF2("%d[BP]", displacement);
M.x86.mode |= SYSMODE_SEG_DS_SS;
return (M.x86.R_BP + displacement) & 0xffff;
case 7:
DECODE_PRINTF2("%d[BX]", displacement);
return (M.x86.R_BX + displacement) & 0xffff;
}
} }
HALT_SYS(); HALT_SYS();
return 0; return 0; /* SHOULD NOT HAPPEN */
/*NOTREACHED */
} }
/****************************************************************************
PARAMETERS:
mod - modifier
rm - RM value to decode
RETURNS:
Offset in memory for the address decoding, multiplexing calls to
the decode_rmXX_address functions
REMARKS:
Return the offset given by "mod" addressing.
****************************************************************************/
unsigned decode_rmXX_address(int mod, int rm)
{
if(mod == 0)
return decode_rm00_address(rm);
if(mod == 1)
return decode_rm01_address(rm);
return decode_rm10_address(rm);
}

17
util/vgabios/x86emu/src/x86emu/fpu.c
View File

@ -2,7 +2,7 @@
* *
* Realmode X86 Emulator Library * Realmode X86 Emulator Library
* *
* Copyright (C) 1996-1999 SciTech Software, Inc. * Copyright (C) 1991-2004 SciTech Software, Inc.
* Copyright (C) David Mosberger-Tang * Copyright (C) David Mosberger-Tang
* Copyright (C) 1999 Egbert Eich * Copyright (C) 1999 Egbert Eich
* *
@ -121,7 +121,7 @@ void x86emuOp_esc_coprocess_d9(u8 X86EMU_UNUSED(op1))
DECODE_PRINTF("\n"); DECODE_PRINTF("\n");
break; break;
case 3: /* register to register */ case 3: /* register to register */
stkelem = (u8) rl; stkelem = (u8)rl;
if (rh < 4) { if (rh < 4) {
DECODE_PRINTF2("ST(%d)\n", stkelem); DECODE_PRINTF2("ST(%d)\n", stkelem);
} else { } else {
@ -342,7 +342,7 @@ void x86emuOp_esc_coprocess_da(u8 X86EMU_UNUSED(op1))
DECODE_PRINTF("\n"); DECODE_PRINTF("\n");
break; break;
case 3: /* register to register */ case 3: /* register to register */
stkelem = (u8) rl; stkelem = (u8)rl;
DECODE_PRINTF2("\tST(%d),ST\n", stkelem); DECODE_PRINTF2("\tST(%d),ST\n", stkelem);
break; break;
} }
@ -550,7 +550,7 @@ void x86emuOp_esc_coprocess_dc(u8 X86EMU_UNUSED(op1))
DECODE_PRINTF("\n"); DECODE_PRINTF("\n");
break; break;
case 3: /* register to register */ case 3: /* register to register */
stkelem = (u8) rl; stkelem = (u8)rl;
DECODE_PRINTF2("\tST(%d),ST\n", stkelem); DECODE_PRINTF2("\tST(%d),ST\n", stkelem);
break; break;
} }
@ -660,7 +660,7 @@ void x86emuOp_esc_coprocess_dd(u8 X86EMU_UNUSED(op1))
DECODE_PRINTF("\n"); DECODE_PRINTF("\n");
break; break;
case 3: /* register to register */ case 3: /* register to register */
stkelem = (u8) rl; stkelem = (u8)rl;
DECODE_PRINTF2("\tST(%d),ST\n", stkelem); DECODE_PRINTF2("\tST(%d),ST\n", stkelem);
break; break;
} }
@ -720,7 +720,8 @@ void x86emuOp_esc_coprocess_dd(u8 X86EMU_UNUSED(op1))
#ifdef DEBUG #ifdef DEBUG
static char *x86emu_fpu_op_de_tab[] = { static char *x86emu_fpu_op_de_tab[] =
{
"FIADD\tWORD PTR ", "FIMUL\tWORD PTR ", "FICOM\tWORD PTR ", "FIADD\tWORD PTR ", "FIMUL\tWORD PTR ", "FICOM\tWORD PTR ",
"FICOMP\tWORD PTR ", "FICOMP\tWORD PTR ",
"FISUB\tWORD PTR ", "FISUBR\tWORD PTR ", "FIDIV\tWORD PTR ", "FISUB\tWORD PTR ", "FISUBR\tWORD PTR ", "FIDIV\tWORD PTR ",
@ -766,7 +767,7 @@ void x86emuOp_esc_coprocess_de(u8 X86EMU_UNUSED(op1))
DECODE_PRINTF("\n"); DECODE_PRINTF("\n");
break; break;
case 3: /* register to register */ case 3: /* register to register */
stkelem = (u8) rl; stkelem = (u8)rl;
DECODE_PRINTF2("\tST(%d),ST\n", stkelem); DECODE_PRINTF2("\tST(%d),ST\n", stkelem);
break; break;
} }
@ -885,7 +886,7 @@ void x86emuOp_esc_coprocess_df(u8 X86EMU_UNUSED(op1))
DECODE_PRINTF("\n"); DECODE_PRINTF("\n");
break; break;
case 3: /* register to register */ case 3: /* register to register */
stkelem = (u8) rl; stkelem = (u8)rl;
DECODE_PRINTF2("\tST(%d)\n", stkelem); DECODE_PRINTF2("\tST(%d)\n", stkelem);
break; break;
} }

2
util/vgabios/x86emu/src/x86emu/makefile
View File

@ -2,7 +2,7 @@
# #
# Realmode X86 Emulator Library # Realmode X86 Emulator Library
# #
# Copyright (C) 1996-1999 SciTech Software, Inc. # Copyright (C) 1991-2004 SciTech Software, Inc.
# #
# ======================================================================== # ========================================================================
# #

34
util/vgabios/x86emu/src/x86emu/makefile.linux
View File

@ -31,9 +31,9 @@
############################################################################# #############################################################################
TARGETLIB = libx86emu.a TARGETLIB = libx86emu.a
TARGETDEBUGLIB =libx86emud.a
OBJS=\ OBJS=\
debug.o \
decode.o \ decode.o \
fpu.o \ fpu.o \
ops.o \ ops.o \
@ -41,20 +41,40 @@ ops2.o \
prim_ops.o \ prim_ops.o \
sys.o sys.o
DEBUGOBJS=debug.d \
decode.d \
fpu.d \
ops.d \
ops2.d \
prim_ops.d \
sys.d
.SUFFIXES: .d
all: $(TARGETLIB) $(TARGETDEBUGLIB)
$(TARGETLIB): $(OBJS) $(TARGETLIB): $(OBJS)
ar rv $(TARGETLIB) $(OBJS) ar rv $(TARGETLIB) $(OBJS)
INCS = -I. -Ix86emu -I../../include $(TARGETDEBUGLIB): $(DEBUGOBJS)
CFLAGS = -D__DRIVER__ -DFORCE_POST -D_CEXPORT= -DNO_LONG_LONG -DDEBUG ar rv $(TARGETDEBUGLIB) $(DEBUGOBJS)
INCS = -I. -I../../include -I../../include/x86emu
#CFLAGS = -D__DRIVER__ -DFORCE_POST -D_CEXPORT= -DNO_LONG_LONG
CFLAGS = -D__DRIVER__ -DFORCE_POST
CDEBUGFLAGS = -DDEBUG
.c.o: .c.o:
gcc -g -O -Wall -c $(CFLAGS) $(INCS) $*.c gcc -g -Os -Wall -c $(CFLAGS) $(INCS) $*.c
.c.d:
gcc -g -O -Wall -c -o$*.d $(CFLAGS) $(CDEBUGFLAGS) $(INCS) $*.c
.cpp.o: .cpp.o:
gcc -c $(CFLAGS) $(INCS) $*.cpp gcc -c $(CFLAGS) $(INCS) $*.cpp
clean: clean:
rm -f *.a *.o rm -f *.a *.o *.d
validate: validate.o libx86emu.a validate: validate.c libx86emu.a x86emu/prim_asm.h
gcc -o validate validate.o -lx86emu -L. gcc $(CFLAGS) $(INCS) -Wall -O2 -o validate validate.c -lx86emu -L.

7771
util/vgabios/x86emu/src/x86emu/ops.c
View File

File diff suppressed because it is too large Load Diff

1784
util/vgabios/x86emu/src/x86emu/ops2.c
View File

File diff suppressed because it is too large Load Diff

1428
util/vgabios/x86emu/src/x86emu/prim_ops.c
View File

File diff suppressed because it is too large Load Diff

2
util/vgabios/x86emu/src/x86emu/sys.c
View File

@ -198,7 +198,7 @@ u8 *mem_ptr(u32 addr, int size)
retaddr = (u8 *) (M.abseg + addr); retaddr = (u8 *) (M.abseg + addr);
//printk("retaddr now 0x%p\n", retaddr); //printk("retaddr now 0x%p\n", retaddr);
} else if (addr < 0x200) { } else if (addr < 0x200) {
//printk("updating int vector 0x%x\n", addr >> 2); printk("updating int vector 0x%x\n", addr >> 2);
retaddr = (u8 *) (M.mem_base + addr); retaddr = (u8 *) (M.mem_base + addr);
} else { } else {
retaddr = (u8 *) (M.mem_base + addr); retaddr = (u8 *) (M.mem_base + addr);

80
util/vgabios/x86emu/src/x86emu/validate.c
View File

@ -2,7 +2,7 @@
* *
* Realmode X86 Emulator Library * Realmode X86 Emulator Library
* *
* Copyright (C) 1996-1999 SciTech Software, Inc. * Copyright (C) 1991-2004 SciTech Software, Inc.
* Copyright (C) David Mosberger-Tang * Copyright (C) David Mosberger-Tang
* Copyright (C) 1999 Egbert Eich * Copyright (C) 1999 Egbert Eich
* *
@ -47,19 +47,27 @@
#include <stdarg.h> #include <stdarg.h>
#include "x86emu.h" #include "x86emu.h"
#include "x86emu/prim_asm.h" #include "x86emu/prim_asm.h"
#include "x86emu/prim_ops.h"
/*-------------------------- Implementation -------------------------------*/ /*-------------------------- Implementation -------------------------------*/
#define true 1 #define true 1
#define false 0 #define false 0
u32 cur_flags_mask = 0;
int flags_are_different(u32 flags1, u32 flags2)
{
return (flags1&cur_flags_mask) != (flags2&cur_flags_mask);
}
#define ALL_FLAGS (F_CF | F_PF | F_AF | F_ZF | F_SF | F_OF) #define ALL_FLAGS (F_CF | F_PF | F_AF | F_ZF | F_SF | F_OF)
#define VAL_START_BINARY(parm_type,res_type,dmax,smax,dincr,sincr) \ #define VAL_START_BINARY(parm_type,res_type,dmax,smax,dincr,sincr) \
{ \ { \
parm_type d,s; \ parm_type d,s; \
res_type r,r_asm; \ res_type r,r_asm; \
ulong flags,inflags; \ u32 flags,inflags; \
int f,failed = false; \ int f,failed = false; \
char buf1[80],buf2[80]; \ char buf1[80],buf2[80]; \
for (d = 0; d < dmax; d += dincr) { \ for (d = 0; d < dmax; d += dincr) { \
@ -70,7 +78,7 @@
#define VAL_TEST_BINARY(name) \ #define VAL_TEST_BINARY(name) \
r_asm = name##_asm(&flags,d,s); \ r_asm = name##_asm(&flags,d,s); \
r = name(d,s); \ r = name(d,s); \
if (r != r_asm || M.x86.R_EFLG != flags) \ if (r != r_asm || flags_are_different(M.x86.R_EFLG, flags)) \
failed = true; \ failed = true; \
if (failed || trace) { if (failed || trace) {
@ -78,7 +86,7 @@
name##_asm(&flags,d,s); \ name##_asm(&flags,d,s); \
name(d,s); \ name(d,s); \
r = r_asm = 0; \ r = r_asm = 0; \
if (M.x86.R_EFLG != flags) \ if (flags_are_different(M.x86.R_EFLG, flags)) \
failed = true; \ failed = true; \
if (failed || trace) { if (failed || trace) {
@ -202,7 +210,7 @@
#define VAL_TEST_TERNARY(name) \ #define VAL_TEST_TERNARY(name) \
r_asm = name##_asm(&flags,d,s,shift); \ r_asm = name##_asm(&flags,d,s,shift); \
r = name(d,s,shift); \ r = name(d,s,shift); \
if (r != r_asm || M.x86.R_EFLG != flags) \ if (r != r_asm || flags_are_different(M.x86.R_EFLG, flags)) \
failed = true; \ failed = true; \
if (failed || trace) { if (failed || trace) {
@ -268,7 +276,7 @@
#define VAL_TEST_UNARY(name) \ #define VAL_TEST_UNARY(name) \
r_asm = name##_asm(&flags,d); \ r_asm = name##_asm(&flags,d); \
r = name(d); \ r = name(d); \
if (r != r_asm || M.x86.R_EFLG != flags) { \ if (r != r_asm || flags_are_different(M.x86.R_EFLG, flags)) { \
failed = true; failed = true;
#define VAL_FAIL_BYTE_UNARY(name) \ #define VAL_FAIL_BYTE_UNARY(name) \
@ -349,7 +357,7 @@
M.x86.R_AL = d; \ M.x86.R_AL = d; \
name(s); \ name(s); \
r = M.x86.R_AX; \ r = M.x86.R_AX; \
if (r != r_asm || M.x86.R_EFLG != flags) \ if (r != r_asm || flags_are_different(M.x86.R_EFLG, flags)) \
failed = true; \ failed = true; \
if (failed || trace) { \ if (failed || trace) { \
if (failed) \ if (failed) \
@ -391,7 +399,7 @@
name(s); \ name(s); \
r_lo = M.x86.R_AX; \ r_lo = M.x86.R_AX; \
r_hi = M.x86.R_DX; \ r_hi = M.x86.R_DX; \
if (r_lo != r_asm_lo || r_hi != r_asm_hi || M.x86.R_EFLG != flags)\ if (r_lo != r_asm_lo || r_hi != r_asm_hi || flags_are_different(M.x86.R_EFLG, flags))\
failed = true; \ failed = true; \
if (failed || trace) { \ if (failed || trace) { \
if (failed) \ if (failed) \
@ -433,7 +441,7 @@
name(s); \ name(s); \
r_lo = M.x86.R_EAX; \ r_lo = M.x86.R_EAX; \
r_hi = M.x86.R_EDX; \ r_hi = M.x86.R_EDX; \
if (r_lo != r_asm_lo || r_hi != r_asm_hi || M.x86.R_EFLG != flags)\ if (r_lo != r_asm_lo || r_hi != r_asm_hi || flags_are_different(M.x86.R_EFLG, flags))\
failed = true; \ failed = true; \
if (failed || trace) { \ if (failed || trace) { \
if (failed) \ if (failed) \
@ -477,7 +485,7 @@
if (M.x86.intr & INTR_SYNCH) \ if (M.x86.intr & INTR_SYNCH) \
continue; \ continue; \
name##_asm(&flags,&r_asm_quot,&r_asm_rem,d,s); \ name##_asm(&flags,&r_asm_quot,&r_asm_rem,d,s); \
if (r_quot != r_asm_quot || r_rem != r_asm_rem || M.x86.R_EFLG != flags) \ if (r_quot != r_asm_quot || r_rem != r_asm_rem || flags_are_different(M.x86.R_EFLG, flags)) \
failed = true; \ failed = true; \
if (failed || trace) { \ if (failed || trace) { \
if (failed) \ if (failed) \
@ -522,7 +530,7 @@
if (M.x86.intr & INTR_SYNCH) \ if (M.x86.intr & INTR_SYNCH) \
continue; \ continue; \
name##_asm(&flags,&r_asm_quot,&r_asm_rem,d & 0xFFFF,d >> 16,s);\ name##_asm(&flags,&r_asm_quot,&r_asm_rem,d & 0xFFFF,d >> 16,s);\
if (r_quot != r_asm_quot || r_rem != r_asm_rem || M.x86.R_EFLG != flags) \ if (r_quot != r_asm_quot || r_rem != r_asm_rem || flags_are_different(M.x86.R_EFLG, flags)) \
failed = true; \ failed = true; \
if (failed || trace) { \ if (failed || trace) { \
if (failed) \ if (failed) \
@ -567,7 +575,7 @@
if (M.x86.intr & INTR_SYNCH) \ if (M.x86.intr & INTR_SYNCH) \
continue; \ continue; \
name##_asm(&flags,&r_asm_quot,&r_asm_rem,d,0,s); \ name##_asm(&flags,&r_asm_quot,&r_asm_rem,d,0,s); \
if (r_quot != r_asm_quot || r_rem != r_asm_rem || M.x86.R_EFLG != flags) \ if (r_quot != r_asm_quot || r_rem != r_asm_rem || flags_are_different(M.x86.R_EFLG, flags)) \
failed = true; \ failed = true; \
if (failed || trace) { \ if (failed || trace) { \
if (failed) \ if (failed) \
@ -600,49 +608,49 @@ void printk(const char *fmt, ...)
va_end(argptr); va_end(argptr);
} }
char *print_flags(char *buf, ulong flags) char * print_flags(char *buf,ulong flags)
{ {
char *separator = ""; char *separator = "";
buf[0] = 0; buf[0] = 0;
if (flags & F_CF) { if (flags & F_CF) {
strcat(buf, separator); strcat(buf,separator);
strcat(buf, "CF"); strcat(buf,"CF");
separator = ","; separator = ",";
} }
if (flags & F_PF) { if (flags & F_PF) {
strcat(buf, separator); strcat(buf,separator);
strcat(buf, "PF"); strcat(buf,"PF");
separator = ","; separator = ",";
} }
if (flags & F_AF) { if (flags & F_AF) {
strcat(buf, separator); strcat(buf,separator);
strcat(buf, "AF"); strcat(buf,"AF");
separator = ","; separator = ",";
} }
if (flags & F_ZF) { if (flags & F_ZF) {
strcat(buf, separator); strcat(buf,separator);
strcat(buf, "ZF"); strcat(buf,"ZF");
separator = ","; separator = ",";
} }
if (flags & F_SF) { if (flags & F_SF) {
strcat(buf, separator); strcat(buf,separator);
strcat(buf, "SF"); strcat(buf,"SF");
separator = ","; separator = ",";
} }
if (flags & F_OF) { if (flags & F_OF) {
strcat(buf, separator); strcat(buf,separator);
strcat(buf, "OF"); strcat(buf,"OF");
separator = ","; separator = ",";
} }
if (separator[0] == 0) if (separator[0] == 0)
strcpy(buf, "None"); strcpy(buf,"None");
return buf; return buf;
} }
int main(int argc) int main(int argc, char *argv[])
{ {
ulong def_flags; u32 def_flags;
int trace = false; int trace = false;
if (argc > 1) if (argc > 1)
@ -650,12 +658,15 @@ int main(int argc)
memset(&M, 0, sizeof(M)); memset(&M, 0, sizeof(M));
def_flags = get_flags_asm() & ~ALL_FLAGS; def_flags = get_flags_asm() & ~ALL_FLAGS;
cur_flags_mask = F_AF | F_CF;
VAL_WORD_UNARY(aaa_word); VAL_WORD_UNARY(aaa_word);
VAL_WORD_UNARY(aas_word); VAL_WORD_UNARY(aas_word);
cur_flags_mask = F_SF | F_ZF | F_PF;
VAL_WORD_UNARY(aad_word); VAL_WORD_UNARY(aad_word);
VAL_WORD_UNARY(aam_word); VAL_WORD_UNARY(aam_word);
cur_flags_mask = ALL_FLAGS;
VAL_BYTE_BYTE_BINARY(adc_byte); VAL_BYTE_BYTE_BINARY(adc_byte);
VAL_WORD_WORD_BINARY(adc_word); VAL_WORD_WORD_BINARY(adc_word);
VAL_LONG_LONG_BINARY(adc_long); VAL_LONG_LONG_BINARY(adc_long);
@ -664,17 +675,21 @@ int main(int argc)
VAL_WORD_WORD_BINARY(add_word); VAL_WORD_WORD_BINARY(add_word);
VAL_LONG_LONG_BINARY(add_long); VAL_LONG_LONG_BINARY(add_long);
cur_flags_mask = ALL_FLAGS & (~F_AF);
VAL_BYTE_BYTE_BINARY(and_byte); VAL_BYTE_BYTE_BINARY(and_byte);
VAL_WORD_WORD_BINARY(and_word); VAL_WORD_WORD_BINARY(and_word);
VAL_LONG_LONG_BINARY(and_long); VAL_LONG_LONG_BINARY(and_long);
cur_flags_mask = ALL_FLAGS;
VAL_BYTE_BYTE_BINARY(cmp_byte); VAL_BYTE_BYTE_BINARY(cmp_byte);
VAL_WORD_WORD_BINARY(cmp_word); VAL_WORD_WORD_BINARY(cmp_word);
VAL_LONG_LONG_BINARY(cmp_long); VAL_LONG_LONG_BINARY(cmp_long);
cur_flags_mask = ALL_FLAGS & (~F_OF);
VAL_BYTE_UNARY(daa_byte); VAL_BYTE_UNARY(daa_byte);
VAL_BYTE_UNARY(das_byte); // Fails for 0x9A (out of range anyway) VAL_BYTE_UNARY(das_byte); // Fails for 0x9A (out of range anyway)
cur_flags_mask = ALL_FLAGS;
VAL_BYTE_UNARY(dec_byte); VAL_BYTE_UNARY(dec_byte);
VAL_WORD_UNARY(dec_word); VAL_WORD_UNARY(dec_word);
VAL_LONG_UNARY(dec_long); VAL_LONG_UNARY(dec_long);
@ -683,10 +698,12 @@ int main(int argc)
VAL_WORD_UNARY(inc_word); VAL_WORD_UNARY(inc_word);
VAL_LONG_UNARY(inc_long); VAL_LONG_UNARY(inc_long);
cur_flags_mask = ALL_FLAGS & (~F_AF);
VAL_BYTE_BYTE_BINARY(or_byte); VAL_BYTE_BYTE_BINARY(or_byte);
VAL_WORD_WORD_BINARY(or_word); VAL_WORD_WORD_BINARY(or_word);
VAL_LONG_LONG_BINARY(or_long); VAL_LONG_LONG_BINARY(or_long);
cur_flags_mask = ALL_FLAGS;
VAL_BYTE_UNARY(neg_byte); VAL_BYTE_UNARY(neg_byte);
VAL_WORD_UNARY(neg_word); VAL_WORD_UNARY(neg_word);
VAL_LONG_UNARY(neg_long); VAL_LONG_UNARY(neg_long);
@ -695,6 +712,7 @@ int main(int argc)
VAL_WORD_UNARY(not_word); VAL_WORD_UNARY(not_word);
VAL_LONG_UNARY(not_long); VAL_LONG_UNARY(not_long);
cur_flags_mask = ALL_FLAGS & (~F_OF);
VAL_BYTE_ROTATE(rcl_byte); VAL_BYTE_ROTATE(rcl_byte);
VAL_WORD_ROTATE(rcl_word); VAL_WORD_ROTATE(rcl_word);
VAL_LONG_ROTATE(rcl_long); VAL_LONG_ROTATE(rcl_long);
@ -711,6 +729,7 @@ int main(int argc)
VAL_WORD_ROTATE(ror_word); VAL_WORD_ROTATE(ror_word);
VAL_LONG_ROTATE(ror_long); VAL_LONG_ROTATE(ror_long);
cur_flags_mask = ALL_FLAGS & (~(F_AF | F_OF));
VAL_BYTE_ROTATE(shl_byte); VAL_BYTE_ROTATE(shl_byte);
VAL_WORD_ROTATE(shl_word); VAL_WORD_ROTATE(shl_word);
VAL_LONG_ROTATE(shl_long); VAL_LONG_ROTATE(shl_long);
@ -723,12 +742,14 @@ int main(int argc)
VAL_WORD_ROTATE(sar_word); VAL_WORD_ROTATE(sar_word);
VAL_LONG_ROTATE(sar_long); VAL_LONG_ROTATE(sar_long);
cur_flags_mask = ALL_FLAGS & (~(F_AF | F_OF));
VAL_WORD_ROTATE_DBL(shld_word); VAL_WORD_ROTATE_DBL(shld_word);
VAL_LONG_ROTATE_DBL(shld_long); VAL_LONG_ROTATE_DBL(shld_long);
VAL_WORD_ROTATE_DBL(shrd_word); VAL_WORD_ROTATE_DBL(shrd_word);
VAL_LONG_ROTATE_DBL(shrd_long); VAL_LONG_ROTATE_DBL(shrd_long);
cur_flags_mask = ALL_FLAGS;
VAL_BYTE_BYTE_BINARY(sbb_byte); VAL_BYTE_BYTE_BINARY(sbb_byte);
VAL_WORD_WORD_BINARY(sbb_word); VAL_WORD_WORD_BINARY(sbb_word);
VAL_LONG_LONG_BINARY(sbb_long); VAL_LONG_LONG_BINARY(sbb_long);
@ -737,6 +758,7 @@ int main(int argc)
VAL_WORD_WORD_BINARY(sub_word); VAL_WORD_WORD_BINARY(sub_word);
VAL_LONG_LONG_BINARY(sub_long); VAL_LONG_LONG_BINARY(sub_long);
cur_flags_mask = ALL_FLAGS & (~F_AF);
VAL_BYTE_BYTE_BINARY(xor_byte); VAL_BYTE_BYTE_BINARY(xor_byte);
VAL_WORD_WORD_BINARY(xor_word); VAL_WORD_WORD_BINARY(xor_word);
VAL_LONG_LONG_BINARY(xor_long); VAL_LONG_LONG_BINARY(xor_long);
@ -745,6 +767,7 @@ int main(int argc)
VAL_VOID_WORD_BINARY(test_word); VAL_VOID_WORD_BINARY(test_word);
VAL_VOID_LONG_BINARY(test_long); VAL_VOID_LONG_BINARY(test_long);
cur_flags_mask = F_CF | F_OF;
VAL_BYTE_MUL(imul_byte); VAL_BYTE_MUL(imul_byte);
VAL_WORD_MUL(imul_word); VAL_WORD_MUL(imul_word);
VAL_LONG_MUL(imul_long); VAL_LONG_MUL(imul_long);
@ -753,6 +776,7 @@ int main(int argc)
VAL_WORD_MUL(mul_word); VAL_WORD_MUL(mul_word);
VAL_LONG_MUL(mul_long); VAL_LONG_MUL(mul_long);
cur_flags_mask = 0;
VAL_BYTE_DIV(idiv_byte); VAL_BYTE_DIV(idiv_byte);
VAL_WORD_DIV(idiv_word); VAL_WORD_DIV(idiv_word);
VAL_LONG_DIV(idiv_long); VAL_LONG_DIV(idiv_long);

5
util/vgabios/x86emu/src/x86emu/x86emu/debug.h
View File

@ -2,7 +2,7 @@
* *
* Realmode X86 Emulator Library * Realmode X86 Emulator Library
* *
* Copyright (C) 1996-1999 SciTech Software, Inc. * Copyright (C) 1991-2004 SciTech Software, Inc.
* Copyright (C) David Mosberger-Tang * Copyright (C) David Mosberger-Tang
* Copyright (C) 1999 Egbert Eich * Copyright (C) 1999 Egbert Eich
* *
@ -35,7 +35,6 @@
* Description: Header file for debug definitions. * Description: Header file for debug definitions.
* *
****************************************************************************/ ****************************************************************************/
/* $XFree86: xc/extras/x86emu/src/x86emu/x86emu/debug.h,v 1.4 2000/11/21 23:10:27 tsi Exp $ */
#ifndef __X86EMU_DEBUG_H #ifndef __X86EMU_DEBUG_H
#define __X86EMU_DEBUG_H #define __X86EMU_DEBUG_H
@ -69,7 +68,7 @@
# define DEBUG_DISASSEMBLE() (M.x86.debug & DEBUG_DISASSEMBLE_F) # define DEBUG_DISASSEMBLE() (M.x86.debug & DEBUG_DISASSEMBLE_F)
# define DEBUG_BREAK() (M.x86.debug & DEBUG_BREAK_F) # define DEBUG_BREAK() (M.x86.debug & DEBUG_BREAK_F)
# define DEBUG_SVC() (M.x86.debug & DEBUG_SVC_F) # define DEBUG_SVC() (M.x86.debug & DEBUG_SVC_F)
# define DEBUG_SAVE_IP_CS() (M.x86.debug & DEBUG_SAVE_IP_CS_F) # define DEBUG_SAVE_IP_CS() (M.x86.debug & DEBUG_SAVE_CS_IP)
# define DEBUG_FS() (M.x86.debug & DEBUG_FS_F) # define DEBUG_FS() (M.x86.debug & DEBUG_FS_F)
# define DEBUG_PROC() (M.x86.debug & DEBUG_PROC_F) # define DEBUG_PROC() (M.x86.debug & DEBUG_PROC_F)

3
util/vgabios/x86emu/src/x86emu/x86emu/decode.h
View File

@ -2,7 +2,7 @@
* *
* Realmode X86 Emulator Library * Realmode X86 Emulator Library
* *
* Copyright (C) 1996-1999 SciTech Software, Inc. * Copyright (C) 1991-2004 SciTech Software, Inc.
* Copyright (C) David Mosberger-Tang * Copyright (C) David Mosberger-Tang
* Copyright (C) 1999 Egbert Eich * Copyright (C) 1999 Egbert Eich
* *
@ -79,6 +79,7 @@ u16* decode_rm_seg_register(int reg);
unsigned decode_rm00_address(int rm); unsigned decode_rm00_address(int rm);
unsigned decode_rm01_address(int rm); unsigned decode_rm01_address(int rm);
unsigned decode_rm10_address(int rm); unsigned decode_rm10_address(int rm);
unsigned decode_rmXX_address(int mod, int rm);
#ifdef __cplusplus #ifdef __cplusplus
} /* End of "C" linkage for C++ */ } /* End of "C" linkage for C++ */

2
util/vgabios/x86emu/src/x86emu/x86emu/fpu.h
View File

@ -2,7 +2,7 @@
* *
* Realmode X86 Emulator Library * Realmode X86 Emulator Library
* *
* Copyright (C) 1996-1999 SciTech Software, Inc. * Copyright (C) 1991-2004 SciTech Software, Inc.
* Copyright (C) David Mosberger-Tang * Copyright (C) David Mosberger-Tang
* Copyright (C) 1999 Egbert Eich * Copyright (C) 1999 Egbert Eich
* *

2
util/vgabios/x86emu/src/x86emu/x86emu/ops.h
View File

@ -2,7 +2,7 @@
* *
* Realmode X86 Emulator Library * Realmode X86 Emulator Library
* *
* Copyright (C) 1996-1999 SciTech Software, Inc. * Copyright (C) 1991-2004 SciTech Software, Inc.
* Copyright (C) David Mosberger-Tang * Copyright (C) David Mosberger-Tang
* Copyright (C) 1999 Egbert Eich * Copyright (C) 1999 Egbert Eich
* *

1024
util/vgabios/x86emu/src/x86emu/x86emu/prim_asm.h
View File

File diff suppressed because it is too large Load Diff

93
util/vgabios/x86emu/src/x86emu/x86emu/prim_ops.h
View File

@ -2,7 +2,7 @@
* *
* Realmode X86 Emulator Library * Realmode X86 Emulator Library
* *
* Copyright (C) 1996-1999 SciTech Software, Inc. * Copyright (C) 1991-2004 SciTech Software, Inc.
* Copyright (C) David Mosberger-Tang * Copyright (C) David Mosberger-Tang
* Copyright (C) 1999 Egbert Eich * Copyright (C) 1999 Egbert Eich
* *
@ -39,8 +39,6 @@
#ifndef __X86EMU_PRIM_OPS_H #ifndef __X86EMU_PRIM_OPS_H
#define __X86EMU_PRIM_OPS_H #define __X86EMU_PRIM_OPS_H
#include "x86emu/prim_asm.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { /* Use "C" linkage when in C++ mode */ extern "C" { /* Use "C" linkage when in C++ mode */
#endif #endif
@ -136,96 +134,9 @@ void push_long (u32 w);
u16 pop_word (void); u16 pop_word (void);
u32 pop_long (void); u32 pop_long (void);
#if defined(__HAVE_INLINE_ASSEMBLER__) && !defined(PRIM_OPS_NO_REDEFINE_ASM)
#define aaa_word(d) aaa_word_asm(&M.x86.R_EFLG,d)
#define aas_word(d) aas_word_asm(&M.x86.R_EFLG,d)
#define aad_word(d) aad_word_asm(&M.x86.R_EFLG,d)
#define aam_word(d) aam_word_asm(&M.x86.R_EFLG,d)
#define adc_byte(d,s) adc_byte_asm(&M.x86.R_EFLG,d,s)
#define adc_word(d,s) adc_word_asm(&M.x86.R_EFLG,d,s)
#define adc_long(d,s) adc_long_asm(&M.x86.R_EFLG,d,s)
#define add_byte(d,s) add_byte_asm(&M.x86.R_EFLG,d,s)
#define add_word(d,s) add_word_asm(&M.x86.R_EFLG,d,s)
#define add_long(d,s) add_long_asm(&M.x86.R_EFLG,d,s)
#define and_byte(d,s) and_byte_asm(&M.x86.R_EFLG,d,s)
#define and_word(d,s) and_word_asm(&M.x86.R_EFLG,d,s)
#define and_long(d,s) and_long_asm(&M.x86.R_EFLG,d,s)
#define cmp_byte(d,s) cmp_byte_asm(&M.x86.R_EFLG,d,s)
#define cmp_word(d,s) cmp_word_asm(&M.x86.R_EFLG,d,s)
#define cmp_long(d,s) cmp_long_asm(&M.x86.R_EFLG,d,s)
#define daa_byte(d) daa_byte_asm(&M.x86.R_EFLG,d)
#define das_byte(d) das_byte_asm(&M.x86.R_EFLG,d)
#define dec_byte(d) dec_byte_asm(&M.x86.R_EFLG,d)
#define dec_word(d) dec_word_asm(&M.x86.R_EFLG,d)
#define dec_long(d) dec_long_asm(&M.x86.R_EFLG,d)
#define inc_byte(d) inc_byte_asm(&M.x86.R_EFLG,d)
#define inc_word(d) inc_word_asm(&M.x86.R_EFLG,d)
#define inc_long(d) inc_long_asm(&M.x86.R_EFLG,d)
#define or_byte(d,s) or_byte_asm(&M.x86.R_EFLG,d,s)
#define or_word(d,s) or_word_asm(&M.x86.R_EFLG,d,s)
#define or_long(d,s) or_long_asm(&M.x86.R_EFLG,d,s)
#define neg_byte(s) neg_byte_asm(&M.x86.R_EFLG,s)
#define neg_word(s) neg_word_asm(&M.x86.R_EFLG,s)
#define neg_long(s) neg_long_asm(&M.x86.R_EFLG,s)
#define not_byte(s) not_byte_asm(&M.x86.R_EFLG,s)
#define not_word(s) not_word_asm(&M.x86.R_EFLG,s)
#define not_long(s) not_long_asm(&M.x86.R_EFLG,s)
#define rcl_byte(d,s) rcl_byte_asm(&M.x86.R_EFLG,d,s)
#define rcl_word(d,s) rcl_word_asm(&M.x86.R_EFLG,d,s)
#define rcl_long(d,s) rcl_long_asm(&M.x86.R_EFLG,d,s)
#define rcr_byte(d,s) rcr_byte_asm(&M.x86.R_EFLG,d,s)
#define rcr_word(d,s) rcr_word_asm(&M.x86.R_EFLG,d,s)
#define rcr_long(d,s) rcr_long_asm(&M.x86.R_EFLG,d,s)
#define rol_byte(d,s) rol_byte_asm(&M.x86.R_EFLG,d,s)
#define rol_word(d,s) rol_word_asm(&M.x86.R_EFLG,d,s)
#define rol_long(d,s) rol_long_asm(&M.x86.R_EFLG,d,s)
#define ror_byte(d,s) ror_byte_asm(&M.x86.R_EFLG,d,s)
#define ror_word(d,s) ror_word_asm(&M.x86.R_EFLG,d,s)
#define ror_long(d,s) ror_long_asm(&M.x86.R_EFLG,d,s)
#define shl_byte(d,s) shl_byte_asm(&M.x86.R_EFLG,d,s)
#define shl_word(d,s) shl_word_asm(&M.x86.R_EFLG,d,s)
#define shl_long(d,s) shl_long_asm(&M.x86.R_EFLG,d,s)
#define shr_byte(d,s) shr_byte_asm(&M.x86.R_EFLG,d,s)
#define shr_word(d,s) shr_word_asm(&M.x86.R_EFLG,d,s)
#define shr_long(d,s) shr_long_asm(&M.x86.R_EFLG,d,s)
#define sar_byte(d,s) sar_byte_asm(&M.x86.R_EFLG,d,s)
#define sar_word(d,s) sar_word_asm(&M.x86.R_EFLG,d,s)
#define sar_long(d,s) sar_long_asm(&M.x86.R_EFLG,d,s)
#define shld_word(d,fill,s) shld_word_asm(&M.x86.R_EFLG,d,fill,s)
#define shld_long(d,fill,s) shld_long_asm(&M.x86.R_EFLG,d,fill,s)
#define shrd_word(d,fill,s) shrd_word_asm(&M.x86.R_EFLG,d,fill,s)
#define shrd_long(d,fill,s) shrd_long_asm(&M.x86.R_EFLG,d,fill,s)
#define sbb_byte(d,s) sbb_byte_asm(&M.x86.R_EFLG,d,s)
#define sbb_word(d,s) sbb_word_asm(&M.x86.R_EFLG,d,s)
#define sbb_long(d,s) sbb_long_asm(&M.x86.R_EFLG,d,s)
#define sub_byte(d,s) sub_byte_asm(&M.x86.R_EFLG,d,s)
#define sub_word(d,s) sub_word_asm(&M.x86.R_EFLG,d,s)
#define sub_long(d,s) sub_long_asm(&M.x86.R_EFLG,d,s)
#define test_byte(d,s) test_byte_asm(&M.x86.R_EFLG,d,s)
#define test_word(d,s) test_word_asm(&M.x86.R_EFLG,d,s)
#define test_long(d,s) test_long_asm(&M.x86.R_EFLG,d,s)
#define xor_byte(d,s) xor_byte_asm(&M.x86.R_EFLG,d,s)
#define xor_word(d,s) xor_word_asm(&M.x86.R_EFLG,d,s)
#define xor_long(d,s) xor_long_asm(&M.x86.R_EFLG,d,s)
#define imul_byte(s) imul_byte_asm(&M.x86.R_EFLG,&M.x86.R_AX,M.x86.R_AL,s)
#define imul_word(s) imul_word_asm(&M.x86.R_EFLG,&M.x86.R_AX,&M.x86.R_DX,M.x86.R_AX,s)
#define imul_long(s) imul_long_asm(&M.x86.R_EFLG,&M.x86.R_EAX,&M.x86.R_EDX,M.x86.R_EAX,s)
#define imul_long_direct(res_lo,res_hi,d,s) imul_long_asm(&M.x86.R_EFLG,res_lo,res_hi,d,s)
#define mul_byte(s) mul_byte_asm(&M.x86.R_EFLG,&M.x86.R_AX,M.x86.R_AL,s)
#define mul_word(s) mul_word_asm(&M.x86.R_EFLG,&M.x86.R_AX,&M.x86.R_DX,M.x86.R_AX,s)
#define mul_long(s) mul_long_asm(&M.x86.R_EFLG,&M.x86.R_EAX,&M.x86.R_EDX,M.x86.R_EAX,s)
#define idiv_byte(s) idiv_byte_asm(&M.x86.R_EFLG,&M.x86.R_AL,&M.x86.R_AH,M.x86.R_AX,s)
#define idiv_word(s) idiv_word_asm(&M.x86.R_EFLG,&M.x86.R_AX,&M.x86.R_DX,M.x86.R_AX,M.x86.R_DX,s)
#define idiv_long(s) idiv_long_asm(&M.x86.R_EFLG,&M.x86.R_EAX,&M.x86.R_EDX,M.x86.R_EAX,M.x86.R_EDX,s)
#define div_byte(s) div_byte_asm(&M.x86.R_EFLG,&M.x86.R_AL,&M.x86.R_AH,M.x86.R_AX,s)
#define div_word(s) div_word_asm(&M.x86.R_EFLG,&M.x86.R_AX,&M.x86.R_DX,M.x86.R_AX,M.x86.R_DX,s)
#define div_long(s) div_long_asm(&M.x86.R_EFLG,&M.x86.R_EAX,&M.x86.R_EDX,M.x86.R_EAX,M.x86.R_EDX,s)
#endif
#ifdef __cplusplus #ifdef __cplusplus
} /* End of "C" linkage for C++ */ } /* End of "C" linkage for C++ */
#endif #endif
#endif /* __X86EMU_PRIM_OPS_H */ #endif /* __X86EMU_PRIM_OPS_H */

10
util/vgabios/x86emu/src/x86emu/x86emu/x86emui.h
View File

@ -2,7 +2,7 @@
* *
* Realmode X86 Emulator Library * Realmode X86 Emulator Library
* *
* Copyright (C) 1996-1999 SciTech Software, Inc. * Copyright (C) 1991-2004 SciTech Software, Inc.
* Copyright (C) David Mosberger-Tang * Copyright (C) David Mosberger-Tang
* Copyright (C) 1999 Egbert Eich * Copyright (C) 1999 Egbert Eich
* *
@ -38,8 +38,6 @@
* *
****************************************************************************/ ****************************************************************************/
/* $XFree86: xc/extras/x86emu/src/x86emu/x86emu/x86emui.h,v 1.4 2001/04/01 13:59:58 tsi Exp $ */
#ifndef __X86EMU_X86EMUI_H #ifndef __X86EMU_X86EMUI_H
#define __X86EMU_X86EMUI_H #define __X86EMU_X86EMUI_H
@ -70,14 +68,12 @@
#include "x86emu/prim_ops.h" #include "x86emu/prim_ops.h"
#include "x86emu/fpu.h" #include "x86emu/fpu.h"
#include "x86emu/fpu_regs.h" #include "x86emu/fpu_regs.h"
#ifndef __KERNEL__
#ifdef IN_MODULE
#include <xf86_ansic.h>
#else
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#endif #endif
/*--------------------------- Inline Functions ----------------------------*/ /*--------------------------- Inline Functions ----------------------------*/
#ifdef __cplusplus #ifdef __cplusplus