Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-20 20:58:51 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

More conversion to the new memory functions.

Browse Source 
And I will resist the urge to personally throttle those responsible
for copying and pasting the m6502 core 4 times. What a disaster.
This commit is contained in:
Aaron Giles 2008-11-22 19:29:29 +00:00
parent 9ee2f770aa
commit 8b675335b5
20 changed files with 338 additions and 304 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
src/emu/cpu/jaguar/jaguar.c
View File

@ -6,6 +6,7 @@
***************************************************************************/
#define NO_LEGACY_MEMORY_HANDLERS 1
#include "debugger.h"
#include "cpuexec.h"
#include "jaguar.h"
@ -237,7 +238,7 @@ static void (*const dsp_op_table[64])(jaguar_state *jaguar, UINT16 op) =
MEMORY ACCESSORS
***************************************************************************/
#define ROPCODE(pc) (program_decrypted_read_word(WORD_XOR_BE((UINT32)(pc))))
#define ROPCODE(J,pc) (memory_decrypted_read_word((J)->program, WORD_XOR_BE((UINT32)(pc))))
@ -505,7 +506,7 @@ static CPU_EXECUTE( jaguargpu )
debugger_instruction_hook(device, jaguar->PC);
/* instruction fetch */
op = ROPCODE(jaguar->PC);
op = ROPCODE(jaguar, jaguar->PC);
jaguar->PC += 2;
/* parse the instruction */
@ -546,7 +547,7 @@ static CPU_EXECUTE( jaguardsp )
debugger_instruction_hook(device, jaguar->PC);
/* instruction fetch */
op = ROPCODE(jaguar->PC);
op = ROPCODE(jaguar, jaguar->PC);
jaguar->PC += 2;
/* parse the instruction */
@ -751,14 +752,14 @@ void imultn_rn_rn(jaguar_state *jaguar, UINT16 op)
jaguar->accum = (INT32)res;
CLR_ZN(jaguar); SET_ZN(jaguar, res);
op = ROPCODE(jaguar->PC);
op = ROPCODE(jaguar, jaguar->PC);
while ((op >> 10) == 20)
{
r1 = jaguar->r[(op >> 5) & 31];
r2 = jaguar->r[op & 31];
jaguar->accum += (INT64)((INT16)r1 * (INT16)r2);
jaguar->PC += 2;
op = ROPCODE(jaguar->PC);
op = ROPCODE(jaguar, jaguar->PC);
}
if ((op >> 10) == 19)
{
@ -774,7 +775,7 @@ void jr_cc_n(jaguar_state *jaguar, UINT16 op)
INT32 r1 = (INT8)((op >> 2) & 0xf8) >> 2;
UINT32 newpc = jaguar->PC + r1;
debugger_instruction_hook(jaguar->device, jaguar->PC);
op = ROPCODE(jaguar->PC);
op = ROPCODE(jaguar, jaguar->PC);
jaguar->PC = newpc;
(*jaguar->table[op >> 10])(jaguar, op);
@ -791,7 +792,7 @@ void jump_cc_rn(jaguar_state *jaguar, UINT16 op)
/* special kludge for risky code in the cojag DSP interrupt handlers */
UINT32 newpc = (jaguar->icount == jaguar->bankswitch_icount) ? jaguar->a[reg] : jaguar->r[reg];
debugger_instruction_hook(jaguar->device, jaguar->PC);
op = ROPCODE(jaguar->PC);
op = ROPCODE(jaguar, jaguar->PC);
jaguar->PC = newpc;
(*jaguar->table[op >> 10])(jaguar, op);
@ -903,7 +904,7 @@ void movefa_rn_rn(jaguar_state *jaguar, UINT16 op)
void movei_n_rn(jaguar_state *jaguar, UINT16 op)
{
UINT32 res = ROPCODE(jaguar->PC) | (ROPCODE(jaguar->PC + 2) << 16);
UINT32 res = ROPCODE(jaguar, jaguar->PC) | (ROPCODE(jaguar, jaguar->PC + 2) << 16);
jaguar->PC += 4;
jaguar->r[op & 31] = res;
}

3
src/emu/cpu/konami/konami.c
View File

@ -34,6 +34,7 @@
*****************************************************************************/
#define NO_LEGACY_MEMORY_HANDLERS 1
#include "debugger.h"
#include "konami.h"
@ -56,6 +57,7 @@ typedef struct
int extra_cycles; /* cycles used up by interrupts */
cpu_irq_callback irq_callback;
const device_config *device;
const address_space *program;
UINT8 int_state; /* SYNC and CWAI flags */
UINT8 nmi_state;
void (*setlines_callback)( int lines ); /* callback called when A16-A23 are set */
@ -392,6 +394,7 @@ static CPU_INIT( konami )
{
konami.irq_callback = irqcallback;
konami.device = device;
konami.program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
state_save_register_item("KONAMI", device->tag, 0, PC);
state_save_register_item("KONAMI", device->tag, 0, U);

8
src/emu/cpu/konami/konami.h
View File

@ -27,26 +27,26 @@ CPU_GET_INFO( konami );
/****************************************************************************/
/* Read a byte from given memory location */
/****************************************************************************/
#define KONAMI_RDMEM(Addr) ((unsigned)program_read_byte_8be(Addr))
#define KONAMI_RDMEM(Addr) ((unsigned)memory_read_byte_8be(konami.program, Addr))
/****************************************************************************/
/* Write a byte to given memory location */
/****************************************************************************/
#define KONAMI_WRMEM(Addr,Value) (program_write_byte_8be(Addr,Value))
#define KONAMI_WRMEM(Addr,Value) (memory_write_byte_8be(konami.program, Addr,Value))
/****************************************************************************/
/* Z80_RDOP() is identical to Z80_RDMEM() except it is used for reading */
/* opcodes. In case of system with memory mapped I/O, this function can be */
/* used to greatly speed up emulation */
/****************************************************************************/
#define KONAMI_RDOP(Addr) ((unsigned)program_decrypted_read_byte(Addr))
#define KONAMI_RDOP(Addr) ((unsigned)memory_decrypted_read_byte(konami.program, Addr))
/****************************************************************************/
/* Z80_RDOP_ARG() is identical to Z80_RDOP() except it is used for reading */
/* opcode arguments. This difference can be used to support systems that */
/* use different encoding mechanisms for opcodes and opcode arguments */
/****************************************************************************/
#define KONAMI_RDOP_ARG(Addr) ((unsigned)program_raw_read_byte(Addr))
#define KONAMI_RDOP_ARG(Addr) ((unsigned)memory_raw_read_byte(konami.program, Addr))
#ifndef FALSE
# define FALSE 0

360
src/emu/cpu/lh5801/5801tbl.c
View File

@ -24,8 +24,8 @@ INLINE UINT8 lh5801_add_generic(int left, int right, int carry)
INLINE UINT16 lh5801_readop_word(void)
{
UINT16 r;
r=program_decrypted_read_byte(P++)<<8;
r|=program_decrypted_read_byte(P++);
r=memory_decrypted_read_byte(lh5801.program,P++)<<8;
r|=memory_decrypted_read_byte(lh5801.program,P++);
return r;
}
@ -37,8 +37,8 @@ INLINE void lh5801_adc(UINT8 data)
INLINE void lh5801_add_mem(int addr, UINT8 data)
{
int v=lh5801_add_generic(program_read_byte(addr),data,0);
program_write_byte(addr,v);
int v=lh5801_add_generic(memory_read_byte(lh5801.program,addr),data,0);
memory_write_byte(lh5801.program,addr,v);
}
INLINE void lh5801_adr(PAIR *reg)
@ -97,10 +97,10 @@ INLINE void lh5801_and(UINT8 data)
INLINE void lh5801_and_mem(int addr, UINT8 data)
{
data&=program_read_byte(addr);
data&=memory_read_byte(lh5801.program,addr);
lh5801.t&=~Z;
if (!data) lh5801.t|=Z;
program_write_byte(addr,data);
memory_write_byte(lh5801.program,addr,data);
}
INLINE void lh5801_bit(UINT8 a, UINT8 b)
@ -125,10 +125,10 @@ INLINE void lh5801_ora(UINT8 data)
INLINE void lh5801_ora_mem(int addr, UINT8 data)
{
data|=program_read_byte(addr);
data|=memory_read_byte(lh5801.program,addr);
lh5801.t&=~Z;
if (!data) lh5801.t|=Z;
program_write_byte(addr,data);
memory_write_byte(lh5801.program,addr,data);
}
INLINE void lh5801_lda(UINT8 data)
@ -141,27 +141,27 @@ INLINE void lh5801_lda(UINT8 data)
INLINE void lh5801_lde(PAIR *reg)
{
// or z flag depends on reg
lh5801.a=program_read_byte(reg->w.l--);
lh5801.a=memory_read_byte(lh5801.program,reg->w.l--);
lh5801.t&=~Z;
if (!lh5801.a) lh5801.t|=Z;
}
INLINE void lh5801_sde(PAIR *reg)
{
program_write_byte(reg->w.l--, lh5801.a);
memory_write_byte(lh5801.program,reg->w.l--, lh5801.a);
}
INLINE void lh5801_lin(PAIR *reg)
{
// or z flag depends on reg
lh5801.a=program_read_byte(reg->w.l++);
lh5801.a=memory_read_byte(lh5801.program,reg->w.l++);
lh5801.t&=~Z;
if (!lh5801.a) lh5801.t|=Z;
}
INLINE void lh5801_sin(PAIR *reg)
{
program_write_byte(reg->w.l++, lh5801.a);
memory_write_byte(lh5801.program,reg->w.l++, lh5801.a);
}
INLINE void lh5801_dec(UINT8 *adr)
@ -176,42 +176,42 @@ INLINE void lh5801_inc(UINT8 *adr)
INLINE void lh5801_pop(void)
{
lh5801.a=program_read_byte(++S);
lh5801.a=memory_read_byte(lh5801.program,++S);
lh5801.t&=~Z;
if (!lh5801.a) lh5801.t|=Z;
}
INLINE void lh5801_pop_word(PAIR *reg)
{
reg->b.h=program_read_byte(++S);
reg->b.l=program_read_byte(++S);
reg->b.h=memory_read_byte(lh5801.program,++S);
reg->b.l=memory_read_byte(lh5801.program,++S);
// z flag?
}
INLINE void lh5801_rtn(void)
{
P=program_read_byte(++S)<<8;
P|=program_read_byte(++S);
P=memory_read_byte(lh5801.program,++S)<<8;
P|=memory_read_byte(lh5801.program,++S);
change_pc(P);
}
INLINE void lh5801_rti(void)
{
P=program_read_byte(++S)<<8;
P|=program_read_byte(++S);
P=memory_read_byte(lh5801.program,++S)<<8;
P|=memory_read_byte(lh5801.program,++S);
change_pc(P);
lh5801.t=program_read_byte(++S);
lh5801.t=memory_read_byte(lh5801.program,++S);
}
INLINE void lh5801_push(UINT8 data)
{
program_write_byte(S--, data);
memory_write_byte(lh5801.program,S--, data);
}
INLINE void lh5801_push_word(UINT16 data)
{
program_write_byte(S--, data&0xff);
program_write_byte(S--, data>>8);
memory_write_byte(lh5801.program,S--, data&0xff);
memory_write_byte(lh5801.program,S--, data>>8);
}
INLINE void lh5801_jmp(UINT16 adr)
@ -222,7 +222,7 @@ INLINE void lh5801_jmp(UINT16 adr)
INLINE void lh5801_branch_plus(int doit)
{
UINT8 t=program_decrypted_read_byte(P++);
UINT8 t=memory_decrypted_read_byte(lh5801.program,P++);
if (doit) {
lh5801_icount-=3;
P+=t;
@ -232,7 +232,7 @@ INLINE void lh5801_branch_plus(int doit)
INLINE void lh5801_branch_minus(int doit)
{
UINT8 t=program_decrypted_read_byte(P++);
UINT8 t=memory_decrypted_read_byte(lh5801.program,P++);
if (doit) {
lh5801_icount-=3;
P-=t;
@ -242,7 +242,7 @@ INLINE void lh5801_branch_minus(int doit)
INLINE void lh5801_lop(void)
{
UINT8 t=program_decrypted_read_byte(P++);
UINT8 t=memory_decrypted_read_byte(lh5801.program,P++);
lh5801_icount-=8;
if (UL--) {
lh5801_icount-=3;
@ -263,8 +263,8 @@ INLINE void lh5801_vector(int doit, int nr)
{
if (doit) {
lh5801_push_word(P);
P=program_read_byte(0xff00+nr)<<8;
P|=program_read_byte(0xff00+nr+1);
P=memory_read_byte(lh5801.program,0xff00+nr)<<8;
P|=memory_read_byte(lh5801.program,0xff00+nr+1);
change_pc(P);
lh5801_icount-=21-8;
}
@ -280,18 +280,18 @@ INLINE void lh5801_aex(void)
INLINE void lh5801_drl(int adr)
{
UINT16 t=lh5801.a|(program_read_byte(adr)<<8);
UINT16 t=lh5801.a|(memory_read_byte(lh5801.program,adr)<<8);
lh5801.a=t>>8;
program_write_byte(adr,t>>4);
memory_write_byte(lh5801.program,adr,t>>4);
}
INLINE void lh5801_drr(int adr)
{
UINT16 t=program_read_byte(adr)|(lh5801.a<<8);
UINT16 t=memory_read_byte(lh5801.program,adr)|(lh5801.a<<8);
lh5801.a=t;
program_write_byte(adr,t>>4);
memory_write_byte(lh5801.program,adr,t>>4);
}
INLINE void lh5801_rol(void)
@ -357,89 +357,89 @@ static void lh5801_instruction_fd(void)
int oper;
int adr;
oper=program_decrypted_read_byte(P++);
oper=memory_decrypted_read_byte(lh5801.program,P++);
switch (oper) {
case 0x01: lh5801_sbc(program_read_byte(0x10000|X)); lh5801_icount-=11;break;
case 0x03: lh5801_adc(program_read_byte(0x10000|X)); lh5801_icount-=11;break;
case 0x05: lh5801_lda(program_read_byte(0x10000|X)); lh5801_icount-=10;break;
case 0x07: lh5801_cpa(lh5801.a, program_read_byte(0x10000|X)); lh5801_icount-=11;break;
case 0x01: lh5801_sbc(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=11;break;
case 0x03: lh5801_adc(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=11;break;
case 0x05: lh5801_lda(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=10;break;
case 0x07: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=11;break;
case 0x08: X=X;lh5801_icount-=11;break; //!!!
case 0x09: lh5801_and(program_read_byte(0x10000|X)); lh5801_icount-=11;break;
case 0x09: lh5801_and(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=11;break;
case 0x0a: lh5801_pop_word(&lh5801.x); lh5801_icount-=15;break;
case 0x0b: lh5801_ora(program_read_byte(0x10000|X)); lh5801_icount-=11;break;
case 0x0c: lh5801_dcs(program_read_byte(0x10000|X)); lh5801_icount-=17; break;
case 0x0d: lh5801_eor(program_read_byte(0x10000|X)); lh5801_icount-=11;break;
case 0x0e: program_write_byte(0x10000|X,lh5801.a); lh5801_icount-=10;break;
case 0x0f: lh5801_bit(program_read_byte(0x10000|X),lh5801.a); lh5801_icount-=11;break;
case 0x11: lh5801_sbc(program_read_byte(0x10000|Y)); lh5801_icount-=11;break;
case 0x13: lh5801_adc(program_read_byte(0x10000|Y)); lh5801_icount-=11;break;
case 0x15: lh5801_lda(program_read_byte(0x10000|Y)); lh5801_icount-=10;break;
case 0x17: lh5801_cpa(lh5801.a, program_read_byte(0x10000|Y)); lh5801_icount-=11;break;
case 0x0b: lh5801_ora(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=11;break;
case 0x0c: lh5801_dcs(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=17; break;
case 0x0d: lh5801_eor(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=11;break;
case 0x0e: memory_write_byte(lh5801.program,0x10000|X,lh5801.a); lh5801_icount-=10;break;
case 0x0f: lh5801_bit(memory_read_byte(lh5801.program,0x10000|X),lh5801.a); lh5801_icount-=11;break;
case 0x11: lh5801_sbc(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=11;break;
case 0x13: lh5801_adc(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=11;break;
case 0x15: lh5801_lda(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=10;break;
case 0x17: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=11;break;
case 0x18: X=Y;lh5801_icount-=11;break;
case 0x19: lh5801_and(program_read_byte(0x10000|Y)); lh5801_icount-=11;break;
case 0x19: lh5801_and(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=11;break;
case 0x1a: lh5801_pop_word(&lh5801.y); lh5801_icount-=15;break;
case 0x1b: lh5801_ora(program_read_byte(0x10000|Y)); lh5801_icount-=11;break;
case 0x1c: lh5801_dcs(program_read_byte(0x10000|Y)); lh5801_icount-=17; break;
case 0x1d: lh5801_eor(program_read_byte(0x10000|Y)); lh5801_icount-=11;break;
case 0x1e: program_write_byte(0x10000|Y,lh5801.a); lh5801_icount-=10;break;
case 0x1f: lh5801_bit(program_read_byte(0x10000|Y),lh5801.a); lh5801_icount-=11;break;
case 0x21: lh5801_sbc(program_read_byte(0x10000|U)); lh5801_icount-=11;break;
case 0x23: lh5801_adc(program_read_byte(0x10000|U)); lh5801_icount-=11;break;
case 0x25: lh5801_lda(program_read_byte(0x10000|U)); lh5801_icount-=10;break;
case 0x27: lh5801_cpa(lh5801.a, program_read_byte(0x10000|U)); lh5801_icount-=11;break;
case 0x1b: lh5801_ora(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=11;break;
case 0x1c: lh5801_dcs(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=17; break;
case 0x1d: lh5801_eor(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=11;break;
case 0x1e: memory_write_byte(lh5801.program,0x10000|Y,lh5801.a); lh5801_icount-=10;break;
case 0x1f: lh5801_bit(memory_read_byte(lh5801.program,0x10000|Y),lh5801.a); lh5801_icount-=11;break;
case 0x21: lh5801_sbc(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=11;break;
case 0x23: lh5801_adc(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=11;break;
case 0x25: lh5801_lda(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=10;break;
case 0x27: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=11;break;
case 0x28: X=U;lh5801_icount-=11;break;
case 0x29: lh5801_and(program_read_byte(0x10000|U)); lh5801_icount-=11;break;
case 0x29: lh5801_and(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=11;break;
case 0x2a: lh5801_pop_word(&lh5801.u); lh5801_icount-=15;break;
case 0x2b: lh5801_ora(program_read_byte(0x10000|U)); lh5801_icount-=11;break;
case 0x2c: lh5801_dcs(program_read_byte(0x10000|U)); lh5801_icount-=17; break;
case 0x2d: lh5801_eor(program_read_byte(0x10000|U)); lh5801_icount-=11;break;
case 0x2e: program_write_byte(0x10000|U,lh5801.a); lh5801_icount-=10;break;
case 0x2f: lh5801_bit(program_read_byte(0x10000|U),lh5801.a); lh5801_icount-=11;break;
case 0x2b: lh5801_ora(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=11;break;
case 0x2c: lh5801_dcs(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=17; break;
case 0x2d: lh5801_eor(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=11;break;
case 0x2e: memory_write_byte(lh5801.program,0x10000|U,lh5801.a); lh5801_icount-=10;break;
case 0x2f: lh5801_bit(memory_read_byte(lh5801.program,0x10000|U),lh5801.a); lh5801_icount-=11;break;
case 0x40: lh5801_inc(&XH);lh5801_icount-=9;break;
case 0x42: lh5801_dec(&XH);lh5801_icount-=9;break;
case 0x48: X=S;lh5801_icount-=11;break;
case 0x49: lh5801_and_mem(0x10000|X, program_decrypted_read_byte(P++)); lh5801_icount-=17;break;
case 0x49: lh5801_and_mem(0x10000|X, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
case 0x4a: X=X;lh5801_icount-=11;break; //!!!
case 0x4b: lh5801_ora_mem(0x10000|X, program_decrypted_read_byte(P++)); lh5801_icount-=17;break;
case 0x4b: lh5801_ora_mem(0x10000|X, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
case 0x4c: lh5801.bf=0;/*off !*/ lh5801_icount-=8;break;
case 0x4d: lh5801_bit(program_read_byte(X|0x10000), program_decrypted_read_byte(P++));lh5801_icount-=14;break;
case 0x4d: lh5801_bit(memory_read_byte(lh5801.program,X|0x10000), memory_decrypted_read_byte(lh5801.program,P++));lh5801_icount-=14;break;
case 0x4e: S=X;lh5801_icount-=11;break;
case 0x4f: lh5801_add_mem(0x10000|X, program_decrypted_read_byte(P++)); lh5801_icount-=17;break;
case 0x4f: lh5801_add_mem(0x10000|X, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
case 0x50: lh5801_inc(&YH);lh5801_icount-=9;break;
case 0x52: lh5801_dec(&YH);lh5801_icount-=9;break;
case 0x58: X=P;lh5801_icount-=11;break;
case 0x59: lh5801_and_mem(0x10000|Y, program_decrypted_read_byte(P++)); lh5801_icount-=17;break;
case 0x59: lh5801_and_mem(0x10000|Y, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
case 0x5a: Y=X;lh5801_icount-=11;break;
case 0x5b: lh5801_ora_mem(0x10000|Y, program_decrypted_read_byte(P++)); lh5801_icount-=17;break;
case 0x5d: lh5801_bit(program_read_byte(Y|0x10000), program_decrypted_read_byte(P++));lh5801_icount-=14;break;
case 0x5b: lh5801_ora_mem(0x10000|Y, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
case 0x5d: lh5801_bit(memory_read_byte(lh5801.program,Y|0x10000), memory_decrypted_read_byte(lh5801.program,P++));lh5801_icount-=14;break;
case 0x5e: lh5801_jmp(X);lh5801_icount-=11;break; // P=X
case 0x5f: lh5801_add_mem(0x10000|Y, program_decrypted_read_byte(P++)); lh5801_icount-=17;break;
case 0x5f: lh5801_add_mem(0x10000|Y, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
case 0x60: lh5801_inc(&UH);lh5801_icount-=9;break;
case 0x62: lh5801_dec(&UH);lh5801_icount-=9;break;
case 0x69: lh5801_and_mem(0x10000|U, program_decrypted_read_byte(P++)); lh5801_icount-=17;break;
case 0x69: lh5801_and_mem(0x10000|U, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
case 0x6a: U=X;lh5801_icount-=11;break;
case 0x6b: lh5801_ora_mem(0x10000|U, program_decrypted_read_byte(P++)); lh5801_icount-=17;break;
case 0x6d: lh5801_bit(program_read_byte(X|0x10000), program_decrypted_read_byte(P++));lh5801_icount-=14;break;
case 0x6f: lh5801_add_mem(0x10000|U, program_decrypted_read_byte(P++)); lh5801_icount-=17;break;
case 0x6b: lh5801_ora_mem(0x10000|U, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
case 0x6d: lh5801_bit(memory_read_byte(lh5801.program,X|0x10000), memory_decrypted_read_byte(lh5801.program,P++));lh5801_icount-=14;break;
case 0x6f: lh5801_add_mem(0x10000|U, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
case 0x81: lh5801.t|=IE; /*sie !*/lh5801_icount-=8;break;
case 0x88: lh5801_push_word(X); lh5801_icount-=14;break;
case 0x8a: lh5801_pop(); lh5801_icount-=12; break;
case 0x8c: lh5801_dca(program_read_byte(0x10000|X)); lh5801_icount-=19; break;
case 0x8c: lh5801_dca(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=19; break;
case 0x8e: /*cdv clears internal devider*/lh5801_icount-=8;break;
case 0x98: lh5801_push_word(Y); lh5801_icount-=14;break;
case 0x9c: lh5801_dca(program_read_byte(0x10000|Y)); lh5801_icount-=19; break;
case 0xa1: lh5801_sbc(program_read_byte(0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
case 0xa3: lh5801_adc(program_read_byte(0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
case 0xa5: lh5801_lda(program_read_byte(0x10000|lh5801_readop_word())); lh5801_icount-=16;break;
case 0xa7: lh5801_cpa(lh5801.a, program_read_byte(0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
case 0x9c: lh5801_dca(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=19; break;
case 0xa1: lh5801_sbc(memory_read_byte(lh5801.program,0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
case 0xa3: lh5801_adc(memory_read_byte(lh5801.program,0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
case 0xa5: lh5801_lda(memory_read_byte(lh5801.program,0x10000|lh5801_readop_word())); lh5801_icount-=16;break;
case 0xa7: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
case 0xa8: lh5801_push_word(U); lh5801_icount-=14;break;
case 0xa9: lh5801_and(program_read_byte(0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
case 0xa9: lh5801_and(memory_read_byte(lh5801.program,0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
case 0xaa: lh5801_lda(lh5801.t); lh5801_icount-=9;break;
case 0xab: lh5801_ora(program_read_byte(0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
case 0xac: lh5801_dca(program_read_byte(0x10000|U)); lh5801_icount-=19; break;
case 0xad: lh5801_eor(program_read_byte(0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
case 0xae: program_write_byte(0x10000|lh5801_readop_word(),lh5801.a); lh5801_icount-=16;break;
case 0xaf: lh5801_bit(program_read_byte(0x10000|lh5801_readop_word()),lh5801.a); lh5801_icount-=17;break;
case 0xab: lh5801_ora(memory_read_byte(lh5801.program,0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
case 0xac: lh5801_dca(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=19; break;
case 0xad: lh5801_eor(memory_read_byte(lh5801.program,0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
case 0xae: memory_write_byte(lh5801.program,0x10000|lh5801_readop_word(),lh5801.a); lh5801_icount-=16;break;
case 0xaf: lh5801_bit(memory_read_byte(lh5801.program,0x10000|lh5801_readop_word()),lh5801.a); lh5801_icount-=17;break;
case 0xb1: /*hlt*/lh5801_icount-=8;break;
case 0xba: lh5801_ita();lh5801_icount-=9;break;
case 0xbe: lh5801.t&=~IE; /*rie !*/lh5801_icount-=8;break;
@ -456,19 +456,19 @@ static void lh5801_instruction_fd(void)
case 0xea: lh5801_adr(&lh5801.u);lh5801_icount-=11;break;
case 0xe9:
adr=lh5801_readop_word()|0x10000;
lh5801_and_mem(adr, program_decrypted_read_byte(P++)); lh5801_icount-=23;
lh5801_and_mem(adr, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=23;
break;
case 0xeb:
adr=lh5801_readop_word()|0x10000;
lh5801_ora_mem(adr, program_decrypted_read_byte(P++)); lh5801_icount-=23;
lh5801_ora_mem(adr, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=23;
break;
case 0xec: lh5801.t=lh5801.a; lh5801_icount-=9;break;
case 0xed:
adr=lh5801_readop_word()|0x10000;lh5801_bit(program_read_byte(adr), program_decrypted_read_byte(P++));
adr=lh5801_readop_word()|0x10000;lh5801_bit(memory_read_byte(lh5801.program,adr), memory_decrypted_read_byte(lh5801.program,P++));
lh5801_icount-=20;break;
case 0xef:
adr=lh5801_readop_word()|0x10000;
lh5801_add_mem(adr, program_decrypted_read_byte(P++)); lh5801_icount-=23;
lh5801_add_mem(adr, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=23;
break;
default:
@ -481,56 +481,56 @@ static void lh5801_instruction(void)
int oper;
int adr;
oper=program_decrypted_read_byte(P++);
oper=memory_decrypted_read_byte(lh5801.program,P++);
switch (oper) {
case 0x00: lh5801_sbc(XL); lh5801_icount-=6;break;
case 0x01: lh5801_sbc(program_read_byte(X)); lh5801_icount-=7;break;
case 0x01: lh5801_sbc(memory_read_byte(lh5801.program,X)); lh5801_icount-=7;break;
case 0x02: lh5801_adc(XL); lh5801_icount-=6;break;
case 0x03: lh5801_adc(program_read_byte(X)); lh5801_icount-=7;break;
case 0x03: lh5801_adc(memory_read_byte(lh5801.program,X)); lh5801_icount-=7;break;
case 0x04: lh5801_lda(XL); lh5801_icount-=5;break;
case 0x05: lh5801_lda(program_read_byte(X)); lh5801_icount-=6;break;
case 0x05: lh5801_lda(memory_read_byte(lh5801.program,X)); lh5801_icount-=6;break;
case 0x06: lh5801_cpa(lh5801.a, XL); lh5801_icount-=6;break;
case 0x07: lh5801_cpa(lh5801.a, program_read_byte(X)); lh5801_icount-=7;break;
case 0x07: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,X)); lh5801_icount-=7;break;
case 0x08: XH=lh5801.a; lh5801_icount-=5; break;
case 0x09: lh5801_and(program_read_byte(X)); lh5801_icount-=7;break;
case 0x09: lh5801_and(memory_read_byte(lh5801.program,X)); lh5801_icount-=7;break;
case 0x0a: XL=lh5801.a; lh5801_icount-=5; break;
case 0x0b: lh5801_ora(program_read_byte(X)); lh5801_icount-=7;break;
case 0x0c: lh5801_dcs(program_read_byte(X)); lh5801_icount-=13; break;
case 0x0d: lh5801_eor(program_read_byte(X)); lh5801_icount-=7;break;
case 0x0e: program_write_byte(X,lh5801.a); lh5801_icount-=6;break;
case 0x0f: lh5801_bit(program_read_byte(X),lh5801.a); lh5801_icount-=7;break;
case 0x0b: lh5801_ora(memory_read_byte(lh5801.program,X)); lh5801_icount-=7;break;
case 0x0c: lh5801_dcs(memory_read_byte(lh5801.program,X)); lh5801_icount-=13; break;
case 0x0d: lh5801_eor(memory_read_byte(lh5801.program,X)); lh5801_icount-=7;break;
case 0x0e: memory_write_byte(lh5801.program,X,lh5801.a); lh5801_icount-=6;break;
case 0x0f: lh5801_bit(memory_read_byte(lh5801.program,X),lh5801.a); lh5801_icount-=7;break;
case 0x10: lh5801_sbc(YL); lh5801_icount-=6;break;
case 0x11: lh5801_sbc(program_read_byte(Y)); lh5801_icount-=7;break;
case 0x11: lh5801_sbc(memory_read_byte(lh5801.program,Y)); lh5801_icount-=7;break;
case 0x12: lh5801_adc(YL); lh5801_icount-=6;break;
case 0x13: lh5801_adc(program_read_byte(Y)); lh5801_icount-=7;break;
case 0x13: lh5801_adc(memory_read_byte(lh5801.program,Y)); lh5801_icount-=7;break;
case 0x14: lh5801_lda(YL); lh5801_icount-=5;break;
case 0x15: lh5801_lda(program_read_byte(Y)); lh5801_icount-=6;break;
case 0x15: lh5801_lda(memory_read_byte(lh5801.program,Y)); lh5801_icount-=6;break;
case 0x16: lh5801_cpa(lh5801.a, YL); lh5801_icount-=6;break;
case 0x17: lh5801_cpa(lh5801.a, program_read_byte(Y)); lh5801_icount-=7;break;
case 0x17: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,Y)); lh5801_icount-=7;break;
case 0x18: YH=lh5801.a; lh5801_icount-=5; break;
case 0x19: lh5801_and(program_read_byte(Y)); lh5801_icount-=7;break;
case 0x19: lh5801_and(memory_read_byte(lh5801.program,Y)); lh5801_icount-=7;break;
case 0x1a: YL=lh5801.a; lh5801_icount-=5; break;
case 0x1b: lh5801_ora(program_read_byte(Y)); lh5801_icount-=7;break;
case 0x1c: lh5801_dcs(program_read_byte(Y)); lh5801_icount-=13; break;
case 0x1d: lh5801_eor(program_read_byte(Y)); lh5801_icount-=7;break;
case 0x1e: program_write_byte(Y,lh5801.a); lh5801_icount-=6;break;
case 0x1f: lh5801_bit(program_read_byte(Y),lh5801.a); lh5801_icount-=7;break;
case 0x1b: lh5801_ora(memory_read_byte(lh5801.program,Y)); lh5801_icount-=7;break;
case 0x1c: lh5801_dcs(memory_read_byte(lh5801.program,Y)); lh5801_icount-=13; break;
case 0x1d: lh5801_eor(memory_read_byte(lh5801.program,Y)); lh5801_icount-=7;break;
case 0x1e: memory_write_byte(lh5801.program,Y,lh5801.a); lh5801_icount-=6;break;
case 0x1f: lh5801_bit(memory_read_byte(lh5801.program,Y),lh5801.a); lh5801_icount-=7;break;
case 0x20: lh5801_sbc(UL); lh5801_icount-=6;break;
case 0x21: lh5801_sbc(program_read_byte(U)); lh5801_icount-=7;break;
case 0x21: lh5801_sbc(memory_read_byte(lh5801.program,U)); lh5801_icount-=7;break;
case 0x22: lh5801_adc(UL); lh5801_icount-=6;break;
case 0x23: lh5801_adc(program_read_byte(U)); lh5801_icount-=7;break;
case 0x23: lh5801_adc(memory_read_byte(lh5801.program,U)); lh5801_icount-=7;break;
case 0x24: lh5801_lda(UL); lh5801_icount-=5;break;
case 0x25: lh5801_lda(program_read_byte(U)); lh5801_icount-=6;break;
case 0x25: lh5801_lda(memory_read_byte(lh5801.program,U)); lh5801_icount-=6;break;
case 0x26: lh5801_cpa(lh5801.a, UL); lh5801_icount-=6;break;
case 0x27: lh5801_cpa(lh5801.a, program_read_byte(U)); lh5801_icount-=7;break;
case 0x27: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,U)); lh5801_icount-=7;break;
case 0x28: UH=lh5801.a; lh5801_icount-=5; break;
case 0x29: lh5801_and(program_read_byte(U)); lh5801_icount-=7;break;
case 0x29: lh5801_and(memory_read_byte(lh5801.program,U)); lh5801_icount-=7;break;
case 0x2a: UL=lh5801.a; lh5801_icount-=5; break;
case 0x2b: lh5801_ora(program_read_byte(U)); lh5801_icount-=7;break;
case 0x2c: lh5801_dcs(program_read_byte(U)); lh5801_icount-=13; break;
case 0x2d: lh5801_eor(program_read_byte(U)); lh5801_icount-=7;break;
case 0x2e: program_write_byte(U,lh5801.a); lh5801_icount-=6;break;
case 0x2f: lh5801_bit(program_read_byte(U),lh5801.a); lh5801_icount-=7;break;
case 0x2b: lh5801_ora(memory_read_byte(lh5801.program,U)); lh5801_icount-=7;break;
case 0x2c: lh5801_dcs(memory_read_byte(lh5801.program,U)); lh5801_icount-=13; break;
case 0x2d: lh5801_eor(memory_read_byte(lh5801.program,U)); lh5801_icount-=7;break;
case 0x2e: memory_write_byte(lh5801.program,U,lh5801.a); lh5801_icount-=6;break;
case 0x2f: lh5801_bit(memory_read_byte(lh5801.program,U),lh5801.a); lh5801_icount-=7;break;
case 0x38: /*nop*/lh5801_icount-=5;break;
case 0x40: lh5801_inc(&XL);lh5801_icount-=5;break;
case 0x41: lh5801_sin(&lh5801.x); lh5801_icount-=6;break;
@ -540,14 +540,14 @@ static void lh5801_instruction(void)
case 0x45: lh5801_lin(&lh5801.x);lh5801_icount-=6;break;
case 0x46: X--;lh5801_icount-=5;break;
case 0x47: lh5801_lde(&lh5801.x);lh5801_icount-=6;break;
case 0x48: XH=program_decrypted_read_byte(P++);lh5801_icount-=6;break;
case 0x49: lh5801_and_mem(X, program_decrypted_read_byte(P++)); lh5801_icount-=13;break;
case 0x4a: XL=program_decrypted_read_byte(P++);lh5801_icount-=6;break;
case 0x4b: lh5801_ora_mem(X, program_decrypted_read_byte(P++)); lh5801_icount-=13;break;
case 0x4c: lh5801_cpa(XH, program_decrypted_read_byte(P++)); lh5801_icount-=7;break;
case 0x4d: lh5801_bit(program_read_byte(X), program_decrypted_read_byte(P++));lh5801_icount-=10;break;
case 0x4e: lh5801_cpa(XL, program_decrypted_read_byte(P++)); lh5801_icount-=7;break;
case 0x4f: lh5801_add_mem(X, program_decrypted_read_byte(P++)); lh5801_icount-=13;break;
case 0x48: XH=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
case 0x49: lh5801_and_mem(X, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
case 0x4a: XL=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
case 0x4b: lh5801_ora_mem(X, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
case 0x4c: lh5801_cpa(XH, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0x4d: lh5801_bit(memory_read_byte(lh5801.program,X), memory_decrypted_read_byte(lh5801.program,P++));lh5801_icount-=10;break;
case 0x4e: lh5801_cpa(XL, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0x4f: lh5801_add_mem(X, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
case 0x50: lh5801_inc(&YL);lh5801_icount-=5;break;
case 0x51: lh5801_sin(&lh5801.y); lh5801_icount-=6;break;
case 0x52: lh5801_dec(&YL);lh5801_icount-=5;break;
@ -556,14 +556,14 @@ static void lh5801_instruction(void)
case 0x55: lh5801_lin(&lh5801.y);lh5801_icount-=6;break;
case 0x56: Y--;lh5801_icount-=5;break;
case 0x57: lh5801_lde(&lh5801.y);lh5801_icount-=6;break;
case 0x58: YH=program_decrypted_read_byte(P++);lh5801_icount-=6;break;
case 0x59: lh5801_and_mem(Y, program_decrypted_read_byte(P++)); lh5801_icount-=13;break;
case 0x5a: YL=program_decrypted_read_byte(P++);lh5801_icount-=6;break;
case 0x5b: lh5801_ora_mem(Y, program_decrypted_read_byte(P++)); lh5801_icount-=13;break;
case 0x5c: lh5801_cpa(YH, program_decrypted_read_byte(P++)); lh5801_icount-=7;break;
case 0x5d: lh5801_bit(program_read_byte(Y), program_decrypted_read_byte(P++));lh5801_icount-=10;break;
case 0x5e: lh5801_cpa(YL, program_decrypted_read_byte(P++)); lh5801_icount-=7;break;
case 0x5f: lh5801_add_mem(Y, program_decrypted_read_byte(P++)); lh5801_icount-=13;break;
case 0x58: YH=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
case 0x59: lh5801_and_mem(Y, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
case 0x5a: YL=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
case 0x5b: lh5801_ora_mem(Y, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
case 0x5c: lh5801_cpa(YH, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0x5d: lh5801_bit(memory_read_byte(lh5801.program,Y), memory_decrypted_read_byte(lh5801.program,P++));lh5801_icount-=10;break;
case 0x5e: lh5801_cpa(YL, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0x5f: lh5801_add_mem(Y, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
case 0x60: lh5801_inc(&UL);lh5801_icount-=5;break;
case 0x61: lh5801_sin(&lh5801.u); lh5801_icount-=6;break;
case 0x62: lh5801_dec(&UL);lh5801_icount-=5;break;
@ -572,14 +572,14 @@ static void lh5801_instruction(void)
case 0x65: lh5801_lin(&lh5801.u);lh5801_icount-=6;break;
case 0x66: U--;lh5801_icount-=5;break;
case 0x67: lh5801_lde(&lh5801.u);lh5801_icount-=6;break;
case 0x68: UH=program_decrypted_read_byte(P++);lh5801_icount-=6;break;
case 0x69: lh5801_and_mem(U, program_decrypted_read_byte(P++)); lh5801_icount-=13;break;
case 0x6a: UL=program_decrypted_read_byte(P++);lh5801_icount-=6;break;
case 0x6b: lh5801_ora_mem(U, program_decrypted_read_byte(P++)); lh5801_icount-=13;break;
case 0x6c: lh5801_cpa(UH, program_decrypted_read_byte(P++)); lh5801_icount-=7;break;
case 0x6d: lh5801_bit(program_read_byte(U), program_decrypted_read_byte(P++));lh5801_icount-=10;break;
case 0x6e: lh5801_cpa(UL, program_decrypted_read_byte(P++)); lh5801_icount-=7;break;
case 0x6f: lh5801_add_mem(U, program_decrypted_read_byte(P++)); lh5801_icount-=13;break;
case 0x68: UH=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
case 0x69: lh5801_and_mem(U, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
case 0x6a: UL=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
case 0x6b: lh5801_ora_mem(U, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
case 0x6c: lh5801_cpa(UH, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0x6d: lh5801_bit(memory_read_byte(lh5801.program,U), memory_decrypted_read_byte(lh5801.program,P++));lh5801_icount-=10;break;
case 0x6e: lh5801_cpa(UL, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0x6f: lh5801_add_mem(U, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
case 0x80: lh5801_sbc(XH); lh5801_icount-=6;break;
case 0x81: lh5801_branch_plus(!(lh5801.t&C)); lh5801_icount-=8; break;
case 0x82: lh5801_adc(XH); lh5801_icount-=6;break;
@ -592,7 +592,7 @@ static void lh5801_instruction(void)
case 0x89: lh5801_branch_plus(!(lh5801.t&Z)); lh5801_icount-=8; break;
case 0x8a: lh5801_rti(); lh5801_icount-=14; break;
case 0x8b: lh5801_branch_plus(lh5801.t&Z); lh5801_icount-=8; break;
case 0x8c: lh5801_dca(program_read_byte(X)); lh5801_icount-=15; break;
case 0x8c: lh5801_dca(memory_read_byte(lh5801.program,X)); lh5801_icount-=15; break;
case 0x8d: lh5801_branch_plus(!(lh5801.t&V)); lh5801_icount-=8; break;
case 0x8e: lh5801_branch_plus(1); lh5801_icount-=5; break;
case 0x8f: lh5801_branch_plus(lh5801.t&V); lh5801_icount-=8; break;
@ -607,45 +607,45 @@ static void lh5801_instruction(void)
case 0x99: lh5801_branch_minus(!(lh5801.t&Z)); lh5801_icount-=8; break;
case 0x9a: lh5801_rtn(); lh5801_icount-=11; break;
case 0x9b: lh5801_branch_minus(lh5801.t&Z); lh5801_icount-=8; break;
case 0x9c: lh5801_dca(program_read_byte(Y)); lh5801_icount-=15; break;
case 0x9c: lh5801_dca(memory_read_byte(lh5801.program,Y)); lh5801_icount-=15; break;
case 0x9d: lh5801_branch_minus(!(lh5801.t&V)); lh5801_icount-=8; break;
case 0x9e: lh5801_branch_minus(1); lh5801_icount-=6; break;
case 0x9f: lh5801_branch_minus(lh5801.t&V); lh5801_icount-=8; break;
case 0xa0: lh5801_sbc(UH); lh5801_icount-=6;break;
case 0xa2: lh5801_adc(UH); lh5801_icount-=6;break;
case 0xa1: lh5801_sbc(program_read_byte(lh5801_readop_word())); lh5801_icount-=13;break;
case 0xa3: lh5801_adc(program_read_byte(lh5801_readop_word())); lh5801_icount-=13;break;
case 0xa1: lh5801_sbc(memory_read_byte(lh5801.program,lh5801_readop_word())); lh5801_icount-=13;break;
case 0xa3: lh5801_adc(memory_read_byte(lh5801.program,lh5801_readop_word())); lh5801_icount-=13;break;
case 0xa4: lh5801_lda(UH); lh5801_icount-=5;break;
case 0xa5: lh5801_lda(program_read_byte(lh5801_readop_word())); lh5801_icount-=12;break;
case 0xa5: lh5801_lda(memory_read_byte(lh5801.program,lh5801_readop_word())); lh5801_icount-=12;break;
case 0xa6: lh5801_cpa(lh5801.a, UH); lh5801_icount-=6;break;
case 0xa7: lh5801_cpa(lh5801.a, program_read_byte(lh5801_readop_word())); lh5801_icount-=13;break;
case 0xa7: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,lh5801_readop_word())); lh5801_icount-=13;break;
case 0xa8: lh5801.pv=1;/*spv!*/ lh5801_icount-=4; break;
case 0xa9: lh5801_and(program_read_byte(lh5801_readop_word())); lh5801_icount-=13;break;
case 0xa9: lh5801_and(memory_read_byte(lh5801.program,lh5801_readop_word())); lh5801_icount-=13;break;
case 0xaa: S=lh5801_readop_word();lh5801_icount-=6;break;
case 0xab: lh5801_ora(program_read_byte(lh5801_readop_word())); lh5801_icount-=13;break;
case 0xac: lh5801_dca(program_read_byte(U)); lh5801_icount-=15; break;
case 0xad: lh5801_eor(program_read_byte(lh5801_readop_word())); lh5801_icount-=13;break;
case 0xae: program_write_byte(lh5801_readop_word(),lh5801.a); lh5801_icount-=12;break;
case 0xaf: lh5801_bit(program_read_byte(lh5801_readop_word()),lh5801.a); lh5801_icount-=13;break;
case 0xb1: lh5801_sbc(program_decrypted_read_byte(P++)); lh5801_icount-=7;break;
case 0xb3: lh5801_adc(program_decrypted_read_byte(P++)); lh5801_icount-=7;break;
case 0xb5: lh5801_lda(program_decrypted_read_byte(P++)); lh5801_icount-=6;break;
case 0xb7: lh5801_cpa(lh5801.a, program_decrypted_read_byte(P++)); lh5801_icount-=7;break;
case 0xab: lh5801_ora(memory_read_byte(lh5801.program,lh5801_readop_word())); lh5801_icount-=13;break;
case 0xac: lh5801_dca(memory_read_byte(lh5801.program,U)); lh5801_icount-=15; break;
case 0xad: lh5801_eor(memory_read_byte(lh5801.program,lh5801_readop_word())); lh5801_icount-=13;break;
case 0xae: memory_write_byte(lh5801.program,lh5801_readop_word(),lh5801.a); lh5801_icount-=12;break;
case 0xaf: lh5801_bit(memory_read_byte(lh5801.program,lh5801_readop_word()),lh5801.a); lh5801_icount-=13;break;
case 0xb1: lh5801_sbc(memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0xb3: lh5801_adc(memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0xb5: lh5801_lda(memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=6;break;
case 0xb7: lh5801_cpa(lh5801.a, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0xb8: lh5801.pv=0;/*rpv!*/ lh5801_icount-=4; break;
case 0xb9: lh5801_and(program_decrypted_read_byte(P++)); lh5801_icount-=7;break;
case 0xb9: lh5801_and(memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0xba: lh5801_jmp(lh5801_readop_word()); lh5801_icount-=12;break;
case 0xbb: lh5801_ora(program_decrypted_read_byte(P++)); lh5801_icount-=7;break;
case 0xbd: lh5801_eor(program_decrypted_read_byte(P++)); lh5801_icount-=7;break;
case 0xbb: lh5801_ora(memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0xbd: lh5801_eor(memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0xbe: lh5801_sjp(); lh5801_icount-=19; break;
case 0xbf: lh5801_bit(lh5801.a, program_decrypted_read_byte(P++));lh5801_icount-=7;break;
case 0xc1: lh5801_vector(!(lh5801.t&C), program_decrypted_read_byte(P++)); lh5801_icount-=8;break;
case 0xc3: lh5801_vector(lh5801.t&C, program_decrypted_read_byte(P++)); lh5801_icount-=8;break;
case 0xc5: lh5801_vector(!(lh5801.t&H), program_decrypted_read_byte(P++)); lh5801_icount-=8;break;
case 0xc7: lh5801_vector(lh5801.t&H, program_decrypted_read_byte(P++)); lh5801_icount-=8;break;
case 0xc9: lh5801_vector(!(lh5801.t&Z), program_decrypted_read_byte(P++)); lh5801_icount-=8;break;
case 0xcb: lh5801_vector(lh5801.t&Z, program_decrypted_read_byte(P++)); lh5801_icount-=8;break;
case 0xcd: lh5801_vector(1, program_decrypted_read_byte(P++)); lh5801_icount-=7;break;
case 0xcf: lh5801_vector(lh5801.t&V, program_decrypted_read_byte(P++)); lh5801_icount-=8;break;
case 0xbf: lh5801_bit(lh5801.a, memory_decrypted_read_byte(lh5801.program,P++));lh5801_icount-=7;break;
case 0xc1: lh5801_vector(!(lh5801.t&C), memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=8;break;
case 0xc3: lh5801_vector(lh5801.t&C, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=8;break;
case 0xc5: lh5801_vector(!(lh5801.t&H), memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=8;break;
case 0xc7: lh5801_vector(lh5801.t&H, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=8;break;
case 0xc9: lh5801_vector(!(lh5801.t&Z), memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=8;break;
case 0xcb: lh5801_vector(lh5801.t&Z, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=8;break;
case 0xcd: lh5801_vector(1, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0xcf: lh5801_vector(lh5801.t&V, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=8;break;
case 0xd1: lh5801_ror(); lh5801_icount-=6; break;
case 0xd3: lh5801_drr(X); lh5801_icount-=12; break;
case 0xd5: lh5801_shr(); lh5801_icount-=6; break;
@ -657,21 +657,21 @@ static void lh5801_instruction(void)
case 0xe1: lh5801.pu=1;/*spu!*/ lh5801_icount-=4; break;
case 0xe3: lh5801.pu=0;/*rpu!*/ lh5801_icount-=4; break;
case 0xe9:
adr=lh5801_readop_word();lh5801_and_mem(adr, program_decrypted_read_byte(P++));
adr=lh5801_readop_word();lh5801_and_mem(adr, memory_decrypted_read_byte(lh5801.program,P++));
lh5801_icount-=19;break;
case 0xeb:
adr=lh5801_readop_word();lh5801_ora_mem(adr, program_decrypted_read_byte(P++));
adr=lh5801_readop_word();lh5801_ora_mem(adr, memory_decrypted_read_byte(lh5801.program,P++));
lh5801_icount-=19;break;
case 0xed:
adr=lh5801_readop_word();lh5801_bit(program_read_byte(adr), program_decrypted_read_byte(P++));
adr=lh5801_readop_word();lh5801_bit(memory_read_byte(lh5801.program,adr), memory_decrypted_read_byte(lh5801.program,P++));
lh5801_icount-=16;break;
case 0xef:
adr=lh5801_readop_word();
lh5801_add_mem(adr, program_decrypted_read_byte(P++)); lh5801_icount-=19;
lh5801_add_mem(adr, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=19;
break;
case 0xf1: lh5801_aex(); lh5801_icount-=6; break;
case 0xf5: program_write_byte(Y++, program_read_byte(X++)); lh5801_icount-=7; break; //tin
case 0xf7: lh5801_cpa(lh5801.a, program_read_byte(X++));lh5801_icount-=7; break; //cin
case 0xf5: memory_write_byte(lh5801.program,Y++, memory_read_byte(lh5801.program,X++)); lh5801_icount-=7; break; //tin
case 0xf7: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,X++));lh5801_icount-=7; break; //cin
case 0xf9: lh5801.t&=~C;lh5801_icount-=4;break;
case 0xfb: lh5801.t|=C;lh5801_icount-=4;break;
case 0xfd: lh5801_instruction_fd();break;

7
src/emu/cpu/lh5801/lh5801.c
View File

@ -17,6 +17,7 @@
* based on info found on an artikel for the tandy trs80 pc2
*
*****************************************************************************/
#define NO_LEGACY_MEMORY_HANDLERS 1
#include "debugger.h"
#include "lh5801.h"
@ -47,6 +48,8 @@ enum
typedef struct
{
const lh5801_cpu_core *config;
const device_config *device;
const address_space *program;
PAIR s, p, u, x, y;
int tm; //9 bit
@ -93,11 +96,13 @@ static CPU_INIT( lh5801 )
{
memset(&lh5801, 0, sizeof(lh5801));
lh5801.config = (const lh5801_cpu_core *) device->static_config;
lh5801.device = device;
lh5801.program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
}
static CPU_RESET( lh5801 )
{
P = (program_read_byte(0xfffe)<<8) | program_read_byte(0xffff);
P = (memory_read_byte(lh5801.program, 0xfffe)<<8) | memory_read_byte(lh5801.program, 0xffff);
change_pc(P);

7
src/emu/cpu/lr35902/lr35902.c
View File

@ -36,6 +36,7 @@
/** Split fetch and execute cycles. **/
/** **/
/*************************************************************/
#define NO_LEGACY_MEMORY_HANDLERS 1
#include "debugger.h"
#include "lr35902.h"
@ -64,6 +65,7 @@ typedef struct {
int ei_delay;
cpu_irq_callback irq_callback;
const device_config *device;
const address_space *program;
/* Timer stuff */
void (*timer_fired_func)(int cycles);
/* Fetch & execute related */
@ -119,8 +121,8 @@ static lr35902_regs Regs;
/* Memory functions */
/****************************************************************************/
#define mem_ReadByte(A) ((UINT8)program_read_byte_8le(A))
#define mem_WriteByte(A,V) (program_write_byte_8le(A,V))
#define mem_ReadByte(A) ((UINT8)memory_read_byte_8le(Regs.w.program,A))
#define mem_WriteByte(A,V) (memory_write_byte_8le(Regs.w.program,A,V))
INLINE UINT16 mem_ReadWord (UINT32 address)
{
@ -183,6 +185,7 @@ static CPU_INIT( lr35902 )
Regs.w.config = (const lr35902_cpu_core *) device->static_config;
Regs.w.irq_callback = irqcallback;
Regs.w.device = device;
Regs.w.program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
}
/*** Reset lr353902 registers: ******************************/

72
src/emu/cpu/m37710/m37710.c
View File

@ -50,7 +50,7 @@
fixed so top 8 bits of X & Y are preserved while in 8-bit mode,
added save state support.
*/
#define NO_LEGACY_MEMORY_HANDLERS 1
#include "debugger.h"
#include "deprecat.h"
#include "cpuexec.h"
@ -417,80 +417,80 @@ static UINT8 m37710_internal_r(int offset)
switch (offset)
{
case 2: // p0
return io_read_byte_8le(M37710_PORT0);
return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT0);
break;
case 3: // p1
return io_read_byte_8le(M37710_PORT1);
return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT1);
break;
case 6: // p2
return io_read_byte_8le(M37710_PORT2);
return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT2);
break;
case 7: // p3
return io_read_byte_8le(M37710_PORT3);
return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT3);
break;
case 0xa: // p4
return io_read_byte_8le(M37710_PORT4);
return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT4);
break;
case 0xb: // p5
return io_read_byte_8le(M37710_PORT5);
return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT5);
break;
case 0xe: // p6
return io_read_byte_8le(M37710_PORT6);
return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT6);
break;
case 0xf: // p7
return io_read_byte_8le(M37710_PORT7);
return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT7);
break;
case 0x12: // p8
return io_read_byte_8le(M37710_PORT8);
return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT8);
break;
case 0x20:
return io_read_byte_8le(M37710_ADC0_L);
return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC0_L);
break;
case 0x21:
return io_read_byte_8le(M37710_ADC0_H);
return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC0_H);
break;
case 0x22:
return io_read_byte_8le(M37710_ADC1_L);
return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC1_L);
break;
case 0x23:
return io_read_byte_8le(M37710_ADC1_H);
return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC1_H);
break;
case 0x24:
return io_read_byte_8le(M37710_ADC2_L);
return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC2_L);
break;
case 0x25:
return io_read_byte_8le(M37710_ADC2_H);
return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC2_H);
break;
case 0x26:
return io_read_byte_8le(M37710_ADC3_L);
return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC3_L);
break;
case 0x27:
return io_read_byte_8le(M37710_ADC3_H);
return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC3_H);
break;
case 0x28:
return io_read_byte_8le(M37710_ADC4_L);
return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC4_L);
break;
case 0x29:
return io_read_byte_8le(M37710_ADC4_H);
return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC4_H);
break;
case 0x2a:
return io_read_byte_8le(M37710_ADC5_L);
return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC5_L);
break;
case 0x2b:
return io_read_byte_8le(M37710_ADC5_H);
return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC5_H);
break;
case 0x2c:
return io_read_byte_8le(M37710_ADC6_L);
return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC6_L);
break;
case 0x2d:
return io_read_byte_8le(M37710_ADC6_H);
return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC6_H);
break;
case 0x2e:
return io_read_byte_8le(M37710_ADC7_L);
return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC7_L);
break;
case 0x2f:
return io_read_byte_8le(M37710_ADC7_H);
return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC7_H);
break;
case 0x35:
return 0xff; // UART control
@ -511,39 +511,39 @@ static void m37710_internal_w(int offset, UINT8 data)
switch(offset)
{
case 2: // p0
io_write_byte_8le(M37710_PORT0, data);
memory_write_byte_8le(m37710i_cpu.io, M37710_PORT0, data);
return;
break;
case 3: // p1
io_write_byte_8le(M37710_PORT1, data);
memory_write_byte_8le(m37710i_cpu.io, M37710_PORT1, data);
return;
break;
case 6: // p2
io_write_byte_8le(M37710_PORT2, data);
memory_write_byte_8le(m37710i_cpu.io, M37710_PORT2, data);
return;
break;
case 7: // p3
io_write_byte_8le(M37710_PORT3, data);
memory_write_byte_8le(m37710i_cpu.io, M37710_PORT3, data);
return;
break;
case 0xa: // p4
io_write_byte_8le(M37710_PORT4, data);
memory_write_byte_8le(m37710i_cpu.io, M37710_PORT4, data);
return;
break;
case 0xb: // p5
io_write_byte_8le(M37710_PORT5, data);
memory_write_byte_8le(m37710i_cpu.io, M37710_PORT5, data);
return;
break;
case 0xe: // p6
io_write_byte_8le(M37710_PORT6, data);
memory_write_byte_8le(m37710i_cpu.io, M37710_PORT6, data);
return;
break;
case 0xf: // p7
io_write_byte_8le(M37710_PORT7, data);
memory_write_byte_8le(m37710i_cpu.io, M37710_PORT7, data);
return;
break;
case 0x12: // p8
io_write_byte_8le(M37710_PORT8, data);
memory_write_byte_8le(m37710i_cpu.io, M37710_PORT8, data);
return;
break;
@ -982,6 +982,8 @@ static CPU_INIT( m37710 )
INT_ACK = irqcallback;
m37710i_cpu.device = device;
m37710i_cpu.program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
m37710i_cpu.io = memory_find_address_space(device, ADDRESS_SPACE_IO);
m37710_ICount = 0;
m37710_fullCount = 0;

10
src/emu/cpu/m37710/m37710.h
View File

@ -107,11 +107,11 @@ void m37710_state_load(void *file);
#undef M37710_CALL_DEBUGGER
#define M37710_CALL_DEBUGGER(x) debugger_instruction_hook(m37710i_cpu.device, x)
#define m37710_read_8(addr) program_read_byte_16le(addr)
#define m37710_write_8(addr,data) program_write_byte_16le(addr,data)
#define m37710_read_8_immediate(A) program_read_byte_16le(A)
#define m37710_read_16(addr) program_read_word_16le(addr)
#define m37710_write_16(addr,data) program_write_word_16le(addr,data)
#define m37710_read_8(addr) memory_read_byte_16le(m37710i_cpu.program, addr)
#define m37710_write_8(addr,data) memory_write_byte_16le(m37710i_cpu.program, addr,data)
#define m37710_read_8_immediate(A) memory_read_byte_16le(m37710i_cpu.program, A)
#define m37710_read_16(addr) memory_read_word_16le(m37710i_cpu.program, addr)
#define m37710_write_16(addr,data) memory_write_word_16le(m37710i_cpu.program, addr,data)
#define m37710_jumping(A) change_pc(A)
#define m37710_branching(A)

2
src/emu/cpu/m37710/m37710cm.h
View File

@ -98,6 +98,8 @@ struct _m37710i_cpu_struct
uint irq_level; /* irq level */
cpu_irq_callback int_ack;
const device_config *device;
const address_space *program;
const address_space *io;
uint stopped; /* Sets how the CPU is stopped */
void (*const *opcodes)(void); /* opcodes with no prefix */
void (*const *opcodes42)(void); /* opcodes with 0x42 prefix */

4
src/emu/cpu/m6502/ill02.h
View File

@ -235,7 +235,7 @@
#if 0
#define SSH \
tmp = S = A & X; \
tmp &= (UINT8)(program_raw_read_byte((PCW + 1) & 0xffff) + 1)
tmp &= (UINT8)(memory_raw_read_byte(m6502->space, (PCW + 1) & 0xffff) + 1)
#endif
/* 6510 ********************************************************
@ -264,7 +264,7 @@
#define KIL \
PCW--; \
logerror("M6510 KILL opcode %04x: %02x\n", \
PCW, program_decrypted_read_byte(PCW))
PCW, memory_decrypted_read_byte(m6502->space, PCW))
/* N2A03 *******************************************************
* ARR logical and, rotate right - no decimal mode

39
src/emu/cpu/m6502/m4510.c
View File

@ -100,6 +100,7 @@ z: xxxx address bits a19 .. a16 for memory accesses with a15 1 ?
1 map 8000-9fff
*/
#define NO_LEGACY_MEMORY_HANDLERS 1
#include "debugger.h"
#include "deprecat.h"
#include "m6502.h"
@ -144,15 +145,16 @@ struct _m4510_Regs {
cpu_irq_callback irq_callback;
const device_config *device;
const address_space *space;
int icount;
read8_space_func rdmem_id; /* readmem callback for indexed instructions */
write8_space_func wrmem_id; /* writemem callback for indexed instructions */
m6502_read_indexed_func rdmem_id; /* readmem callback for indexed instructions */
m6502_write_indexed_func wrmem_id; /* writemem callback for indexed instructions */
UINT8 ddr;
UINT8 port;
UINT8 (*port_read)(void);
void (*port_write)(UINT8 data);
m6510_port_read_func port_read;
m6510_port_write_func port_write;
};
static void *token;
@ -164,27 +166,27 @@ static void *token;
INLINE int m4510_cpu_readop(m4510_Regs *m4510)
{
register UINT16 t=m4510->pc.w.l++;
return program_decrypted_read_byte(M4510_MEM(t));
return memory_decrypted_read_byte(m4510->space, M4510_MEM(t));
}
INLINE int m4510_cpu_readop_arg(m4510_Regs *m4510)
{
register UINT16 t=m4510->pc.w.l++;
return program_raw_read_byte(M4510_MEM(t));
return memory_raw_read_byte(m4510->space, M4510_MEM(t));
}
#define M4510
#include "t65ce02.c"
static READ8_HANDLER( default_rdmem_id )
static UINT8 default_rdmem_id(const address_space *space, offs_t address)
{
m4510_Regs *m4510 = token;
return program_read_byte_8le(M4510_MEM(offset));
m4510_Regs *m4510 = space->cpu->token;
return memory_read_byte_8le(space, M4510_MEM(address));
}
static WRITE8_HANDLER( default_wrmem_id )
static void default_wrmem_id(const address_space *space, offs_t address, UINT8 data)
{
m4510_Regs *m4510 = token;
program_write_byte_8le(M4510_MEM(offset), data);
m4510_Regs *m4510 = space->cpu->token;
memory_write_byte_8le(space, M4510_MEM(address), data);
}
static CPU_INIT( m4510 )
@ -198,6 +200,7 @@ static CPU_INIT( m4510 )
m4510->wrmem_id = default_wrmem_id;
m4510->irq_callback = irqcallback;
m4510->device = device;
m4510->space = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
}
static CPU_RESET( m4510 )
@ -368,7 +371,7 @@ static READ8_HANDLER( m4510_read_0000 )
break;
case 0x0001: /* Data Port */
if (m4510->port_read)
result = m4510->port_read();
result = m4510->port_read(m4510->device, 0);
result = (m4510->ddr & m4510->port) | (~m4510->ddr & result);
break;
}
@ -390,7 +393,7 @@ static WRITE8_HANDLER( m4510_write_0000 )
}
if (m4510->port_write)
m4510->port_write(m4510_get_port(m4510));
m4510->port_write(m4510->device, 0, m4510_get_port(m4510));
}
static ADDRESS_MAP_START(m4510_mem, ADDRESS_SPACE_PROGRAM, 8)
@ -444,10 +447,10 @@ static CPU_SET_INFO( m4510 )
case CPUINFO_INT_REGISTER + M4510_MEM7: m4510->mem[7] = info->i; break;
/* --- the following bits of info are set as pointers to data or functions --- */
case CPUINFO_PTR_M6502_READINDEXED_CALLBACK: m4510->rdmem_id = (read8_space_func) info->f; break;
case CPUINFO_PTR_M6502_WRITEINDEXED_CALLBACK: m4510->wrmem_id = (write8_space_func) info->f; break;
case CPUINFO_PTR_M6510_PORTREAD: m4510->port_read = (UINT8 (*)(void)) info->f; break;
case CPUINFO_PTR_M6510_PORTWRITE: m4510->port_write = (void (*)(UINT8)) info->f; break;
case CPUINFO_PTR_M6502_READINDEXED_CALLBACK: m4510->rdmem_id = (m6502_read_indexed_func) info->f; break;
case CPUINFO_PTR_M6502_WRITEINDEXED_CALLBACK: m4510->wrmem_id = (m6502_write_indexed_func) info->f; break;
case CPUINFO_PTR_M6510_PORTREAD: m4510->port_read = (m6510_port_read_func) info->f; break;
case CPUINFO_PTR_M6510_PORTWRITE: m4510->port_write = (m6510_port_write_func) info->f; break;
}
}

31
src/emu/cpu/m6502/m6502.c
View File

@ -24,6 +24,8 @@
/* 10.March 2000 PeT added 6502 set overflow input line */
/* 13.September 2000 PeT N2A03 jmp indirect */
#define NO_LEGACY_MEMORY_HANDLERS 1
#if ((HAS_M65SC02 || HAS_DECO16) && !HAS_M65C02)
#undef HAS_M65C02
#define HAS_M65C02 1
@ -76,17 +78,18 @@ struct _m6502_Regs
cpu_irq_callback irq_callback;
const device_config *device;
const address_space *space;
const address_space *io;
int int_occured;
int icount;
read8_space_func rdmem_id; /* readmem callback for indexed instructions */
write8_space_func wrmem_id; /* writemem callback for indexed instructions */
m6502_read_indexed_func rdmem_id; /* readmem callback for indexed instructions */
m6502_write_indexed_func wrmem_id; /* writemem callback for indexed instructions */
#if (HAS_M6510) || (HAS_M6510T) || (HAS_M8502) || (HAS_M7501)
UINT8 ddr;
UINT8 port;
UINT8 (*port_read)(UINT8 direction);
void (*port_write)(UINT8 direction, UINT8 data);
m6510_port_read_func port_read;
m6510_port_write_func port_write;
#endif
};
@ -95,8 +98,8 @@ struct _m6502_Regs
static void *token;
//static m6502_Regs *m6502;
static READ8_HANDLER( default_rdmem_id ) { return program_read_byte_8le(offset); }
static WRITE8_HANDLER( default_wdmem_id ) { program_write_byte_8le(offset, data); }
static UINT8 default_rdmem_id(const address_space *space, offs_t offset) { return memory_read_byte_8le(space, offset); }
static void default_wdmem_id(const address_space *space, offs_t offset, UINT8 data) { memory_write_byte_8le(space, offset, data); }
/***************************************************************
* include the opcode macros, functions and tables
@ -141,7 +144,7 @@ static void m6502_common_init(const device_config *device, int index, int clock,
m6502->irq_callback = irqcallback;
m6502->device = device;
m6502->space = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM);
m6502->space = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
m6502->subtype = subtype;
m6502->insn = insn;
m6502->rdmem_id = default_rdmem_id;
@ -392,7 +395,7 @@ static READ8_HANDLER( m6510_read_0000 )
break;
case 0x0001: /* Data Port */
if (m6502->port_read)
result = m6502->port_read( m6502->ddr );
result = m6502->port_read( m6502->device, m6502->ddr );
result = (m6502->ddr & m6502->port) | (~m6502->ddr & result);
break;
}
@ -414,7 +417,7 @@ static WRITE8_HANDLER( m6510_write_0000 )
}
if (m6502->port_write)
m6502->port_write( m6502->ddr, m6502->port & m6502->ddr );
m6502->port_write( m6502->device, m6502->ddr, m6502->port & m6502->ddr );
}
static ADDRESS_MAP_START(m6510_mem, ADDRESS_SPACE_PROGRAM, 8)
@ -552,7 +555,9 @@ static CPU_INIT( m65sc02 )
static CPU_INIT( deco16 )
{
m6502_Regs *m6502 = device->token;
m6502_common_init(device, index, clock, irqcallback, SUBTYPE_DECO16, insndeco16, "deco16");
m6502->io = memory_find_address_space(device, ADDRESS_SPACE_IO);
}
@ -715,8 +720,8 @@ static CPU_SET_INFO( m6502 )
case CPUINFO_INT_REGISTER + M6502_ZP: m6502->zp.w.l = info->i; break;
/* --- the following bits of info are set as pointers to data or functions --- */
case CPUINFO_PTR_M6502_READINDEXED_CALLBACK: m6502->rdmem_id = (read8_space_func) info->f; break;
case CPUINFO_PTR_M6502_WRITEINDEXED_CALLBACK: m6502->wrmem_id = (write8_space_func) info->f; break;
case CPUINFO_PTR_M6502_READINDEXED_CALLBACK: m6502->rdmem_id = (m6502_read_indexed_func) info->f; break;
case CPUINFO_PTR_M6502_WRITEINDEXED_CALLBACK: m6502->wrmem_id = (m6502_write_indexed_func) info->f; break;
}
}
@ -850,8 +855,8 @@ static CPU_SET_INFO( m6510 )
switch (state)
{
/* --- the following bits of info are set as pointers to data or functions --- */
case CPUINFO_PTR_M6510_PORTREAD: m6502->port_read = (UINT8 (*)(UINT8)) info->f; break;
case CPUINFO_PTR_M6510_PORTWRITE: m6502->port_write = (void (*)(UINT8,UINT8)) info->f; break;
case CPUINFO_PTR_M6510_PORTREAD: m6502->port_read = (m6510_port_read_func) info->f; break;
case CPUINFO_PTR_M6510_PORTWRITE: m6502->port_write = (m6510_port_write_func) info->f; break;
default: CPU_SET_INFO_CALL(m6502); break;
}

6
src/emu/cpu/m6502/m6502.h
View File

@ -62,6 +62,12 @@ enum
positiv edge sets overflow flag */
#define M6502_SET_OVERFLOW 1
typedef UINT8 (*m6502_read_indexed_func)(const address_space *space, offs_t address);
typedef void (*m6502_write_indexed_func)(const address_space *space, offs_t address, UINT8 data);
typedef UINT8 (*m6510_port_read_func)(const device_config *device, UINT8 direction);
typedef void (*m6510_port_write_func)(const device_config *device, UINT8 direction, UINT8 data);
enum
{
CPUINFO_PTR_M6502_READINDEXED_CALLBACK = CPUINFO_PTR_CPU_SPECIFIC,

15
src/emu/cpu/m6502/m6509.c
View File

@ -37,6 +37,7 @@ addresses take place.
*/
#define NO_LEGACY_MEMORY_HANDLERS 1
#include "debugger.h"
#include "deprecat.h"
#include "m6509.h"
@ -83,8 +84,8 @@ struct _m6509_Regs {
int icount;
read8_space_func rdmem_id; /* readmem callback for indexed instructions */
write8_space_func wrmem_id; /* readmem callback for indexed instructions */
m6502_read_indexed_func rdmem_id; /* readmem callback for indexed instructions */
m6502_write_indexed_func wrmem_id; /* writemem callback for indexed instructions */
};
static void *token;
@ -131,8 +132,8 @@ static ADDRESS_MAP_START(m6509_mem, ADDRESS_SPACE_PROGRAM, 8)
AM_RANGE(0x00001, 0x00001) AM_MIRROR(0xF0000) AM_READWRITE(m6509_read_00001, m6509_write_00001)
ADDRESS_MAP_END
static READ8_HANDLER( default_rdmem_id ) { return program_read_byte_8le(offset); }
static WRITE8_HANDLER( default_wdmem_id ) { program_write_byte_8le(offset, data); }
static UINT8 default_rdmem_id(const address_space *space, offs_t address) { return memory_read_byte_8le(space, address); }
static void default_wdmem_id(const address_space *space, offs_t address, UINT8 data) { memory_write_byte_8le(space, address, data); }
static CPU_INIT( m6509 )
{
@ -144,7 +145,7 @@ static CPU_INIT( m6509 )
m6509->wrmem_id = default_wdmem_id;
m6509->irq_callback = irqcallback;
m6509->device = device;
m6509->space = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM);
m6509->space = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
}
static CPU_RESET( m6509 )
@ -338,8 +339,8 @@ static CPU_SET_INFO( m6509 )
case CPUINFO_INT_REGISTER + M6509_ZP: m6509->zp.w.l = info->i; break;
/* --- the following bits of info are set as pointers to data or functions --- */
case CPUINFO_PTR_M6502_READINDEXED_CALLBACK: m6509->rdmem_id = (read8_space_func) info->f; break;
case CPUINFO_PTR_M6502_WRITEINDEXED_CALLBACK: m6509->wrmem_id = (write8_space_func) info->f; break;
case CPUINFO_PTR_M6502_READINDEXED_CALLBACK: m6509->rdmem_id = (m6502_read_indexed_func) info->f; break;
case CPUINFO_PTR_M6502_WRITEINDEXED_CALLBACK: m6509->wrmem_id = (m6502_write_indexed_func) info->f; break;
}
}

15
src/emu/cpu/m6502/m65ce02.c
View File

@ -37,6 +37,7 @@
*/
#define NO_LEGACY_MEMORY_HANDLERS 1
#include "debugger.h"
#include "deprecat.h"
#include "m65ce02.h"
@ -75,8 +76,9 @@ struct _m65ce02_Regs {
UINT8 irq_state;
cpu_irq_callback irq_callback;
const device_config *device;
read8_space_func rdmem_id; /* readmem callback for indexed instructions */
write8_space_func wrmem_id; /* writemem callback for indexed instructions */
const address_space *space;
m6502_read_indexed_func rdmem_id; /* readmem callback for indexed instructions */
m6502_write_indexed_func wrmem_id; /* writemem callback for indexed instructions */
};
static void *token;
@ -86,8 +88,8 @@ static void *token;
#include "t65ce02.c"
static READ8_HANDLER( default_rdmem_id ) { return program_read_byte_8le(offset); }
static WRITE8_HANDLER( default_wdmem_id ) { program_write_byte_8le(offset, data); }
static UINT8 default_rdmem_id(const address_space *space, offs_t address) { return memory_read_byte_8le(space, address); }
static void default_wdmem_id(const address_space *space, offs_t address, UINT8 data) { memory_write_byte_8le(space, address, data); }
static CPU_INIT( m65ce02 )
{
@ -95,6 +97,7 @@ static CPU_INIT( m65ce02 )
m65ce02.wrmem_id = default_wdmem_id;
m65ce02.irq_callback = irqcallback;
m65ce02.device = device;
m65ce02.space = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
}
static CPU_RESET( m65ce02 )
@ -261,8 +264,8 @@ static CPU_SET_INFO( m65ce02 )
case CPUINFO_INT_REGISTER + M65CE02_ZP: m65ce02.zp.b.l = info->i; break;
/* --- the following bits of info are set as pointers to data or functions --- */
case CPUINFO_PTR_M6502_READINDEXED_CALLBACK: m65ce02.rdmem_id = (read8_space_func) info->f; break;
case CPUINFO_PTR_M6502_WRITEINDEXED_CALLBACK: m65ce02.wrmem_id = (write8_space_func) info->f; break;
case CPUINFO_PTR_M6502_READINDEXED_CALLBACK: m65ce02.rdmem_id = (m6502_read_indexed_func) info->f; break;
case CPUINFO_PTR_M6502_WRITEINDEXED_CALLBACK: m65ce02.wrmem_id = (m6502_write_indexed_func) info->f; break;
}
}

6
src/emu/cpu/m6502/minc4510.h
View File

@ -54,10 +54,10 @@
#define CHANGE_PC change_pc(M4510_MEM(PCD))
#define PEEK_OP() program_decrypted_read_byte(M4510_MEM(PCW))
#define PEEK_OP() memory_decrypted_read_byte(m4510->space, M4510_MEM(PCW))
#define RDMEM(addr) program_read_byte_8le(M4510_MEM(addr)); m4510->icount -= 1
#define WRMEM(addr,data) program_write_byte_8le(M4510_MEM(addr),data); m4510->icount -= 1
#define RDMEM(addr) memory_read_byte_8le(m4510->space, M4510_MEM(addr)); m4510->icount -= 1
#define WRMEM(addr,data) memory_write_byte_8le(m4510->space, M4510_MEM(addr),data); m4510->icount -= 1
/***************************************************************
* RDOP read an opcode

14
src/emu/cpu/m6502/mincce02.h
View File

@ -47,8 +47,8 @@
#define PPC m65ce02->ppc.d
#define RDMEM_ID m65ce02->rdmem_id
#define WRMEM_ID m65ce02->wrmem_id
#define RDMEM_ID(a) m65ce02->rdmem_id(m65ce02->space, a)
#define WRMEM_ID(a,d) m65ce02->wrmem_id(m65ce02->space, a, d)
#define IRQ_STATE m65ce02->irq_state
#define AFTER_CLI m65ce02->after_cli
@ -58,14 +58,14 @@
/***************************************************************
* RDOP read an opcode
***************************************************************/
#define RDOP() program_decrypted_read_byte(PCW++); m65ce02->icount -= 1
#define RDOP() memory_decrypted_read_byte(m65ce02->space, PCW++); m65ce02->icount -= 1
/***************************************************************
* RDOPARG read an opcode argument
***************************************************************/
#define RDOPARG() program_raw_read_byte(PCW++); m65ce02->icount -= 1
#define RDOPARG() memory_raw_read_byte(m65ce02->space, PCW++); m65ce02->icount -= 1
#define PEEK_OP() program_decrypted_read_byte(PCW)
#define PEEK_OP() memory_decrypted_read_byte(m65ce02->space, PCW)
#define RDMEM(addr) program_read_byte_8le(addr); m65ce02->icount -= 1
#define WRMEM(addr,data) program_write_byte_8le(addr,data); m65ce02->icount -= 1
#define RDMEM(addr) memory_read_byte_8le(m65ce02->space, addr); m65ce02->icount -= 1
#define WRMEM(addr,data) memory_write_byte_8le(m65ce02->space, addr,data); m65ce02->icount -= 1

10
src/emu/cpu/m6502/ops02.h
View File

@ -72,22 +72,22 @@
/***************************************************************
* RDOP read an opcode
***************************************************************/
#define RDOP() program_decrypted_read_byte(PCW++); m6502->icount -= 1
#define RDOP() memory_decrypted_read_byte(m6502->space, PCW++); m6502->icount -= 1
/***************************************************************
* RDOPARG read an opcode argument
***************************************************************/
#define RDOPARG() program_raw_read_byte(PCW++); m6502->icount -= 1
#define RDOPARG() memory_raw_read_byte(m6502->space, PCW++); m6502->icount -= 1
/***************************************************************
* RDMEM read memory
***************************************************************/
#define RDMEM(addr) program_read_byte_8le(addr); m6502->icount -= 1
#define RDMEM(addr) memory_read_byte_8le(m6502->space, addr); m6502->icount -= 1
/***************************************************************
* WRMEM write memory
***************************************************************/
#define WRMEM(addr,data) program_write_byte_8le(addr,data); m6502->icount -= 1
#define WRMEM(addr,data) memory_write_byte_8le(m6502->space, addr,data); m6502->icount -= 1
/***************************************************************
* BRA branch relative
@ -508,7 +508,7 @@
* ILL Illegal opcode
***************************************************************/
#define ILL \
logerror("M6502 illegal opcode %04x: %02x\n",(PCW-1)&0xffff, program_decrypted_read_byte((PCW-1)&0xffff))
logerror("M6502 illegal opcode %04x: %02x\n",(PCW-1)&0xffff, memory_decrypted_read_byte(m6502->space, (PCW-1)&0xffff))
/* 6502 ********************************************************
* INC Increment memory

10
src/emu/cpu/m6502/ops09.h
View File

@ -37,25 +37,25 @@
* RDOP read an opcode
***************************************************************/
#undef RDOP
#define RDOP() program_decrypted_read_byte((PCW++)|PB); m6502->icount -= 1
#define RDOP() memory_decrypted_read_byte(m6502->space, (PCW++)|PB); m6502->icount -= 1
/***************************************************************
* RDOPARG read an opcode argument
***************************************************************/
#undef RDOPARG
#define RDOPARG() program_raw_read_byte((PCW++)|PB); m6502->icount -= 1
#define RDOPARG() memory_raw_read_byte(m6502->space, (PCW++)|PB); m6502->icount -= 1
/***************************************************************
* RDMEM read memory
***************************************************************/
#undef RDMEM
#define RDMEM(addr) program_read_byte_8le(addr); m6502->icount -= 1
#define RDMEM(addr) memory_read_byte_8le(m6502->space, addr); m6502->icount -= 1
/***************************************************************
* WRMEM write memory
***************************************************************/
#undef WRMEM
#define WRMEM(addr,data) program_write_byte_8le(addr,data); m6502->icount -= 1
#define WRMEM(addr,data) memory_write_byte_8le(m6502->space, addr,data); m6502->icount -= 1
/***************************************************************
* push a register onto the stack
@ -208,4 +208,4 @@
#undef KIL
#define KIL \
PCW--; \
logerror("M6509 KILL opcode %05x: %02x\n", PCD, program_decrypted_read_byte(PCD))
logerror("M6509 KILL opcode %05x: %02x\n", PCD, memory_decrypted_read_byte(m6502->space, PCD))

6
src/emu/cpu/m6502/tdeco16.c
View File

@ -189,7 +189,7 @@ OP(27) { RD_DUM; ILL; } /* 2 ILL / 5 RMB2 ZPG ?? */
OP(47) { RD_DUM; ILL; } /* 2 ILL / 5 RMB4 ZPG ?? */
OP(67) {
int tmp; RD_IMM;
m6502->a=io_read_byte_8le(0);
m6502->a=memory_read_byte_8le(m6502->io,0);
// logerror("%04x: VBL (0x67)\n",cpu_get_pc(Machine->activecpu));
@ -275,7 +275,7 @@ OP(2b) { RD_DUM; ILL; } /* 2 ILL */
OP(4b) { int tmp; m6502->icount -= 1; RD_IMM;
logerror("%04x: OP4B %02x\n",cpu_get_pc(Machine->activecpu),tmp);
// m6502->a=io_read_byte_8le(0);
// m6502->a=memory_read_byte_8le(m6502->io,0);
//tilt??
@ -367,7 +367,7 @@ OP(6f) { RD_DUM; ILL; } /* 2 ILL / 5 BBR6 ZPG ?? */
OP(8f) { int tmp; m6502->icount -= 1; RD_IMM;
logerror("%04x: BANK (8F) %02x\n",cpu_get_pc(Machine->activecpu),tmp);
io_write_byte_8le(0,tmp);
memory_write_byte_8le(m6502->io,0,tmp);
//swap bank in/out