diff --git a/src/emu/cpu/jaguar/jaguar.c b/src/emu/cpu/jaguar/jaguar.c
index abd8848e3dd..849f6d943a9 100644
--- a/src/emu/cpu/jaguar/jaguar.c
+++ b/src/emu/cpu/jaguar/jaguar.c
@@ -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;
 }
diff --git a/src/emu/cpu/konami/konami.c b/src/emu/cpu/konami/konami.c
index 0505955f80b..5c3db5ab29e 100644
--- a/src/emu/cpu/konami/konami.c
+++ b/src/emu/cpu/konami/konami.c
@@ -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);
diff --git a/src/emu/cpu/konami/konami.h b/src/emu/cpu/konami/konami.h
index 3c05cc1e296..fee0f96ed5f 100644
--- a/src/emu/cpu/konami/konami.h
+++ b/src/emu/cpu/konami/konami.h
@@ -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
diff --git a/src/emu/cpu/lh5801/5801tbl.c b/src/emu/cpu/lh5801/5801tbl.c
index b73cc148a19..5b6f18550cb 100644
--- a/src/emu/cpu/lh5801/5801tbl.c
+++ b/src/emu/cpu/lh5801/5801tbl.c
@@ -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;
diff --git a/src/emu/cpu/lh5801/lh5801.c b/src/emu/cpu/lh5801/lh5801.c
index ab691b0e727..547e8c4e886 100644
--- a/src/emu/cpu/lh5801/lh5801.c
+++ b/src/emu/cpu/lh5801/lh5801.c
@@ -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);
 
diff --git a/src/emu/cpu/lr35902/lr35902.c b/src/emu/cpu/lr35902/lr35902.c
index 8098acb5ac0..d7b5b6907d1 100644
--- a/src/emu/cpu/lr35902/lr35902.c
+++ b/src/emu/cpu/lr35902/lr35902.c
@@ -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: ******************************/
diff --git a/src/emu/cpu/m37710/m37710.c b/src/emu/cpu/m37710/m37710.c
index 4412df65611..7a90307fa82 100644
--- a/src/emu/cpu/m37710/m37710.c
+++ b/src/emu/cpu/m37710/m37710.c
@@ -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;
diff --git a/src/emu/cpu/m37710/m37710.h b/src/emu/cpu/m37710/m37710.h
index 53afdfe19b2..d92ddabd5ec 100644
--- a/src/emu/cpu/m37710/m37710.h
+++ b/src/emu/cpu/m37710/m37710.h
@@ -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)
 
diff --git a/src/emu/cpu/m37710/m37710cm.h b/src/emu/cpu/m37710/m37710cm.h
index a99dd995cd6..ffd50272035 100644
--- a/src/emu/cpu/m37710/m37710cm.h
+++ b/src/emu/cpu/m37710/m37710cm.h
@@ -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 */
diff --git a/src/emu/cpu/m6502/ill02.h b/src/emu/cpu/m6502/ill02.h
index b8dc90ac7d9..2ba934ab54c 100644
--- a/src/emu/cpu/m6502/ill02.h
+++ b/src/emu/cpu/m6502/ill02.h
@@ -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
diff --git a/src/emu/cpu/m6502/m4510.c b/src/emu/cpu/m6502/m4510.c
index b52d0f31903..1f880277343 100644
--- a/src/emu/cpu/m6502/m4510.c
+++ b/src/emu/cpu/m6502/m4510.c
@@ -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;
 	}
 }
 
diff --git a/src/emu/cpu/m6502/m6502.c b/src/emu/cpu/m6502/m6502.c
index fe662ad8ff3..704f67d16fd 100644
--- a/src/emu/cpu/m6502/m6502.c
+++ b/src/emu/cpu/m6502/m6502.c
@@ -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;
 	}
diff --git a/src/emu/cpu/m6502/m6502.h b/src/emu/cpu/m6502/m6502.h
index 0c4e5931802..c8795d86117 100644
--- a/src/emu/cpu/m6502/m6502.h
+++ b/src/emu/cpu/m6502/m6502.h
@@ -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,
diff --git a/src/emu/cpu/m6502/m6509.c b/src/emu/cpu/m6502/m6509.c
index 10c09c3cea2..125a26d688a 100644
--- a/src/emu/cpu/m6502/m6509.c
+++ b/src/emu/cpu/m6502/m6509.c
@@ -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;
 	}
 }
 
diff --git a/src/emu/cpu/m6502/m65ce02.c b/src/emu/cpu/m6502/m65ce02.c
index 5d25b444254..4d782652788 100644
--- a/src/emu/cpu/m6502/m65ce02.c
+++ b/src/emu/cpu/m6502/m65ce02.c
@@ -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;
 	}
 }
 
diff --git a/src/emu/cpu/m6502/minc4510.h b/src/emu/cpu/m6502/minc4510.h
index a0929bd4187..1dae1f2e11a 100644
--- a/src/emu/cpu/m6502/minc4510.h
+++ b/src/emu/cpu/m6502/minc4510.h
@@ -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
diff --git a/src/emu/cpu/m6502/mincce02.h b/src/emu/cpu/m6502/mincce02.h
index a401f489dba..4a685af4993 100644
--- a/src/emu/cpu/m6502/mincce02.h
+++ b/src/emu/cpu/m6502/mincce02.h
@@ -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
diff --git a/src/emu/cpu/m6502/ops02.h b/src/emu/cpu/m6502/ops02.h
index e3572c50a4b..f35c31a83cf 100644
--- a/src/emu/cpu/m6502/ops02.h
+++ b/src/emu/cpu/m6502/ops02.h
@@ -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
diff --git a/src/emu/cpu/m6502/ops09.h b/src/emu/cpu/m6502/ops09.h
index 0832875bf94..4f0f9f91e0d 100644
--- a/src/emu/cpu/m6502/ops09.h
+++ b/src/emu/cpu/m6502/ops09.h
@@ -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))
diff --git a/src/emu/cpu/m6502/tdeco16.c b/src/emu/cpu/m6502/tdeco16.c
index 603387b340c..4766142cb4a 100644
--- a/src/emu/cpu/m6502/tdeco16.c
+++ b/src/emu/cpu/m6502/tdeco16.c
@@ -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