Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-21 13:18:56 +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 "debugger.h"
#include "cpuexec.h" #include "cpuexec.h"
#include "jaguar.h" #include "jaguar.h"
@ -237,7 +238,7 @@ static void (*const dsp_op_table[64])(jaguar_state *jaguar, UINT16 op) =
MEMORY ACCESSORS 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); debugger_instruction_hook(device, jaguar->PC);
/* instruction fetch */ /* instruction fetch */
op = ROPCODE(jaguar->PC); op = ROPCODE(jaguar, jaguar->PC);
jaguar->PC += 2; jaguar->PC += 2;
/* parse the instruction */ /* parse the instruction */
@ -546,7 +547,7 @@ static CPU_EXECUTE( jaguardsp )
debugger_instruction_hook(device, jaguar->PC); debugger_instruction_hook(device, jaguar->PC);
/* instruction fetch */ /* instruction fetch */
op = ROPCODE(jaguar->PC); op = ROPCODE(jaguar, jaguar->PC);
jaguar->PC += 2; jaguar->PC += 2;
/* parse the instruction */ /* parse the instruction */
@ -751,14 +752,14 @@ void imultn_rn_rn(jaguar_state *jaguar, UINT16 op)
jaguar->accum = (INT32)res; jaguar->accum = (INT32)res;
CLR_ZN(jaguar); SET_ZN(jaguar, res); CLR_ZN(jaguar); SET_ZN(jaguar, res);
op = ROPCODE(jaguar->PC); op = ROPCODE(jaguar, jaguar->PC);
while ((op >> 10) == 20) while ((op >> 10) == 20)
{ {
r1 = jaguar->r[(op >> 5) & 31]; r1 = jaguar->r[(op >> 5) & 31];
r2 = jaguar->r[op & 31]; r2 = jaguar->r[op & 31];
jaguar->accum += (INT64)((INT16)r1 * (INT16)r2); jaguar->accum += (INT64)((INT16)r1 * (INT16)r2);
jaguar->PC += 2; jaguar->PC += 2;
op = ROPCODE(jaguar->PC); op = ROPCODE(jaguar, jaguar->PC);
} }
if ((op >> 10) == 19) if ((op >> 10) == 19)
{ {
@ -774,7 +775,7 @@ void jr_cc_n(jaguar_state *jaguar, UINT16 op)
INT32 r1 = (INT8)((op >> 2) & 0xf8) >> 2; INT32 r1 = (INT8)((op >> 2) & 0xf8) >> 2;
UINT32 newpc = jaguar->PC + r1; UINT32 newpc = jaguar->PC + r1;
debugger_instruction_hook(jaguar->device, jaguar->PC); debugger_instruction_hook(jaguar->device, jaguar->PC);
op = ROPCODE(jaguar->PC); op = ROPCODE(jaguar, jaguar->PC);
jaguar->PC = newpc; jaguar->PC = newpc;
(*jaguar->table[op >> 10])(jaguar, op); (*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 */ /* special kludge for risky code in the cojag DSP interrupt handlers */
UINT32 newpc = (jaguar->icount == jaguar->bankswitch_icount) ? jaguar->a[reg] : jaguar->r[reg]; UINT32 newpc = (jaguar->icount == jaguar->bankswitch_icount) ? jaguar->a[reg] : jaguar->r[reg];
debugger_instruction_hook(jaguar->device, jaguar->PC); debugger_instruction_hook(jaguar->device, jaguar->PC);
op = ROPCODE(jaguar->PC); op = ROPCODE(jaguar, jaguar->PC);
jaguar->PC = newpc; jaguar->PC = newpc;
(*jaguar->table[op >> 10])(jaguar, op); (*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) 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->PC += 4;
jaguar->r[op & 31] = res; 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 "debugger.h"
#include "konami.h" #include "konami.h"
@ -56,6 +57,7 @@ typedef struct
int extra_cycles; /* cycles used up by interrupts */ int extra_cycles; /* cycles used up by interrupts */
cpu_irq_callback irq_callback; cpu_irq_callback irq_callback;
const device_config *device; const device_config *device;
const address_space *program;
UINT8 int_state; /* SYNC and CWAI flags */ UINT8 int_state; /* SYNC and CWAI flags */
UINT8 nmi_state; UINT8 nmi_state;
void (*setlines_callback)( int lines ); /* callback called when A16-A23 are set */ 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.irq_callback = irqcallback;
konami.device = device; 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, PC);
state_save_register_item("KONAMI", device->tag, 0, U); 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 */ /* 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 */ /* 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 */ /* 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 */ /* opcodes. In case of system with memory mapped I/O, this function can be */
/* used to greatly speed up emulation */ /* 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 */ /* 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 */ /* opcode arguments. This difference can be used to support systems that */
/* use different encoding mechanisms for opcodes and opcode arguments */ /* 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 #ifndef FALSE
# define FALSE 0 # 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) INLINE UINT16 lh5801_readop_word(void)
{ {
UINT16 r; UINT16 r;
r=program_decrypted_read_byte(P++)<<8; r=memory_decrypted_read_byte(lh5801.program,P++)<<8;
r|=program_decrypted_read_byte(P++); r|=memory_decrypted_read_byte(lh5801.program,P++);
return r; return r;
} }
@ -37,8 +37,8 @@ INLINE void lh5801_adc(UINT8 data)
INLINE void lh5801_add_mem(int addr, UINT8 data) INLINE void lh5801_add_mem(int addr, UINT8 data)
{ {
int v=lh5801_add_generic(program_read_byte(addr),data,0); int v=lh5801_add_generic(memory_read_byte(lh5801.program,addr),data,0);
program_write_byte(addr,v); memory_write_byte(lh5801.program,addr,v);
} }
INLINE void lh5801_adr(PAIR *reg) 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) INLINE void lh5801_and_mem(int addr, UINT8 data)
{ {
data&=program_read_byte(addr); data&=memory_read_byte(lh5801.program,addr);
lh5801.t&=~Z; lh5801.t&=~Z;
if (!data) 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) 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) INLINE void lh5801_ora_mem(int addr, UINT8 data)
{ {
data|=program_read_byte(addr); data|=memory_read_byte(lh5801.program,addr);
lh5801.t&=~Z; lh5801.t&=~Z;
if (!data) 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) INLINE void lh5801_lda(UINT8 data)
@ -141,27 +141,27 @@ INLINE void lh5801_lda(UINT8 data)
INLINE void lh5801_lde(PAIR *reg) INLINE void lh5801_lde(PAIR *reg)
{ {
// or z flag depends on 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; lh5801.t&=~Z;
if (!lh5801.a) lh5801.t|=Z; if (!lh5801.a) lh5801.t|=Z;
} }
INLINE void lh5801_sde(PAIR *reg) 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) INLINE void lh5801_lin(PAIR *reg)
{ {
// or z flag depends on 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; lh5801.t&=~Z;
if (!lh5801.a) lh5801.t|=Z; if (!lh5801.a) lh5801.t|=Z;
} }
INLINE void lh5801_sin(PAIR *reg) 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) INLINE void lh5801_dec(UINT8 *adr)
@ -176,42 +176,42 @@ INLINE void lh5801_inc(UINT8 *adr)
INLINE void lh5801_pop(void) INLINE void lh5801_pop(void)
{ {
lh5801.a=program_read_byte(++S); lh5801.a=memory_read_byte(lh5801.program,++S);
lh5801.t&=~Z; lh5801.t&=~Z;
if (!lh5801.a) lh5801.t|=Z; if (!lh5801.a) lh5801.t|=Z;
} }
INLINE void lh5801_pop_word(PAIR *reg) INLINE void lh5801_pop_word(PAIR *reg)
{ {
reg->b.h=program_read_byte(++S); reg->b.h=memory_read_byte(lh5801.program,++S);
reg->b.l=program_read_byte(++S); reg->b.l=memory_read_byte(lh5801.program,++S);
// z flag? // z flag?
} }
INLINE void lh5801_rtn(void) INLINE void lh5801_rtn(void)
{ {
P=program_read_byte(++S)<<8; P=memory_read_byte(lh5801.program,++S)<<8;
P|=program_read_byte(++S); P|=memory_read_byte(lh5801.program,++S);
change_pc(P); change_pc(P);
} }
INLINE void lh5801_rti(void) INLINE void lh5801_rti(void)
{ {
P=program_read_byte(++S)<<8; P=memory_read_byte(lh5801.program,++S)<<8;
P|=program_read_byte(++S); P|=memory_read_byte(lh5801.program,++S);
change_pc(P); change_pc(P);
lh5801.t=program_read_byte(++S); lh5801.t=memory_read_byte(lh5801.program,++S);
} }
INLINE void lh5801_push(UINT8 data) 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) INLINE void lh5801_push_word(UINT16 data)
{ {
program_write_byte(S--, data&0xff); memory_write_byte(lh5801.program,S--, data&0xff);
program_write_byte(S--, data>>8); memory_write_byte(lh5801.program,S--, data>>8);
} }
INLINE void lh5801_jmp(UINT16 adr) INLINE void lh5801_jmp(UINT16 adr)
@ -222,7 +222,7 @@ INLINE void lh5801_jmp(UINT16 adr)
INLINE void lh5801_branch_plus(int doit) 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) { if (doit) {
lh5801_icount-=3; lh5801_icount-=3;
P+=t; P+=t;
@ -232,7 +232,7 @@ INLINE void lh5801_branch_plus(int doit)
INLINE void lh5801_branch_minus(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) { if (doit) {
lh5801_icount-=3; lh5801_icount-=3;
P-=t; P-=t;
@ -242,7 +242,7 @@ INLINE void lh5801_branch_minus(int doit)
INLINE void lh5801_lop(void) INLINE void lh5801_lop(void)
{ {
UINT8 t=program_decrypted_read_byte(P++); UINT8 t=memory_decrypted_read_byte(lh5801.program,P++);
lh5801_icount-=8; lh5801_icount-=8;
if (UL--) { if (UL--) {
lh5801_icount-=3; lh5801_icount-=3;
@ -263,8 +263,8 @@ INLINE void lh5801_vector(int doit, int nr)
{ {
if (doit) { if (doit) {
lh5801_push_word(P); lh5801_push_word(P);
P=program_read_byte(0xff00+nr)<<8; P=memory_read_byte(lh5801.program,0xff00+nr)<<8;
P|=program_read_byte(0xff00+nr+1); P|=memory_read_byte(lh5801.program,0xff00+nr+1);
change_pc(P); change_pc(P);
lh5801_icount-=21-8; lh5801_icount-=21-8;
} }
@ -280,18 +280,18 @@ INLINE void lh5801_aex(void)
INLINE void lh5801_drl(int adr) 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; lh5801.a=t>>8;
program_write_byte(adr,t>>4); memory_write_byte(lh5801.program,adr,t>>4);
} }
INLINE void lh5801_drr(int adr) 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; lh5801.a=t;
program_write_byte(adr,t>>4); memory_write_byte(lh5801.program,adr,t>>4);
} }
INLINE void lh5801_rol(void) INLINE void lh5801_rol(void)
@ -357,89 +357,89 @@ static void lh5801_instruction_fd(void)
int oper; int oper;
int adr; int adr;
oper=program_decrypted_read_byte(P++); oper=memory_decrypted_read_byte(lh5801.program,P++);
switch (oper) { switch (oper) {
case 0x01: lh5801_sbc(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(program_read_byte(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(program_read_byte(0x10000|X)); lh5801_icount-=10;break; case 0x05: lh5801_lda(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=10;break;
case 0x07: lh5801_cpa(lh5801.a, program_read_byte(0x10000|X)); lh5801_icount-=11;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 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 0x0a: lh5801_pop_word(&lh5801.x); lh5801_icount-=15;break;
case 0x0b: lh5801_ora(program_read_byte(0x10000|X)); lh5801_icount-=11;break; case 0x0b: lh5801_ora(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=11;break;
case 0x0c: lh5801_dcs(program_read_byte(0x10000|X)); lh5801_icount-=17; break; case 0x0c: lh5801_dcs(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=17; break;
case 0x0d: lh5801_eor(program_read_byte(0x10000|X)); lh5801_icount-=11;break; case 0x0d: lh5801_eor(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=11;break;
case 0x0e: program_write_byte(0x10000|X,lh5801.a); lh5801_icount-=10;break; case 0x0e: memory_write_byte(lh5801.program,0x10000|X,lh5801.a); lh5801_icount-=10;break;
case 0x0f: lh5801_bit(program_read_byte(0x10000|X),lh5801.a); lh5801_icount-=11;break; case 0x0f: lh5801_bit(memory_read_byte(lh5801.program,0x10000|X),lh5801.a); lh5801_icount-=11;break;
case 0x11: lh5801_sbc(program_read_byte(0x10000|Y)); lh5801_icount-=11;break; case 0x11: lh5801_sbc(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=11;break;
case 0x13: lh5801_adc(program_read_byte(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(program_read_byte(0x10000|Y)); lh5801_icount-=10;break; case 0x15: lh5801_lda(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=10;break;
case 0x17: lh5801_cpa(lh5801.a, program_read_byte(0x10000|Y)); lh5801_icount-=11;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 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 0x1a: lh5801_pop_word(&lh5801.y); lh5801_icount-=15;break;
case 0x1b: lh5801_ora(program_read_byte(0x10000|Y)); lh5801_icount-=11;break; case 0x1b: lh5801_ora(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=11;break;
case 0x1c: lh5801_dcs(program_read_byte(0x10000|Y)); lh5801_icount-=17; break; case 0x1c: lh5801_dcs(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=17; break;
case 0x1d: lh5801_eor(program_read_byte(0x10000|Y)); lh5801_icount-=11;break; case 0x1d: lh5801_eor(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=11;break;
case 0x1e: program_write_byte(0x10000|Y,lh5801.a); lh5801_icount-=10;break; case 0x1e: memory_write_byte(lh5801.program,0x10000|Y,lh5801.a); lh5801_icount-=10;break;
case 0x1f: lh5801_bit(program_read_byte(0x10000|Y),lh5801.a); lh5801_icount-=11;break; case 0x1f: lh5801_bit(memory_read_byte(lh5801.program,0x10000|Y),lh5801.a); lh5801_icount-=11;break;
case 0x21: lh5801_sbc(program_read_byte(0x10000|U)); lh5801_icount-=11;break; case 0x21: lh5801_sbc(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=11;break;
case 0x23: lh5801_adc(program_read_byte(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(program_read_byte(0x10000|U)); lh5801_icount-=10;break; case 0x25: lh5801_lda(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=10;break;
case 0x27: lh5801_cpa(lh5801.a, program_read_byte(0x10000|U)); lh5801_icount-=11;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 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 0x2a: lh5801_pop_word(&lh5801.u); lh5801_icount-=15;break;
case 0x2b: lh5801_ora(program_read_byte(0x10000|U)); lh5801_icount-=11;break; case 0x2b: lh5801_ora(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=11;break;
case 0x2c: lh5801_dcs(program_read_byte(0x10000|U)); lh5801_icount-=17; break; case 0x2c: lh5801_dcs(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=17; break;
case 0x2d: lh5801_eor(program_read_byte(0x10000|U)); lh5801_icount-=11;break; case 0x2d: lh5801_eor(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=11;break;
case 0x2e: program_write_byte(0x10000|U,lh5801.a); lh5801_icount-=10;break; case 0x2e: memory_write_byte(lh5801.program,0x10000|U,lh5801.a); lh5801_icount-=10;break;
case 0x2f: lh5801_bit(program_read_byte(0x10000|U),lh5801.a); lh5801_icount-=11;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 0x40: lh5801_inc(&XH);lh5801_icount-=9;break;
case 0x42: lh5801_dec(&XH);lh5801_icount-=9;break; case 0x42: lh5801_dec(&XH);lh5801_icount-=9;break;
case 0x48: X=S;lh5801_icount-=11;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 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 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 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 0x50: lh5801_inc(&YH);lh5801_icount-=9;break;
case 0x52: lh5801_dec(&YH);lh5801_icount-=9;break; case 0x52: lh5801_dec(&YH);lh5801_icount-=9;break;
case 0x58: X=P;lh5801_icount-=11;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 0x5a: Y=X;lh5801_icount-=11;break;
case 0x5b: lh5801_ora_mem(0x10000|Y, program_decrypted_read_byte(P++)); lh5801_icount-=17;break; case 0x5b: lh5801_ora_mem(0x10000|Y, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
case 0x5d: lh5801_bit(program_read_byte(Y|0x10000), program_decrypted_read_byte(P++));lh5801_icount-=14;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 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 0x60: lh5801_inc(&UH);lh5801_icount-=9;break;
case 0x62: lh5801_dec(&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 0x6a: U=X;lh5801_icount-=11;break;
case 0x6b: lh5801_ora_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(program_read_byte(X|0x10000), program_decrypted_read_byte(P++));lh5801_icount-=14;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, program_decrypted_read_byte(P++)); lh5801_icount-=17;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 0x81: lh5801.t|=IE; /*sie !*/lh5801_icount-=8;break;
case 0x88: lh5801_push_word(X); lh5801_icount-=14;break; case 0x88: lh5801_push_word(X); lh5801_icount-=14;break;
case 0x8a: lh5801_pop(); lh5801_icount-=12; 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 0x8e: /*cdv clears internal devider*/lh5801_icount-=8;break;
case 0x98: lh5801_push_word(Y); lh5801_icount-=14;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 0x9c: lh5801_dca(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=19; break;
case 0xa1: lh5801_sbc(program_read_byte(0x10000|lh5801_readop_word())); lh5801_icount-=17;break; case 0xa1: lh5801_sbc(memory_read_byte(lh5801.program,0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
case 0xa3: lh5801_adc(program_read_byte(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(program_read_byte(0x10000|lh5801_readop_word())); lh5801_icount-=16;break; case 0xa5: lh5801_lda(memory_read_byte(lh5801.program,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 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 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 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 0xab: lh5801_ora(memory_read_byte(lh5801.program,0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
case 0xac: lh5801_dca(program_read_byte(0x10000|U)); lh5801_icount-=19; break; case 0xac: lh5801_dca(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=19; break;
case 0xad: lh5801_eor(program_read_byte(0x10000|lh5801_readop_word())); lh5801_icount-=17;break; case 0xad: lh5801_eor(memory_read_byte(lh5801.program,0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
case 0xae: program_write_byte(0x10000|lh5801_readop_word(),lh5801.a); lh5801_icount-=16;break; case 0xae: memory_write_byte(lh5801.program,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 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 0xb1: /*hlt*/lh5801_icount-=8;break;
case 0xba: lh5801_ita();lh5801_icount-=9;break; case 0xba: lh5801_ita();lh5801_icount-=9;break;
case 0xbe: lh5801.t&=~IE; /*rie !*/lh5801_icount-=8;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 0xea: lh5801_adr(&lh5801.u);lh5801_icount-=11;break;
case 0xe9: case 0xe9:
adr=lh5801_readop_word()|0x10000; 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; break;
case 0xeb: case 0xeb:
adr=lh5801_readop_word()|0x10000; 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; break;
case 0xec: lh5801.t=lh5801.a; lh5801_icount-=9;break; case 0xec: lh5801.t=lh5801.a; lh5801_icount-=9;break;
case 0xed: 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; lh5801_icount-=20;break;
case 0xef: case 0xef:
adr=lh5801_readop_word()|0x10000; 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; break;
default: default:
@ -481,56 +481,56 @@ static void lh5801_instruction(void)
int oper; int oper;
int adr; int adr;
oper=program_decrypted_read_byte(P++); oper=memory_decrypted_read_byte(lh5801.program,P++);
switch (oper) { switch (oper) {
case 0x00: lh5801_sbc(XL); lh5801_icount-=6;break; 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 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 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 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 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 0x0a: XL=lh5801.a; lh5801_icount-=5; break;
case 0x0b: lh5801_ora(program_read_byte(X)); lh5801_icount-=7;break; case 0x0b: lh5801_ora(memory_read_byte(lh5801.program,X)); lh5801_icount-=7;break;
case 0x0c: lh5801_dcs(program_read_byte(X)); lh5801_icount-=13; break; case 0x0c: lh5801_dcs(memory_read_byte(lh5801.program,X)); lh5801_icount-=13; break;
case 0x0d: lh5801_eor(program_read_byte(X)); lh5801_icount-=7;break; case 0x0d: lh5801_eor(memory_read_byte(lh5801.program,X)); lh5801_icount-=7;break;
case 0x0e: program_write_byte(X,lh5801.a); lh5801_icount-=6;break; case 0x0e: memory_write_byte(lh5801.program,X,lh5801.a); lh5801_icount-=6;break;
case 0x0f: lh5801_bit(program_read_byte(X),lh5801.a); lh5801_icount-=7;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 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 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 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 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 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 0x1a: YL=lh5801.a; lh5801_icount-=5; break;
case 0x1b: lh5801_ora(program_read_byte(Y)); lh5801_icount-=7;break; case 0x1b: lh5801_ora(memory_read_byte(lh5801.program,Y)); lh5801_icount-=7;break;
case 0x1c: lh5801_dcs(program_read_byte(Y)); lh5801_icount-=13; break; case 0x1c: lh5801_dcs(memory_read_byte(lh5801.program,Y)); lh5801_icount-=13; break;
case 0x1d: lh5801_eor(program_read_byte(Y)); lh5801_icount-=7;break; case 0x1d: lh5801_eor(memory_read_byte(lh5801.program,Y)); lh5801_icount-=7;break;
case 0x1e: program_write_byte(Y,lh5801.a); lh5801_icount-=6;break; case 0x1e: memory_write_byte(lh5801.program,Y,lh5801.a); lh5801_icount-=6;break;
case 0x1f: lh5801_bit(program_read_byte(Y),lh5801.a); lh5801_icount-=7;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 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 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 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 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 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 0x2a: UL=lh5801.a; lh5801_icount-=5; break;
case 0x2b: lh5801_ora(program_read_byte(U)); lh5801_icount-=7;break; case 0x2b: lh5801_ora(memory_read_byte(lh5801.program,U)); lh5801_icount-=7;break;
case 0x2c: lh5801_dcs(program_read_byte(U)); lh5801_icount-=13; break; case 0x2c: lh5801_dcs(memory_read_byte(lh5801.program,U)); lh5801_icount-=13; break;
case 0x2d: lh5801_eor(program_read_byte(U)); lh5801_icount-=7;break; case 0x2d: lh5801_eor(memory_read_byte(lh5801.program,U)); lh5801_icount-=7;break;
case 0x2e: program_write_byte(U,lh5801.a); lh5801_icount-=6;break; case 0x2e: memory_write_byte(lh5801.program,U,lh5801.a); lh5801_icount-=6;break;
case 0x2f: lh5801_bit(program_read_byte(U),lh5801.a); lh5801_icount-=7;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 0x38: /*nop*/lh5801_icount-=5;break;
case 0x40: lh5801_inc(&XL);lh5801_icount-=5;break; case 0x40: lh5801_inc(&XL);lh5801_icount-=5;break;
case 0x41: lh5801_sin(&lh5801.x); lh5801_icount-=6;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 0x45: lh5801_lin(&lh5801.x);lh5801_icount-=6;break;
case 0x46: X--;lh5801_icount-=5;break; case 0x46: X--;lh5801_icount-=5;break;
case 0x47: lh5801_lde(&lh5801.x);lh5801_icount-=6;break; case 0x47: lh5801_lde(&lh5801.x);lh5801_icount-=6;break;
case 0x48: XH=program_decrypted_read_byte(P++);lh5801_icount-=6;break; case 0x48: XH=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
case 0x49: lh5801_and_mem(X, program_decrypted_read_byte(P++)); lh5801_icount-=13;break; case 0x49: lh5801_and_mem(X, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
case 0x4a: XL=program_decrypted_read_byte(P++);lh5801_icount-=6;break; case 0x4a: XL=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
case 0x4b: lh5801_ora_mem(X, program_decrypted_read_byte(P++)); lh5801_icount-=13;break; case 0x4b: lh5801_ora_mem(X, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
case 0x4c: lh5801_cpa(XH, program_decrypted_read_byte(P++)); lh5801_icount-=7;break; case 0x4c: lh5801_cpa(XH, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0x4d: lh5801_bit(program_read_byte(X), program_decrypted_read_byte(P++));lh5801_icount-=10;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, program_decrypted_read_byte(P++)); lh5801_icount-=7;break; case 0x4e: lh5801_cpa(XL, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0x4f: lh5801_add_mem(X, program_decrypted_read_byte(P++)); lh5801_icount-=13;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 0x50: lh5801_inc(&YL);lh5801_icount-=5;break;
case 0x51: lh5801_sin(&lh5801.y); lh5801_icount-=6;break; case 0x51: lh5801_sin(&lh5801.y); lh5801_icount-=6;break;
case 0x52: lh5801_dec(&YL);lh5801_icount-=5;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 0x55: lh5801_lin(&lh5801.y);lh5801_icount-=6;break;
case 0x56: Y--;lh5801_icount-=5;break; case 0x56: Y--;lh5801_icount-=5;break;
case 0x57: lh5801_lde(&lh5801.y);lh5801_icount-=6;break; case 0x57: lh5801_lde(&lh5801.y);lh5801_icount-=6;break;
case 0x58: YH=program_decrypted_read_byte(P++);lh5801_icount-=6;break; case 0x58: YH=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
case 0x59: lh5801_and_mem(Y, program_decrypted_read_byte(P++)); lh5801_icount-=13;break; case 0x59: lh5801_and_mem(Y, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
case 0x5a: YL=program_decrypted_read_byte(P++);lh5801_icount-=6;break; case 0x5a: YL=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
case 0x5b: lh5801_ora_mem(Y, program_decrypted_read_byte(P++)); lh5801_icount-=13;break; case 0x5b: lh5801_ora_mem(Y, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
case 0x5c: lh5801_cpa(YH, program_decrypted_read_byte(P++)); lh5801_icount-=7;break; case 0x5c: lh5801_cpa(YH, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0x5d: lh5801_bit(program_read_byte(Y), program_decrypted_read_byte(P++));lh5801_icount-=10;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, program_decrypted_read_byte(P++)); lh5801_icount-=7;break; case 0x5e: lh5801_cpa(YL, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0x5f: lh5801_add_mem(Y, program_decrypted_read_byte(P++)); lh5801_icount-=13;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 0x60: lh5801_inc(&UL);lh5801_icount-=5;break;
case 0x61: lh5801_sin(&lh5801.u); lh5801_icount-=6;break; case 0x61: lh5801_sin(&lh5801.u); lh5801_icount-=6;break;
case 0x62: lh5801_dec(&UL);lh5801_icount-=5;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 0x65: lh5801_lin(&lh5801.u);lh5801_icount-=6;break;
case 0x66: U--;lh5801_icount-=5;break; case 0x66: U--;lh5801_icount-=5;break;
case 0x67: lh5801_lde(&lh5801.u);lh5801_icount-=6;break; case 0x67: lh5801_lde(&lh5801.u);lh5801_icount-=6;break;
case 0x68: UH=program_decrypted_read_byte(P++);lh5801_icount-=6;break; case 0x68: UH=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
case 0x69: lh5801_and_mem(U, program_decrypted_read_byte(P++)); lh5801_icount-=13;break; case 0x69: lh5801_and_mem(U, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
case 0x6a: UL=program_decrypted_read_byte(P++);lh5801_icount-=6;break; case 0x6a: UL=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
case 0x6b: lh5801_ora_mem(U, program_decrypted_read_byte(P++)); lh5801_icount-=13;break; case 0x6b: lh5801_ora_mem(U, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
case 0x6c: lh5801_cpa(UH, program_decrypted_read_byte(P++)); lh5801_icount-=7;break; case 0x6c: lh5801_cpa(UH, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0x6d: lh5801_bit(program_read_byte(U), program_decrypted_read_byte(P++));lh5801_icount-=10;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, program_decrypted_read_byte(P++)); lh5801_icount-=7;break; case 0x6e: lh5801_cpa(UL, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0x6f: lh5801_add_mem(U, program_decrypted_read_byte(P++)); lh5801_icount-=13;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 0x80: lh5801_sbc(XH); lh5801_icount-=6;break;
case 0x81: lh5801_branch_plus(!(lh5801.t&C)); lh5801_icount-=8; break; case 0x81: lh5801_branch_plus(!(lh5801.t&C)); lh5801_icount-=8; break;
case 0x82: lh5801_adc(XH); lh5801_icount-=6;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 0x89: lh5801_branch_plus(!(lh5801.t&Z)); lh5801_icount-=8; break;
case 0x8a: lh5801_rti(); lh5801_icount-=14; break; case 0x8a: lh5801_rti(); lh5801_icount-=14; break;
case 0x8b: lh5801_branch_plus(lh5801.t&Z); lh5801_icount-=8; 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 0x8d: lh5801_branch_plus(!(lh5801.t&V)); lh5801_icount-=8; break;
case 0x8e: lh5801_branch_plus(1); lh5801_icount-=5; break; case 0x8e: lh5801_branch_plus(1); lh5801_icount-=5; break;
case 0x8f: lh5801_branch_plus(lh5801.t&V); lh5801_icount-=8; 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 0x99: lh5801_branch_minus(!(lh5801.t&Z)); lh5801_icount-=8; break;
case 0x9a: lh5801_rtn(); lh5801_icount-=11; break; case 0x9a: lh5801_rtn(); lh5801_icount-=11; break;
case 0x9b: lh5801_branch_minus(lh5801.t&Z); lh5801_icount-=8; 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 0x9d: lh5801_branch_minus(!(lh5801.t&V)); lh5801_icount-=8; break;
case 0x9e: lh5801_branch_minus(1); lh5801_icount-=6; break; case 0x9e: lh5801_branch_minus(1); lh5801_icount-=6; break;
case 0x9f: lh5801_branch_minus(lh5801.t&V); lh5801_icount-=8; break; case 0x9f: lh5801_branch_minus(lh5801.t&V); lh5801_icount-=8; break;
case 0xa0: lh5801_sbc(UH); lh5801_icount-=6;break; case 0xa0: lh5801_sbc(UH); lh5801_icount-=6;break;
case 0xa2: lh5801_adc(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 0xa1: lh5801_sbc(memory_read_byte(lh5801.program,lh5801_readop_word())); lh5801_icount-=13;break;
case 0xa3: lh5801_adc(program_read_byte(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 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 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 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 0xaa: S=lh5801_readop_word();lh5801_icount-=6;break;
case 0xab: lh5801_ora(program_read_byte(lh5801_readop_word())); lh5801_icount-=13;break; case 0xab: lh5801_ora(memory_read_byte(lh5801.program,lh5801_readop_word())); lh5801_icount-=13;break;
case 0xac: lh5801_dca(program_read_byte(U)); lh5801_icount-=15; break; case 0xac: lh5801_dca(memory_read_byte(lh5801.program,U)); lh5801_icount-=15; break;
case 0xad: lh5801_eor(program_read_byte(lh5801_readop_word())); lh5801_icount-=13;break; case 0xad: lh5801_eor(memory_read_byte(lh5801.program,lh5801_readop_word())); lh5801_icount-=13;break;
case 0xae: program_write_byte(lh5801_readop_word(),lh5801.a); lh5801_icount-=12;break; case 0xae: memory_write_byte(lh5801.program,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 0xaf: lh5801_bit(memory_read_byte(lh5801.program,lh5801_readop_word()),lh5801.a); lh5801_icount-=13;break;
case 0xb1: lh5801_sbc(program_decrypted_read_byte(P++)); lh5801_icount-=7;break; case 0xb1: lh5801_sbc(memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0xb3: lh5801_adc(program_decrypted_read_byte(P++)); lh5801_icount-=7;break; case 0xb3: lh5801_adc(memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0xb5: lh5801_lda(program_decrypted_read_byte(P++)); lh5801_icount-=6;break; case 0xb5: lh5801_lda(memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=6;break;
case 0xb7: lh5801_cpa(lh5801.a, program_decrypted_read_byte(P++)); lh5801_icount-=7;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 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 0xba: lh5801_jmp(lh5801_readop_word()); lh5801_icount-=12;break;
case 0xbb: lh5801_ora(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(program_decrypted_read_byte(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 0xbe: lh5801_sjp(); lh5801_icount-=19; break;
case 0xbf: lh5801_bit(lh5801.a, program_decrypted_read_byte(P++));lh5801_icount-=7;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), program_decrypted_read_byte(P++)); lh5801_icount-=8;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, program_decrypted_read_byte(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), program_decrypted_read_byte(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, program_decrypted_read_byte(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), program_decrypted_read_byte(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, program_decrypted_read_byte(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, program_decrypted_read_byte(P++)); lh5801_icount-=7;break; case 0xcd: lh5801_vector(1, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
case 0xcf: lh5801_vector(lh5801.t&V, program_decrypted_read_byte(P++)); lh5801_icount-=8;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 0xd1: lh5801_ror(); lh5801_icount-=6; break;
case 0xd3: lh5801_drr(X); lh5801_icount-=12; break; case 0xd3: lh5801_drr(X); lh5801_icount-=12; break;
case 0xd5: lh5801_shr(); lh5801_icount-=6; 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 0xe1: lh5801.pu=1;/*spu!*/ lh5801_icount-=4; break;
case 0xe3: lh5801.pu=0;/*rpu!*/ lh5801_icount-=4; break; case 0xe3: lh5801.pu=0;/*rpu!*/ lh5801_icount-=4; break;
case 0xe9: 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; lh5801_icount-=19;break;
case 0xeb: 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; lh5801_icount-=19;break;
case 0xed: 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; lh5801_icount-=16;break;
case 0xef: case 0xef:
adr=lh5801_readop_word(); 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; break;
case 0xf1: lh5801_aex(); lh5801_icount-=6; 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 0xf5: memory_write_byte(lh5801.program,Y++, memory_read_byte(lh5801.program,X++)); lh5801_icount-=7; break; //tin
case 0xf7: lh5801_cpa(lh5801.a, program_read_byte(X++));lh5801_icount-=7; break; //cin 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 0xf9: lh5801.t&=~C;lh5801_icount-=4;break;
case 0xfb: lh5801.t|=C;lh5801_icount-=4;break; case 0xfb: lh5801.t|=C;lh5801_icount-=4;break;
case 0xfd: lh5801_instruction_fd();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 * based on info found on an artikel for the tandy trs80 pc2
* *
*****************************************************************************/ *****************************************************************************/
#define NO_LEGACY_MEMORY_HANDLERS 1
#include "debugger.h" #include "debugger.h"
#include "lh5801.h" #include "lh5801.h"
@ -47,6 +48,8 @@ enum
typedef struct typedef struct
{ {
const lh5801_cpu_core *config; const lh5801_cpu_core *config;
const device_config *device;
const address_space *program;
PAIR s, p, u, x, y; PAIR s, p, u, x, y;
int tm; //9 bit int tm; //9 bit
@ -93,11 +96,13 @@ static CPU_INIT( lh5801 )
{ {
memset(&lh5801, 0, sizeof(lh5801)); memset(&lh5801, 0, sizeof(lh5801));
lh5801.config = (const lh5801_cpu_core *) device->static_config; 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 ) 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); change_pc(P);

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

@ -36,6 +36,7 @@
/** Split fetch and execute cycles. **/ /** Split fetch and execute cycles. **/
/** **/ /** **/
/*************************************************************/ /*************************************************************/
#define NO_LEGACY_MEMORY_HANDLERS 1
#include "debugger.h" #include "debugger.h"
#include "lr35902.h" #include "lr35902.h"
@ -64,6 +65,7 @@ typedef struct {
int ei_delay; int ei_delay;
cpu_irq_callback irq_callback; cpu_irq_callback irq_callback;
const device_config *device; const device_config *device;
const address_space *program;
/* Timer stuff */ /* Timer stuff */
void (*timer_fired_func)(int cycles); void (*timer_fired_func)(int cycles);
/* Fetch & execute related */ /* Fetch & execute related */
@ -119,8 +121,8 @@ static lr35902_regs Regs;
/* Memory functions */ /* Memory functions */
/****************************************************************************/ /****************************************************************************/
#define mem_ReadByte(A) ((UINT8)program_read_byte_8le(A)) #define mem_ReadByte(A) ((UINT8)memory_read_byte_8le(Regs.w.program,A))
#define mem_WriteByte(A,V) (program_write_byte_8le(A,V)) #define mem_WriteByte(A,V) (memory_write_byte_8le(Regs.w.program,A,V))
INLINE UINT16 mem_ReadWord (UINT32 address) 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.config = (const lr35902_cpu_core *) device->static_config;
Regs.w.irq_callback = irqcallback; Regs.w.irq_callback = irqcallback;
Regs.w.device = device; Regs.w.device = device;
Regs.w.program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
} }
/*** Reset lr353902 registers: ******************************/ /*** 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, fixed so top 8 bits of X & Y are preserved while in 8-bit mode,
added save state support. added save state support.
*/ */
#define NO_LEGACY_MEMORY_HANDLERS 1
#include "debugger.h" #include "debugger.h"
#include "deprecat.h" #include "deprecat.h"
#include "cpuexec.h" #include "cpuexec.h"
@ -417,80 +417,80 @@ static UINT8 m37710_internal_r(int offset)
switch (offset) switch (offset)
{ {
case 2: // p0 case 2: // p0
return io_read_byte_8le(M37710_PORT0); return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT0);
break; break;
case 3: // p1 case 3: // p1
return io_read_byte_8le(M37710_PORT1); return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT1);
break; break;
case 6: // p2 case 6: // p2
return io_read_byte_8le(M37710_PORT2); return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT2);
break; break;
case 7: // p3 case 7: // p3
return io_read_byte_8le(M37710_PORT3); return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT3);
break; break;
case 0xa: // p4 case 0xa: // p4
return io_read_byte_8le(M37710_PORT4); return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT4);
break; break;
case 0xb: // p5 case 0xb: // p5
return io_read_byte_8le(M37710_PORT5); return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT5);
break; break;
case 0xe: // p6 case 0xe: // p6
return io_read_byte_8le(M37710_PORT6); return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT6);
break; break;
case 0xf: // p7 case 0xf: // p7
return io_read_byte_8le(M37710_PORT7); return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT7);
break; break;
case 0x12: // p8 case 0x12: // p8
return io_read_byte_8le(M37710_PORT8); return memory_read_byte_8le(m37710i_cpu.io, M37710_PORT8);
break; break;
case 0x20: case 0x20:
return io_read_byte_8le(M37710_ADC0_L); return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC0_L);
break; break;
case 0x21: case 0x21:
return io_read_byte_8le(M37710_ADC0_H); return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC0_H);
break; break;
case 0x22: case 0x22:
return io_read_byte_8le(M37710_ADC1_L); return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC1_L);
break; break;
case 0x23: case 0x23:
return io_read_byte_8le(M37710_ADC1_H); return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC1_H);
break; break;
case 0x24: case 0x24:
return io_read_byte_8le(M37710_ADC2_L); return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC2_L);
break; break;
case 0x25: case 0x25:
return io_read_byte_8le(M37710_ADC2_H); return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC2_H);
break; break;
case 0x26: case 0x26:
return io_read_byte_8le(M37710_ADC3_L); return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC3_L);
break; break;
case 0x27: case 0x27:
return io_read_byte_8le(M37710_ADC3_H); return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC3_H);
break; break;
case 0x28: case 0x28:
return io_read_byte_8le(M37710_ADC4_L); return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC4_L);
break; break;
case 0x29: case 0x29:
return io_read_byte_8le(M37710_ADC4_H); return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC4_H);
break; break;
case 0x2a: case 0x2a:
return io_read_byte_8le(M37710_ADC5_L); return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC5_L);
break; break;
case 0x2b: case 0x2b:
return io_read_byte_8le(M37710_ADC5_H); return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC5_H);
break; break;
case 0x2c: case 0x2c:
return io_read_byte_8le(M37710_ADC6_L); return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC6_L);
break; break;
case 0x2d: case 0x2d:
return io_read_byte_8le(M37710_ADC6_H); return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC6_H);
break; break;
case 0x2e: case 0x2e:
return io_read_byte_8le(M37710_ADC7_L); return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC7_L);
break; break;
case 0x2f: case 0x2f:
return io_read_byte_8le(M37710_ADC7_H); return memory_read_byte_8le(m37710i_cpu.io, M37710_ADC7_H);
break; break;
case 0x35: case 0x35:
return 0xff; // UART control return 0xff; // UART control
@ -511,39 +511,39 @@ static void m37710_internal_w(int offset, UINT8 data)
switch(offset) switch(offset)
{ {
case 2: // p0 case 2: // p0
io_write_byte_8le(M37710_PORT0, data); memory_write_byte_8le(m37710i_cpu.io, M37710_PORT0, data);
return; return;
break; break;
case 3: // p1 case 3: // p1
io_write_byte_8le(M37710_PORT1, data); memory_write_byte_8le(m37710i_cpu.io, M37710_PORT1, data);
return; return;
break; break;
case 6: // p2 case 6: // p2
io_write_byte_8le(M37710_PORT2, data); memory_write_byte_8le(m37710i_cpu.io, M37710_PORT2, data);
return; return;
break; break;
case 7: // p3 case 7: // p3
io_write_byte_8le(M37710_PORT3, data); memory_write_byte_8le(m37710i_cpu.io, M37710_PORT3, data);
return; return;
break; break;
case 0xa: // p4 case 0xa: // p4
io_write_byte_8le(M37710_PORT4, data); memory_write_byte_8le(m37710i_cpu.io, M37710_PORT4, data);
return; return;
break; break;
case 0xb: // p5 case 0xb: // p5
io_write_byte_8le(M37710_PORT5, data); memory_write_byte_8le(m37710i_cpu.io, M37710_PORT5, data);
return; return;
break; break;
case 0xe: // p6 case 0xe: // p6
io_write_byte_8le(M37710_PORT6, data); memory_write_byte_8le(m37710i_cpu.io, M37710_PORT6, data);
return; return;
break; break;
case 0xf: // p7 case 0xf: // p7
io_write_byte_8le(M37710_PORT7, data); memory_write_byte_8le(m37710i_cpu.io, M37710_PORT7, data);
return; return;
break; break;
case 0x12: // p8 case 0x12: // p8
io_write_byte_8le(M37710_PORT8, data); memory_write_byte_8le(m37710i_cpu.io, M37710_PORT8, data);
return; return;
break; break;
@ -982,6 +982,8 @@ static CPU_INIT( m37710 )
INT_ACK = irqcallback; INT_ACK = irqcallback;
m37710i_cpu.device = device; 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_ICount = 0;
m37710_fullCount = 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 #undef M37710_CALL_DEBUGGER
#define M37710_CALL_DEBUGGER(x) debugger_instruction_hook(m37710i_cpu.device, x) #define M37710_CALL_DEBUGGER(x) debugger_instruction_hook(m37710i_cpu.device, x)
#define m37710_read_8(addr) program_read_byte_16le(addr) #define m37710_read_8(addr) memory_read_byte_16le(m37710i_cpu.program, addr)
#define m37710_write_8(addr,data) program_write_byte_16le(addr,data) #define m37710_write_8(addr,data) memory_write_byte_16le(m37710i_cpu.program, addr,data)
#define m37710_read_8_immediate(A) program_read_byte_16le(A) #define m37710_read_8_immediate(A) memory_read_byte_16le(m37710i_cpu.program, A)
#define m37710_read_16(addr) program_read_word_16le(addr) #define m37710_read_16(addr) memory_read_word_16le(m37710i_cpu.program, addr)
#define m37710_write_16(addr,data) program_write_word_16le(addr,data) #define m37710_write_16(addr,data) memory_write_word_16le(m37710i_cpu.program, addr,data)
#define m37710_jumping(A) change_pc(A) #define m37710_jumping(A) change_pc(A)
#define m37710_branching(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 */ uint irq_level; /* irq level */
cpu_irq_callback int_ack; cpu_irq_callback int_ack;
const device_config *device; const device_config *device;
const address_space *program;
const address_space *io;
uint stopped; /* Sets how the CPU is stopped */ uint stopped; /* Sets how the CPU is stopped */
void (*const *opcodes)(void); /* opcodes with no prefix */ void (*const *opcodes)(void); /* opcodes with no prefix */
void (*const *opcodes42)(void); /* opcodes with 0x42 prefix */ void (*const *opcodes42)(void); /* opcodes with 0x42 prefix */

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

@ -235,7 +235,7 @@
#if 0 #if 0
#define SSH \ #define SSH \
tmp = S = A & X; \ 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 #endif
/* 6510 ******************************************************** /* 6510 ********************************************************
@ -264,7 +264,7 @@
#define KIL \ #define KIL \
PCW--; \ PCW--; \
logerror("M6510 KILL opcode %04x: %02x\n", \ logerror("M6510 KILL opcode %04x: %02x\n", \
PCW, program_decrypted_read_byte(PCW)) PCW, memory_decrypted_read_byte(m6502->space, PCW))
/* N2A03 ******************************************************* /* N2A03 *******************************************************
* ARR logical and, rotate right - no decimal mode * 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 1 map 8000-9fff
*/ */
#define NO_LEGACY_MEMORY_HANDLERS 1
#include "debugger.h" #include "debugger.h"
#include "deprecat.h" #include "deprecat.h"
#include "m6502.h" #include "m6502.h"
@ -144,15 +145,16 @@ struct _m4510_Regs {
cpu_irq_callback irq_callback; cpu_irq_callback irq_callback;
const device_config *device; const device_config *device;
const address_space *space;
int icount; int icount;
read8_space_func rdmem_id; /* readmem callback for indexed instructions */ m6502_read_indexed_func rdmem_id; /* readmem callback for indexed instructions */
write8_space_func wrmem_id; /* writemem callback for indexed instructions */ m6502_write_indexed_func wrmem_id; /* writemem callback for indexed instructions */
UINT8 ddr; UINT8 ddr;
UINT8 port; UINT8 port;
UINT8 (*port_read)(void); m6510_port_read_func port_read;
void (*port_write)(UINT8 data); m6510_port_write_func port_write;
}; };
static void *token; static void *token;
@ -164,27 +166,27 @@ static void *token;
INLINE int m4510_cpu_readop(m4510_Regs *m4510) INLINE int m4510_cpu_readop(m4510_Regs *m4510)
{ {
register UINT16 t=m4510->pc.w.l++; 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) INLINE int m4510_cpu_readop_arg(m4510_Regs *m4510)
{ {
register UINT16 t=m4510->pc.w.l++; 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 #define M4510
#include "t65ce02.c" #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; m4510_Regs *m4510 = space->cpu->token;
return program_read_byte_8le(M4510_MEM(offset)); 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; m4510_Regs *m4510 = space->cpu->token;
program_write_byte_8le(M4510_MEM(offset), data); memory_write_byte_8le(space, M4510_MEM(address), data);
} }
static CPU_INIT( m4510 ) static CPU_INIT( m4510 )
@ -198,6 +200,7 @@ static CPU_INIT( m4510 )
m4510->wrmem_id = default_wrmem_id; m4510->wrmem_id = default_wrmem_id;
m4510->irq_callback = irqcallback; m4510->irq_callback = irqcallback;
m4510->device = device; m4510->device = device;
m4510->space = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
} }
static CPU_RESET( m4510 ) static CPU_RESET( m4510 )
@ -368,7 +371,7 @@ static READ8_HANDLER( m4510_read_0000 )
break; break;
case 0x0001: /* Data Port */ case 0x0001: /* Data Port */
if (m4510->port_read) if (m4510->port_read)
result = m4510->port_read(); result = m4510->port_read(m4510->device, 0);
result = (m4510->ddr & m4510->port) | (~m4510->ddr & result); result = (m4510->ddr & m4510->port) | (~m4510->ddr & result);
break; break;
} }
@ -390,7 +393,7 @@ static WRITE8_HANDLER( m4510_write_0000 )
} }
if (m4510->port_write) 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) 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; 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 --- */ /* --- 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_READINDEXED_CALLBACK: m4510->rdmem_id = (m6502_read_indexed_func) info->f; break;
case CPUINFO_PTR_M6502_WRITEINDEXED_CALLBACK: m4510->wrmem_id = (write8_space_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 = (UINT8 (*)(void)) 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 = (void (*)(UINT8)) 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 */ /* 10.March 2000 PeT added 6502 set overflow input line */
/* 13.September 2000 PeT N2A03 jmp indirect */ /* 13.September 2000 PeT N2A03 jmp indirect */
#define NO_LEGACY_MEMORY_HANDLERS 1
#if ((HAS_M65SC02 || HAS_DECO16) && !HAS_M65C02) #if ((HAS_M65SC02 || HAS_DECO16) && !HAS_M65C02)
#undef HAS_M65C02 #undef HAS_M65C02
#define HAS_M65C02 1 #define HAS_M65C02 1
@ -76,17 +78,18 @@ struct _m6502_Regs
cpu_irq_callback irq_callback; cpu_irq_callback irq_callback;
const device_config *device; const device_config *device;
const address_space *space; const address_space *space;
const address_space *io;
int int_occured; int int_occured;
int icount; int icount;
read8_space_func rdmem_id; /* readmem callback for indexed instructions */ m6502_read_indexed_func rdmem_id; /* readmem callback for indexed instructions */
write8_space_func wrmem_id; /* writemem callback for indexed instructions */ m6502_write_indexed_func wrmem_id; /* writemem callback for indexed instructions */
#if (HAS_M6510) || (HAS_M6510T) || (HAS_M8502) || (HAS_M7501) #if (HAS_M6510) || (HAS_M6510T) || (HAS_M8502) || (HAS_M7501)
UINT8 ddr; UINT8 ddr;
UINT8 port; UINT8 port;
UINT8 (*port_read)(UINT8 direction); m6510_port_read_func port_read;
void (*port_write)(UINT8 direction, UINT8 data); m6510_port_write_func port_write;
#endif #endif
}; };
@ -95,8 +98,8 @@ struct _m6502_Regs
static void *token; static void *token;
//static m6502_Regs *m6502; //static m6502_Regs *m6502;
static READ8_HANDLER( default_rdmem_id ) { return program_read_byte_8le(offset); } static UINT8 default_rdmem_id(const address_space *space, offs_t offset) { return memory_read_byte_8le(space, offset); }
static WRITE8_HANDLER( default_wdmem_id ) { program_write_byte_8le(offset, data); } 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 * 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->irq_callback = irqcallback;
m6502->device = device; 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->subtype = subtype;
m6502->insn = insn; m6502->insn = insn;
m6502->rdmem_id = default_rdmem_id; m6502->rdmem_id = default_rdmem_id;
@ -392,7 +395,7 @@ static READ8_HANDLER( m6510_read_0000 )
break; break;
case 0x0001: /* Data Port */ case 0x0001: /* Data Port */
if (m6502->port_read) 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); result = (m6502->ddr & m6502->port) | (~m6502->ddr & result);
break; break;
} }
@ -414,7 +417,7 @@ static WRITE8_HANDLER( m6510_write_0000 )
} }
if (m6502->port_write) 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) static ADDRESS_MAP_START(m6510_mem, ADDRESS_SPACE_PROGRAM, 8)
@ -552,7 +555,9 @@ static CPU_INIT( m65sc02 )
static CPU_INIT( deco16 ) static CPU_INIT( deco16 )
{ {
m6502_Regs *m6502 = device->token;
m6502_common_init(device, index, clock, irqcallback, SUBTYPE_DECO16, insndeco16, "deco16"); 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; 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 --- */ /* --- 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_READINDEXED_CALLBACK: m6502->rdmem_id = (m6502_read_indexed_func) info->f; break;
case CPUINFO_PTR_M6502_WRITEINDEXED_CALLBACK: m6502->wrmem_id = (write8_space_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) switch (state)
{ {
/* --- the following bits of info are set as pointers to data or functions --- */ /* --- 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_PORTREAD: m6502->port_read = (m6510_port_read_func) info->f; break;
case CPUINFO_PTR_M6510_PORTWRITE: m6502->port_write = (void (*)(UINT8,UINT8)) 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; 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 */ positiv edge sets overflow flag */
#define M6502_SET_OVERFLOW 1 #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 enum
{ {
CPUINFO_PTR_M6502_READINDEXED_CALLBACK = CPUINFO_PTR_CPU_SPECIFIC, 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 "debugger.h"
#include "deprecat.h" #include "deprecat.h"
#include "m6509.h" #include "m6509.h"
@ -83,8 +84,8 @@ struct _m6509_Regs {
int icount; int icount;
read8_space_func rdmem_id; /* readmem callback for indexed instructions */ m6502_read_indexed_func rdmem_id; /* readmem callback for indexed instructions */
write8_space_func wrmem_id; /* readmem callback for indexed instructions */ m6502_write_indexed_func wrmem_id; /* writemem callback for indexed instructions */
}; };
static void *token; 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) AM_RANGE(0x00001, 0x00001) AM_MIRROR(0xF0000) AM_READWRITE(m6509_read_00001, m6509_write_00001)
ADDRESS_MAP_END ADDRESS_MAP_END
static READ8_HANDLER( default_rdmem_id ) { return program_read_byte_8le(offset); } static UINT8 default_rdmem_id(const address_space *space, offs_t address) { return memory_read_byte_8le(space, address); }
static WRITE8_HANDLER( default_wdmem_id ) { program_write_byte_8le(offset, data); } 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 ) static CPU_INIT( m6509 )
{ {
@ -144,7 +145,7 @@ static CPU_INIT( m6509 )
m6509->wrmem_id = default_wdmem_id; m6509->wrmem_id = default_wdmem_id;
m6509->irq_callback = irqcallback; m6509->irq_callback = irqcallback;
m6509->device = device; 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 ) 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; 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 --- */ /* --- 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_READINDEXED_CALLBACK: m6509->rdmem_id = (m6502_read_indexed_func) info->f; break;
case CPUINFO_PTR_M6502_WRITEINDEXED_CALLBACK: m6509->wrmem_id = (write8_space_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 "debugger.h"
#include "deprecat.h" #include "deprecat.h"
#include "m65ce02.h" #include "m65ce02.h"
@ -75,8 +76,9 @@ struct _m65ce02_Regs {
UINT8 irq_state; UINT8 irq_state;
cpu_irq_callback irq_callback; cpu_irq_callback irq_callback;
const device_config *device; const device_config *device;
read8_space_func rdmem_id; /* readmem callback for indexed instructions */ const address_space *space;
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 */
}; };
static void *token; static void *token;
@ -86,8 +88,8 @@ static void *token;
#include "t65ce02.c" #include "t65ce02.c"
static READ8_HANDLER( default_rdmem_id ) { return program_read_byte_8le(offset); } static UINT8 default_rdmem_id(const address_space *space, offs_t address) { return memory_read_byte_8le(space, address); }
static WRITE8_HANDLER( default_wdmem_id ) { program_write_byte_8le(offset, data); } 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 ) static CPU_INIT( m65ce02 )
{ {
@ -95,6 +97,7 @@ static CPU_INIT( m65ce02 )
m65ce02.wrmem_id = default_wdmem_id; m65ce02.wrmem_id = default_wdmem_id;
m65ce02.irq_callback = irqcallback; m65ce02.irq_callback = irqcallback;
m65ce02.device = device; m65ce02.device = device;
m65ce02.space = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
} }
static CPU_RESET( m65ce02 ) 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; 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 --- */ /* --- 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_READINDEXED_CALLBACK: m65ce02.rdmem_id = (m6502_read_indexed_func) info->f; break;
case CPUINFO_PTR_M6502_WRITEINDEXED_CALLBACK: m65ce02.wrmem_id = (write8_space_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 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 RDMEM(addr) memory_read_byte_8le(m4510->space, M4510_MEM(addr)); m4510->icount -= 1
#define WRMEM(addr,data) program_write_byte_8le(M4510_MEM(addr),data); m4510->icount -= 1 #define WRMEM(addr,data) memory_write_byte_8le(m4510->space, M4510_MEM(addr),data); m4510->icount -= 1
/*************************************************************** /***************************************************************
* RDOP read an opcode * RDOP read an opcode

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

@ -47,8 +47,8 @@
#define PPC m65ce02->ppc.d #define PPC m65ce02->ppc.d
#define RDMEM_ID m65ce02->rdmem_id #define RDMEM_ID(a) m65ce02->rdmem_id(m65ce02->space, a)
#define WRMEM_ID m65ce02->wrmem_id #define WRMEM_ID(a,d) m65ce02->wrmem_id(m65ce02->space, a, d)
#define IRQ_STATE m65ce02->irq_state #define IRQ_STATE m65ce02->irq_state
#define AFTER_CLI m65ce02->after_cli #define AFTER_CLI m65ce02->after_cli
@ -58,14 +58,14 @@
/*************************************************************** /***************************************************************
* RDOP read an opcode * 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 * 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 RDMEM(addr) memory_read_byte_8le(m65ce02->space, addr); m65ce02->icount -= 1
#define WRMEM(addr,data) program_write_byte_8le(addr,data); 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 * 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 * 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 * 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 * 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 * BRA branch relative
@ -508,7 +508,7 @@
* ILL Illegal opcode * ILL Illegal opcode
***************************************************************/ ***************************************************************/
#define ILL \ #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 ******************************************************** /* 6502 ********************************************************
* INC Increment memory * INC Increment memory

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

@ -37,25 +37,25 @@
* RDOP read an opcode * RDOP read an opcode
***************************************************************/ ***************************************************************/
#undef RDOP #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 * RDOPARG read an opcode argument
***************************************************************/ ***************************************************************/
#undef RDOPARG #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 * RDMEM read memory
***************************************************************/ ***************************************************************/
#undef RDMEM #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 * WRMEM write memory
***************************************************************/ ***************************************************************/
#undef WRMEM #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 * push a register onto the stack
@ -208,4 +208,4 @@
#undef KIL #undef KIL
#define KIL \ #define KIL \
PCW--; \ 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(47) { RD_DUM; ILL; } /* 2 ILL / 5 RMB4 ZPG ?? */
OP(67) { OP(67) {
int tmp; RD_IMM; 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)); // 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; OP(4b) { int tmp; m6502->icount -= 1; RD_IMM;
logerror("%04x: OP4B %02x\n",cpu_get_pc(Machine->activecpu),tmp); 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?? //tilt??
@ -367,7 +367,7 @@ OP(6f) { RD_DUM; ILL; } /* 2 ILL / 5 BBR6 ZPG ?? */
OP(8f) { int tmp; m6502->icount -= 1; RD_IMM; OP(8f) { int tmp; m6502->icount -= 1; RD_IMM;
logerror("%04x: BANK (8F) %02x\n",cpu_get_pc(Machine->activecpu),tmp); 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 //swap bank in/out