np2/i286c/i286c.c - diff

Return to i286c.c CVS log

Up to [RetroPC.NET] / np2 / i286c

Diff for /np2/i286c/i286c.c between versions 1.11 and 1.27

version 1.11, 2003/12/01 10:45:46	version 1.27, 2005/03/05 06:02:29
Line 1	Line 1
#include "compiler.h"	#include "compiler.h"
#include "i286.h"	#include "cpucore.h"
#include "i286c.h"	#include "i286c.h"
#include "v30patch.h"	#include "v30patch.h"
#include "memory.h"
#include "pccore.h"	#include "pccore.h"
#include "iocore.h"	#include "iocore.h"
#include "dmap.h"	#include "dmax86.h"
#include "i286c.mcr"	#include "i286c.mcr"
	#if defined(ENABLE_TRAP)
	#include "steptrap.h"
	#endif


I286CORE i286core;	I286CORE i286core;

const BYTE iflags[256] = { // Z_FLAG, S_FLAG, P_FLAG	const UINT8 iflags[512] = { // Z_FLAG, S_FLAG, P_FLAG
0x44, 0x00, 0x00, 0x04, 0x00, 0x04, 0x04, 0x00,	0x44, 0x00, 0x00, 0x04, 0x00, 0x04, 0x04, 0x00,
0x00, 0x04, 0x04, 0x00, 0x04, 0x00, 0x00, 0x04,	0x00, 0x04, 0x04, 0x00, 0x04, 0x00, 0x00, 0x04,
0x00, 0x04, 0x04, 0x00, 0x04, 0x00, 0x00, 0x04,	0x00, 0x04, 0x04, 0x00, 0x04, 0x00, 0x00, 0x04,
Line 43 const BYTE iflags[256] = { // Z_FLAG	Line 45 const BYTE iflags[256] = { // Z_FLAG
0x80, 0x84, 0x84, 0x80, 0x84, 0x80, 0x80, 0x84,	0x80, 0x84, 0x84, 0x80, 0x84, 0x80, 0x80, 0x84,
0x84, 0x80, 0x80, 0x84, 0x80, 0x84, 0x84, 0x80,	0x84, 0x80, 0x80, 0x84, 0x80, 0x84, 0x84, 0x80,
0x84, 0x80, 0x80, 0x84, 0x80, 0x84, 0x84, 0x80,	0x84, 0x80, 0x80, 0x84, 0x80, 0x84, 0x84, 0x80,
0x80, 0x84, 0x84, 0x80, 0x84, 0x80, 0x80, 0x84};	0x80, 0x84, 0x84, 0x80, 0x84, 0x80, 0x80, 0x84,
	0x45, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
	0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
	0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
	0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
	0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
	0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
	0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
	0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
	0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
	0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
	0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
	0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
	0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
	0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
	0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
	0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
	0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
	0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
	0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
	0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
	0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
	0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
	0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
	0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
	0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
	0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
	0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
	0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
	0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
	0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
	0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
	0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85};


// ----	// ----

BYTE _szpcflag8[0x200];

#if !defined(MEMOPTIMIZE)	#if !defined(MEMOPTIMIZE)
BYTE _szpflag16[0x10000];	UINT8 _szpflag16[0x10000];
#endif	#endif

#if !defined(MEMOPTIMIZE) \|\| (MEMOPTIMIZE < 2)	#if !defined(MEMOPTIMIZE) \|\| (MEMOPTIMIZE < 2)
BYTE *_reg8_b53[256];	UINT8 *_reg8_b53[256];
BYTE *_reg8_b20[256];	UINT8 *_reg8_b20[256];
#endif	#endif
#if !defined(MEMOPTIMIZE) \|\| (MEMOPTIMIZE < 2)	#if !defined(MEMOPTIMIZE) \|\| (MEMOPTIMIZE < 2)
UINT16 *_reg16_b53[256];	UINT16 *_reg16_b53[256];
UINT16 *_reg16_b20[256];	UINT16 *_reg16_b20[256];
#endif	#endif

void i286_initialize(void) {	void i286c_initialize(void) {

	#if !defined(MEMOPTIMIZE) \|\| (MEMOPTIMIZE < 2)
UINT i;	UINT i;
UINT bit;	#endif
BYTE f;

for (i=0; i<0x100; i++) {
f = P_FLAG;
for (bit=0x80; bit; bit>>=1) {
if (i & bit) {
f ^= P_FLAG;
}
}
if (!(i & 0xff)) {
f \|= Z_FLAG;
}
if (i & 0x80) {
f \|= S_FLAG;
}
_szpcflag8[i+0x000] = f;
_szpcflag8[i+0x100] = f \| C_FLAG;
}

#if !defined(MEMOPTIMIZE) \|\| (MEMOPTIMIZE < 2)	#if !defined(MEMOPTIMIZE) \|\| (MEMOPTIMIZE < 2)
for (i=0; i<0x100; i++) {	for (i=0; i<0x100; i++) {
Line 95 void i286_initialize(void) {	Line 110 void i286_initialize(void) {
pos = ((i & 0x20)?0:1);	pos = ((i & 0x20)?0:1);
#endif	#endif
pos += ((i >> 3) & 3) * 2;	pos += ((i >> 3) & 3) * 2;
_reg8_b53[i] = ((BYTE *)&I286_REG) + pos;	_reg8_b53[i] = ((UINT8 *)&I286_REG) + pos;
#if defined(BYTESEX_LITTLE)	#if defined(BYTESEX_LITTLE)
pos = ((i & 0x4)?1:0);	pos = ((i & 0x4)?1:0);
#else	#else
pos = ((i & 0x4)?0:1);	pos = ((i & 0x4)?0:1);
#endif	#endif
pos += (i & 3) * 2;	pos += (i & 3) * 2;
_reg8_b20[i] = ((BYTE *)&I286_REG) + pos;	_reg8_b20[i] = ((UINT8 *)&I286_REG) + pos;
#if !defined(MEMOPTIMIZE) \|\| (MEMOPTIMIZE < 2)	#if !defined(MEMOPTIMIZE) \|\| (MEMOPTIMIZE < 2)
_reg16_b53[i] = ((UINT16 *)&I286_REG) + ((i >> 3) & 7);	_reg16_b53[i] = ((UINT16 *)&I286_REG) + ((i >> 3) & 7);
_reg16_b20[i] = ((UINT16 *)&I286_REG) + (i & 7);	_reg16_b20[i] = ((UINT16 *)&I286_REG) + (i & 7);
Line 112 void i286_initialize(void) {	Line 127 void i286_initialize(void) {

#if !defined(MEMOPTIMIZE)	#if !defined(MEMOPTIMIZE)
for (i=0; i<0x10000; i++) {	for (i=0; i<0x10000; i++) {
	REG8 f;
	UINT bit;
f = P_FLAG;	f = P_FLAG;
for (bit=0x80; bit; bit>>=1) {	for (bit=0x80; bit; bit>>=1) {
if (i & bit) {	if (i & bit) {
Line 130 void i286_initialize(void) {	Line 147 void i286_initialize(void) {
#if !defined(MEMOPTIMIZE) \|\| (MEMOPTIMIZE < 2)	#if !defined(MEMOPTIMIZE) \|\| (MEMOPTIMIZE < 2)
i286cea_initialize();	i286cea_initialize();
#endif	#endif
v30init();	v30cinit();
	ZeroMemory(&i286core, sizeof(i286core));
}	}

void i286_reset(void) {	void i286c_deinitialize(void) {

	if (CPU_EXTMEM) {
	_MFREE(CPU_EXTMEM);
	CPU_EXTMEM = NULL;
	CPU_EXTMEMSIZE = 0;
	}
	}

	static void i286c_initreg(void) {

	I286_CS = 0xf000;
	CS_BASE = 0xf0000;
	I286_IP = 0xfff0;
	I286_ADRSMASK = 0xfffff;
	}

	void i286c_reset(void) {

i286_initialize();
ZeroMemory(&i286core.s, sizeof(i286core.s));	ZeroMemory(&i286core.s, sizeof(i286core.s));
I286_CS = 0x1fc0;	i286c_initreg();
CS_BASE = 0x1fc00;	}
i286core.s.adrsmask = 0xfffff;
	void i286c_shut(void) {

	ZeroMemory(&i286core.s, offsetof(I286STAT, cpu_type));
	i286c_initreg();
}	}

void i286_resetprefetch(void) {	void i286c_setextsize(UINT32 size) {

	if (CPU_EXTMEMSIZE != size) {
	if (CPU_EXTMEM) {
	_MFREE(CPU_EXTMEM);
	CPU_EXTMEM = NULL;
	}
	if (size) {
	CPU_EXTMEM = (UINT8 *)_MALLOC(size + 16, "EXTMEM");
	if (CPU_EXTMEM == NULL) {
	size = 0;
	}
	}
	CPU_EXTMEMSIZE = size;
	}
	i286core.e.ems[0] = mem + 0xc0000;
	i286core.e.ems[1] = mem + 0xc4000;
	i286core.e.ems[2] = mem + 0xc8000;
	i286core.e.ems[3] = mem + 0xcc000;
}	}

void CPUCALL i286_intnum(UINT vect, REG16 IP) {	void i286c_setemm(UINT frame, UINT32 addr) {

const BYTE *ptr;	UINT8 *ptr;

	frame &= 3;
	if (addr < USE_HIMEM) {
	ptr = mem + addr;
	}
	else if ((addr - 0x100000 + 0x4000) <= CPU_EXTMEMSIZE) {
	ptr = CPU_EXTMEM + (addr - 0x100000);
	}
	else {
	ptr = mem + 0xc0000 + (frame << 14);
	}
	i286core.e.ems[frame] = ptr;
	}


	void CPUCALL i286c_intnum(UINT vect, REG16 IP) {

	const UINT8 *ptr;

REGPUSH0(REAL_FLAGREG)	REGPUSH0(REAL_FLAGREG)
REGPUSH0(I286_CS)	REGPUSH0(I286_CS)
Line 156 const BYTE *ptr;	Line 230 const BYTE *ptr;
I286_FLAG &= ~(T_FLAG \| I_FLAG);	I286_FLAG &= ~(T_FLAG \| I_FLAG);
I286_TRAP = 0;	I286_TRAP = 0;

ptr = I286_MEM + (vect * 4);	ptr = mem + (vect * 4);
I286_IP = LOADINTELWORD(ptr+0); // real mode!	I286_IP = LOADINTELWORD(ptr+0); // real mode!
I286_CS = LOADINTELWORD(ptr+2); // real mode!	I286_CS = LOADINTELWORD(ptr+2); // real mode!
CS_BASE = I286_CS << 4;	CS_BASE = I286_CS << 4;
I286_WORKCLOCK(20);	I286_WORKCLOCK(20);
}	}

void CPUCALL i286_interrupt(BYTE vect) {	void CPUCALL i286c_interrupt(REG8 vect) {

UINT op;	UINT op;
const BYTE *ptr;	const UINT8 *ptr;

op = i286_memoryread(I286_IP + CS_BASE);	op = i286_memoryread(I286_IP + CS_BASE);
if (op == 0xf4) { // hlt	if (op == 0xf4) { // hlt
Line 179 const BYTE *ptr;	Line 253 const BYTE *ptr;
I286_FLAG &= ~(T_FLAG \| I_FLAG);	I286_FLAG &= ~(T_FLAG \| I_FLAG);
I286_TRAP = 0;	I286_TRAP = 0;

ptr = I286_MEM + (vect * 4);	ptr = mem + (vect * 4);
I286_IP = LOADINTELWORD(ptr+0); // real mode!	I286_IP = LOADINTELWORD(ptr + 0); // real mode!
I286_CS = LOADINTELWORD(ptr+2); // real mode!	I286_CS = LOADINTELWORD(ptr + 2); // real mode!
CS_BASE = I286_CS << 4;	CS_BASE = I286_CS << 4;
I286_WORKCLOCK(20);	I286_WORKCLOCK(20);
}	}

void i286(void) {	void i286c(void) {

UINT opcode;	UINT opcode;

if (I286_TRAP) {	if (I286_TRAP) {
do {	do {
	#if defined(ENABLE_TRAP)
	steptrap(CPU_CS, CPU_IP);
	#endif
GET_PCBYTE(opcode);	GET_PCBYTE(opcode);
i286op[opcode]();	i286op[opcode]();
if (I286_TRAP) {	if (I286_TRAP) {
i286_interrupt(1);	i286c_interrupt(1);
}	}
dmap_i286();	dmax86();
} while(I286_REMCLOCK > 0);	} while(I286_REMCLOCK > 0);
}	}
else if (dmac.working) {	else if (dmac.working) {
do {	do {
	#if defined(ENABLE_TRAP)
	steptrap(CPU_CS, CPU_IP);
	#endif
GET_PCBYTE(opcode);	GET_PCBYTE(opcode);
i286op[opcode]();	i286op[opcode]();
dmap_i286();	dmax86();
} while(I286_REMCLOCK > 0);	} while(I286_REMCLOCK > 0);
}	}
else {	else {
do {	do {
	#if defined(ENABLE_TRAP)
	steptrap(CPU_CS, CPU_IP);
	#endif
GET_PCBYTE(opcode);	GET_PCBYTE(opcode);
i286op[opcode]();	i286op[opcode]();
} while(I286_REMCLOCK > 0);	} while(I286_REMCLOCK > 0);
}	}
}	}

void i286_step(void) {	void i286c_step(void) {

UINT opcode;	UINT opcode;

Line 229 void i286_step(void) {	Line 312 void i286_step(void) {
if (I286_OV) {	if (I286_OV) {
I286_FLAG \|= (O_FLAG);	I286_FLAG \|= (O_FLAG);
}	}
dmap_i286();	dmax86();
}	}


// ---- test	// ---- test

#if defined(I286C_TEST)	#if defined(I286C_TEST)
BYTE BYTESZPF(UINT r) {	UINT8 BYTESZPF(UINT r) {

if (r & (~0xff)) {	if (r & (~0xff)) {
TRACEOUT(("BYTESZPF bound error: %x", r));	TRACEOUT(("BYTESZPF bound error: %x", r));
}	}
return(_szpcflag8[r & 0xff]);	return(iflags[r & 0xff]);
}	}

BYTE BYTESZPCF(UINT r) {	UINT8 BYTESZPCF(UINT r) {

if (r & (~0x1ff)) {	if (r & (~0x1ff)) {
TRACEOUT(("BYTESZPCF bound error: %x", r));	TRACEOUT(("BYTESZPCF bound error: %x", r));
}	}
return(_szpcflag8[r & 0x1ff]);	return(iflags[r & 0x1ff]);
}	}

BYTE WORDSZPF(UINT32 r) {	UINT8 WORDSZPF(UINT32 r) {

BYTE f1;	UINT8 f1;
BYTE f2;	UINT8 f2;

if (r & (~0xffff)) {	if (r & (~0xffff)) {
TRACEOUT(("WORDSZPF bound error: %x", r));	TRACEOUT(("WORDSZPF bound error: %x", r));
}	}
f1 = _szpflag16[r & 0xffff];	f1 = _szpflag16[r & 0xffff];
f2 = _szpcflag8[r & 0xff] & P_FLAG;	f2 = iflags[r & 0xff] & P_FLAG;
f2 += (r)?0:Z_FLAG;	f2 += (r)?0:Z_FLAG;
f2 += (r >> 8) & S_FLAG;	f2 += (r >> 8) & S_FLAG;
if (f1 != f2) {	if (f1 != f2) {
Line 270 BYTE WORDSZPF(UINT32 r) {	Line 353 BYTE WORDSZPF(UINT32 r) {
return(f1);	return(f1);
}	}

BYTE WORDSZPCF(UINT32 r) {	UINT8 WORDSZPCF(UINT32 r) {

BYTE f1;	UINT8 f1;
BYTE f2;	UINT8 f2;

if ((r & 0xffff0000) && (!(r & 0x00010000))) {	if ((r & 0xffff0000) && (!(r & 0x00010000))) {
TRACEOUT(("WORDSZPCF bound error: %x", r));	TRACEOUT(("WORDSZPCF bound error: %x", r));
Line 281 BYTE WORDSZPCF(UINT32 r) {	Line 364 BYTE WORDSZPCF(UINT32 r) {
f1 = (r >> 16) & 1;	f1 = (r >> 16) & 1;
f1 += _szpflag16[LOW16(r)];	f1 += _szpflag16[LOW16(r)];

f2 = _szpcflag8[r & 0xff] & P_FLAG;	f2 = iflags[r & 0xff] & P_FLAG;
f2 += (LOW16(r))?0:Z_FLAG;	f2 += (LOW16(r))?0:Z_FLAG;
f2 += (r >> 8) & S_FLAG;	f2 += (r >> 8) & S_FLAG;
f2 += (r >> 16) & 1;	f2 += (r >> 16) & 1;

RetroPC.NET-CVS <cvs@retropc.net>

Removed from v.1.11
changed lines
	Added in v.1.27