diff --git a/src/devices/cpu/e132xs/32xsdefs.h b/src/devices/cpu/e132xs/32xsdefs.h
index 9ddcdb33de0..e1f10ae9e29 100644
--- a/src/devices/cpu/e132xs/32xsdefs.h
+++ b/src/devices/cpu/e132xs/32xsdefs.h
@@ -130,7 +130,7 @@
 #define IO_WRITE_W(addr, data)  m_io->write_dword(((addr) >> 11) & 0x7ffc, data)
 
 
-#define READ_OP(addr)          m_direct->read_word((addr), m_opcodexor)
+#define READ_OP(addr)          m_direct->read_word((addr), m_core->opcodexor)
 
 // set C in adds/addsi/subs/sums
 #define SETCARRYS 0
@@ -141,21 +141,21 @@
 /* Internal registers */
 
 #define OP              m_op
-#define PC              m_global_regs[0] //Program Counter
-#define SR              m_global_regs[1] //Status Register
-#define FER             m_global_regs[2] //Floating-Point Exception Register
+#define PC              m_core->global_regs[0] //Program Counter
+#define SR              m_core->global_regs[1] //Status Register
+#define FER             m_core->global_regs[2] //Floating-Point Exception Register
 // 03 - 15  General Purpose Registers
 // 16 - 17  Reserved
-#define SP              m_global_regs[18] //Stack Pointer
-#define UB              m_global_regs[19] //Upper Stack Bound
-#define BCR             m_global_regs[20] //Bus Control Register
-#define TPR             m_global_regs[21] //Timer Prescaler Register
-#define TCR             m_global_regs[22] //Timer Compare Register
+#define SP              m_core->global_regs[18] //Stack Pointer
+#define UB              m_core->global_regs[19] //Upper Stack Bound
+#define BCR             m_core->global_regs[20] //Bus Control Register
+#define TPR             m_core->global_regs[21] //Timer Prescaler Register
+#define TCR             m_core->global_regs[22] //Timer Compare Register
 #define TR              compute_tr() //Timer Register
-#define WCR             m_global_regs[24] //Watchdog Compare Register
-#define ISR             m_global_regs[25] //Input Status Register
-#define FCR             m_global_regs[26] //Function Control Register
-#define MCR             m_global_regs[27] //Memory Control Register
+#define WCR             m_core->global_regs[24] //Watchdog Compare Register
+#define ISR             m_core->global_regs[25] //Input Status Register
+#define FCR             m_core->global_regs[26] //Function Control Register
+#define MCR             m_core->global_regs[27] //Memory Control Register
 // 28 - 31  Reserved
 
 #define C_MASK                  0x00000001
@@ -194,7 +194,7 @@
 #define GET_S                   ((SR & S_MASK)>>18)     // bit 18 //SUPERVISOR STATE
 #define GET_ILC                 ((SR & 0x00180000)>>19) // bits 20 - 19 //INSTRUCTION-LENGTH
 /* if FL is zero it is always interpreted as 16 */
-#define GET_FL                  m_fl_lut[((SR >> 21) & 0xf)] // bits 24 - 21 //FRAME LENGTH
+#define GET_FL                  m_core->fl_lut[((SR >> 21) & 0xf)] // bits 24 - 21 //FRAME LENGTH
 #define GET_FP                  ((SR & 0xfe000000)>>25) // bits 31 - 25 //FRAME POINTER
 
 #define SET_C(val)              (SR = (SR & ~C_MASK) | (val))
diff --git a/src/devices/cpu/e132xs/e132xs.cpp b/src/devices/cpu/e132xs/e132xs.cpp
index e193c9a14de..8df198a2d5a 100644
--- a/src/devices/cpu/e132xs/e132xs.cpp
+++ b/src/devices/cpu/e132xs/e132xs.cpp
@@ -202,7 +202,6 @@ hyperstone_device::hyperstone_device(const machine_config &mconfig, const char *
 	: cpu_device(mconfig, type, tag, owner, clock)
 	, m_program_config("program", ENDIANNESS_BIG, prg_data_width, 32, 0, internal_map)
 	, m_io_config("io", ENDIANNESS_BIG, io_data_width, 15)
-	, m_icount(0)
 	, m_cache(CACHE_SIZE + sizeof(hyperstone_device))
 	, m_drcuml(nullptr)
 	, m_drcfe(nullptr)
@@ -371,7 +370,7 @@ gms30c2232_device::gms30c2232_device(const machine_config &mconfig, const char *
 uint32_t hyperstone_device::get_trap_addr(uint8_t trapno)
 {
 	uint32_t addr;
-	if( m_trap_entry == 0xffffff00 ) /* @ MEM3 */
+	if( m_core->trap_entry == 0xffffff00 ) /* @ MEM3 */
 	{
 		addr = trapno * 4;
 	}
@@ -379,7 +378,7 @@ uint32_t hyperstone_device::get_trap_addr(uint8_t trapno)
 	{
 		addr = (63 - trapno) * 4;
 	}
-	addr |= m_trap_entry;
+	addr |= m_core->trap_entry;
 
 	return addr;
 }
@@ -388,13 +387,13 @@ uint32_t hyperstone_device::get_trap_addr(uint8_t trapno)
 uint32_t hyperstone_device::get_emu_code_addr(uint8_t num) /* num is OP */
 {
 	uint32_t addr;
-	if( m_trap_entry == 0xffffff00 ) /* @ MEM3 */
+	if( m_core->trap_entry == 0xffffff00 ) /* @ MEM3 */
 	{
-		addr = (m_trap_entry - 0x100) | ((num & 0xf) << 4);
+		addr = (m_core->trap_entry - 0x100) | ((num & 0xf) << 4);
 	}
 	else
 	{
-		addr = m_trap_entry | (0x10c | ((0xcf - num) << 4));
+		addr = m_core->trap_entry | (0x10c | ((0xcf - num) << 4));
 	}
 	return addr;
 }
@@ -418,7 +417,7 @@ void hyperstone_device::dump_registers()
 	total_ops++;
 	if (total_ops < 0ULL)
 	{
-		//if (m_global_regs[0] == 0x11094)
+		//if (m_core->global_regs[0] == 0x11094)
 		//{
 		//	total_11094++;
 		//}
@@ -427,69 +426,69 @@ void hyperstone_device::dump_registers()
 		//printf("Total non-log hits of 0x11094: %d\n", (uint32_t)total_11094);
 	}
 	uint8_t packed[4];
-	packed[0] = (uint8_t)m_intblock;
-	packed[1] = (uint8_t)(m_icount >> 16);
-	packed[2] = (uint8_t)(m_icount >>  8);
-	packed[3] = (uint8_t)(m_icount >>  0);
+	packed[0] = (uint8_t)m_core->intblock;
+	packed[1] = (uint8_t)(m_core->icount >> 16);
+	packed[2] = (uint8_t)(m_core->icount >>  8);
+	packed[3] = (uint8_t)(m_core->icount >>  0);
 	fwrite(packed, 1, 4, m_trace_log);
-	fwrite(m_global_regs, 4, 32, m_trace_log);
-	fwrite(m_local_regs, 4, 64, m_trace_log);
+	fwrite(m_core->global_regs, 4, 32, m_trace_log);
+	fwrite(m_core->local_regs, 4, 64, m_trace_log);
 }
 #endif
 
 void hyperstone_device::compute_tr()
 {
-	uint64_t cycles_since_base = total_cycles() - m_tr_base_cycles;
-	uint64_t clocks_since_base = cycles_since_base >> m_clck_scale;
-	m_tr_result = m_tr_base_value + (clocks_since_base / m_tr_clocks_per_tick);
+	uint64_t cycles_since_base = total_cycles() - m_core->tr_base_cycles;
+	uint64_t clocks_since_base = cycles_since_base >> m_core->clck_scale;
+	m_core->tr_result = m_core->tr_base_value + (clocks_since_base / m_core->tr_clocks_per_tick);
 }
 
 void hyperstone_device::update_timer_prescale()
 {
 	TPR &= ~0x80000000;
-	m_clck_scale = (TPR >> 26) & m_clock_scale_mask;
-	m_clock_cycles_1 = 1 << m_clck_scale;
-	m_clock_cycles_2 = 2 << m_clck_scale;
-	m_clock_cycles_3 = 3 << m_clck_scale;
-	m_clock_cycles_4 = 4 << m_clck_scale;
-	m_clock_cycles_6 = 6 << m_clck_scale;
-	m_clock_cycles_36 = 36 << m_clck_scale;
-	m_tr_clocks_per_tick = ((TPR >> 16) & 0xff) + 2;
-	m_tr_base_value = m_tr_result;
-	m_tr_base_cycles = total_cycles();
+	m_core->clck_scale = (TPR >> 26) & m_core->clock_scale_mask;
+	m_core->clock_cycles_1 = 1 << m_core->clck_scale;
+	m_core->clock_cycles_2 = 2 << m_core->clck_scale;
+	m_core->clock_cycles_3 = 3 << m_core->clck_scale;
+	m_core->clock_cycles_4 = 4 << m_core->clck_scale;
+	m_core->clock_cycles_6 = 6 << m_core->clck_scale;
+	m_core->clock_cycles_36 = 36 << m_core->clck_scale;
+	m_core->tr_clocks_per_tick = ((TPR >> 16) & 0xff) + 2;
+	m_core->tr_base_value = m_core->tr_result;
+	m_core->tr_base_cycles = total_cycles();
 }
 
 void hyperstone_device::adjust_timer_interrupt()
 {
-	uint64_t cycles_since_base = total_cycles() - m_tr_base_cycles;
-	uint64_t clocks_since_base = cycles_since_base >> m_clck_scale;
-	uint64_t cycles_until_next_clock = cycles_since_base - (clocks_since_base << m_clck_scale);
+	uint64_t cycles_since_base = total_cycles() - m_core->tr_base_cycles;
+	uint64_t clocks_since_base = cycles_since_base >> m_core->clck_scale;
+	uint64_t cycles_until_next_clock = cycles_since_base - (clocks_since_base << m_core->clck_scale);
 
 	if (cycles_until_next_clock == 0)
-		cycles_until_next_clock = (uint64_t)(1 << m_clck_scale);
+		cycles_until_next_clock = (uint64_t)(1 << m_core->clck_scale);
 
 	/* special case: if we have a change pending, set a timer to fire then */
 	if (TPR & 0x80000000)
 	{
-		uint64_t clocks_until_int = m_tr_clocks_per_tick - (clocks_since_base % m_tr_clocks_per_tick);
-		uint64_t cycles_until_int = (clocks_until_int << m_clck_scale) + cycles_until_next_clock;
+		uint64_t clocks_until_int = m_core->tr_clocks_per_tick - (clocks_since_base % m_core->tr_clocks_per_tick);
+		uint64_t cycles_until_int = (clocks_until_int << m_core->clck_scale) + cycles_until_next_clock;
 		m_timer->adjust(cycles_to_attotime(cycles_until_int + 1), 1);
 	}
 
 	/* else if the timer interrupt is enabled, configure it to fire at the appropriate time */
 	else if (!(FCR & 0x00800000))
 	{
-		uint32_t curtr = m_tr_base_value + (clocks_since_base / m_tr_clocks_per_tick);
+		uint32_t curtr = m_core->tr_base_value + (clocks_since_base / m_core->tr_clocks_per_tick);
 		uint32_t delta = TCR - curtr;
 		if (delta > 0x80000000)
 		{
-			if (!m_timer_int_pending)
+			if (!m_core->timer_int_pending)
 				m_timer->adjust(attotime::zero);
 		}
 		else
 		{
-			uint64_t clocks_until_int = mulu_32x32(delta, m_tr_clocks_per_tick);
-			uint64_t cycles_until_int = (clocks_until_int << m_clck_scale) + cycles_until_next_clock;
+			uint64_t clocks_until_int = mulu_32x32(delta, m_core->tr_clocks_per_tick);
+			uint64_t cycles_until_int = (clocks_until_int << m_core->clck_scale) + cycles_until_next_clock;
 			m_timer->adjust(cycles_to_attotime(cycles_until_int));
 		}
 	}
@@ -511,8 +510,8 @@ TIMER_CALLBACK_MEMBER( hyperstone_device::timer_callback )
 
 	/* see if the timer is right for firing */
 	compute_tr();
-	if (!((m_tr_result - TCR) & 0x80000000))
-		m_timer_int_pending = 1;
+	if (!((m_core->tr_result - TCR) & 0x80000000))
+		m_core->timer_int_pending = 1;
 
 	/* adjust ourselves for the next time */
 	else
@@ -559,17 +558,17 @@ uint32_t hyperstone_device::get_global_register(uint8_t code)
 	if (code == TR_REGISTER)
 	{
 		/* it is common to poll this in a loop */
-		if (m_icount > m_tr_clocks_per_tick / 2)
-			m_icount -= m_tr_clocks_per_tick / 2;
+		if (m_core->icount > m_core->tr_clocks_per_tick / 2)
+			m_core->icount -= m_core->tr_clocks_per_tick / 2;
 		compute_tr();
-		return m_tr_result;
+		return m_core->tr_result;
 	}
-	return m_global_regs[code & 0x1f];
+	return m_core->global_regs[code & 0x1f];
 }
 
 void hyperstone_device::set_local_register(uint8_t code, uint32_t val)
 {
-	m_local_regs[(code + GET_FP) & 0x3f] = val;
+	m_core->local_regs[(code + GET_FP) & 0x3f] = val;
 }
 
 void hyperstone_device::set_global_register(uint8_t code, uint32_t val)
@@ -584,8 +583,8 @@ void hyperstone_device::set_global_register(uint8_t code, uint32_t val)
 		case SR_REGISTER:
 			SET_LOW_SR(val); // only a RET instruction can change the full content of SR
 			SR &= ~0x40; //reserved bit 6 always zero
-			if (m_intblock < 1)
-				m_intblock = 1;
+			if (m_core->intblock < 1)
+				m_core->intblock = 1;
 			return;
 		case 2:
 		case 3:
@@ -604,17 +603,17 @@ void hyperstone_device::set_global_register(uint8_t code, uint32_t val)
 		case 16:
 		// are the below ones set only when privilege bit is set?
 		case 17:
-			m_global_regs[code] = val;
+			m_core->global_regs[code] = val;
 			return;
 		case SP_REGISTER:
 		case UB_REGISTER:
-			m_global_regs[code] = val & ~3;
+			m_core->global_regs[code] = val & ~3;
 			return;
 		case BCR_REGISTER:
-			m_global_regs[code] = val;
+			m_core->global_regs[code] = val;
 			return;
 		case TPR_REGISTER:
-			m_global_regs[code] = val;
+			m_core->global_regs[code] = val;
 			if (!(val & 0x80000000)) /* change immediately */
 			{
 				compute_tr();
@@ -623,46 +622,46 @@ void hyperstone_device::set_global_register(uint8_t code, uint32_t val)
 			adjust_timer_interrupt();
 			return;
 		case TCR_REGISTER:
-			if (m_global_regs[code] != val)
+			if (m_core->global_regs[code] != val)
 			{
-				m_global_regs[code] = val;
+				m_core->global_regs[code] = val;
 				adjust_timer_interrupt();
-				if (m_intblock < 1)
-					m_intblock = 1;
+				if (m_core->intblock < 1)
+					m_core->intblock = 1;
 			}
 			return;
 		case TR_REGISTER:
-			m_global_regs[code] = val;
-			m_tr_base_value = val;
-			m_tr_base_cycles = total_cycles();
+			m_core->global_regs[code] = val;
+			m_core->tr_base_value = val;
+			m_core->tr_base_cycles = total_cycles();
 			adjust_timer_interrupt();
 			return;
 		case WCR_REGISTER:
-			m_global_regs[code] = val;
+			m_core->global_regs[code] = val;
 			return;
 		case ISR_REGISTER:
 			return;
 		case FCR_REGISTER:
-			if ((m_global_regs[code] ^ val) & 0x00800000)
+			if ((m_core->global_regs[code] ^ val) & 0x00800000)
 				adjust_timer_interrupt();
-			m_global_regs[code] = val;
-			if (m_intblock < 1)
-				m_intblock = 1;
+			m_core->global_regs[code] = val;
+			if (m_core->intblock < 1)
+				m_core->intblock = 1;
 			return;
 		case MCR_REGISTER:
 		{
 			// bits 14..12 EntryTableMap
 			const int which = (val & 0x7000) >> 12;
 			assert(which < 4 || which == 7);
-			m_trap_entry = s_trap_entries[which];
-			m_global_regs[code] = val;
+			m_core->trap_entry = s_trap_entries[which];
+			m_core->global_regs[code] = val;
 			return;
 		}
 		case 28:
 		case 29:
 		case 30:
 		case 31:
-			m_global_regs[code] = val;
+			m_core->global_regs[code] = val;
 			return;
 	}
 }
@@ -679,10 +678,10 @@ constexpr uint32_t WRITE_ONLY_REGMASK = (1 << BCR_REGISTER) | (1 << TPR_REGISTER
 do                                                                                  \
 {                                                                                   \
 	/* if PC is used in a delay instruction, the delayed PC should be used */       \
-	if (m_delay_slot)                                                               \
+	if (m_core->delay_slot)                                                         \
 	{                                                                               \
-		PC = m_delay_pc;                                                            \
-		m_delay_slot = 0;                                                       	\
+		PC = m_core->delay_pc;                                                      \
+		m_core->delay_slot = 0;                                                     \
 	}                                                                               \
 } while (0)
 
@@ -804,7 +803,7 @@ void hyperstone_device::hyperstone_br()
 	PC += offset;
 	SR &= ~M_MASK;
 
-	m_icount -= m_clock_cycles_2;
+	m_core->icount -= m_core->clock_cycles_2;
 }
 
 void hyperstone_device::execute_trap(uint32_t addr)
@@ -816,15 +815,15 @@ void hyperstone_device::execute_trap(uint32_t addr)
 	SET_FL(6);
 	SET_FP(reg);
 
-	m_local_regs[(0 + reg) & 0x3f] = (PC & ~1) | GET_S;
-	m_local_regs[(1 + reg) & 0x3f] = oldSR;
+	m_core->local_regs[(0 + reg) & 0x3f] = (PC & ~1) | GET_S;
+	m_core->local_regs[(1 + reg) & 0x3f] = oldSR;
 
 	SR &= ~(M_MASK | T_MASK);
 	SR |= (L_MASK | S_MASK);
 
 	PC = addr;
 
-	m_icount -= m_clock_cycles_2;
+	m_core->icount -= m_core->clock_cycles_2;
 }
 
 
@@ -837,15 +836,15 @@ void hyperstone_device::execute_int(uint32_t addr)
 	SET_FL(2);
 	SET_FP(reg);
 
-	m_local_regs[(0 + reg) & 0x3f] = (PC & ~1) | GET_S;
-	m_local_regs[(1 + reg) & 0x3f] = oldSR;
+	m_core->local_regs[(0 + reg) & 0x3f] = (PC & ~1) | GET_S;
+	m_core->local_regs[(1 + reg) & 0x3f] = oldSR;
 
 	SR &= ~(M_MASK | T_MASK);
 	SR |= (L_MASK | S_MASK | I_MASK);
 
 	PC = addr;
 
-	m_icount -= m_clock_cycles_2;
+	m_core->icount -= m_core->clock_cycles_2;
 }
 
 /* TODO: mask Parity Error and Extended Overflow exceptions */
@@ -858,15 +857,15 @@ void hyperstone_device::execute_exception(uint32_t addr)
 	SET_FL(2);
 	SET_FP(reg);
 
-	m_local_regs[(0 + reg) & 0x3f] = (PC & ~1) | GET_S;
-	m_local_regs[(1 + reg) & 0x3f] = oldSR;
+	m_core->local_regs[(0 + reg) & 0x3f] = (PC & ~1) | GET_S;
+	m_core->local_regs[(1 + reg) & 0x3f] = oldSR;
 
 	SR &= ~(M_MASK | T_MASK);
 	SR |= (L_MASK | S_MASK);
 
 	PC = addr;
 
-	m_icount -= m_clock_cycles_2;
+	m_core->icount -= m_core->clock_cycles_2;
 }
 
 void hyperstone_device::execute_software()
@@ -875,8 +874,8 @@ void hyperstone_device::execute_software()
 
 	const uint32_t fp = GET_FP;
 	const uint32_t src_code = SRC_CODE;
-	const uint32_t sreg = m_local_regs[(src_code + fp) & 0x3f];
-	const uint32_t sregf = m_local_regs[(src_code + 1 + fp) & 0x3f];
+	const uint32_t sreg = m_core->local_regs[(src_code + fp) & 0x3f];
+	const uint32_t sregf = m_core->local_regs[(src_code + 1 + fp) & 0x3f];
 
 	SET_ILC(1<<19);
 
@@ -888,11 +887,11 @@ void hyperstone_device::execute_software()
 	//that can be set by a following frame instruction
 	const uint32_t stack_of_dst = (SP & ~0xff) + 0x100 + (((fp + DST_CODE) & 0x3f) << 2); //converted to 32bits offset
 
-	m_local_regs[(reg + 0) & 0x3f] = stack_of_dst;
-	m_local_regs[(reg + 1) & 0x3f] = sreg;
-	m_local_regs[(reg + 2) & 0x3f] = sregf;
-	m_local_regs[(reg + 3) & 0x3f] = (PC & ~1) | GET_S;
-	m_local_regs[(reg + 4) & 0x3f] = SR;
+	m_core->local_regs[(reg + 0) & 0x3f] = stack_of_dst;
+	m_core->local_regs[(reg + 1) & 0x3f] = sreg;
+	m_core->local_regs[(reg + 2) & 0x3f] = sregf;
+	m_core->local_regs[(reg + 3) & 0x3f] = (PC & ~1) | GET_S;
+	m_core->local_regs[(reg + 4) & 0x3f] = SR;
 
 	SET_FL(6);
 	SET_FP(reg);
@@ -902,7 +901,7 @@ void hyperstone_device::execute_software()
 
 	PC = addr;
 
-	m_icount -= m_clock_cycles_6;
+	m_core->icount -= m_core->clock_cycles_6;
 }
 
 
@@ -930,7 +929,7 @@ template <hyperstone_device::is_timer TIMER>
 void hyperstone_device::check_interrupts()
 {
 	/* Interrupt-Lock flag isn't set */
-	if (GET_L || m_intblock > 0)
+	if (GET_L || m_core->intblock > 0)
 		return;
 
 	/* quick exit if nothing */
@@ -1008,7 +1007,7 @@ void hyperstone_device::check_interrupts()
 		/* timer int might be priority 6 if FCR bits 20-21 == 3; FCR bit 23 inhibits interrupt */
 		if (TIMER && (FCR & 0x00b00000) == 0x00300000)
 		{
-			m_timer_int_pending = 0;
+			m_core->timer_int_pending = 0;
 			execute_int(get_trap_addr(TRAPNO_TIMER));
 			return;
 		}
@@ -1024,7 +1023,7 @@ void hyperstone_device::check_interrupts()
 		/* timer int might be priority 8 if FCR bits 20-21 == 2; FCR bit 23 inhibits interrupt */
 		if (TIMER && (FCR & 0x00b00000) == 0x00200000)
 		{
-			m_timer_int_pending = 0;
+			m_core->timer_int_pending = 0;
 			execute_int(get_trap_addr(TRAPNO_TIMER));
 			return;
 		}
@@ -1040,7 +1039,7 @@ void hyperstone_device::check_interrupts()
 		/* timer int might be priority 10 if FCR bits 20-21 == 1; FCR bit 23 inhibits interrupt */
 		if (TIMER && (FCR & 0x00b00000) == 0x00100000)
 		{
-			m_timer_int_pending = 0;
+			m_core->timer_int_pending = 0;
 			execute_int(get_trap_addr(TRAPNO_TIMER));
 			return;
 		}
@@ -1056,7 +1055,7 @@ void hyperstone_device::check_interrupts()
 		/* timer int might be priority 12 if FCR bits 20-21 == 0; FCR bit 23 inhibits interrupt */
 		if (TIMER && (FCR & 0x00b00000) == 0x00000000)
 		{
-			m_timer_int_pending = 0;
+			m_core->timer_int_pending = 0;
 			execute_int(get_trap_addr(TRAPNO_TIMER));
 			return;
 		}
@@ -1094,6 +1093,9 @@ void hyperstone_device::device_start()
 
 void hyperstone_device::init(int scale_mask)
 {
+	m_core = (internal_hyperstone_state *)m_cache.alloc_near(sizeof(internal_hyperstone_state));
+	memset(m_core, 0, sizeof(internal_hyperstone_state));
+
 #if ENABLE_E132XS_DRC
 	m_enable_drc = allow_drc();
 #else
@@ -1108,61 +1110,43 @@ void hyperstone_device::init(int scale_mask)
 #endif
 
 	memset(m_op_counts, 0, sizeof(uint32_t) * 256);
-	memset(m_global_regs, 0, sizeof(uint32_t) * 32);
-	memset(m_local_regs, 0, sizeof(uint32_t) * 64);
+	memset(m_core->global_regs, 0, sizeof(uint32_t) * 32);
+	memset(m_core->local_regs, 0, sizeof(uint32_t) * 64);
 	m_op = 0;
-	m_trap_entry = 0;
-	m_clock_scale_mask = 0;
-	m_clck_scale = 0;
-	m_clock_cycles_1 = 0;
-	m_clock_cycles_2 = 0;
-	m_clock_cycles_3 = 0;
-	m_clock_cycles_4 = 0;
-	m_clock_cycles_6 = 0;
-	m_clock_cycles_36 = 0;
-
-	m_tr_base_cycles = 0;
-	m_tr_base_value = 0;
-	m_tr_result = 0;
-	m_tr_clocks_per_tick = 0;
-	m_timer_int_pending = 0;
 
 	m_instruction_length = 0;
-	m_intblock = 0;
-
-	m_icount = 0;
 
 	m_program = &space(AS_PROGRAM);
 	m_direct = m_program->direct<0>();
 	m_io = &space(AS_IO);
 
 	m_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(hyperstone_device::timer_callback), this));
-	m_clock_scale_mask = scale_mask;
+	m_core->clock_scale_mask = scale_mask;
 
 	for (uint8_t i = 0; i < 16; i++)
 	{
-		m_fl_lut[i] = (i ? i : 16);
+		m_core->fl_lut[i] = (i ? i : 16);
 	}
 
 	uint32_t umlflags = 0;
 	m_drcuml = std::make_unique<drcuml_state>(*this, m_cache, umlflags, 1, 32, 1);
 
 	// add UML symbols-
-	m_drcuml->symbol_add(&m_global_regs[0], sizeof(uint32_t), "pc");
-	m_drcuml->symbol_add(&m_global_regs[1], sizeof(uint32_t), "sr");
-	m_drcuml->symbol_add(&m_icount, sizeof(m_icount), "icount");
+	m_drcuml->symbol_add(&m_core->global_regs[0], sizeof(uint32_t), "pc");
+	m_drcuml->symbol_add(&m_core->global_regs[1], sizeof(uint32_t), "sr");
+	m_drcuml->symbol_add(&m_core->icount, sizeof(m_core->icount), "icount");
 
 	char buf[4];
 	for (int i=0; i < 32; i++)
 	{
 		sprintf(buf, "g%d", i);
-		m_drcuml->symbol_add(&m_global_regs[i], sizeof(uint32_t), buf);
+		m_drcuml->symbol_add(&m_core->global_regs[i], sizeof(uint32_t), buf);
 	}
 
 	for (int i=0; i < 64; i++)
 	{
 		sprintf(buf, "l%d", i);
-		m_drcuml->symbol_add(&m_local_regs[i], sizeof(uint32_t), buf);
+		m_drcuml->symbol_add(&m_core->local_regs[i], sizeof(uint32_t), buf);
 	}
 
 	m_drcuml->symbol_add(&m_drc_arg0, sizeof(uint32_t), "arg0");
@@ -1177,229 +1161,229 @@ void hyperstone_device::init(int scale_mask)
 	m_cache_dirty = true;
 
 	// register our state for the debugger
-	state_add(STATE_GENPC,    "GENPC",     m_global_regs[0]).noshow();
-	state_add(STATE_GENPCBASE, "CURPC",    m_global_regs[0]).noshow();
-	state_add(STATE_GENFLAGS, "GENFLAGS",  m_global_regs[1]).callimport().callexport().formatstr("%40s").noshow();
-	state_add(E132XS_PC,      "PC", m_global_regs[0]).mask(0xffffffff);
-	state_add(E132XS_SR,      "SR", m_global_regs[1]).mask(0xffffffff);
-	state_add(E132XS_FER,     "FER", m_global_regs[2]).mask(0xffffffff);
-	state_add(E132XS_G3,      "G3", m_global_regs[3]).mask(0xffffffff);
-	state_add(E132XS_G4,      "G4", m_global_regs[4]).mask(0xffffffff);
-	state_add(E132XS_G5,      "G5", m_global_regs[5]).mask(0xffffffff);
-	state_add(E132XS_G6,      "G6", m_global_regs[6]).mask(0xffffffff);
-	state_add(E132XS_G7,      "G7", m_global_regs[7]).mask(0xffffffff);
-	state_add(E132XS_G8,      "G8", m_global_regs[8]).mask(0xffffffff);
-	state_add(E132XS_G9,      "G9", m_global_regs[9]).mask(0xffffffff);
-	state_add(E132XS_G10,     "G10", m_global_regs[10]).mask(0xffffffff);
-	state_add(E132XS_G11,     "G11", m_global_regs[11]).mask(0xffffffff);
-	state_add(E132XS_G12,     "G12", m_global_regs[12]).mask(0xffffffff);
-	state_add(E132XS_G13,     "G13", m_global_regs[13]).mask(0xffffffff);
-	state_add(E132XS_G14,     "G14", m_global_regs[14]).mask(0xffffffff);
-	state_add(E132XS_G15,     "G15", m_global_regs[15]).mask(0xffffffff);
-	state_add(E132XS_G16,     "G16", m_global_regs[16]).mask(0xffffffff);
-	state_add(E132XS_G17,     "G17", m_global_regs[17]).mask(0xffffffff);
-	state_add(E132XS_SP,      "SP", m_global_regs[18]).mask(0xffffffff);
-	state_add(E132XS_UB,      "UB", m_global_regs[19]).mask(0xffffffff);
-	state_add(E132XS_BCR,     "BCR", m_global_regs[20]).mask(0xffffffff);
-	state_add(E132XS_TPR,     "TPR", m_global_regs[21]).mask(0xffffffff);
-	state_add(E132XS_TCR,     "TCR", m_global_regs[22]).mask(0xffffffff);
-	state_add(E132XS_TR,      "TR", m_global_regs[23]).mask(0xffffffff);
-	state_add(E132XS_WCR,     "WCR", m_global_regs[24]).mask(0xffffffff);
-	state_add(E132XS_ISR,     "ISR", m_global_regs[25]).mask(0xffffffff);
-	state_add(E132XS_FCR,     "FCR", m_global_regs[26]).mask(0xffffffff);
-	state_add(E132XS_MCR,     "MCR", m_global_regs[27]).mask(0xffffffff);
-	state_add(E132XS_G28,     "G28", m_global_regs[28]).mask(0xffffffff);
-	state_add(E132XS_G29,     "G29", m_global_regs[29]).mask(0xffffffff);
-	state_add(E132XS_G30,     "G30", m_global_regs[30]).mask(0xffffffff);
-	state_add(E132XS_G31,     "G31", m_global_regs[31]).mask(0xffffffff);
-	state_add(E132XS_CL0,     "CL0", m_local_regs[(0 + GET_FP) % 64]).mask(0xffffffff);
-	state_add(E132XS_CL1,     "CL1", m_local_regs[(1 + GET_FP) % 64]).mask(0xffffffff);
-	state_add(E132XS_CL2,     "CL2", m_local_regs[(2 + GET_FP) % 64]).mask(0xffffffff);
-	state_add(E132XS_CL3,     "CL3", m_local_regs[(3 + GET_FP) % 64]).mask(0xffffffff);
-	state_add(E132XS_CL4,     "CL4", m_local_regs[(4 + GET_FP) % 64]).mask(0xffffffff);
-	state_add(E132XS_CL5,     "CL5", m_local_regs[(5 + GET_FP) % 64]).mask(0xffffffff);
-	state_add(E132XS_CL6,     "CL6", m_local_regs[(6 + GET_FP) % 64]).mask(0xffffffff);
-	state_add(E132XS_CL7,     "CL7", m_local_regs[(7 + GET_FP) % 64]).mask(0xffffffff);
-	state_add(E132XS_CL8,     "CL8", m_local_regs[(8 + GET_FP) % 64]).mask(0xffffffff);
-	state_add(E132XS_CL9,     "CL9", m_local_regs[(9 + GET_FP) % 64]).mask(0xffffffff);
-	state_add(E132XS_CL10,    "CL10", m_local_regs[(10 + GET_FP) % 64]).mask(0xffffffff);
-	state_add(E132XS_CL11,    "CL11", m_local_regs[(11 + GET_FP) % 64]).mask(0xffffffff);
-	state_add(E132XS_CL12,    "CL12", m_local_regs[(12 + GET_FP) % 64]).mask(0xffffffff);
-	state_add(E132XS_CL13,    "CL13", m_local_regs[(13 + GET_FP) % 64]).mask(0xffffffff);
-	state_add(E132XS_CL14,    "CL14", m_local_regs[(14 + GET_FP) % 64]).mask(0xffffffff);
-	state_add(E132XS_CL15,    "CL15", m_local_regs[(15 + GET_FP) % 64]).mask(0xffffffff);
-	state_add(E132XS_L0,      "L0", m_local_regs[0]).mask(0xffffffff);
-	state_add(E132XS_L1,      "L1", m_local_regs[1]).mask(0xffffffff);
-	state_add(E132XS_L2,      "L2", m_local_regs[2]).mask(0xffffffff);
-	state_add(E132XS_L3,      "L3", m_local_regs[3]).mask(0xffffffff);
-	state_add(E132XS_L4,      "L4", m_local_regs[4]).mask(0xffffffff);
-	state_add(E132XS_L5,      "L5", m_local_regs[5]).mask(0xffffffff);
-	state_add(E132XS_L6,      "L6", m_local_regs[6]).mask(0xffffffff);
-	state_add(E132XS_L7,      "L7", m_local_regs[7]).mask(0xffffffff);
-	state_add(E132XS_L8,      "L8", m_local_regs[8]).mask(0xffffffff);
-	state_add(E132XS_L9,      "L9", m_local_regs[9]).mask(0xffffffff);
-	state_add(E132XS_L10,     "L10", m_local_regs[10]).mask(0xffffffff);
-	state_add(E132XS_L11,     "L11", m_local_regs[11]).mask(0xffffffff);
-	state_add(E132XS_L12,     "L12", m_local_regs[12]).mask(0xffffffff);
-	state_add(E132XS_L13,     "L13", m_local_regs[13]).mask(0xffffffff);
-	state_add(E132XS_L14,     "L14", m_local_regs[14]).mask(0xffffffff);
-	state_add(E132XS_L15,     "L15", m_local_regs[15]).mask(0xffffffff);
-	state_add(E132XS_L16,     "L16", m_local_regs[16]).mask(0xffffffff);
-	state_add(E132XS_L17,     "L17", m_local_regs[17]).mask(0xffffffff);
-	state_add(E132XS_L18,     "L18", m_local_regs[18]).mask(0xffffffff);
-	state_add(E132XS_L19,     "L19", m_local_regs[19]).mask(0xffffffff);
-	state_add(E132XS_L20,     "L20", m_local_regs[20]).mask(0xffffffff);
-	state_add(E132XS_L21,     "L21", m_local_regs[21]).mask(0xffffffff);
-	state_add(E132XS_L22,     "L22", m_local_regs[22]).mask(0xffffffff);
-	state_add(E132XS_L23,     "L23", m_local_regs[23]).mask(0xffffffff);
-	state_add(E132XS_L24,     "L24", m_local_regs[24]).mask(0xffffffff);
-	state_add(E132XS_L25,     "L25", m_local_regs[25]).mask(0xffffffff);
-	state_add(E132XS_L26,     "L26", m_local_regs[26]).mask(0xffffffff);
-	state_add(E132XS_L27,     "L27", m_local_regs[27]).mask(0xffffffff);
-	state_add(E132XS_L28,     "L28", m_local_regs[28]).mask(0xffffffff);
-	state_add(E132XS_L29,     "L29", m_local_regs[29]).mask(0xffffffff);
-	state_add(E132XS_L30,     "L30", m_local_regs[30]).mask(0xffffffff);
-	state_add(E132XS_L31,     "L31", m_local_regs[31]).mask(0xffffffff);
-	state_add(E132XS_L32,     "L32", m_local_regs[32]).mask(0xffffffff);
-	state_add(E132XS_L33,     "L33", m_local_regs[33]).mask(0xffffffff);
-	state_add(E132XS_L34,     "L34", m_local_regs[34]).mask(0xffffffff);
-	state_add(E132XS_L35,     "L35", m_local_regs[35]).mask(0xffffffff);
-	state_add(E132XS_L36,     "L36", m_local_regs[36]).mask(0xffffffff);
-	state_add(E132XS_L37,     "L37", m_local_regs[37]).mask(0xffffffff);
-	state_add(E132XS_L38,     "L38", m_local_regs[38]).mask(0xffffffff);
-	state_add(E132XS_L39,     "L39", m_local_regs[39]).mask(0xffffffff);
-	state_add(E132XS_L40,     "L40", m_local_regs[40]).mask(0xffffffff);
-	state_add(E132XS_L41,     "L41", m_local_regs[41]).mask(0xffffffff);
-	state_add(E132XS_L42,     "L42", m_local_regs[42]).mask(0xffffffff);
-	state_add(E132XS_L43,     "L43", m_local_regs[43]).mask(0xffffffff);
-	state_add(E132XS_L44,     "L44", m_local_regs[44]).mask(0xffffffff);
-	state_add(E132XS_L45,     "L45", m_local_regs[45]).mask(0xffffffff);
-	state_add(E132XS_L46,     "L46", m_local_regs[46]).mask(0xffffffff);
-	state_add(E132XS_L47,     "L47", m_local_regs[47]).mask(0xffffffff);
-	state_add(E132XS_L48,     "L48", m_local_regs[48]).mask(0xffffffff);
-	state_add(E132XS_L49,     "L49", m_local_regs[49]).mask(0xffffffff);
-	state_add(E132XS_L50,     "L50", m_local_regs[50]).mask(0xffffffff);
-	state_add(E132XS_L51,     "L51", m_local_regs[51]).mask(0xffffffff);
-	state_add(E132XS_L52,     "L52", m_local_regs[52]).mask(0xffffffff);
-	state_add(E132XS_L53,     "L53", m_local_regs[53]).mask(0xffffffff);
-	state_add(E132XS_L54,     "L54", m_local_regs[54]).mask(0xffffffff);
-	state_add(E132XS_L55,     "L55", m_local_regs[55]).mask(0xffffffff);
-	state_add(E132XS_L56,     "L56", m_local_regs[56]).mask(0xffffffff);
-	state_add(E132XS_L57,     "L57", m_local_regs[57]).mask(0xffffffff);
-	state_add(E132XS_L58,     "L58", m_local_regs[58]).mask(0xffffffff);
-	state_add(E132XS_L59,     "L59", m_local_regs[59]).mask(0xffffffff);
-	state_add(E132XS_L60,     "L60", m_local_regs[60]).mask(0xffffffff);
-	state_add(E132XS_L61,     "L61", m_local_regs[61]).mask(0xffffffff);
-	state_add(E132XS_L62,     "L62", m_local_regs[62]).mask(0xffffffff);
-	state_add(E132XS_L63,     "L63", m_local_regs[63]).mask(0xffffffff);
+	state_add(STATE_GENPC,    "GENPC",     m_core->global_regs[0]).noshow();
+	state_add(STATE_GENPCBASE, "CURPC",    m_core->global_regs[0]).noshow();
+	state_add(STATE_GENFLAGS, "GENFLAGS",  m_core->global_regs[1]).callimport().callexport().formatstr("%40s").noshow();
+	state_add(E132XS_PC,      "PC", m_core->global_regs[0]).mask(0xffffffff);
+	state_add(E132XS_SR,      "SR", m_core->global_regs[1]).mask(0xffffffff);
+	state_add(E132XS_FER,     "FER", m_core->global_regs[2]).mask(0xffffffff);
+	state_add(E132XS_G3,      "G3", m_core->global_regs[3]).mask(0xffffffff);
+	state_add(E132XS_G4,      "G4", m_core->global_regs[4]).mask(0xffffffff);
+	state_add(E132XS_G5,      "G5", m_core->global_regs[5]).mask(0xffffffff);
+	state_add(E132XS_G6,      "G6", m_core->global_regs[6]).mask(0xffffffff);
+	state_add(E132XS_G7,      "G7", m_core->global_regs[7]).mask(0xffffffff);
+	state_add(E132XS_G8,      "G8", m_core->global_regs[8]).mask(0xffffffff);
+	state_add(E132XS_G9,      "G9", m_core->global_regs[9]).mask(0xffffffff);
+	state_add(E132XS_G10,     "G10", m_core->global_regs[10]).mask(0xffffffff);
+	state_add(E132XS_G11,     "G11", m_core->global_regs[11]).mask(0xffffffff);
+	state_add(E132XS_G12,     "G12", m_core->global_regs[12]).mask(0xffffffff);
+	state_add(E132XS_G13,     "G13", m_core->global_regs[13]).mask(0xffffffff);
+	state_add(E132XS_G14,     "G14", m_core->global_regs[14]).mask(0xffffffff);
+	state_add(E132XS_G15,     "G15", m_core->global_regs[15]).mask(0xffffffff);
+	state_add(E132XS_G16,     "G16", m_core->global_regs[16]).mask(0xffffffff);
+	state_add(E132XS_G17,     "G17", m_core->global_regs[17]).mask(0xffffffff);
+	state_add(E132XS_SP,      "SP", m_core->global_regs[18]).mask(0xffffffff);
+	state_add(E132XS_UB,      "UB", m_core->global_regs[19]).mask(0xffffffff);
+	state_add(E132XS_BCR,     "BCR", m_core->global_regs[20]).mask(0xffffffff);
+	state_add(E132XS_TPR,     "TPR", m_core->global_regs[21]).mask(0xffffffff);
+	state_add(E132XS_TCR,     "TCR", m_core->global_regs[22]).mask(0xffffffff);
+	state_add(E132XS_TR,      "TR", m_core->global_regs[23]).mask(0xffffffff);
+	state_add(E132XS_WCR,     "WCR", m_core->global_regs[24]).mask(0xffffffff);
+	state_add(E132XS_ISR,     "ISR", m_core->global_regs[25]).mask(0xffffffff);
+	state_add(E132XS_FCR,     "FCR", m_core->global_regs[26]).mask(0xffffffff);
+	state_add(E132XS_MCR,     "MCR", m_core->global_regs[27]).mask(0xffffffff);
+	state_add(E132XS_G28,     "G28", m_core->global_regs[28]).mask(0xffffffff);
+	state_add(E132XS_G29,     "G29", m_core->global_regs[29]).mask(0xffffffff);
+	state_add(E132XS_G30,     "G30", m_core->global_regs[30]).mask(0xffffffff);
+	state_add(E132XS_G31,     "G31", m_core->global_regs[31]).mask(0xffffffff);
+	state_add(E132XS_CL0,     "CL0", m_core->local_regs[(0 + GET_FP) % 64]).mask(0xffffffff);
+	state_add(E132XS_CL1,     "CL1", m_core->local_regs[(1 + GET_FP) % 64]).mask(0xffffffff);
+	state_add(E132XS_CL2,     "CL2", m_core->local_regs[(2 + GET_FP) % 64]).mask(0xffffffff);
+	state_add(E132XS_CL3,     "CL3", m_core->local_regs[(3 + GET_FP) % 64]).mask(0xffffffff);
+	state_add(E132XS_CL4,     "CL4", m_core->local_regs[(4 + GET_FP) % 64]).mask(0xffffffff);
+	state_add(E132XS_CL5,     "CL5", m_core->local_regs[(5 + GET_FP) % 64]).mask(0xffffffff);
+	state_add(E132XS_CL6,     "CL6", m_core->local_regs[(6 + GET_FP) % 64]).mask(0xffffffff);
+	state_add(E132XS_CL7,     "CL7", m_core->local_regs[(7 + GET_FP) % 64]).mask(0xffffffff);
+	state_add(E132XS_CL8,     "CL8", m_core->local_regs[(8 + GET_FP) % 64]).mask(0xffffffff);
+	state_add(E132XS_CL9,     "CL9", m_core->local_regs[(9 + GET_FP) % 64]).mask(0xffffffff);
+	state_add(E132XS_CL10,    "CL10", m_core->local_regs[(10 + GET_FP) % 64]).mask(0xffffffff);
+	state_add(E132XS_CL11,    "CL11", m_core->local_regs[(11 + GET_FP) % 64]).mask(0xffffffff);
+	state_add(E132XS_CL12,    "CL12", m_core->local_regs[(12 + GET_FP) % 64]).mask(0xffffffff);
+	state_add(E132XS_CL13,    "CL13", m_core->local_regs[(13 + GET_FP) % 64]).mask(0xffffffff);
+	state_add(E132XS_CL14,    "CL14", m_core->local_regs[(14 + GET_FP) % 64]).mask(0xffffffff);
+	state_add(E132XS_CL15,    "CL15", m_core->local_regs[(15 + GET_FP) % 64]).mask(0xffffffff);
+	state_add(E132XS_L0,      "L0", m_core->local_regs[0]).mask(0xffffffff);
+	state_add(E132XS_L1,      "L1", m_core->local_regs[1]).mask(0xffffffff);
+	state_add(E132XS_L2,      "L2", m_core->local_regs[2]).mask(0xffffffff);
+	state_add(E132XS_L3,      "L3", m_core->local_regs[3]).mask(0xffffffff);
+	state_add(E132XS_L4,      "L4", m_core->local_regs[4]).mask(0xffffffff);
+	state_add(E132XS_L5,      "L5", m_core->local_regs[5]).mask(0xffffffff);
+	state_add(E132XS_L6,      "L6", m_core->local_regs[6]).mask(0xffffffff);
+	state_add(E132XS_L7,      "L7", m_core->local_regs[7]).mask(0xffffffff);
+	state_add(E132XS_L8,      "L8", m_core->local_regs[8]).mask(0xffffffff);
+	state_add(E132XS_L9,      "L9", m_core->local_regs[9]).mask(0xffffffff);
+	state_add(E132XS_L10,     "L10", m_core->local_regs[10]).mask(0xffffffff);
+	state_add(E132XS_L11,     "L11", m_core->local_regs[11]).mask(0xffffffff);
+	state_add(E132XS_L12,     "L12", m_core->local_regs[12]).mask(0xffffffff);
+	state_add(E132XS_L13,     "L13", m_core->local_regs[13]).mask(0xffffffff);
+	state_add(E132XS_L14,     "L14", m_core->local_regs[14]).mask(0xffffffff);
+	state_add(E132XS_L15,     "L15", m_core->local_regs[15]).mask(0xffffffff);
+	state_add(E132XS_L16,     "L16", m_core->local_regs[16]).mask(0xffffffff);
+	state_add(E132XS_L17,     "L17", m_core->local_regs[17]).mask(0xffffffff);
+	state_add(E132XS_L18,     "L18", m_core->local_regs[18]).mask(0xffffffff);
+	state_add(E132XS_L19,     "L19", m_core->local_regs[19]).mask(0xffffffff);
+	state_add(E132XS_L20,     "L20", m_core->local_regs[20]).mask(0xffffffff);
+	state_add(E132XS_L21,     "L21", m_core->local_regs[21]).mask(0xffffffff);
+	state_add(E132XS_L22,     "L22", m_core->local_regs[22]).mask(0xffffffff);
+	state_add(E132XS_L23,     "L23", m_core->local_regs[23]).mask(0xffffffff);
+	state_add(E132XS_L24,     "L24", m_core->local_regs[24]).mask(0xffffffff);
+	state_add(E132XS_L25,     "L25", m_core->local_regs[25]).mask(0xffffffff);
+	state_add(E132XS_L26,     "L26", m_core->local_regs[26]).mask(0xffffffff);
+	state_add(E132XS_L27,     "L27", m_core->local_regs[27]).mask(0xffffffff);
+	state_add(E132XS_L28,     "L28", m_core->local_regs[28]).mask(0xffffffff);
+	state_add(E132XS_L29,     "L29", m_core->local_regs[29]).mask(0xffffffff);
+	state_add(E132XS_L30,     "L30", m_core->local_regs[30]).mask(0xffffffff);
+	state_add(E132XS_L31,     "L31", m_core->local_regs[31]).mask(0xffffffff);
+	state_add(E132XS_L32,     "L32", m_core->local_regs[32]).mask(0xffffffff);
+	state_add(E132XS_L33,     "L33", m_core->local_regs[33]).mask(0xffffffff);
+	state_add(E132XS_L34,     "L34", m_core->local_regs[34]).mask(0xffffffff);
+	state_add(E132XS_L35,     "L35", m_core->local_regs[35]).mask(0xffffffff);
+	state_add(E132XS_L36,     "L36", m_core->local_regs[36]).mask(0xffffffff);
+	state_add(E132XS_L37,     "L37", m_core->local_regs[37]).mask(0xffffffff);
+	state_add(E132XS_L38,     "L38", m_core->local_regs[38]).mask(0xffffffff);
+	state_add(E132XS_L39,     "L39", m_core->local_regs[39]).mask(0xffffffff);
+	state_add(E132XS_L40,     "L40", m_core->local_regs[40]).mask(0xffffffff);
+	state_add(E132XS_L41,     "L41", m_core->local_regs[41]).mask(0xffffffff);
+	state_add(E132XS_L42,     "L42", m_core->local_regs[42]).mask(0xffffffff);
+	state_add(E132XS_L43,     "L43", m_core->local_regs[43]).mask(0xffffffff);
+	state_add(E132XS_L44,     "L44", m_core->local_regs[44]).mask(0xffffffff);
+	state_add(E132XS_L45,     "L45", m_core->local_regs[45]).mask(0xffffffff);
+	state_add(E132XS_L46,     "L46", m_core->local_regs[46]).mask(0xffffffff);
+	state_add(E132XS_L47,     "L47", m_core->local_regs[47]).mask(0xffffffff);
+	state_add(E132XS_L48,     "L48", m_core->local_regs[48]).mask(0xffffffff);
+	state_add(E132XS_L49,     "L49", m_core->local_regs[49]).mask(0xffffffff);
+	state_add(E132XS_L50,     "L50", m_core->local_regs[50]).mask(0xffffffff);
+	state_add(E132XS_L51,     "L51", m_core->local_regs[51]).mask(0xffffffff);
+	state_add(E132XS_L52,     "L52", m_core->local_regs[52]).mask(0xffffffff);
+	state_add(E132XS_L53,     "L53", m_core->local_regs[53]).mask(0xffffffff);
+	state_add(E132XS_L54,     "L54", m_core->local_regs[54]).mask(0xffffffff);
+	state_add(E132XS_L55,     "L55", m_core->local_regs[55]).mask(0xffffffff);
+	state_add(E132XS_L56,     "L56", m_core->local_regs[56]).mask(0xffffffff);
+	state_add(E132XS_L57,     "L57", m_core->local_regs[57]).mask(0xffffffff);
+	state_add(E132XS_L58,     "L58", m_core->local_regs[58]).mask(0xffffffff);
+	state_add(E132XS_L59,     "L59", m_core->local_regs[59]).mask(0xffffffff);
+	state_add(E132XS_L60,     "L60", m_core->local_regs[60]).mask(0xffffffff);
+	state_add(E132XS_L61,     "L61", m_core->local_regs[61]).mask(0xffffffff);
+	state_add(E132XS_L62,     "L62", m_core->local_regs[62]).mask(0xffffffff);
+	state_add(E132XS_L63,     "L63", m_core->local_regs[63]).mask(0xffffffff);
 
-	save_item(NAME(m_global_regs));
-	save_item(NAME(m_local_regs));
-	save_item(NAME(m_trap_entry));
-	save_item(NAME(m_delay_pc));
+	save_item(NAME(m_core->global_regs));
+	save_item(NAME(m_core->local_regs));
+	save_item(NAME(m_core->trap_entry));
+	save_item(NAME(m_core->delay_pc));
 	save_item(NAME(m_instruction_length));
-	save_item(NAME(m_intblock));
-	save_item(NAME(m_delay_slot));
-	save_item(NAME(m_delay_slot_taken));
-	save_item(NAME(m_tr_clocks_per_tick));
-	save_item(NAME(m_tr_base_value));
-	save_item(NAME(m_tr_base_cycles));
-	save_item(NAME(m_timer_int_pending));
-	save_item(NAME(m_clck_scale));
-	save_item(NAME(m_clock_scale_mask));
-	save_item(NAME(m_clock_cycles_1));
-	save_item(NAME(m_clock_cycles_2));
-	save_item(NAME(m_clock_cycles_3));
-	save_item(NAME(m_clock_cycles_4));
-	save_item(NAME(m_clock_cycles_6));
-	save_item(NAME(m_clock_cycles_36));
+	save_item(NAME(m_core->intblock));
+	save_item(NAME(m_core->delay_slot));
+	save_item(NAME(m_core->delay_slot_taken));
+	save_item(NAME(m_core->tr_clocks_per_tick));
+	save_item(NAME(m_core->tr_base_value));
+	save_item(NAME(m_core->tr_base_cycles));
+	save_item(NAME(m_core->timer_int_pending));
+	save_item(NAME(m_core->clck_scale));
+	save_item(NAME(m_core->clock_scale_mask));
+	save_item(NAME(m_core->clock_cycles_1));
+	save_item(NAME(m_core->clock_cycles_2));
+	save_item(NAME(m_core->clock_cycles_3));
+	save_item(NAME(m_core->clock_cycles_4));
+	save_item(NAME(m_core->clock_cycles_6));
+	save_item(NAME(m_core->clock_cycles_36));
 
 	// set our instruction counter
-	m_icountptr = &m_icount;
+	m_icountptr = &m_core->icount;
 }
 
 void e116t_device::device_start()
 {
 	init(0);
-	m_opcodexor = 0;
+	m_core->opcodexor = 0;
 }
 
 void e116xt_device::device_start()
 {
 	init(3);
-	m_opcodexor = 0;
+	m_core->opcodexor = 0;
 }
 
 void e116xs_device::device_start()
 {
 	init(7);
-	m_opcodexor = 0;
+	m_core->opcodexor = 0;
 }
 
 void e116xsr_device::device_start()
 {
 	init(7);
-	m_opcodexor = 0;
+	m_core->opcodexor = 0;
 }
 
 void gms30c2116_device::device_start()
 {
 	init(0);
-	m_opcodexor = 0;
+	m_core->opcodexor = 0;
 }
 
 void gms30c2216_device::device_start()
 {
 	init(0);
-	m_opcodexor = 0;
+	m_core->opcodexor = 0;
 }
 
 void e132n_device::device_start()
 {
 	init(0);
-	m_opcodexor = WORD_XOR_BE(0);
+	m_core->opcodexor = WORD_XOR_BE(0);
 }
 
 void e132t_device::device_start()
 {
 	init(0);
-	m_opcodexor = WORD_XOR_BE(0);
+	m_core->opcodexor = WORD_XOR_BE(0);
 }
 
 void e132xn_device::device_start()
 {
 	init(3);
-	m_opcodexor = WORD_XOR_BE(0);
+	m_core->opcodexor = WORD_XOR_BE(0);
 }
 
 void e132xt_device::device_start()
 {
 	init(3);
-	m_opcodexor = WORD_XOR_BE(0);
+	m_core->opcodexor = WORD_XOR_BE(0);
 }
 
 void e132xs_device::device_start()
 {
 	init(7);
-	m_opcodexor = WORD_XOR_BE(0);
+	m_core->opcodexor = WORD_XOR_BE(0);
 }
 
 void e132xsr_device::device_start()
 {
 	init(7);
-	m_opcodexor = WORD_XOR_BE(0);
+	m_core->opcodexor = WORD_XOR_BE(0);
 }
 
 void gms30c2132_device::device_start()
 {
 	init(0);
-	m_opcodexor = WORD_XOR_BE(0);
+	m_core->opcodexor = WORD_XOR_BE(0);
 }
 
 void gms30c2232_device::device_start()
 {
 	init(0);
-	m_opcodexor = WORD_XOR_BE(0);
+	m_core->opcodexor = WORD_XOR_BE(0);
 }
 
 void hyperstone_device::device_reset()
@@ -1410,9 +1394,9 @@ void hyperstone_device::device_reset()
 	m_direct = m_program->direct<0>();
 	m_io = &space(AS_IO);
 
-	m_tr_clocks_per_tick = 2;
+	m_core->tr_clocks_per_tick = 2;
 
-	m_trap_entry = s_trap_entries[E132XS_ENTRY_MEM3]; // default entry point @ MEM3
+	m_core->trap_entry = s_trap_entries[E132XS_ENTRY_MEM3]; // default entry point @ MEM3
 
 	set_global_register(BCR_REGISTER, ~0);
 	set_global_register(MCR_REGISTER, ~0);
@@ -1433,7 +1417,7 @@ void hyperstone_device::device_reset()
 	set_local_register(0, (PC & 0xfffffffe) | GET_S);
 	set_local_register(1, SR);
 
-	m_icount -= m_clock_cycles_2;
+	m_core->icount -= m_core->clock_cycles_2;
 }
 
 void hyperstone_device::device_stop()
@@ -1510,7 +1494,7 @@ void hyperstone_device::state_string_export(const device_state_entry &entry, std
 				GET_T ? 'T':'.',
 				GET_L ? 'L':'.',
 				GET_I ? 'I':'.',
-				m_global_regs[1] & 0x00040 ? '?':'.',
+				m_core->global_regs[1] & 0x00040 ? '?':'.',
 				GET_H ? 'H':'.',
 				GET_M ? 'M':'.',
 				GET_V ? 'V':'.',
@@ -1551,7 +1535,7 @@ bool hyperstone_device::get_h() const
 
 void hyperstone_device::hyperstone_trap()
 {
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 
 	static const uint32_t conditions[16] = {
 		0, 0, 0, 0, N_MASK | Z_MASK, N_MASK | Z_MASK, N_MASK, N_MASK, C_MASK | Z_MASK, C_MASK | Z_MASK, C_MASK, C_MASK, Z_MASK, Z_MASK, V_MASK, 0
@@ -1649,15 +1633,15 @@ void hyperstone_device::execute_run()
 		return;
 	}
 
-	if (m_intblock < 0)
-		m_intblock = 0;
+	if (m_core->intblock < 0)
+		m_core->intblock = 0;
 
-	if (m_timer_int_pending)
+	if (m_core->timer_int_pending)
 		check_interrupts<IS_TIMER>();
 	else
 		check_interrupts<NO_TIMER>();
 
-	while (m_icount > 0)
+	while (m_core->icount > 0)
 	{
 #if E132XS_LOG_INTERPRETER_REGS
 		dump_registers();
@@ -1935,16 +1919,16 @@ void hyperstone_device::execute_run()
 
 		SET_ILC(m_instruction_length);
 
-		if (GET_T && GET_P && !m_delay_slot) /* Not in a Delayed Branch instructions */
+		if (GET_T && GET_P && !m_core->delay_slot) /* Not in a Delayed Branch instructions */
 		{
 			uint32_t addr = get_trap_addr(TRAPNO_TRACE_EXCEPTION);
 			execute_exception(addr);
 		}
 
-		if (--m_intblock <= 0)
+		if (--m_core->intblock <= 0)
 		{
-			m_intblock = 0;
-			if (m_timer_int_pending)
+			m_core->intblock = 0;
+			if (m_core->timer_int_pending)
 				check_interrupts<IS_TIMER>();
 			else
 				check_interrupts<NO_TIMER>();
diff --git a/src/devices/cpu/e132xs/e132xs.h b/src/devices/cpu/e132xs/e132xs.h
index f2e73fc72c3..08ca7548308 100644
--- a/src/devices/cpu/e132xs/e132xs.h
+++ b/src/devices/cpu/e132xs/e132xs.h
@@ -139,6 +139,45 @@ public:
 	void adjust_timer_interrupt();
 
 protected:
+	struct internal_hyperstone_state
+	{
+		// CPU registers
+		uint32_t  global_regs[32];
+		uint32_t  local_regs[64];
+		uint8_t   fl_lut[16];
+
+		/* internal stuff */
+		uint32_t  trap_entry;   // entry point to get trap address
+
+		uint8_t   clock_scale_mask;
+		uint8_t   clck_scale;
+		uint32_t  clock_cycles_1;
+		uint32_t  clock_cycles_2;
+		uint32_t  clock_cycles_3;
+		uint32_t  clock_cycles_4;
+		uint32_t  clock_cycles_6;
+		uint32_t  clock_cycles_36;
+
+		uint64_t  tr_base_cycles;
+		uint32_t  tr_base_value;
+		uint32_t  tr_result;
+		uint32_t  tr_clocks_per_tick;
+		uint32_t  timer_int_pending;
+
+		uint64_t  numcycles;
+
+		uint32_t  delay_pc;
+		uint32_t  delay_slot;
+		uint32_t  delay_slot_taken;
+
+		uint32_t  opcodexor;
+
+		int32_t   intblock;
+
+		// other internal state
+		int       icount;
+	};
+
 	enum reg_bank
 	{
 		LOCAL = 0,
@@ -251,46 +290,15 @@ protected:
 	direct_read_data<0> *m_direct;
 	address_space *m_io;
 
-	// CPU registers
-	uint32_t  m_global_regs[32];
-	uint32_t  m_local_regs[64];
-
-	/* internal stuff */
 	uint16_t  m_op;           // opcode
-	uint32_t  m_trap_entry;   // entry point to get trap address
 
-	uint8_t   m_clock_scale_mask;
-	uint8_t   m_clck_scale;
-	uint32_t   m_clock_cycles_1;
-	uint32_t   m_clock_cycles_2;
-	uint32_t   m_clock_cycles_3;
-	uint32_t   m_clock_cycles_4;
-	uint32_t   m_clock_cycles_6;
-	uint32_t   m_clock_cycles_36;
+	/* core state */
+	internal_hyperstone_state *m_core;
+
+	int32_t   m_instruction_length;
 
-	uint64_t  m_tr_base_cycles;
-	uint32_t  m_tr_base_value;
-	uint32_t  m_tr_result;
-	uint32_t  m_tr_clocks_per_tick;
-	uint32_t  m_timer_int_pending;
 	emu_timer *m_timer;
 
-	uint64_t m_numcycles;
-
-	uint32_t m_prev_pc;
-	uint32_t m_delay_pc;
-	uint32_t m_delay_slot;
-	uint32_t m_delay_slot_taken;
-
-	uint32_t m_opcodexor;
-
-	int32_t m_instruction_length;
-	int32_t m_intblock;
-
-	// other internal state
-	int     m_icount;
-
-	uint8_t m_fl_lut[16];
 	static const uint32_t s_trap_entries[8];
 	static const int32_t s_immediate_values[16];
 
diff --git a/src/devices/cpu/e132xs/e132xsdrc.cpp b/src/devices/cpu/e132xs/e132xsdrc.cpp
index 6796311d3cc..6fba028205c 100644
--- a/src/devices/cpu/e132xs/e132xsdrc.cpp
+++ b/src/devices/cpu/e132xs/e132xsdrc.cpp
@@ -8,8 +8,8 @@
 
 using namespace uml;
 
-#define DRC_PC mem(m_global_regs)
-#define DRC_SR mem(&m_global_regs[1])
+#define DRC_PC mem(m_core->global_regs)
+#define DRC_SR mem(&m_core->global_regs[1])
 
 void hyperstone_device::execute_run_drc()
 {
@@ -33,11 +33,11 @@ void hyperstone_device::execute_run_drc()
 		/* if we need to recompile, do it */
 		if (execute_result == EXECUTE_MISSING_CODE)
 		{
-			code_compile_block(m_global_regs[0]);
+			code_compile_block(m_core->global_regs[0]);
 		}
 		else if (execute_result == EXECUTE_UNMAPPED_CODE)
 		{
-			fatalerror("Attempted to execute unmapped code at PC=%08X\n", m_global_regs[0]);
+			fatalerror("Attempted to execute unmapped code at PC=%08X\n", m_core->global_regs[0]);
 		}
 		else if (execute_result == EXECUTE_RESET_CACHE)
 		{
@@ -117,7 +117,7 @@ static void cfunc_dump_registers(void *param)
 
 void hyperstone_device::ccfunc_total_cycles()
 {
-	m_numcycles = total_cycles();
+	m_core->numcycles = total_cycles();
 }
 
 static void cfunc_total_cycles(void *param)
@@ -198,13 +198,13 @@ void hyperstone_device::generate_get_trap_addr(drcuml_block *block, uml::code_la
 {
 	int no_subtract;
 	UML_MOV(block, I0, trapno);
-	UML_CMP(block, mem(&m_trap_entry), 0xffffff00);
+	UML_CMP(block, mem(&m_core->trap_entry), 0xffffff00);
 	UML_JMPc(block, uml::COND_E, no_subtract = label++);
 	UML_SUB(block, I0, 63, I0);
 
 	UML_LABEL(block, no_subtract);
 	UML_SHL(block, I0, I0, 2);
-	UML_OR(block, I0, I0, mem(&m_trap_entry));
+	UML_OR(block, I0, I0, mem(&m_core->trap_entry));
 }
 
 /*-------------------------------------------------
@@ -370,16 +370,16 @@ void hyperstone_device::static_generate_exception(uint32_t exception, const char
 	UML_AND(block, I1, DRC_PC, ~1);
 	UML_ROLAND(block, I2, DRC_SR, 14, 1);
 	UML_OR(block, I1, I1, I2);
-	UML_STORE(block, (void *)m_local_regs, I3, I1, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I3, I1, SIZE_DWORD, SCALE_x4);
 	UML_ADD(block, I3, I3, 1);
 	UML_AND(block, I3, I3, 0x3f);
-	UML_STORE(block, (void *)m_local_regs, I3, I4, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I3, I4, SIZE_DWORD, SCALE_x4);
 
 	UML_AND(block, DRC_SR, DRC_SR, ~(M_MASK | T_MASK));
 	UML_OR(block, DRC_SR, DRC_SR, (L_MASK | S_MASK));
 
 	UML_MOV(block, DRC_PC, I0);
-	UML_SUB(block, mem(&m_icount), mem(&m_icount), 2);
+	UML_SUB(block, mem(&m_core->icount), mem(&m_core->icount), 2);
 	UML_EXHc(block, uml::COND_S, *m_out_of_cycles, 0);
 
 	UML_HASHJMP(block, 0, I0, *m_nocode);// hashjmp <mode>,i0,nocode
@@ -404,11 +404,11 @@ void hyperstone_device::static_generate_interrupt_checks()
 	int done_int = labelnum++;
 	int int_pending = labelnum++;
 	int timer_int_pending = labelnum++;
-	UML_CMP(block, mem(&m_intblock), 0);
+	UML_CMP(block, mem(&m_core->intblock), 0);
 	UML_JMPc(block, uml::COND_G, done_int);
 	UML_TEST(block, DRC_SR, L_MASK);
 	UML_JMPc(block, uml::COND_NZ, done_int);
-	UML_TEST(block, mem(&m_timer_int_pending), 1);
+	UML_TEST(block, mem(&m_core->timer_int_pending), 1);
 	UML_JMPc(block, uml::COND_NZ, timer_int_pending);
 	UML_TEST(block, mem(&ISR), 0x7f);
 	UML_JMPc(block, uml::COND_NZ, int_pending);
@@ -455,7 +455,7 @@ void hyperstone_device::static_generate_entry_point()
 	//load_fast_iregs(block);
 
 	/* generate a hash jump via the current mode and PC */
-	UML_HASHJMP(block, 0, mem(&m_global_regs[0]), *m_nocode);
+	UML_HASHJMP(block, 0, mem(&m_core->global_regs[0]), *m_nocode);
 	block->end();
 }
 
@@ -662,7 +662,7 @@ void hyperstone_device::generate_interrupt_checks_with_timer(drcuml_block *block
 	int skip_timer_pri6 = labelnum++;
 	UML_CMP(block, I2, 0x3);
 	UML_JMPc(block, uml::COND_NE, skip_timer_pri6);
-	UML_MOV(block, mem(&m_timer_int_pending), 0);
+	UML_MOV(block, mem(&m_core->timer_int_pending), 0);
 	generate_get_trap_addr(block, labelnum, TRAPNO_TIMER);
 	generate_trap_exception_or_int<IS_INT>(block);
 	UML_LABEL(block, skip_timer_pri6);
@@ -681,7 +681,7 @@ void hyperstone_device::generate_interrupt_checks_with_timer(drcuml_block *block
 	int skip_timer_pri8 = labelnum++;
 	UML_CMP(block, I2, 0x2);
 	UML_JMPc(block, uml::COND_NE, skip_timer_pri8);
-	UML_MOV(block, mem(&m_timer_int_pending), 0);
+	UML_MOV(block, mem(&m_core->timer_int_pending), 0);
 	generate_get_trap_addr(block, labelnum, TRAPNO_TIMER);
 	generate_trap_exception_or_int<IS_INT>(block);
 	UML_LABEL(block, skip_timer_pri8);
@@ -700,7 +700,7 @@ void hyperstone_device::generate_interrupt_checks_with_timer(drcuml_block *block
 	int skip_timer_pri10 = labelnum++;
 	UML_CMP(block, I2, 0x1);
 	UML_JMPc(block, uml::COND_NE, skip_timer_pri10);
-	UML_MOV(block, mem(&m_timer_int_pending), 0);
+	UML_MOV(block, mem(&m_core->timer_int_pending), 0);
 	generate_get_trap_addr(block, labelnum, TRAPNO_TIMER);
 	generate_trap_exception_or_int<IS_INT>(block);
 	UML_LABEL(block, skip_timer_pri10);
@@ -719,7 +719,7 @@ void hyperstone_device::generate_interrupt_checks_with_timer(drcuml_block *block
 	int skip_timer_pri12 = labelnum++;
 	UML_CMP(block, I2, 0x0);
 	UML_JMPc(block, uml::COND_NE, skip_timer_pri12);
-	UML_MOV(block, mem(&m_timer_int_pending), 0);
+	UML_MOV(block, mem(&m_core->timer_int_pending), 0);
 	generate_get_trap_addr(block, labelnum, TRAPNO_TIMER);
 	generate_trap_exception_or_int<IS_INT>(block);
 	UML_LABEL(block, skip_timer_pri12);
@@ -770,18 +770,18 @@ void hyperstone_device::generate_update_cycles(drcuml_block *block, bool check_i
 {
 	if (check_interrupts)
 	{
-		UML_SUB(block, mem(&m_intblock), mem(&m_intblock), 1);
-		UML_MOVc(block, uml::COND_S, mem(&m_intblock), 0);
+		UML_SUB(block, mem(&m_core->intblock), mem(&m_core->intblock), 1);
+		UML_MOVc(block, uml::COND_S, mem(&m_core->intblock), 0);
 
 		UML_CALLH(block, *m_interrupt_checks);
 	}
 	else
 	{
-		UML_SUB(block, mem(&m_intblock), mem(&m_intblock), 1);
-		UML_MOVc(block, uml::COND_S, mem(&m_intblock), 0);
+		UML_SUB(block, mem(&m_core->intblock), mem(&m_core->intblock), 1);
+		UML_MOVc(block, uml::COND_S, mem(&m_core->intblock), 0);
 	}
 
-	UML_SUB(block, mem(&m_icount), mem(&m_icount), I7);
+	UML_SUB(block, mem(&m_core->icount), mem(&m_core->icount), I7);
 	UML_EXHc(block, uml::COND_S, *m_out_of_cycles, DRC_PC);
 	UML_EXHc(block, uml::COND_Z, *m_out_of_cycles, DRC_PC);
 	UML_MOV(block, I7, 0);
@@ -806,7 +806,7 @@ void hyperstone_device::generate_checksum_block(drcuml_block *block, compiler_st
 		{
 			uint32_t sum = seqhead->opptr.w[0];
 			uint32_t addr = seqhead->physpc;
-			void *base = m_direct->read_ptr(addr, m_opcodexor);
+			void *base = m_direct->read_ptr(addr, m_core->opcodexor);
 			if (base == nullptr)
 			{
 				printf("m_direct->read_ptr returned nullptr for address %08x\n", addr);
@@ -817,7 +817,7 @@ void hyperstone_device::generate_checksum_block(drcuml_block *block, compiler_st
 			if (seqhead->delay.first() != nullptr && seqhead->physpc != seqhead->delay.first()->physpc)
 			{
 				addr = seqhead->delay.first()->physpc;
-				base = m_direct->read_ptr(addr, m_opcodexor);
+				base = m_direct->read_ptr(addr, m_core->opcodexor);
 				assert(base != nullptr);
 				UML_LOAD(block, I1, base, 0, SIZE_WORD, SCALE_x1);
 				UML_ADD(block, I0, I0, I1);
@@ -832,7 +832,7 @@ void hyperstone_device::generate_checksum_block(drcuml_block *block, compiler_st
 	else /* full verification; sum up everything */
 	{
 		uint32_t addr = seqhead->physpc;
-		void *base = m_direct->read_ptr(addr, m_opcodexor);
+		void *base = m_direct->read_ptr(addr, m_core->opcodexor);
 		if (base == nullptr)
 		{
 			printf("m_direct->read_ptr returned nullptr for address %08x\n", addr);
@@ -844,7 +844,7 @@ void hyperstone_device::generate_checksum_block(drcuml_block *block, compiler_st
 			if (!(curdesc->flags & OPFLAG_VIRTUAL_NOOP))
 			{
 				addr = curdesc->physpc;
-				base = m_direct->read_ptr(addr, m_opcodexor);
+				base = m_direct->read_ptr(addr, m_core->opcodexor);
 				assert(base != nullptr);
 				UML_LOAD(block, I1, base, 0, SIZE_WORD, SCALE_x1);
 				UML_ADD(block, I0, I0, I1);
@@ -853,7 +853,7 @@ void hyperstone_device::generate_checksum_block(drcuml_block *block, compiler_st
 				if (curdesc->delay.first() != nullptr && (curdesc == seqlast || (curdesc->next() != nullptr && curdesc->next()->physpc != curdesc->delay.first()->physpc)))
 				{
 					addr = curdesc->delay.first()->physpc;
-					base = m_direct->read_ptr(addr, m_opcodexor);
+					base = m_direct->read_ptr(addr, m_core->opcodexor);
 					assert(base != nullptr);
 					UML_LOAD(block, I1, base, 0, SIZE_WORD, SCALE_x1);
 					UML_ADD(block, I0, I0, I1);
@@ -1214,9 +1214,9 @@ bool hyperstone_device::generate_opcode(drcuml_block *block, compiler_state *com
 	}
 
 	int no_delay_taken = compiler->m_labelnum++;
-	UML_TEST(block, mem(&m_delay_slot_taken), ~0);
+	UML_TEST(block, mem(&m_core->delay_slot_taken), ~0);
 	UML_JMPc(block, uml::COND_Z, no_delay_taken);
-	UML_MOV(block, mem(&m_delay_slot_taken), 0);
+	UML_MOV(block, mem(&m_core->delay_slot_taken), 0);
 	generate_update_cycles(block);
 	UML_HASHJMP(block, 0, DRC_PC, *m_nocode);
 	UML_LABEL(block, no_delay_taken);
@@ -1225,7 +1225,7 @@ bool hyperstone_device::generate_opcode(drcuml_block *block, compiler_state *com
 	UML_AND(block, I0, DRC_SR, (T_MASK | P_MASK));
 	UML_CMP(block, I0, (T_MASK | P_MASK));
 	UML_JMPc(block, uml::COND_NE, done = compiler->m_labelnum++);
-	UML_TEST(block, mem(&m_delay_slot), 1);
+	UML_TEST(block, mem(&m_core->delay_slot), 1);
 	UML_EXHc(block, uml::COND_E, *m_exception[EXCEPTION_TRACE], 0);
 
 	UML_LABEL(block, done);
diff --git a/src/devices/cpu/e132xs/e132xsdrc_ops.hxx b/src/devices/cpu/e132xs/e132xsdrc_ops.hxx
index 2c427432d2b..f80f1587154 100644
--- a/src/devices/cpu/e132xs/e132xsdrc_ops.hxx
+++ b/src/devices/cpu/e132xs/e132xsdrc_ops.hxx
@@ -8,10 +8,10 @@ constexpr uint32_t WRITE_ONLY_REGMASK = (1 << BCR_REGISTER) | (1 << TPR_REGISTER
 void hyperstone_device::generate_check_delay_pc(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
 	/* if PC is used in a delay instruction, the delayed PC should be used */
-	UML_TEST(block, mem(&m_delay_slot), 1);
-	UML_MOVc(block, uml::COND_NZ, DRC_PC, mem(&m_delay_pc));
-	UML_MOVc(block, uml::COND_NZ, mem(&m_delay_slot), 0);
-	UML_SETc(block, uml::COND_NZ, mem(&m_delay_slot_taken));
+	UML_TEST(block, mem(&m_core->delay_slot), 1);
+	UML_MOVc(block, uml::COND_NZ, DRC_PC, mem(&m_core->delay_pc));
+	UML_MOVc(block, uml::COND_NZ, mem(&m_core->delay_slot), 0);
+	UML_SETc(block, uml::COND_NZ, mem(&m_core->delay_slot_taken));
 }
 
 void hyperstone_device::generate_decode_const(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
@@ -153,17 +153,17 @@ void hyperstone_device::generate_set_global_register(drcuml_block *block, compil
 	UML_LABEL(block, set_sr);
 	UML_ROLINS(block, DRC_SR, I5, 0, 0x0000ffff);
 	UML_AND(block, DRC_SR, DRC_SR, ~0x40);
-	UML_TEST(block, mem(&m_intblock), ~0);
-	UML_MOVc(block, uml::COND_Z, mem(&m_intblock), 1);
+	UML_TEST(block, mem(&m_core->intblock), ~0);
+	UML_MOVc(block, uml::COND_Z, mem(&m_core->intblock), 1);
 	UML_JMP(block, done);
 
 	UML_LABEL(block, generic_store);
-	UML_STORE(block, (void *)m_global_regs, I4, I5, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->global_regs, I4, I5, SIZE_DWORD, SCALE_x4);
 	UML_JMP(block, done);
 
 	int above_bcr;
 	UML_LABEL(block, extended);
-	UML_SUB(block, mem(&m_icount), mem(&m_icount), I7);
+	UML_SUB(block, mem(&m_core->icount), mem(&m_core->icount), I7);
 	UML_MOV(block, I7, 0);
 	UML_CMP(block, I4, 17);
 	UML_JMPc(block, uml::COND_BE, generic_store);
@@ -193,12 +193,12 @@ void hyperstone_device::generate_set_global_register(drcuml_block *block, compil
 	// Set MCR
 	UML_ROLAND(block, I6, I5, 20, 0x7);
 	UML_LOAD(block, I6, (void *)s_trap_entries, I6, SIZE_DWORD, SCALE_x4);
-	UML_MOV(block, mem(&m_trap_entry), I6);
+	UML_MOV(block, mem(&m_core->trap_entry), I6);
 	UML_JMP(block, generic_store);
 
 	int skip_compute_tr;
 	UML_LABEL(block, set_tpr);
-	UML_STORE(block, (void *)m_global_regs, I4, I5, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->global_regs, I4, I5, SIZE_DWORD, SCALE_x4);
 	UML_TEST(block, I5, 0x80000000);
 	UML_JMPc(block, uml::COND_NZ, skip_compute_tr = compiler->m_labelnum++);
 	UML_CALLC(block, cfunc_compute_tr, this);
@@ -208,34 +208,34 @@ void hyperstone_device::generate_set_global_register(drcuml_block *block, compil
 	UML_JMP(block, done);
 
 	UML_LABEL(block, set_tcr);
-	UML_LOAD(block, I6, (void *)m_global_regs, I4, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I6, (void *)m_core->global_regs, I4, SIZE_DWORD, SCALE_x4);
 	UML_CMP(block, I6, I5);
 	UML_JMPc(block, uml::COND_E, done);
-	UML_STORE(block, (void *)m_global_regs, I4, I5, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->global_regs, I4, I5, SIZE_DWORD, SCALE_x4);
 	UML_CALLC(block, cfunc_adjust_timer_interrupt, this);
-	UML_CMP(block, mem(&m_intblock), 1);
-	UML_MOVc(block, uml::COND_L, mem(&m_intblock), 1);
+	UML_CMP(block, mem(&m_core->intblock), 1);
+	UML_MOVc(block, uml::COND_L, mem(&m_core->intblock), 1);
 	UML_JMP(block, done);
 
 	UML_LABEL(block, set_tr);
-	UML_STORE(block, (void *)m_global_regs, I4, I5, SIZE_DWORD, SCALE_x4);
-	UML_MOV(block, mem(&m_tr_base_value), I5);
+	UML_STORE(block, (void *)m_core->global_regs, I4, I5, SIZE_DWORD, SCALE_x4);
+	UML_MOV(block, mem(&m_core->tr_base_value), I5);
 	UML_CALLC(block, cfunc_total_cycles, this);
-	UML_DMOV(block, mem(&m_tr_base_cycles), mem(&m_numcycles));
+	UML_DMOV(block, mem(&m_core->tr_base_cycles), mem(&m_core->numcycles));
 	UML_CALLC(block, cfunc_adjust_timer_interrupt, this);
 	UML_JMP(block, done);
 
 	int skip_adjust_timer;
 	UML_LABEL(block, set_fcr);
-	UML_LOAD(block, I6, (void *)m_global_regs, I4, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I6, (void *)m_core->global_regs, I4, SIZE_DWORD, SCALE_x4);
 	UML_XOR(block, I6, I6, I5);
 	UML_TEST(block, I6, 0x80000000);
 	UML_JMPc(block, uml::COND_Z, skip_adjust_timer = compiler->m_labelnum++);
 	UML_CALLC(block, cfunc_adjust_timer_interrupt, this);
 	UML_LABEL(block, skip_adjust_timer);
-	UML_STORE(block, (void *)m_global_regs, I4, I5, SIZE_DWORD, SCALE_x4);
-	UML_CMP(block, mem(&m_intblock), 1);
-	UML_MOVc(block, uml::COND_L, mem(&m_intblock), 1);
+	UML_STORE(block, (void *)m_core->global_regs, I4, I5, SIZE_DWORD, SCALE_x4);
+	UML_CMP(block, mem(&m_core->intblock), 1);
+	UML_MOVc(block, uml::COND_L, mem(&m_core->intblock), 1);
 	// Fall through to done
 
 	UML_LABEL(block, done);
@@ -244,7 +244,7 @@ void hyperstone_device::generate_set_global_register(drcuml_block *block, compil
 template <hyperstone_device::trap_exception_or_int TYPE>
 void hyperstone_device::generate_trap_exception_or_int(drcuml_block *block)
 {
-	UML_ADD(block, I7, I7, mem(&m_clock_cycles_2));
+	UML_ADD(block, I7, I7, mem(&m_core->clock_cycles_2));
 
 	UML_MOV(block, I4, DRC_SR);
 
@@ -263,10 +263,10 @@ void hyperstone_device::generate_trap_exception_or_int(drcuml_block *block)
 	UML_AND(block, I1, I3, 0x3f);
 	UML_AND(block, I2, DRC_PC, ~1);
 	UML_ROLINS(block, I2, DRC_SR, 32-S_SHIFT, 1);
-	UML_STORE(block, (void *)m_local_regs, I1, I2, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I1, I2, SIZE_DWORD, SCALE_x4);
 	UML_ADD(block, I2, I1, 1);
 	UML_AND(block, I3, I2, 0x3f);
-	UML_STORE(block, (void *)m_local_regs, I3, I4, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I3, I4, SIZE_DWORD, SCALE_x4);
 
 	UML_AND(block, DRC_SR, DRC_SR, ~(M_MASK | T_MASK));
 	if (TYPE == IS_INT)
@@ -294,7 +294,7 @@ void hyperstone_device::generate_exception(drcuml_block *block, compiler_state *
 
 void hyperstone_device::generate_software(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_6));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_6));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -308,17 +308,17 @@ void hyperstone_device::generate_software(drcuml_block *block, compiler_state *c
 
 	UML_ADD(block, I2, I3, src_code);
 	UML_AND(block, I4, I2, 0x3f);
-	UML_LOAD(block, I0, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4); // I0 = sreg
+	UML_LOAD(block, I0, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4); // I0 = sreg
 	UML_ADD(block, I2, I3, srcf_code);
 	UML_AND(block, I4, I2, 0x3f);
-	UML_LOAD(block, I1, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4); // I1 = sregf
+	UML_LOAD(block, I1, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4); // I1 = sregf
 
 	UML_ROLINS(block, DRC_SR, 1, 19, 0x00180000);
 
 	uint32_t num = op >> 8;
 	int mem3 = compiler->m_labelnum++;
 	int have_code_addr = compiler->m_labelnum++;
-	UML_MOV(block, I4, mem(&m_trap_entry));
+	UML_MOV(block, I4, mem(&m_core->trap_entry));
 	UML_CMP(block, I4, 0xffffff00);
 	UML_JMPc(block, uml::COND_E, mem3);
 	UML_OR(block, I5, I4, (0x10c | ((0xcf - num) << 4)));
@@ -343,23 +343,23 @@ void hyperstone_device::generate_software(drcuml_block *block, compiler_state *c
 	UML_ADD(block, I6, I6, I2); // I6 = (SP & ~0xff) + 0x100 + (((fp + DST_CODE) & 0x3f) << 2)
 
 	UML_AND(block, I2, I4, 0x3f);
-	UML_STORE(block, (void *)m_local_regs, I2, I6, SIZE_DWORD, SCALE_x4); // m_local_regs[(reg + 0) & 0x3f] = stack_of_dst;
+	UML_STORE(block, (void *)m_core->local_regs, I2, I6, SIZE_DWORD, SCALE_x4); // m_core->local_regs[(reg + 0) & 0x3f] = stack_of_dst;
 	UML_ADD(block, I6, I2, 1);
 	UML_AND(block, I2, I6, 0x3f);
-	UML_STORE(block, (void *)m_local_regs, I2, I0, SIZE_DWORD, SCALE_x4); // m_local_regs[(reg + 1) & 0x3f] = sreg;
+	UML_STORE(block, (void *)m_core->local_regs, I2, I0, SIZE_DWORD, SCALE_x4); // m_core->local_regs[(reg + 1) & 0x3f] = sreg;
 	UML_ADD(block, I6, I2, 1);
 	UML_AND(block, I2, I6, 0x3f);
-	UML_STORE(block, (void *)m_local_regs, I2, I1, SIZE_DWORD, SCALE_x4); // m_local_regs[(reg + 2) & 0x3f] = sregf;
+	UML_STORE(block, (void *)m_core->local_regs, I2, I1, SIZE_DWORD, SCALE_x4); // m_core->local_regs[(reg + 2) & 0x3f] = sregf;
 
 	UML_AND(block, I0, DRC_PC, ~1);
 	UML_ROLINS(block, I0, DRC_SR, 32-S_SHIFT, 1);
 	UML_ADD(block, I6, I2, 1);
 	UML_AND(block, I2, I6, 0x3f);
-	UML_STORE(block, (void *)m_local_regs, I2, I0, SIZE_DWORD, SCALE_x4); // m_local_regs[(reg + 3) & 0x3f] = (PC & ~1) | GET_S;
+	UML_STORE(block, (void *)m_core->local_regs, I2, I0, SIZE_DWORD, SCALE_x4); // m_core->local_regs[(reg + 3) & 0x3f] = (PC & ~1) | GET_S;
 
 	UML_ADD(block, I6, I2, 1);
 	UML_AND(block, I2, I6, 0x3f);
-	UML_STORE(block, (void *)m_local_regs, I2, DRC_SR, SIZE_DWORD, SCALE_x4); // m_local_regs[(reg + 4) & 0x3f] = oldSR;
+	UML_STORE(block, (void *)m_core->local_regs, I2, DRC_SR, SIZE_DWORD, SCALE_x4); // m_core->local_regs[(reg + 4) & 0x3f] = oldSR;
 
 	UML_MOV(block, DRC_PC, I5); // PC = addr
 
@@ -375,7 +375,7 @@ void hyperstone_device::generate_software(drcuml_block *block, compiler_state *c
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_chk(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -389,13 +389,13 @@ void hyperstone_device::generate_chk(drcuml_block *block, compiler_state *compil
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I1, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 	if (SRC_GLOBAL)
@@ -407,7 +407,7 @@ void hyperstone_device::generate_chk(drcuml_block *block, compiler_state *compil
 		}
 		else
 		{
-			UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 			UML_CMP(block, I1, I0);
 			if (src_code == PC_REGISTER)
 				UML_EXHc(block, uml::COND_AE, *m_exception[EXCEPTION_RANGE_ERROR], 0);
@@ -419,7 +419,7 @@ void hyperstone_device::generate_chk(drcuml_block *block, compiler_state *compil
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 
 		UML_CMP(block, I1, I0);
 		UML_EXHc(block, uml::COND_A, *m_exception[EXCEPTION_RANGE_ERROR], 0);
@@ -430,7 +430,7 @@ void hyperstone_device::generate_chk(drcuml_block *block, compiler_state *compil
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_movd(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_2));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -452,19 +452,19 @@ void hyperstone_device::generate_movd(drcuml_block *block, compiler_state *compi
 		UML_AND(block, I1, DRC_SR, (S_MASK | L_MASK));
 		if (SRC_GLOBAL)
 		{
-			UML_LOAD(block, I2, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
-			UML_LOAD(block, I3, (void *)m_global_regs, srcf_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I2, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I3, (void *)m_core->global_regs, srcf_code, SIZE_DWORD, SCALE_x4);
 		}
 		else
 		{
 			UML_ROLAND(block, I5, DRC_SR, 7, 0x7f);
 			UML_ADD(block, I3, I5, src_code);
 			UML_AND(block, I4, I3, 0x3f);
-			UML_LOAD(block, I2, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I2, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 
 			UML_ADD(block, I6, I5, srcf_code);
 			UML_AND(block, I5, I6, 0x3f);
-			UML_LOAD(block, I3, (void *)m_local_regs, I5, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I3, (void *)m_core->local_regs, I5, SIZE_DWORD, SCALE_x4);
 		}
 
 		UML_AND(block, DRC_PC, I2, ~1);
@@ -473,8 +473,8 @@ void hyperstone_device::generate_movd(drcuml_block *block, compiler_state *compi
 		UML_ROLINS(block, DRC_SR, I2, S_SHIFT, S_MASK);
 		UML_ROLINS(block, DRC_SR, (1<<19), 0, ILC_MASK);
 
-		UML_TEST(block, mem(&m_intblock), ~0);
-		UML_MOVc(block, uml::COND_Z, mem(&m_intblock), 1);
+		UML_TEST(block, mem(&m_core->intblock), ~0);
+		UML_MOVc(block, uml::COND_Z, mem(&m_core->intblock), 1);
 
 		int no_exception;
 		UML_AND(block, I2, DRC_SR, (S_MASK | L_MASK));
@@ -515,7 +515,7 @@ void hyperstone_device::generate_movd(drcuml_block *block, compiler_state *compi
 		UML_SUB(block, I0, I0, 4);
 		UML_CALLH(block, *m_mem_read32);
 		UML_ROLAND(block, I2, I0, 30, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
 		UML_ADD(block, I3, I3, 1);
 		UML_TEST(block, I3, ~0);
 		UML_JMP(block, pop_next);
@@ -545,10 +545,10 @@ void hyperstone_device::generate_movd(drcuml_block *block, compiler_state *compi
 			UML_ROLAND(block, I0, DRC_SR, 7, 0x7f);
 			UML_ADD(block, I0, I0, dst_code);
 			UML_AND(block, I0, I0, 0x3f);
-			UML_STORE(block, (void *)m_local_regs, I0, 0, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->local_regs, I0, 0, SIZE_DWORD, SCALE_x4);
 			UML_ADD(block, I0, I0, 1);
 			UML_AND(block, I0, I0, 0x3f);
-			UML_STORE(block, (void *)m_local_regs, I0, 0, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->local_regs, I0, 0, SIZE_DWORD, SCALE_x4);
 		}
 	}
 	else // Rd doesn't denote PC and Rs doesn't denote SR
@@ -560,17 +560,17 @@ void hyperstone_device::generate_movd(drcuml_block *block, compiler_state *compi
 
 		if (SRC_GLOBAL)
 		{
-			UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
-			UML_LOAD(block, I1, (void *)m_global_regs, srcf_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I1, (void *)m_core->global_regs, srcf_code, SIZE_DWORD, SCALE_x4);
 		}
 		else
 		{
 			UML_ADD(block, I0, I3, src_code);
 			UML_AND(block, I0, I0, 0x3f);
-			UML_LOAD(block, I0, (void *)m_local_regs, I0, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I0, (void *)m_core->local_regs, I0, SIZE_DWORD, SCALE_x4);
 			UML_ADD(block, I1, I3, srcf_code);
 			UML_AND(block, I1, I1, 0x3f);
-			UML_LOAD(block, I1, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I1, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 		}
 
 		UML_AND(block, DRC_SR, DRC_SR, ~(Z_MASK | N_MASK));
@@ -599,10 +599,10 @@ void hyperstone_device::generate_movd(drcuml_block *block, compiler_state *compi
 		{
 			UML_ADD(block, I2, I3, dst_code);
 			UML_AND(block, I2, I2, 0x3f);
-			UML_STORE(block, (void *)m_local_regs, I2, I0, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->local_regs, I2, I0, SIZE_DWORD, SCALE_x4);
 			UML_ADD(block, I2, I3, dstf_code);
 			UML_AND(block, I2, I2, 0x3f);
-			UML_STORE(block, (void *)m_local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
 		}
 	}
 }
@@ -611,7 +611,7 @@ void hyperstone_device::generate_movd(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL, hyperstone_device::sign_mode SIGNED>
 void hyperstone_device::generate_divsu(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_36));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_36));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -629,27 +629,27 @@ void hyperstone_device::generate_divsu(drcuml_block *block, compiler_state *comp
 		UML_ROLAND(block, I3, DRC_SR, 7, 0x7f);
 
 	if (SRC_GLOBAL)
-		UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I1, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
-		UML_LOAD(block, I2, (void *)m_global_regs, dstf_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->global_regs, dstf_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I5, I2, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I5, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I5, SIZE_DWORD, SCALE_x4);
 		UML_ADD(block, I4, I3, dstf_code);
 		UML_AND(block, I6, I4, 0x3f);
-		UML_LOAD(block, I2, (void *)m_local_regs, I6, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->local_regs, I6, SIZE_DWORD, SCALE_x4);
 	}
 
 #ifndef PTR64
@@ -683,13 +683,13 @@ void hyperstone_device::generate_divsu(drcuml_block *block, compiler_state *comp
 
 	if (DST_GLOBAL)
 	{
-		UML_STORE(block, (void *)m_global_regs, dst_code, I4, SIZE_DWORD, SCALE_x4);
-		UML_STORE(block, (void *)m_global_regs, dstf_code, I2, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->global_regs, dst_code, I4, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->global_regs, dstf_code, I2, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
-		UML_STORE(block, (void *)m_local_regs, I5, I4, SIZE_DWORD, SCALE_x4);
-		UML_STORE(block, (void *)m_local_regs, I6, I2, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I5, I4, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I6, I2, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_JMP(block, done);
@@ -705,7 +705,7 @@ void hyperstone_device::generate_divsu(drcuml_block *block, compiler_state *comp
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_xm(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t dst_code = (op & 0xf0) >> 4;
@@ -739,13 +739,13 @@ void hyperstone_device::generate_xm(drcuml_block *block, compiler_state *compile
 		if (src_code == SR_REGISTER)
 			UML_AND(block, I0, DRC_SR, C_MASK);
 		else
-			UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 	if ((SRC_GLOBAL && (src_code == SR_REGISTER)) || (DST_GLOBAL && (dst_code < 2)))
@@ -782,13 +782,13 @@ void hyperstone_device::generate_xm(drcuml_block *block, compiler_state *compile
 
 	if (DST_GLOBAL)
 	{
-		UML_STORE(block, (void *)m_global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I6, I3, dst_code);
 		UML_AND(block, I4, I6, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -796,7 +796,7 @@ void hyperstone_device::generate_xm(drcuml_block *block, compiler_state *compile
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_mask(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t src_code = op & 0xf;
@@ -810,13 +810,13 @@ void hyperstone_device::generate_mask(drcuml_block *block, compiler_state *compi
 
 	if (SRC_GLOBAL)
 	{
-		UML_LOAD(block, I2, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I2, I2, 0x3f);
-		UML_LOAD(block, I2, (void *)m_local_regs, I2, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->local_regs, I2, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_AND(block, I1, I1, I2);
@@ -840,7 +840,7 @@ void hyperstone_device::generate_mask(drcuml_block *block, compiler_state *compi
 	{
 		UML_ADD(block, I0, I3, dst_code);
 		UML_AND(block, I0, I0, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I0, I1, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I0, I1, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -848,7 +848,7 @@ void hyperstone_device::generate_mask(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_sum(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t src_code = op & 0xf;
@@ -864,13 +864,13 @@ void hyperstone_device::generate_sum(drcuml_block *block, compiler_state *compil
 
 	if (SRC_GLOBAL)
 	{
-		UML_LOAD(block, I2, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I2, I2, 0x3f);
-		UML_LOAD(block, I2, (void *)m_local_regs, I2, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->local_regs, I2, SIZE_DWORD, SCALE_x4);
 	}
 
 #ifndef PTR64
@@ -908,7 +908,7 @@ void hyperstone_device::generate_sum(drcuml_block *block, compiler_state *compil
 	{
 		UML_ADD(block, I0, I3, dst_code);
 		UML_AND(block, I2, I0, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I2, I5, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I2, I5, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -925,7 +925,7 @@ void hyperstone_device::generate_sums(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_cmp(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t src_code = op & 0xf;
@@ -941,24 +941,24 @@ void hyperstone_device::generate_cmp(drcuml_block *block, compiler_state *compil
 		if (src_code == SR_REGISTER)
 			UML_AND(block, I0, DRC_SR, C_MASK);
 		else
-			UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I1, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 #ifndef PTR64
@@ -1000,18 +1000,18 @@ void hyperstone_device::generate_get_global_register(drcuml_block *block, compil
 	UML_CMP(block, I1, TR_REGISTER);
 	UML_JMPc(block, uml::COND_NE, regular_load);
 
-	UML_SHR(block, I2, mem(&m_tr_clocks_per_tick), 1);
-	UML_SUB(block, mem(&m_icount), mem(&m_icount), I7);
+	UML_SHR(block, I2, mem(&m_core->tr_clocks_per_tick), 1);
+	UML_SUB(block, mem(&m_core->icount), mem(&m_core->icount), I7);
 	UML_MOV(block, I7, 0);
-	UML_CMP(block, mem(&m_icount), I2);
+	UML_CMP(block, mem(&m_core->icount), I2);
 	UML_MOVc(block, uml::COND_BE, I2, 0);
-	UML_SUB(block, mem(&m_icount), mem(&m_icount), I2);
+	UML_SUB(block, mem(&m_core->icount), mem(&m_core->icount), I2);
 	UML_CALLC(block, cfunc_compute_tr, this);
-	UML_MOV(block, I5, mem(&m_tr_result));
+	UML_MOV(block, I5, mem(&m_core->tr_result));
 	UML_JMP(block, done);
 
 	UML_LABEL(block, regular_load);
-	UML_LOAD(block, I5, (void *)m_global_regs, I1, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I5, (void *)m_core->global_regs, I1, SIZE_DWORD, SCALE_x4);
 	UML_SHL(block, I2, 1, I1);
 	UML_TEST(block, I2, WRITE_ONLY_REGMASK);
 	UML_MOVc(block, uml::COND_NZ, I5, 0);
@@ -1022,7 +1022,7 @@ void hyperstone_device::generate_get_global_register(drcuml_block *block, compil
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_mov(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t src_code = op & 0xf;
@@ -1052,7 +1052,7 @@ void hyperstone_device::generate_mov(drcuml_block *block, compiler_state *compil
 		UML_ROLAND(block, I1, DRC_SR, 7, 0x7f);
 		UML_ADD(block, I2, I1, src_code);
 		UML_AND(block, I2, I2, 0x3f);
-		UML_LOAD(block, I5, (void *)m_local_regs, I2, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I5, (void *)m_core->local_regs, I2, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_AND(block, DRC_SR, DRC_SR, ~(Z_MASK | N_MASK));
@@ -1079,7 +1079,7 @@ void hyperstone_device::generate_mov(drcuml_block *block, compiler_state *compil
 		UML_AND(block, DRC_SR, DRC_SR, ~H_MASK);
 		UML_ADD(block, I2, I1, dst_code);
 		UML_AND(block, I2, I2, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I2, I5, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I2, I5, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_LABEL(block, done);
@@ -1089,7 +1089,7 @@ void hyperstone_device::generate_mov(drcuml_block *block, compiler_state *compil
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_add(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t src_code = op & 0xf;
@@ -1105,24 +1105,24 @@ void hyperstone_device::generate_add(drcuml_block *block, compiler_state *compil
 		if (src_code == SR_REGISTER)
 			UML_AND(block, I0, DRC_SR, 1);
 		else
-			UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I2, I2, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I2, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I2, SIZE_DWORD, SCALE_x4);
 	}
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I1, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I3, I3, dst_code);
 		UML_AND(block, I3, I3, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I3, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I3, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_ADD(block, I2, I0, I1);
@@ -1156,12 +1156,12 @@ void hyperstone_device::generate_add(drcuml_block *block, compiler_state *compil
 		}
 		else
 		{
-			UML_STORE(block, (void *)m_global_regs, dst_code, I2, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, dst_code, I2, SIZE_DWORD, SCALE_x4);
 		}
 	}
 	else
 	{
-		UML_STORE(block, (void *)m_local_regs, I3, I2, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I3, I2, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -1178,7 +1178,7 @@ void hyperstone_device::generate_adds(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_cmpb(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t src_code = op & 0xf;
@@ -1191,24 +1191,24 @@ void hyperstone_device::generate_cmpb(drcuml_block *block, compiler_state *compi
 
 	if (SRC_GLOBAL)
 	{
-		UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I1, I2, src_code);
 		UML_AND(block, I1, I1, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 	}
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I1, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I2, src_code);
 		UML_AND(block, I2, I2, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I2, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I2, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_TEST(block, I1, I0);
@@ -1220,7 +1220,7 @@ void hyperstone_device::generate_cmpb(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_subc(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t src_code = op & 0xf;
@@ -1240,7 +1240,7 @@ void hyperstone_device::generate_subc(drcuml_block *block, compiler_state *compi
 	{
 		if (src_code != SR_REGISTER)
 		{
-			UML_LOAD(block, I2, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I2, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 #ifndef PTR64
 			UML_DAND(block, I2, I2, 0x00000000ffffffffULL);
 #endif
@@ -1251,7 +1251,7 @@ void hyperstone_device::generate_subc(drcuml_block *block, compiler_state *compi
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I2, I2, 0x3f);
-		UML_LOAD(block, I2, (void *)m_local_regs, I2, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->local_regs, I2, SIZE_DWORD, SCALE_x4);
 #ifndef PTR64
 		UML_DAND(block, I2, I2, 0x00000000ffffffffULL);
 #endif
@@ -1260,13 +1260,13 @@ void hyperstone_device::generate_subc(drcuml_block *block, compiler_state *compi
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I1, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 #ifndef PTR64
@@ -1303,7 +1303,7 @@ void hyperstone_device::generate_subc(drcuml_block *block, compiler_state *compi
 	}
 	else
 	{
-		UML_STORE(block, (void *)m_local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -1311,7 +1311,7 @@ void hyperstone_device::generate_subc(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_sub(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t src_code = op & 0xf;
@@ -1327,24 +1327,24 @@ void hyperstone_device::generate_sub(drcuml_block *block, compiler_state *compil
 		if (src_code == SR_REGISTER)
 			UML_AND(block, I0, DRC_SR, 1);
 		else
-			UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I1, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 #ifndef PTR64
@@ -1388,14 +1388,14 @@ void hyperstone_device::generate_sub(drcuml_block *block, compiler_state *compil
 		}
 		else
 		{
-			UML_STORE(block, (void *)m_global_regs, dst_code, I2, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, dst_code, I2, SIZE_DWORD, SCALE_x4);
 		}
 	}
 	else
 	{
 		UML_ADD(block, I4, I3, dst_code);
 		UML_AND(block, I5, I4, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I5, I2, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I5, I2, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -1403,7 +1403,7 @@ void hyperstone_device::generate_sub(drcuml_block *block, compiler_state *compil
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_subs(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t src_code = op & 0xf;
@@ -1419,24 +1419,24 @@ void hyperstone_device::generate_subs(drcuml_block *block, compiler_state *compi
 		if (src_code == SR_REGISTER)
 			UML_AND(block, I0, DRC_SR, 1);
 		else
-			UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I2, I2, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I2, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I2, SIZE_DWORD, SCALE_x4);
 	}
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I1, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I2, I2, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I2, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I2, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_DSEXT(block, I0, I0, SIZE_DWORD);
@@ -1470,14 +1470,14 @@ void hyperstone_device::generate_subs(drcuml_block *block, compiler_state *compi
 		}
 		else
 		{
-			UML_STORE(block, (void *)m_global_regs, dst_code, I2, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, dst_code, I2, SIZE_DWORD, SCALE_x4);
 		}
 	}
 	else
 	{
 		UML_ADD(block, I4, I3, dst_code);
 		UML_AND(block, I5, I4, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I5, I2, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I5, I2, SIZE_DWORD, SCALE_x4);
 	}
 
 	int no_exception = compiler->m_labelnum++;
@@ -1491,7 +1491,7 @@ void hyperstone_device::generate_subs(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_addc(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t src_code = op & 0xf;
@@ -1510,7 +1510,7 @@ void hyperstone_device::generate_addc(drcuml_block *block, compiler_state *compi
 		}
 		else
 		{
-			UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 			UML_AND(block, I1, DRC_SR, 1);
 #ifndef PTR64
 			UML_DAND(block, I0, I0, 0x00000000ffffffffULL);
@@ -1523,7 +1523,7 @@ void hyperstone_device::generate_addc(drcuml_block *block, compiler_state *compi
 	{
 		UML_ADD(block, I1, I3, src_code);
 		UML_AND(block, I1, I1, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 		UML_AND(block, I1, DRC_SR, 1);
 #ifndef PTR64
 		UML_DAND(block, I0, I0, 0x00000000ffffffffULL);
@@ -1534,13 +1534,13 @@ void hyperstone_device::generate_addc(drcuml_block *block, compiler_state *compi
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I1, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I3, I3, dst_code);
 		UML_AND(block, I3, I3, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I3, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I3, SIZE_DWORD, SCALE_x4);
 	}
 
 #ifndef PTR64
@@ -1577,12 +1577,12 @@ void hyperstone_device::generate_addc(drcuml_block *block, compiler_state *compi
 		}
 		else
 		{
-			UML_STORE(block, (void *)m_global_regs, dst_code, I0, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, dst_code, I0, SIZE_DWORD, SCALE_x4);
 		}
 	}
 	else
 	{
-		UML_STORE(block, (void *)m_local_regs, I3, I0, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I3, I0, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -1590,7 +1590,7 @@ void hyperstone_device::generate_addc(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_neg(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -1604,13 +1604,13 @@ void hyperstone_device::generate_neg(drcuml_block *block, compiler_state *compil
 
 	if (SRC_GLOBAL)
 	{
-		UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I1, I2, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 	}
 
 #ifndef PTR64
@@ -1641,14 +1641,14 @@ void hyperstone_device::generate_neg(drcuml_block *block, compiler_state *compil
 		}
 		else
 		{
-			UML_STORE(block, (void *)m_global_regs, dst_code, I2, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, dst_code, I2, SIZE_DWORD, SCALE_x4);
 		}
 	}
 	else
 	{
 		UML_ADD(block, I1, I3, dst_code);
 		UML_AND(block, I4, I1, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I4, I2, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I4, I2, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -1665,7 +1665,7 @@ void hyperstone_device::generate_negs(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_and(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -1679,24 +1679,24 @@ void hyperstone_device::generate_and(drcuml_block *block, compiler_state *compil
 
 	if (SRC_GLOBAL)
 	{
-		UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I1, I2, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 	}
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I1, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_AND(block, I5, I1, I0);
@@ -1715,12 +1715,12 @@ void hyperstone_device::generate_and(drcuml_block *block, compiler_state *compil
 		}
 		else
 		{
-			UML_STORE(block, (void *)m_global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
 		}
 	}
 	else
 	{
-		UML_STORE(block, (void *)m_local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -1728,7 +1728,7 @@ void hyperstone_device::generate_and(drcuml_block *block, compiler_state *compil
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_andn(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -1742,24 +1742,24 @@ void hyperstone_device::generate_andn(drcuml_block *block, compiler_state *compi
 
 	if (SRC_GLOBAL)
 	{
-		UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I1, I2, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 	}
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I1, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_XOR(block, I2, I0, ~0);
@@ -1779,12 +1779,12 @@ void hyperstone_device::generate_andn(drcuml_block *block, compiler_state *compi
 		}
 		else
 		{
-			UML_STORE(block, (void *)m_global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
 		}
 	}
 	else
 	{
-		UML_STORE(block, (void *)m_local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -1792,7 +1792,7 @@ void hyperstone_device::generate_andn(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_or(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -1806,24 +1806,24 @@ void hyperstone_device::generate_or(drcuml_block *block, compiler_state *compile
 
 	if (SRC_GLOBAL)
 	{
-		UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I1, I2, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 	}
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I1, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_OR(block, I5, I1, I0);
@@ -1842,12 +1842,12 @@ void hyperstone_device::generate_or(drcuml_block *block, compiler_state *compile
 		}
 		else
 		{
-			UML_STORE(block, (void *)m_global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
 		}
 	}
 	else
 	{
-		UML_STORE(block, (void *)m_local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -1855,7 +1855,7 @@ void hyperstone_device::generate_or(drcuml_block *block, compiler_state *compile
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_xor(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -1869,24 +1869,24 @@ void hyperstone_device::generate_xor(drcuml_block *block, compiler_state *compil
 
 	if (SRC_GLOBAL)
 	{
-		UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I1, I2, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 	}
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I1, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_XOR(block, I5, I1, I0);
@@ -1905,12 +1905,12 @@ void hyperstone_device::generate_xor(drcuml_block *block, compiler_state *compil
 		}
 		else
 		{
-			UML_STORE(block, (void *)m_global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
 		}
 	}
 	else
 	{
-		UML_STORE(block, (void *)m_local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -1918,7 +1918,7 @@ void hyperstone_device::generate_xor(drcuml_block *block, compiler_state *compil
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_not(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -1931,12 +1931,12 @@ void hyperstone_device::generate_not(drcuml_block *block, compiler_state *compil
 		UML_ROLAND(block, I3, DRC_SR, 7, 0x7f);
 
 	if (SRC_GLOBAL)
-		UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I1, I2, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_XOR(block, I5, I0, ~0);
@@ -1955,14 +1955,14 @@ void hyperstone_device::generate_not(drcuml_block *block, compiler_state *compil
 		}
 		else
 		{
-			UML_STORE(block, (void *)m_global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
 		}
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -1970,7 +1970,7 @@ void hyperstone_device::generate_not(drcuml_block *block, compiler_state *compil
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::imm_size IMM_LONG>
 void hyperstone_device::generate_cmpi(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t dst_code = (op & 0xf0) >> 4;
@@ -1988,14 +1988,14 @@ void hyperstone_device::generate_cmpi(drcuml_block *block, compiler_state *compi
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I2, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ROLAND(block, I3, DRC_SR, 7, 0x7f);
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I2, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_AND(block, DRC_SR, DRC_SR, ~(V_MASK | Z_MASK | N_MASK | C_MASK));
@@ -2032,7 +2032,7 @@ void hyperstone_device::generate_cmpi(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::imm_size IMM_LONG>
 void hyperstone_device::generate_movi(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t dst_code = (op & 0xf0) >> 4;
@@ -2097,7 +2097,7 @@ void hyperstone_device::generate_movi(drcuml_block *block, compiler_state *compi
 		UML_ROLAND(block, I2, DRC_SR, 7, 0x7f);
 		UML_ADD(block, I0, I2, dst_code);
 		UML_AND(block, I0, I0, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I0, I1, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I0, I1, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -2105,7 +2105,7 @@ void hyperstone_device::generate_movi(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::imm_size IMM_LONG>
 void hyperstone_device::generate_addi(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t dst_code = (op & 0xf0) >> 4;
@@ -2120,14 +2120,14 @@ void hyperstone_device::generate_addi(drcuml_block *block, compiler_state *compi
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I2, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ROLAND(block, I3, DRC_SR, 7, 0x7f);
 		UML_ADD(block, I4, I3, dst_code);
 		UML_AND(block, I5, I4, 0x3f);
-		UML_LOAD(block, I2, (void *)m_local_regs, I5, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->local_regs, I5, SIZE_DWORD, SCALE_x4);
 	}
 
 	if (!(op & 0x10f))
@@ -2180,14 +2180,14 @@ void hyperstone_device::generate_addi(drcuml_block *block, compiler_state *compi
 		}
 		else
 		{
-			UML_STORE(block, (void *)m_global_regs, dst_code, I0, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, dst_code, I0, SIZE_DWORD, SCALE_x4);
 		}
 	}
 	else
 	{
 		UML_ADD(block, I4, I3, dst_code);
 		UML_AND(block, I5, I4, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I5, I0, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I5, I0, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -2204,7 +2204,7 @@ void hyperstone_device::generate_addsi(drcuml_block *block, compiler_state *comp
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::imm_size IMM_LONG>
 void hyperstone_device::generate_cmpbi(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t dst_code = (op & 0xf0) >> 4;
@@ -2214,14 +2214,14 @@ void hyperstone_device::generate_cmpbi(drcuml_block *block, compiler_state *comp
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I2, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ROLAND(block, I3, DRC_SR, 7, 0x7f);
 		UML_ADD(block, I4, I3, dst_code);
 		UML_AND(block, I5, I4, 0x3f);
-		UML_LOAD(block, I2, (void *)m_local_regs, I5, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->local_regs, I5, SIZE_DWORD, SCALE_x4);
 	}
 
 	const uint32_t n = ((op & 0x100) >> 4) | (op & 0x0f);
@@ -2285,7 +2285,7 @@ void hyperstone_device::generate_cmpbi(drcuml_block *block, compiler_state *comp
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::imm_size IMM_LONG>
 void hyperstone_device::generate_andni(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t dst_code = (op & 0xf0) >> 4;
@@ -2301,14 +2301,14 @@ void hyperstone_device::generate_andni(drcuml_block *block, compiler_state *comp
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I2, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ROLAND(block, I3, DRC_SR, 7, 0x7f);
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I2, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_XOR(block, I1, I1, ~0);
@@ -2332,14 +2332,14 @@ void hyperstone_device::generate_andni(drcuml_block *block, compiler_state *comp
 		}
 		else
 		{
-			UML_STORE(block, (void *)m_global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
 		}
 	}
 	else
 	{
 		UML_ADD(block, I4, I3, dst_code);
 		UML_AND(block, I4, I4, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -2347,7 +2347,7 @@ void hyperstone_device::generate_andni(drcuml_block *block, compiler_state *comp
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::imm_size IMM_LONG>
 void hyperstone_device::generate_ori(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t dst_code = (op & 0xf0) >> 4;
@@ -2365,14 +2365,14 @@ void hyperstone_device::generate_ori(drcuml_block *block, compiler_state *compil
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I2, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ROLAND(block, I3, DRC_SR, 7, 0x7f);
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I2, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_OR(block, I5, I2, I1);
@@ -2395,14 +2395,14 @@ void hyperstone_device::generate_ori(drcuml_block *block, compiler_state *compil
 		}
 		else
 		{
-			UML_STORE(block, (void *)m_global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
 		}
 	}
 	else
 	{
 		UML_ADD(block, I4, I3, dst_code);
 		UML_AND(block, I4, I4, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -2410,7 +2410,7 @@ void hyperstone_device::generate_ori(drcuml_block *block, compiler_state *compil
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::imm_size IMM_LONG>
 void hyperstone_device::generate_xori(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	const uint32_t dst_code = (op & 0xf0) >> 4;
@@ -2428,14 +2428,14 @@ void hyperstone_device::generate_xori(drcuml_block *block, compiler_state *compi
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I2, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ROLAND(block, I3, DRC_SR, 7, 0x7f);
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I2, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_XOR(block, I5, I2, I1);
@@ -2458,14 +2458,14 @@ void hyperstone_device::generate_xori(drcuml_block *block, compiler_state *compi
 		}
 		else
 		{
-			UML_STORE(block, (void *)m_global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
 		}
 	}
 	else
 	{
 		UML_ADD(block, I4, I3, dst_code);
 		UML_AND(block, I4, I4, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -2473,7 +2473,7 @@ void hyperstone_device::generate_xori(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::shift_type HI_N>
 void hyperstone_device::generate_shrdi(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_2));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -2485,11 +2485,11 @@ void hyperstone_device::generate_shrdi(drcuml_block *block, compiler_state *comp
 
 	UML_ADD(block, I2, I3, dst_code);
 	UML_AND(block, I1, I2, 0x3f);
-	UML_LOAD(block, I0, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4); // I0 = sreg
+	UML_LOAD(block, I0, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4); // I0 = sreg
 
 	UML_ADD(block, I2, I3, dst_code + 1);
 	UML_AND(block, I6, I2, 0x3f);
-	UML_LOAD(block, I2, (void *)m_local_regs, I6, SIZE_DWORD, SCALE_x4); // I1 = sregf
+	UML_LOAD(block, I2, (void *)m_core->local_regs, I6, SIZE_DWORD, SCALE_x4); // I1 = sregf
 
 #ifndef PTR64
 	UML_DAND(block, I2, I2, 0x00000000ffffffff);
@@ -2518,15 +2518,15 @@ void hyperstone_device::generate_shrdi(drcuml_block *block, compiler_state *comp
 	UML_DROLINS(block, I5, I2, 3, N_MASK);
 	UML_OR(block, DRC_SR, I4, I5);
 
-	UML_STORE(block, (void *)m_local_regs, I6, I2, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I6, I2, SIZE_DWORD, SCALE_x4);
 	UML_DSHR(block, I0, I2, 32);
-	UML_STORE(block, (void *)m_local_regs, I1, I0, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I1, I0, SIZE_DWORD, SCALE_x4);
 }
 
 
 void hyperstone_device::generate_shrd(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_2));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -2545,11 +2545,11 @@ void hyperstone_device::generate_shrd(drcuml_block *block, compiler_state *compi
 
 	UML_ADD(block, I2, I3, dst_code);
 	UML_AND(block, I4, I2, 0x3f);
-	UML_LOAD(block, I0, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I0, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 
 	UML_ADD(block, I2, I3, dstf_code);
 	UML_AND(block, I5, I2, 0x3f);
-	UML_LOAD(block, I1, (void *)m_local_regs, I5, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I1, (void *)m_core->local_regs, I5, SIZE_DWORD, SCALE_x4);
 
 #ifndef PTR64
 	UML_DAND(block, I1, I1, 0x00000000ffffffff);
@@ -2560,7 +2560,7 @@ void hyperstone_device::generate_shrd(drcuml_block *block, compiler_state *compi
 
 	UML_ADD(block, I2, I3, src_code);
 	UML_AND(block, I6, I2, 0x3f);
-	UML_LOAD(block, I2, (void *)m_local_regs, I6, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I2, (void *)m_core->local_regs, I6, SIZE_DWORD, SCALE_x4);
 	UML_AND(block, I6, I2, 0x1f);
 
 	int no_shift = compiler->m_labelnum++;
@@ -2580,15 +2580,15 @@ void hyperstone_device::generate_shrd(drcuml_block *block, compiler_state *compi
 	UML_DROLINS(block, I1, I0, 3, N_MASK);
 	UML_ROLINS(block, DRC_SR, I1, 0, (C_MASK | Z_MASK | N_MASK));
 
-	UML_STORE(block, (void *)m_local_regs, I5, I0, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I5, I0, SIZE_DWORD, SCALE_x4);
 	UML_DSHR(block, I1, I0, 32);
-	UML_STORE(block, (void *)m_local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
 }
 
 
 void hyperstone_device::generate_shr(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -2601,11 +2601,11 @@ void hyperstone_device::generate_shr(drcuml_block *block, compiler_state *compil
 
 	UML_ADD(block, I2, I3, dst_code);
 	UML_AND(block, I4, I2, 0x3f);
-	UML_LOAD(block, I0, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4); // I0 = dreg
+	UML_LOAD(block, I0, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4); // I0 = dreg
 
 	UML_ADD(block, I2, I3, src_code);
 	UML_AND(block, I1, I2, 0x3f);
-	UML_LOAD(block, I5, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I5, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 	UML_AND(block, I1, I5, 0x1f); // I1 = sreg & 0x1f
 
 	UML_AND(block, I6, DRC_SR, ~(C_MASK | Z_MASK | N_MASK));
@@ -2630,14 +2630,14 @@ void hyperstone_device::generate_shr(drcuml_block *block, compiler_state *compil
 	UML_ROLINS(block, I5, I0, 3, N_MASK);
 
 	UML_OR(block, DRC_SR, I5, I6);
-	UML_STORE(block, (void *)m_local_regs, I4, I0, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I4, I0, SIZE_DWORD, SCALE_x4);
 }
 
 
 template <hyperstone_device::shift_type HI_N, hyperstone_device::reg_bank DST_GLOBAL>
 void hyperstone_device::generate_shri(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -2647,14 +2647,14 @@ void hyperstone_device::generate_shri(drcuml_block *block, compiler_state *compi
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I4, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I4, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ROLAND(block, I3, DRC_SR, 7, 0x7f);
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I6, I2, 0x3f);
-		UML_LOAD(block, I4, (void *)m_local_regs, I6, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I4, (void *)m_core->local_regs, I6, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_AND(block, I1, DRC_SR, ~(C_MASK | Z_MASK | N_MASK));
@@ -2677,7 +2677,7 @@ void hyperstone_device::generate_shri(drcuml_block *block, compiler_state *compi
 	}
 	else
 	{
-		UML_STORE(block, (void *)m_local_regs, I6, I5, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I6, I5, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -2693,7 +2693,7 @@ void hyperstone_device::generate_sardi(drcuml_block *block, compiler_state *comp
 
 void hyperstone_device::generate_sard(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_2));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -2712,11 +2712,11 @@ void hyperstone_device::generate_sard(drcuml_block *block, compiler_state *compi
 
 	UML_ADD(block, I2, I3, dst_code);
 	UML_AND(block, I4, I2, 0x3f);
-	UML_LOAD(block, I0, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I0, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 
 	UML_ADD(block, I2, I3, dstf_code);
 	UML_AND(block, I5, I2, 0x3f);
-	UML_LOAD(block, I1, (void *)m_local_regs, I5, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I1, (void *)m_core->local_regs, I5, SIZE_DWORD, SCALE_x4);
 
 #ifndef PTR64
 	UML_DAND(block, I1, I1, 0x00000000ffffffff);
@@ -2727,7 +2727,7 @@ void hyperstone_device::generate_sard(drcuml_block *block, compiler_state *compi
 
 	UML_ADD(block, I2, I3, src_code);
 	UML_AND(block, I6, I2, 0x3f);
-	UML_LOAD(block, I2, (void *)m_local_regs, I6, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I2, (void *)m_core->local_regs, I6, SIZE_DWORD, SCALE_x4);
 	UML_AND(block, I6, I2, 0x1f);
 
 	int no_shift = compiler->m_labelnum++;
@@ -2747,15 +2747,15 @@ void hyperstone_device::generate_sard(drcuml_block *block, compiler_state *compi
 	UML_DROLINS(block, I1, I0, 3, N_MASK);
 	UML_ROLINS(block, DRC_SR, I1, 0, (C_MASK | Z_MASK | N_MASK));
 
-	UML_STORE(block, (void *)m_local_regs, I5, I0, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I5, I0, SIZE_DWORD, SCALE_x4);
 	UML_DSHR(block, I1, I0, 32);
-	UML_STORE(block, (void *)m_local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
 }
 
 
 void hyperstone_device::generate_sar(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -2767,11 +2767,11 @@ void hyperstone_device::generate_sar(drcuml_block *block, compiler_state *compil
 	UML_ROLAND(block, I1, DRC_SR, 7, 0x7f);
 	UML_ADD(block, I2, I1, dst_code);
 	UML_AND(block, I2, I2, 0x3f);
-	UML_LOAD(block, I0, (void *)m_local_regs, I2, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I0, (void *)m_core->local_regs, I2, SIZE_DWORD, SCALE_x4);
 
 	UML_ADD(block, I1, I1, src_code);
 	UML_AND(block, I1, I1, 0x3f);
-	UML_LOAD(block, I1, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I1, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 	UML_AND(block, I1, I1, 0x1f);
 
 	int no_shift = compiler->m_labelnum++;
@@ -2790,14 +2790,14 @@ void hyperstone_device::generate_sar(drcuml_block *block, compiler_state *compil
 	UML_ROLINS(block, I3, I0, 3, N_MASK);
 	UML_ROLINS(block, DRC_SR, I3, 0, (N_MASK | Z_MASK | C_MASK));
 
-	UML_STORE(block, (void *)m_local_regs, I2, I0, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I2, I0, SIZE_DWORD, SCALE_x4);
 }
 
 
 template <hyperstone_device::shift_type HI_N, hyperstone_device::reg_bank DST_GLOBAL>
 void hyperstone_device::generate_sari(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -2807,14 +2807,14 @@ void hyperstone_device::generate_sari(drcuml_block *block, compiler_state *compi
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I0, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ROLAND(block, I1, DRC_SR, 7, 0x7f);
 		UML_ADD(block, I1, I1, dst_code);
 		UML_AND(block, I1, I1, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 	}
 
 	const uint32_t n = HI_N ? DRC_HI_N_VALUE : DRC_LO_N_VALUE;
@@ -2844,12 +2844,12 @@ void hyperstone_device::generate_sari(drcuml_block *block, compiler_state *compi
 		}
 		else
 		{
-			UML_STORE(block, (void *)m_global_regs, dst_code, I0, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, dst_code, I0, SIZE_DWORD, SCALE_x4);
 		}
 	}
 	else
 	{
-		UML_STORE(block, (void *)m_local_regs, I1, I0, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I1, I0, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -2857,7 +2857,7 @@ void hyperstone_device::generate_sari(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::shift_type HI_N>
 void hyperstone_device::generate_shldi(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_2));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -2870,11 +2870,11 @@ void hyperstone_device::generate_shldi(drcuml_block *block, compiler_state *comp
 
 	UML_ADD(block, I2, I4, dst_code);
 	UML_AND(block, I2, I2, 0x3f); // I2: dst_code
-	UML_LOAD(block, I6, (void *)m_local_regs, I2, SIZE_DWORD, SCALE_x4); // I0: high_order
+	UML_LOAD(block, I6, (void *)m_core->local_regs, I2, SIZE_DWORD, SCALE_x4); // I0: high_order
 
 	UML_ADD(block, I3, I4, dstf_code);
 	UML_AND(block, I3, I3, 0x3f); // I3: dstf_code
-	UML_LOAD(block, I1, (void *)m_local_regs, I3, SIZE_DWORD, SCALE_x4); // I1: low_order
+	UML_LOAD(block, I1, (void *)m_core->local_regs, I3, SIZE_DWORD, SCALE_x4); // I1: low_order
 
 #ifndef PTR64
 	UML_DAND(block, I1, I1, 0x00000000ffffffff);
@@ -2917,15 +2917,15 @@ void hyperstone_device::generate_shldi(drcuml_block *block, compiler_state *comp
 	UML_OR(block, I1, I1, I4);
 	UML_ROLINS(block, DRC_SR, I1, 0, (N_MASK | Z_MASK | V_MASK));
 
-	UML_STORE(block, (void *)m_local_regs, I3, I0, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I3, I0, SIZE_DWORD, SCALE_x4);
 	UML_DSHR(block, I0, I0, 32);
-	UML_STORE(block, (void *)m_local_regs, I2, I0, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I2, I0, SIZE_DWORD, SCALE_x4);
 }
 
 
 void hyperstone_device::generate_shld(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_2));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -2944,11 +2944,11 @@ void hyperstone_device::generate_shld(drcuml_block *block, compiler_state *compi
 
 	UML_ADD(block, I2, I4, dst_code);
 	UML_AND(block, I2, I2, 0x3f); // I2: dst_code
-	UML_LOAD(block, I6, (void *)m_local_regs, I2, SIZE_DWORD, SCALE_x4); // I0: high_order
+	UML_LOAD(block, I6, (void *)m_core->local_regs, I2, SIZE_DWORD, SCALE_x4); // I0: high_order
 
 	UML_ADD(block, I3, I4, dstf_code);
 	UML_AND(block, I3, I3, 0x3f); // I3: dstf_code
-	UML_LOAD(block, I1, (void *)m_local_regs, I3, SIZE_DWORD, SCALE_x4); // I1: low_order
+	UML_LOAD(block, I1, (void *)m_core->local_regs, I3, SIZE_DWORD, SCALE_x4); // I1: low_order
 
 #ifndef PTR64
 	UML_DAND(block, I1, I1, 0x00000000ffffffff);
@@ -2959,7 +2959,7 @@ void hyperstone_device::generate_shld(drcuml_block *block, compiler_state *compi
 
 	UML_ADD(block, I4, I4, src_code);
 	UML_AND(block, I4, I4, 0x3f);
-	UML_LOAD(block, I4, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I4, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	UML_AND(block, I4, I4, 0x1f); // I4: n
 
 	UML_DSHR(block, I1, 0xffffffff00000000ULL, I4); // I1: mask
@@ -2994,15 +2994,15 @@ void hyperstone_device::generate_shld(drcuml_block *block, compiler_state *compi
 	UML_OR(block, I1, I1, I4);
 	UML_ROLINS(block, DRC_SR, I1, 0, (N_MASK | Z_MASK | V_MASK));
 
-	UML_STORE(block, (void *)m_local_regs, I3, I0, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I3, I0, SIZE_DWORD, SCALE_x4);
 	UML_DSHR(block, I0, I0, 32);
-	UML_STORE(block, (void *)m_local_regs, I2, I0, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I2, I0, SIZE_DWORD, SCALE_x4);
 }
 
 
 void hyperstone_device::generate_shl(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -3015,11 +3015,11 @@ void hyperstone_device::generate_shl(drcuml_block *block, compiler_state *compil
 
 	UML_ADD(block, I2, I3, dst_code);
 	UML_AND(block, I4, I2, 0x3f);
-	UML_LOAD(block, I0, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4); // I0 = dreg
+	UML_LOAD(block, I0, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4); // I0 = dreg
 
 	UML_ADD(block, I2, I3, src_code);
 	UML_AND(block, I1, I2, 0x3f);
-	UML_LOAD(block, I5, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I5, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 	UML_AND(block, I1, I5, 0x1f); // I1 = sreg & 0x1f
 
 	UML_AND(block, I6, DRC_SR, ~(C_MASK | Z_MASK | N_MASK | V_MASK));
@@ -3058,14 +3058,14 @@ void hyperstone_device::generate_shl(drcuml_block *block, compiler_state *compil
 	UML_ROLINS(block, I5, I0, 3, N_MASK);
 
 	UML_OR(block, DRC_SR, I5, I6);
-	UML_STORE(block, (void *)m_local_regs, I4, I0, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I4, I0, SIZE_DWORD, SCALE_x4);
 }
 
 
 template <hyperstone_device::shift_type HI_N, hyperstone_device::reg_bank DST_GLOBAL>
 void hyperstone_device::generate_shli(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -3075,14 +3075,14 @@ void hyperstone_device::generate_shli(drcuml_block *block, compiler_state *compi
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I4, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I4, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ROLAND(block, I3, DRC_SR, 7, 0x7f);
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I6, I2, 0x3f);
-		UML_LOAD(block, I4, (void *)m_local_regs, I6, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I4, (void *)m_core->local_regs, I6, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_AND(block, I1, DRC_SR, ~(C_MASK | Z_MASK | N_MASK | V_MASK));
@@ -3132,14 +3132,14 @@ void hyperstone_device::generate_shli(drcuml_block *block, compiler_state *compi
 	}
 	else
 	{
-		UML_STORE(block, (void *)m_local_regs, I6, I5, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I6, I5, SIZE_DWORD, SCALE_x4);
 	}
 }
 
 
 void hyperstone_device::generate_testlz(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_2));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -3151,19 +3151,19 @@ void hyperstone_device::generate_testlz(drcuml_block *block, compiler_state *com
 	UML_ROLAND(block, I3, DRC_SR, 7, 0x7f);
 	UML_ADD(block, I2, I3, src_code);
 	UML_AND(block, I1, I2, 0x3f);
-	UML_LOAD(block, I0, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I0, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 
 	UML_LZCNT(block, I4, I0);
 
 	UML_ADD(block, I2, I3, dst_code);
 	UML_AND(block, I1, I2, 0x3f);
-	UML_STORE(block, (void *)m_local_regs, I1, I4, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I1, I4, SIZE_DWORD, SCALE_x4);
 }
 
 
 void hyperstone_device::generate_rol(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -3176,11 +3176,11 @@ void hyperstone_device::generate_rol(drcuml_block *block, compiler_state *compil
 
 	UML_ADD(block, I2, I3, dst_code);
 	UML_AND(block, I4, I2, 0x3f);
-	UML_LOAD(block, I0, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4); // I0 = dreg
+	UML_LOAD(block, I0, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4); // I0 = dreg
 
 	UML_ADD(block, I2, I3, src_code);
 	UML_AND(block, I1, I2, 0x3f);
-	UML_LOAD(block, I5, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I5, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 	UML_AND(block, I1, I5, 0x1f); // I1 = sreg & 0x1f
 
 	int no_shift = compiler->m_labelnum++;
@@ -3214,7 +3214,7 @@ void hyperstone_device::generate_rol(drcuml_block *block, compiler_state *compil
 
 	UML_OR(block, I5, I5, I6);
 	UML_ROLINS(block, DRC_SR, I5, 0, (V_MASK | N_MASK | Z_MASK | C_MASK));
-	UML_STORE(block, (void *)m_local_regs, I4, I2, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I4, I2, SIZE_DWORD, SCALE_x4);
 }
 
 
@@ -3264,19 +3264,19 @@ void hyperstone_device::generate_ldxx1(drcuml_block *block, compiler_state *comp
 		if (dst_code == SR_REGISTER)
 			UML_MOV(block, I4, 0);
 		else
-			UML_LOAD(block, I4, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I4, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I5, I2, 0x3f);
-		UML_LOAD(block, I4, (void *)m_local_regs, I5, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I4, (void *)m_core->local_regs, I5, SIZE_DWORD, SCALE_x4);
 	}
 
 	switch (sub_type)
 	{
 		case 0: // LDBS.A
-			UML_MOV(block, I7, mem(&m_clock_cycles_1));
+			UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 			UML_ADD(block, I0, I4, extra_s);
 			UML_CALLH(block, *m_mem_read8);
 			UML_SEXT(block, I5, I1, SIZE_BYTE);
@@ -3292,12 +3292,12 @@ void hyperstone_device::generate_ldxx1(drcuml_block *block, compiler_state *comp
 			{
 				UML_ADD(block, I2, I3, src_code);
 				UML_AND(block, I2, I2, 0x3f);
-				UML_STORE(block, (void *)m_local_regs, I2, I5, SIZE_DWORD, SCALE_x4);
+				UML_STORE(block, (void *)m_core->local_regs, I2, I5, SIZE_DWORD, SCALE_x4);
 			}
 			break;
 
 		case 1: // LDBU.A
-			UML_MOV(block, I7, mem(&m_clock_cycles_1));
+			UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 			UML_ADD(block, I0, I4, extra_s);
 			UML_CALLH(block, *m_mem_read8);
 
@@ -3313,12 +3313,12 @@ void hyperstone_device::generate_ldxx1(drcuml_block *block, compiler_state *comp
 			{
 				UML_ADD(block, I2, I3, src_code);
 				UML_AND(block, I2, I2, 0x3f);
-				UML_STORE(block, (void *)m_local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
+				UML_STORE(block, (void *)m_core->local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
 			}
 			break;
 
 		case 2:
-			UML_MOV(block, I7, mem(&m_clock_cycles_1));
+			UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 			UML_ADD(block, I0, I4, extra_s & ~1);
 			UML_AND(block, I0, I0, ~1);
 			UML_CALLH(block, *m_mem_read16);
@@ -3343,11 +3343,11 @@ void hyperstone_device::generate_ldxx1(drcuml_block *block, compiler_state *comp
 				if (extra_s & 1)
 				{
 					UML_SEXT(block, I5, I1, SIZE_WORD);
-					UML_STORE(block, (void *)m_local_regs, I2, I5, SIZE_DWORD, SCALE_x4);
+					UML_STORE(block, (void *)m_core->local_regs, I2, I5, SIZE_DWORD, SCALE_x4);
 				}
 				else
 				{
-					UML_STORE(block, (void *)m_local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
+					UML_STORE(block, (void *)m_core->local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
 				}
 			}
 			break;
@@ -3361,7 +3361,7 @@ void hyperstone_device::generate_ldxx1(drcuml_block *block, compiler_state *comp
 			switch (switch_val)
 			{
 				case 0: // LDW.A/D
-					UML_MOV(block, I7, mem(&m_clock_cycles_1));
+					UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 					UML_CALLH(block, *m_mem_read32);
 
 					if (SRC_GLOBAL)
@@ -3376,11 +3376,11 @@ void hyperstone_device::generate_ldxx1(drcuml_block *block, compiler_state *comp
 					{
 						UML_ADD(block, I2, I3, src_code);
 						UML_AND(block, I2, I2, 0x3f);
-						UML_STORE(block, (void *)m_local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
+						UML_STORE(block, (void *)m_core->local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
 					}
 					break;
 				case 1: // LDD.A
-					UML_MOV(block, I7, mem(&m_clock_cycles_2));
+					UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 					UML_CALLH(block, *m_mem_read32);
 
 					if (SRC_GLOBAL)
@@ -3395,7 +3395,7 @@ void hyperstone_device::generate_ldxx1(drcuml_block *block, compiler_state *comp
 					{
 						UML_ADD(block, I2, I3, src_code);
 						UML_AND(block, I2, I2, 0x3f);
-						UML_STORE(block, (void *)m_local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
+						UML_STORE(block, (void *)m_core->local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
 					}
 
 					UML_ADD(block, I0, I0, 4);
@@ -3413,11 +3413,11 @@ void hyperstone_device::generate_ldxx1(drcuml_block *block, compiler_state *comp
 					{
 						UML_ADD(block, I2, I3, srcf_code);
 						UML_AND(block, I2, I2, 0x3f);
-						UML_STORE(block, (void *)m_local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
+						UML_STORE(block, (void *)m_core->local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
 					}
 					break;
 				case 2: // LDW.IOD
-					UML_MOV(block, I7, mem(&m_clock_cycles_1));
+					UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 					UML_ROLAND(block, I0, I0, 21, 0x7ffc);
 					UML_CALLH(block, *m_io_read32);
 
@@ -3433,12 +3433,12 @@ void hyperstone_device::generate_ldxx1(drcuml_block *block, compiler_state *comp
 					{
 						UML_ADD(block, I2, I3, src_code);
 						UML_AND(block, I2, I2, 0x3f);
-						UML_STORE(block, (void *)m_local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
+						UML_STORE(block, (void *)m_core->local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
 					}
 					break;
 
 				case 3: // LDD.IODs
-					UML_MOV(block, I7, mem(&m_clock_cycles_2));
+					UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 					UML_ROLAND(block, I0, I0, 21, 0x7ffc);
 					UML_CALLH(block, *m_io_read32);
 
@@ -3454,7 +3454,7 @@ void hyperstone_device::generate_ldxx1(drcuml_block *block, compiler_state *comp
 					{
 						UML_ADD(block, I2, I3, src_code);
 						UML_AND(block, I2, I2, 0x3f);
-						UML_STORE(block, (void *)m_local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
+						UML_STORE(block, (void *)m_core->local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
 					}
 
 					UML_ADD(block, I0, I0, 4);
@@ -3472,7 +3472,7 @@ void hyperstone_device::generate_ldxx1(drcuml_block *block, compiler_state *comp
 					{
 						UML_ADD(block, I2, I3, srcf_code);
 						UML_AND(block, I2, I2, 0x3f);
-						UML_STORE(block, (void *)m_local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
+						UML_STORE(block, (void *)m_core->local_regs, I2, I1, SIZE_DWORD, SCALE_x4);
 					}
 					break;
 			}
@@ -3531,13 +3531,13 @@ void hyperstone_device::generate_ldxx2(drcuml_block *block, compiler_state *comp
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I6, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I6, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I5, I2, 0x3f);
-		UML_LOAD(block, I6, (void *)m_local_regs, I5, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I6, (void *)m_core->local_regs, I5, SIZE_DWORD, SCALE_x4);
 	}
 
 	switch (sub_type)
@@ -3546,7 +3546,7 @@ void hyperstone_device::generate_ldxx2(drcuml_block *block, compiler_state *comp
 		case 1: // LDBU.N
 		case 2: // LDHS.N, LDHU.N
 		{
-			UML_MOV(block, I7, mem(&m_clock_cycles_1));
+			UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 			if (sub_type == 0)
 			{
 				UML_MOV(block, I0, I6);
@@ -3578,7 +3578,7 @@ void hyperstone_device::generate_ldxx2(drcuml_block *block, compiler_state *comp
 			{
 				UML_ADD(block, I2, I3, src_code);
 				UML_AND(block, I4, I2, 0x3f);
-				UML_STORE(block, (void *)m_local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
+				UML_STORE(block, (void *)m_core->local_regs, I4, I5, SIZE_DWORD, SCALE_x4);
 			}
 
 			if (DST_GLOBAL != SRC_GLOBAL || src_code != dst_code)
@@ -3590,13 +3590,13 @@ void hyperstone_device::generate_ldxx2(drcuml_block *block, compiler_state *comp
 
 				if (DST_GLOBAL)
 				{
-					UML_STORE(block, (void *)m_global_regs, dst_code, I4, SIZE_DWORD, SCALE_x4);
+					UML_STORE(block, (void *)m_core->global_regs, dst_code, I4, SIZE_DWORD, SCALE_x4);
 				}
 				else
 				{
 					UML_ADD(block, I2, I3, dst_code);
 					UML_AND(block, I5, I2, 0x3f);
-					UML_STORE(block, (void *)m_local_regs, I5, I4, SIZE_DWORD, SCALE_x4);
+					UML_STORE(block, (void *)m_core->local_regs, I5, I4, SIZE_DWORD, SCALE_x4);
 				}
 			}
 			break;
@@ -3606,7 +3606,7 @@ void hyperstone_device::generate_ldxx2(drcuml_block *block, compiler_state *comp
 			{
 				case 0: // LDW.N
 				{
-					UML_MOV(block, I7, mem(&m_clock_cycles_1));
+					UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 					UML_AND(block, I0, I6, ~3);
 					UML_CALLH(block, *m_mem_read32);
 
@@ -3620,7 +3620,7 @@ void hyperstone_device::generate_ldxx2(drcuml_block *block, compiler_state *comp
 					{
 						UML_ADD(block, I2, I3, src_code);
 						UML_AND(block, I4, I2, 0x3f);
-						UML_STORE(block, (void *)m_local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
+						UML_STORE(block, (void *)m_core->local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
 					}
 
 					if (DST_GLOBAL != SRC_GLOBAL || src_code != dst_code)
@@ -3629,20 +3629,20 @@ void hyperstone_device::generate_ldxx2(drcuml_block *block, compiler_state *comp
 
 						if (DST_GLOBAL)
 						{
-							UML_STORE(block, (void *)m_global_regs, dst_code, I4, SIZE_DWORD, SCALE_x4);
+							UML_STORE(block, (void *)m_core->global_regs, dst_code, I4, SIZE_DWORD, SCALE_x4);
 						}
 						else
 						{
 							UML_ADD(block, I2, I3, dst_code);
 							UML_AND(block, I5, I2, 0x3f);
-							UML_STORE(block, (void *)m_local_regs, I5, I4, SIZE_DWORD, SCALE_x4);
+							UML_STORE(block, (void *)m_core->local_regs, I5, I4, SIZE_DWORD, SCALE_x4);
 						}
 					}
 					break;
 				}
 				case 1: // LDD.N
 				{
-					UML_MOV(block, I7, mem(&m_clock_cycles_2));
+					UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 					UML_AND(block, I0, I6, ~3);
 					UML_CALLH(block, *m_mem_read32);
 
@@ -3663,14 +3663,14 @@ void hyperstone_device::generate_ldxx2(drcuml_block *block, compiler_state *comp
 					{
 						UML_ADD(block, I2, I3, src_code);
 						UML_AND(block, I4, I2, 0x3f);
-						UML_STORE(block, (void *)m_local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
+						UML_STORE(block, (void *)m_core->local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
 
 						UML_ADD(block, I0, I0, 4);
 						UML_CALLH(block, *m_mem_read32);
 
 						UML_ADD(block, I2, I3, srcf_code);
 						UML_AND(block, I4, I2, 0x3f);
-						UML_STORE(block, (void *)m_local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
+						UML_STORE(block, (void *)m_core->local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
 					}
 
 					if (DST_GLOBAL != SRC_GLOBAL || src_code != dst_code)
@@ -3679,13 +3679,13 @@ void hyperstone_device::generate_ldxx2(drcuml_block *block, compiler_state *comp
 
 						if (DST_GLOBAL)
 						{
-							UML_STORE(block, (void *)m_global_regs, dst_code, I4, SIZE_DWORD, SCALE_x4);
+							UML_STORE(block, (void *)m_core->global_regs, dst_code, I4, SIZE_DWORD, SCALE_x4);
 						}
 						else
 						{
 							UML_ADD(block, I2, I3, dst_code);
 							UML_AND(block, I5, I2, 0x3f);
-							UML_STORE(block, (void *)m_local_regs, I5, I4, SIZE_DWORD, SCALE_x4);
+							UML_STORE(block, (void *)m_core->local_regs, I5, I4, SIZE_DWORD, SCALE_x4);
 						}
 					}
 					break;
@@ -3695,17 +3695,17 @@ void hyperstone_device::generate_ldxx2(drcuml_block *block, compiler_state *comp
 					break;
 				case 3: // LDW.S
 				{
-					UML_MOV(block, I7, mem(&m_clock_cycles_3));
+					UML_MOV(block, I7, mem(&m_core->clock_cycles_3));
 
 					int below_sp = compiler->m_labelnum++;
 					int done = compiler->m_labelnum++;
 
-					UML_MOV(block, I2, mem(&m_global_regs[SP_REGISTER]));
+					UML_MOV(block, I2, mem(&m_core->global_regs[SP_REGISTER]));
 					UML_CMP(block, I6, I2);
 					UML_JMPc(block, uml::COND_B, below_sp);
 
 					UML_ROLAND(block, I0, I6, 30, 0x3f);
-					UML_LOAD(block, I1, (void *)m_local_regs, I0, SIZE_DWORD, SCALE_x4);
+					UML_LOAD(block, I1, (void *)m_core->local_regs, I0, SIZE_DWORD, SCALE_x4);
 					UML_JMP(block, done);
 
 					UML_LABEL(block, below_sp);
@@ -3724,7 +3724,7 @@ void hyperstone_device::generate_ldxx2(drcuml_block *block, compiler_state *comp
 					{
 						UML_ADD(block, I2, I3, src_code);
 						UML_AND(block, I4, I2, 0x3f);
-						UML_STORE(block, (void *)m_local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
+						UML_STORE(block, (void *)m_core->local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
 					}
 
 					if (DST_GLOBAL != SRC_GLOBAL || src_code != dst_code)
@@ -3733,13 +3733,13 @@ void hyperstone_device::generate_ldxx2(drcuml_block *block, compiler_state *comp
 
 						if (DST_GLOBAL)
 						{
-							UML_STORE(block, (void *)m_global_regs, dst_code, I4, SIZE_DWORD, SCALE_x4);
+							UML_STORE(block, (void *)m_core->global_regs, dst_code, I4, SIZE_DWORD, SCALE_x4);
 						}
 						else
 						{
 							UML_ADD(block, I2, I3, dst_code);
 							UML_AND(block, I5, I2, 0x3f);
-							UML_STORE(block, (void *)m_local_regs, I5, I4, SIZE_DWORD, SCALE_x4);
+							UML_STORE(block, (void *)m_core->local_regs, I5, I4, SIZE_DWORD, SCALE_x4);
 						}
 					}
 					break;
@@ -3795,13 +3795,13 @@ void hyperstone_device::generate_stxx1(drcuml_block *block, compiler_state *comp
 		if (dst_code == SR_REGISTER)
 			UML_MOV(block, I0, 0);
 		else
-			UML_LOAD(block, I0, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I0, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I1, I3, dst_code);
 		UML_AND(block, I1, I1, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 	}
 
 	if (SRC_GLOBAL)
@@ -3809,13 +3809,13 @@ void hyperstone_device::generate_stxx1(drcuml_block *block, compiler_state *comp
 		if (src_code == SR_REGISTER)
 			UML_MOV(block, I1, 0);
 		else
-			UML_LOAD(block, I1, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I1, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I1, I3, src_code);
 		UML_AND(block, I1, I1, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 	}
 
 	switch (sub_type)
@@ -3823,14 +3823,14 @@ void hyperstone_device::generate_stxx1(drcuml_block *block, compiler_state *comp
 		case 0: // STBS.D
 		case 1: // STBU.D
 			// TODO: missing trap on range error for STBS.D
-			UML_MOV(block, I7, mem(&m_clock_cycles_1));
+			UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 			UML_ADD(block, I0, I0, extra_s);
 			UML_CALLH(block, *m_mem_write8);
 			break;
 
 		case 2: // STHS.D, STHU.D
 			// TODO: missing trap on range error with STHS.D
-			UML_MOV(block, I7, mem(&m_clock_cycles_1));
+			UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 			UML_ADD(block, I0, I0, extra_s);
 			UML_AND(block, I0, I0, ~1);
 			UML_CALLH(block, *m_mem_write16);
@@ -3840,14 +3840,14 @@ void hyperstone_device::generate_stxx1(drcuml_block *block, compiler_state *comp
 			switch (extra_s & 3)
 			{
 				case 0: // STW.D
-					UML_MOV(block, I7, mem(&m_clock_cycles_1));
+					UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 					UML_ADD(block, I0, I0, extra_s & ~1);
 					UML_AND(block, I0, I0, ~3);
 					UML_CALLH(block, *m_mem_write32);
 					break;
 				case 1: // STD.D
 				{
-					UML_MOV(block, I7, mem(&m_clock_cycles_2));
+					UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 					UML_ADD(block, I0, I0, extra_s & ~1);
 					UML_AND(block, I0, I0, ~3);
 					UML_CALLH(block, *m_mem_write32);
@@ -3857,13 +3857,13 @@ void hyperstone_device::generate_stxx1(drcuml_block *block, compiler_state *comp
 						if (src_code == SR_REGISTER)
 							UML_MOV(block, I1, 0);
 						else
-							UML_LOAD(block, I1, (void *)m_global_regs, src_code + 1, SIZE_DWORD, SCALE_x4);
+							UML_LOAD(block, I1, (void *)m_core->global_regs, src_code + 1, SIZE_DWORD, SCALE_x4);
 					}
 					else
 					{
 						UML_ADD(block, I1, I3, src_code + 1);
 						UML_AND(block, I1, I1, 0x3f);
-						UML_LOAD(block, I1, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+						UML_LOAD(block, I1, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 					}
 
 					UML_ADD(block, I0, I0, 4);
@@ -3871,14 +3871,14 @@ void hyperstone_device::generate_stxx1(drcuml_block *block, compiler_state *comp
 					break;
 				}
 				case 2: // STW.IOD
-					UML_MOV(block, I7, mem(&m_clock_cycles_1));
+					UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 					UML_ADD(block, I0, I0, extra_s & ~3);
 					UML_ROLAND(block, I0, I0, 21, 0x7ffc);
 					UML_CALLH(block, *m_io_write32);
 					break;
 				case 3: // STD.IOD
 				{
-					UML_MOV(block, I7, mem(&m_clock_cycles_2));
+					UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 					UML_ADD(block, I0, I0, extra_s & ~1); // Is this correct?
 					UML_ROLAND(block, I0, I0, 21, 0x7ffc);
 					UML_CALLH(block, *m_io_write32);
@@ -3888,13 +3888,13 @@ void hyperstone_device::generate_stxx1(drcuml_block *block, compiler_state *comp
 						if (src_code == SR_REGISTER)
 							UML_MOV(block, I1, 0);
 						else
-							UML_LOAD(block, I1, (void *)m_global_regs, src_code + 1, SIZE_DWORD, SCALE_x4);
+							UML_LOAD(block, I1, (void *)m_core->global_regs, src_code + 1, SIZE_DWORD, SCALE_x4);
 					}
 					else
 					{
 						UML_ADD(block, I1, I3, src_code + 1);
 						UML_AND(block, I1, I1, 0x3f);
-						UML_LOAD(block, I1, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+						UML_LOAD(block, I1, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 					}
 
 					UML_ADD(block, I0, I0, 4);
@@ -3948,7 +3948,7 @@ void hyperstone_device::generate_stxx2(drcuml_block *block, compiler_state *comp
 	if (DST_GLOBAL && dst_code < 2)
 	{
 		printf("Denoted PC or SR in hyperstone_ldxx2. PC = %08X\n", desc->pc);
-		UML_MOV(block, I7, mem(&m_clock_cycles_1));
+		UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 		return;
 	}
 
@@ -3957,13 +3957,13 @@ void hyperstone_device::generate_stxx2(drcuml_block *block, compiler_state *comp
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I0, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I6, I2, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I6, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I6, SIZE_DWORD, SCALE_x4);
 	}
 
 	if (SRC_GLOBAL)
@@ -3971,13 +3971,13 @@ void hyperstone_device::generate_stxx2(drcuml_block *block, compiler_state *comp
 		if (src_code == SR_REGISTER)
 			UML_MOV(block, I1, 0);
 		else
-			UML_LOAD(block, I1, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I1, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I5, I2, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I5, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I5, SIZE_DWORD, SCALE_x4);
 	}
 
 	switch (sub_type)
@@ -3985,64 +3985,64 @@ void hyperstone_device::generate_stxx2(drcuml_block *block, compiler_state *comp
 		case 0: // STBS.N
 		case 1: // STBU.N
 			// TODO: missing trap on range error with STBS.N
-			UML_MOV(block, I7, mem(&m_clock_cycles_1));
+			UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 			UML_CALLH(block, *m_mem_write8);
 			UML_ADD(block, I0, I0, extra_s);
 
 			if (DST_GLOBAL)
-				UML_STORE(block, (void *)m_global_regs, dst_code, I0, SIZE_DWORD, SCALE_x4);
+				UML_STORE(block, (void *)m_core->global_regs, dst_code, I0, SIZE_DWORD, SCALE_x4);
 			else
-				UML_STORE(block, (void *)m_local_regs, I6, I0, SIZE_DWORD, SCALE_x4);
+				UML_STORE(block, (void *)m_core->local_regs, I6, I0, SIZE_DWORD, SCALE_x4);
 			break;
 		case 2: // STHS.N, STHU.N
 			// TODO: missing trap on range error with STHS.N
-			UML_MOV(block, I7, mem(&m_clock_cycles_1));
+			UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 			UML_MOV(block, I5, I0);
 			UML_AND(block, I0, I0, ~1);
 			UML_CALLH(block, *m_mem_write16);
 			UML_ADD(block, I5, I5, extra_s & ~1);
 
 			if (DST_GLOBAL)
-				UML_STORE(block, (void *)m_global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
+				UML_STORE(block, (void *)m_core->global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
 			else
-				UML_STORE(block, (void *)m_local_regs, I6, I5, SIZE_DWORD, SCALE_x4);
+				UML_STORE(block, (void *)m_core->local_regs, I6, I5, SIZE_DWORD, SCALE_x4);
 			break;
 		case 3:
 			switch (extra_s & 3)
 			{
 				case 0: // STW.N
-					UML_MOV(block, I7, mem(&m_clock_cycles_1));
+					UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 					UML_MOV(block, I5, I0);
 					UML_AND(block, I0, I0, ~3);
 					UML_CALLH(block, *m_mem_write32);
 					UML_ADD(block, I5, I5, extra_s);
 
 					if (DST_GLOBAL)
-						UML_STORE(block, (void *)m_global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
+						UML_STORE(block, (void *)m_core->global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
 					else
-						UML_STORE(block, (void *)m_local_regs, I6, I5, SIZE_DWORD, SCALE_x4);
+						UML_STORE(block, (void *)m_core->local_regs, I6, I5, SIZE_DWORD, SCALE_x4);
 					break;
 				case 1: // STD.N
-					UML_MOV(block, I7, mem(&m_clock_cycles_2));
+					UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 					UML_MOV(block, I5, I0);
 					UML_AND(block, I0, I0, ~3);
 					UML_CALLH(block, *m_mem_write32);
 
 					UML_ADD(block, I5, I5, extra_s & ~1);
 					if (DST_GLOBAL)
-						UML_STORE(block, (void *)m_global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
+						UML_STORE(block, (void *)m_core->global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
 					else
-						UML_STORE(block, (void *)m_local_regs, I6, I5, SIZE_DWORD, SCALE_x4);
+						UML_STORE(block, (void *)m_core->local_regs, I6, I5, SIZE_DWORD, SCALE_x4);
 
 					if (SRC_GLOBAL)
 					{
-						UML_LOAD(block, I1, (void *)m_global_regs, src_code + 1, SIZE_DWORD, SCALE_x4);
+						UML_LOAD(block, I1, (void *)m_core->global_regs, src_code + 1, SIZE_DWORD, SCALE_x4);
 					}
 					else
 					{
 						UML_ADD(block, I2, I3, src_code + 1);
 						UML_AND(block, I4, I2, 0x3f);
-						UML_LOAD(block, I1, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+						UML_LOAD(block, I1, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 					}
 
 					UML_ADD(block, I0, I0, 4);
@@ -4053,7 +4053,7 @@ void hyperstone_device::generate_stxx2(drcuml_block *block, compiler_state *comp
 					break;
 				case 3: // STW.S
 				{
-					UML_MOV(block, I7, mem(&m_clock_cycles_3));
+					UML_MOV(block, I7, mem(&m_core->clock_cycles_3));
 
 					int less_than_sp = compiler->m_labelnum++;
 					int store_done = compiler->m_labelnum++;
@@ -4063,7 +4063,7 @@ void hyperstone_device::generate_stxx2(drcuml_block *block, compiler_state *comp
 					UML_JMPc(block, uml::COND_B, less_than_sp);
 
 					UML_ROLAND(block, I4, I0, 30, 0x3f);
-					UML_STORE(block, (void *)m_local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
+					UML_STORE(block, (void *)m_core->local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
 					UML_JMP(block, store_done);
 
 					UML_LABEL(block, less_than_sp);
@@ -4073,9 +4073,9 @@ void hyperstone_device::generate_stxx2(drcuml_block *block, compiler_state *comp
 					UML_LABEL(block, store_done);
 					UML_ADD(block, I5, I5, extra_s & ~3);
 					if (DST_GLOBAL)
-						UML_STORE(block, (void *)m_global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
+						UML_STORE(block, (void *)m_core->global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
 					else
-						UML_STORE(block, (void *)m_local_regs, I6, I5, SIZE_DWORD, SCALE_x4);
+						UML_STORE(block, (void *)m_core->local_regs, I6, I5, SIZE_DWORD, SCALE_x4);
 					break;
 				}
 			}
@@ -4087,7 +4087,7 @@ void hyperstone_device::generate_stxx2(drcuml_block *block, compiler_state *comp
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL, hyperstone_device::sign_mode SIGNED>
 void hyperstone_device::generate_mulsu(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_36));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_36));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -4105,23 +4105,23 @@ void hyperstone_device::generate_mulsu(drcuml_block *block, compiler_state *comp
 		UML_ROLAND(block, I3, DRC_SR, 7, 0x7f);
 
 	if (SRC_GLOBAL)
-		UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 	if (DST_GLOBAL)
 	{
-		UML_LOAD(block, I1, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I6, I2, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I6, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I6, SIZE_DWORD, SCALE_x4);
 	}
 
 	if (SIGNED == IS_SIGNED)
@@ -4138,19 +4138,19 @@ void hyperstone_device::generate_mulsu(drcuml_block *block, compiler_state *comp
 
 	if (DST_GLOBAL)
 	{
-		UML_STORE(block, (void *)m_global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
-		UML_STORE(block, (void *)m_global_regs, dstf_code, I4, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->global_regs, dst_code, I5, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->global_regs, dstf_code, I4, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
-		UML_STORE(block, (void *)m_local_regs, I6, I5, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I6, I5, SIZE_DWORD, SCALE_x4);
 		UML_ADD(block, I2, I3, dstf_code);
 		UML_AND(block, I5, I2, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I5, I4, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I5, I4, SIZE_DWORD, SCALE_x4);
 	}
 
 	int done = compiler->m_labelnum++;
-	UML_MOV(block, I7, mem(&m_clock_cycles_6));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_6));
 	if (SIGNED == IS_SIGNED)
 	{
 		UML_CMP(block, I0, 0xffff8000);
@@ -4169,7 +4169,7 @@ void hyperstone_device::generate_mulsu(drcuml_block *block, compiler_state *comp
 		UML_CMP(block, I1, 0x0000ffff);
 		UML_JMPc(block, uml::COND_A, done);
 	}
-	UML_SUB(block, I7, I7, mem(&m_clock_cycles_2));
+	UML_SUB(block, I7, I7, mem(&m_core->clock_cycles_2));
 
 	UML_LABEL(block, done);
 }
@@ -4195,21 +4195,21 @@ void hyperstone_device::generate_mul(drcuml_block *block, compiler_state *compil
 		UML_ROLAND(block, I3, DRC_SR, 7, 0x7f);
 
 	if (SRC_GLOBAL)
-		UML_LOAD(block, I0, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I1, I2, 0x3f);
-		UML_LOAD(block, I0, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I0, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 	}
 
 	if (DST_GLOBAL)
-		UML_LOAD(block, I1, (void *)m_global_regs, dst_code, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->global_regs, dst_code, SIZE_DWORD, SCALE_x4);
 	else
 	{
 		UML_ADD(block, I2, I3, dst_code);
 		UML_AND(block, I6, I2, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I6, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I6, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_MULU(block, I2, I3, I0, I1);
@@ -4222,11 +4222,11 @@ void hyperstone_device::generate_mul(drcuml_block *block, compiler_state *compil
 	UML_ROLINS(block, DRC_SR, I5, 0, (Z_MASK | N_MASK));
 
 	if (DST_GLOBAL)
-		UML_STORE(block, (void *)m_global_regs, dst_code, I2, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->global_regs, dst_code, I2, SIZE_DWORD, SCALE_x4);
 	else
-		UML_STORE(block, (void *)m_local_regs, I6, I2, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I6, I2, SIZE_DWORD, SCALE_x4);
 
-	UML_MOV(block, I7, mem(&m_clock_cycles_3));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_3));
 	int add_cycles = compiler->m_labelnum++;
 	int done = compiler->m_labelnum++;
 	UML_CMP(block, I0, 0xffff8000);
@@ -4240,7 +4240,7 @@ void hyperstone_device::generate_mul(drcuml_block *block, compiler_state *compil
 	UML_JMP(block, done);
 
 	UML_LABEL(block, add_cycles);
-	UML_ADD(block, I7, I7, mem(&m_clock_cycles_2));
+	UML_ADD(block, I7, I7, mem(&m_core->clock_cycles_2));
 
 	UML_LABEL(block, done);
 	// TODO: proper cycle counts
@@ -4250,7 +4250,7 @@ void hyperstone_device::generate_mul(drcuml_block *block, compiler_state *compil
 template <hyperstone_device::shift_type HI_N, hyperstone_device::reg_bank DST_GLOBAL>
 void hyperstone_device::generate_set(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	const uint16_t op = desc->opptr.w[0];
 
@@ -4288,7 +4288,7 @@ void hyperstone_device::generate_set(drcuml_block *block, compiler_state *compil
 		if (n == 0)
 		{
 			int no_low_bit = compiler->m_labelnum++;
-			UML_MOV(block, I1, mem(&m_global_regs[SP_REGISTER]));
+			UML_MOV(block, I1, mem(&m_core->global_regs[SP_REGISTER]));
 			UML_AND(block, I0, I1, 0xfffffe00);
 			UML_ROLINS(block, I0, DRC_SR, 9, 0x000001fc);
 			UML_TEST(block, I1, 0x100);
@@ -4318,14 +4318,14 @@ void hyperstone_device::generate_set(drcuml_block *block, compiler_state *compil
 
 	if (DST_GLOBAL)
 	{
-		UML_STORE(block, (void *)m_global_regs, dst_code, I0, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->global_regs, dst_code, I0, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ROLAND(block, I1, DRC_SR, 7, 0x7f);
 		UML_ADD(block, I2, I1, dst_code);
 		UML_AND(block, I3, I2, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I3, I0, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I3, I0, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -4333,7 +4333,7 @@ void hyperstone_device::generate_set(drcuml_block *block, compiler_state *compil
 template <hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_ldwr(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	const uint16_t op = desc->opptr.w[0];
 
@@ -4345,7 +4345,7 @@ void hyperstone_device::generate_ldwr(drcuml_block *block, compiler_state *compi
 	UML_ROLAND(block, I3, DRC_SR, 7, 0x7f);
 	UML_ADD(block, I2, I3, dst_code);
 	UML_AND(block, I4, I2, 0x3f);
-	UML_LOAD(block, I0, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I0, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	UML_AND(block, I0, I0, ~3);
 	UML_CALLH(block, *m_mem_read32);
 
@@ -4361,7 +4361,7 @@ void hyperstone_device::generate_ldwr(drcuml_block *block, compiler_state *compi
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -4369,7 +4369,7 @@ void hyperstone_device::generate_ldwr(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_lddr(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_2));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -4381,7 +4381,7 @@ void hyperstone_device::generate_lddr(drcuml_block *block, compiler_state *compi
 	UML_ROLAND(block, I3, DRC_SR, 7, 0x7f);
 	UML_ADD(block, I2, I3, dst_code);
 	UML_AND(block, I1, I2, 0x3f);
-	UML_LOAD(block, I0, (void *)m_local_regs, I1, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I0, (void *)m_core->local_regs, I1, SIZE_DWORD, SCALE_x4);
 	UML_AND(block, I0, I0, ~3);
 	UML_CALLH(block, *m_mem_read32);
 
@@ -4402,14 +4402,14 @@ void hyperstone_device::generate_lddr(drcuml_block *block, compiler_state *compi
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
 
 		UML_ADD(block, I0, I0, 4);
 		UML_CALLH(block, *m_mem_read32);
 
 		UML_ADD(block, I2, I3, src_code + 1);
 		UML_AND(block, I4, I2, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
 	}
 }
 
@@ -4417,7 +4417,7 @@ void hyperstone_device::generate_lddr(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_ldwp(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	const uint16_t op = desc->opptr.w[0];
 
@@ -4429,7 +4429,7 @@ void hyperstone_device::generate_ldwp(drcuml_block *block, compiler_state *compi
 	UML_ROLAND(block, I0, DRC_SR, 7, 0x7f);
 	UML_ADD(block, I1, I0, dst_code);
 	UML_AND(block, I2, I1, 0x3f);
-	UML_LOAD(block, I0, (void *)m_local_regs, I2, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I0, (void *)m_core->local_regs, I2, SIZE_DWORD, SCALE_x4);
 
 	UML_ADD(block, I3, I0, 4);
 	UML_AND(block, I0, I0, ~3);
@@ -4444,7 +4444,7 @@ void hyperstone_device::generate_ldwp(drcuml_block *block, compiler_state *compi
 		UML_ROLAND(block, I0, DRC_SR, 7, 0x7f);
 		UML_ADD(block, I1, I0, dst_code);
 		UML_AND(block, I2, I1, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I2, I3, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I2, I3, SIZE_DWORD, SCALE_x4);
 
 		if (src_code == PC_REGISTER)
 			generate_branch(block, desc->targetpc);
@@ -4454,13 +4454,13 @@ void hyperstone_device::generate_ldwp(drcuml_block *block, compiler_state *compi
 		UML_ROLAND(block, I0, DRC_SR, 7, 0x7f);
 		UML_ADD(block, I4, I0, src_code);
 		UML_AND(block, I5, I4, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I5, I1, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I5, I1, SIZE_DWORD, SCALE_x4);
 
 		if (src_code != dst_code)
 		{
 			UML_ADD(block, I4, I0, dst_code);
 			UML_AND(block, I5, I4, 0x3f);
-			UML_STORE(block, (void *)m_local_regs, I5, I3, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->local_regs, I5, I3, SIZE_DWORD, SCALE_x4);
 		}
 	}
 }
@@ -4469,7 +4469,7 @@ void hyperstone_device::generate_ldwp(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_lddp(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_2));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 
 	const uint16_t op = desc->opptr.w[0];
 
@@ -4481,7 +4481,7 @@ void hyperstone_device::generate_lddp(drcuml_block *block, compiler_state *compi
 	UML_ROLAND(block, I0, DRC_SR, 7, 0x7f);
 	UML_ADD(block, I1, I0, dst_code);
 	UML_AND(block, I2, I1, 0x3f);
-	UML_LOAD(block, I0, (void *)m_local_regs, I2, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I0, (void *)m_core->local_regs, I2, SIZE_DWORD, SCALE_x4);
 
 	UML_ADD(block, I3, I0, 8);
 	UML_AND(block, I0, I0, ~3);
@@ -4502,7 +4502,7 @@ void hyperstone_device::generate_lddp(drcuml_block *block, compiler_state *compi
 		UML_ROLAND(block, I0, DRC_SR, 7, 0x7f);
 		UML_ADD(block, I1, I0, dst_code);
 		UML_AND(block, I2, I1, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I2, I3, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I2, I3, SIZE_DWORD, SCALE_x4);
 
 		if (src_code == PC_REGISTER || (src_code + 1) == PC_REGISTER)
 			generate_branch(block, desc->targetpc);
@@ -4512,16 +4512,16 @@ void hyperstone_device::generate_lddp(drcuml_block *block, compiler_state *compi
 		UML_ROLAND(block, I0, DRC_SR, 7, 0x7f);
 		UML_ADD(block, I4, I0, src_code);
 		UML_AND(block, I5, I4, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I5, I2, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I5, I2, SIZE_DWORD, SCALE_x4);
 		UML_ADD(block, I4, I0, src_code + 1);
 		UML_AND(block, I5, I4, 0x3f);
-		UML_STORE(block, (void *)m_local_regs, I5, I1, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I5, I1, SIZE_DWORD, SCALE_x4);
 
 		if (src_code != dst_code && (src_code + 1) != dst_code)
 		{
 			UML_ADD(block, I4, I0, dst_code);
 			UML_AND(block, I5, I4, 0x3f);
-			UML_STORE(block, (void *)m_local_regs, I5, I3, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->local_regs, I5, I3, SIZE_DWORD, SCALE_x4);
 		}
 	}
 }
@@ -4530,7 +4530,7 @@ void hyperstone_device::generate_lddp(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_stwr(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	const uint16_t op = desc->opptr.w[0];
 
@@ -4546,18 +4546,18 @@ void hyperstone_device::generate_stwr(drcuml_block *block, compiler_state *compi
 		if (src_code == SR_REGISTER)
 			UML_MOV(block, I1, 0);
 		else
-			UML_LOAD(block, I1, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I1, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I2, I2, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I2, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I2, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_ADD(block, I2, I3, dst_code);
 	UML_AND(block, I4, I2, 0x3f);
-	UML_LOAD(block, I0, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I0, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	UML_AND(block, I0, I0, ~3);
 	UML_CALLH(block, *m_mem_write32);
 }
@@ -4566,7 +4566,7 @@ void hyperstone_device::generate_stwr(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_stdr(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_2));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 
 	const uint16_t op = desc->opptr.w[0];
 
@@ -4582,26 +4582,26 @@ void hyperstone_device::generate_stdr(drcuml_block *block, compiler_state *compi
 		if (src_code == SR_REGISTER)
 			UML_MOV(block, I1, 0);
 		else
-			UML_LOAD(block, I1, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I1, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 
 		if ((src_code + 1) == SR_REGISTER)
 			UML_MOV(block, I2, 0);
 		else
-			UML_LOAD(block, I2, (void *)m_global_regs, src_code + 1, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I2, (void *)m_core->global_regs, src_code + 1, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I4, I3, src_code);
 		UML_AND(block, I5, I4, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I5, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I5, SIZE_DWORD, SCALE_x4);
 		UML_ADD(block, I4, I3, src_code + 1);
 		UML_AND(block, I5, I4, 0x3f);
-		UML_LOAD(block, I2, (void *)m_local_regs, I5, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->local_regs, I5, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_ADD(block, I4, I3, dst_code);
 	UML_AND(block, I5, I4, 0x3f);
-	UML_LOAD(block, I0, (void *)m_local_regs, I5, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I0, (void *)m_core->local_regs, I5, SIZE_DWORD, SCALE_x4);
 	UML_AND(block, I0, I0, ~3);
 
 	UML_CALLH(block, *m_mem_write32);
@@ -4614,7 +4614,7 @@ void hyperstone_device::generate_stdr(drcuml_block *block, compiler_state *compi
 template <hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_stwp(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	const uint16_t op = desc->opptr.w[0];
 
@@ -4630,29 +4630,29 @@ void hyperstone_device::generate_stwp(drcuml_block *block, compiler_state *compi
 		if (src_code == SR_REGISTER)
 			UML_MOV(block, I1, 0);
 		else
-			UML_LOAD(block, I1, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I1, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I0, I2, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I0, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I0, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_ADD(block, I2, I3, dst_code);
 	UML_AND(block, I4, I2, 0x3f);
-	UML_LOAD(block, I5, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I5, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4);
 	UML_AND(block, I0, I5, ~3);
 	UML_CALLH(block, *m_mem_write32);
 	UML_ADD(block, I2, I5, 4);
-	UML_STORE(block, (void *)m_local_regs, I4, I2, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I4, I2, SIZE_DWORD, SCALE_x4);
 }
 
 
 template <hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_stdp(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_2));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 
 	const uint16_t op = desc->opptr.w[0];
 
@@ -4664,27 +4664,27 @@ void hyperstone_device::generate_stdp(drcuml_block *block, compiler_state *compi
 	UML_ROLAND(block, I3, DRC_SR, 7, 0x7f);
 	UML_ADD(block, I2, I3, dst_code);
 	UML_AND(block, I4, I2, 0x3f); // I4 = dst_code
-	UML_LOAD(block, I0, (void *)m_local_regs, I4, SIZE_DWORD, SCALE_x4); // I0 = dreg
+	UML_LOAD(block, I0, (void *)m_core->local_regs, I4, SIZE_DWORD, SCALE_x4); // I0 = dreg
 
 	if (SRC_GLOBAL)
 	{
 		if (src_code == SR_REGISTER)
 			UML_MOV(block, I1, 0);
 		else
-			UML_LOAD(block, I1, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I1, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 
 		UML_CALLH(block, *m_mem_write32);
 
 		if ((src_code + 1) == SR_REGISTER)
 			UML_MOV(block, I1, 0);
 		else
-			UML_LOAD(block, I1, (void *)m_global_regs, src_code + 1, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I1, (void *)m_core->global_regs, src_code + 1, SIZE_DWORD, SCALE_x4);
 
 		UML_ADD(block, I2, I0, 4);
 		UML_AND(block, I0, I2, ~3);
 		UML_CALLH(block, *m_mem_write32);
 		UML_ADD(block, I2, I2, 4);
-		UML_STORE(block, (void *)m_local_regs, I4, I2, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I4, I2, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
@@ -4695,7 +4695,7 @@ void hyperstone_device::generate_stdp(drcuml_block *block, compiler_state *compi
 		UML_AND(block, I0, I0, ~3);
 		UML_ADD(block, I2, I3, src_code);
 		UML_AND(block, I5, I2, 0x3f);
-		UML_LOAD(block, I1, (void *)m_local_regs, I5, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I5, SIZE_DWORD, SCALE_x4);
 		UML_CALLH(block, *m_mem_write32);
 
 		UML_ADD(block, I2, I5, 1);
@@ -4704,12 +4704,12 @@ void hyperstone_device::generate_stdp(drcuml_block *block, compiler_state *compi
 		UML_CMP(block, I4, I5);
 		UML_JMPc(block, uml::COND_E, srcf_dst_equal);
 
-		UML_STORE(block, (void *)m_local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
-		UML_LOAD(block, I1, (void *)m_local_regs, I5, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I1, (void *)m_core->local_regs, I5, SIZE_DWORD, SCALE_x4);
 		UML_JMP(block, done);
 
 		UML_LABEL(block, srcf_dst_equal);
-		UML_STORE(block, (void *)m_local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
+		UML_STORE(block, (void *)m_core->local_regs, I4, I1, SIZE_DWORD, SCALE_x4);
 
 		UML_LABEL(block, done);
 		UML_ADD(block, I0, I0, 4);
@@ -4736,7 +4736,7 @@ void hyperstone_device::generate_b(drcuml_block *block, compiler_state *compiler
 	UML_LABEL(block, skip);
 	generate_ignore_pcrel(block, desc);
 	generate_check_delay_pc(block, compiler, desc);
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	UML_LABEL(block, done);
 }
@@ -4744,7 +4744,7 @@ void hyperstone_device::generate_b(drcuml_block *block, compiler_state *compiler
 
 void hyperstone_device::generate_br(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_2));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 
 	generate_decode_pcrel(block, desc);
 	generate_check_delay_pc(block, compiler, desc);
@@ -4774,7 +4774,7 @@ void hyperstone_device::generate_db(drcuml_block *block, compiler_state *compile
 	UML_JMP(block, done);
 
 	UML_LABEL(block, skip_jump);
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 	generate_ignore_pcrel(block, desc);
 	generate_check_delay_pc(block, compiler, desc);
 
@@ -4784,20 +4784,20 @@ void hyperstone_device::generate_db(drcuml_block *block, compiler_state *compile
 
 void hyperstone_device::generate_dbr(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_2));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_2));
 
 	generate_decode_pcrel(block, desc);
 	generate_check_delay_pc(block, compiler, desc);
 
-	UML_MOV(block, mem(&m_delay_slot), 1);
-	UML_ADD(block, mem(&m_delay_pc), DRC_PC, I1);
-	UML_MOV(block, mem(&m_intblock), 3);
+	UML_MOV(block, mem(&m_core->delay_slot), 1);
+	UML_ADD(block, mem(&m_core->delay_pc), DRC_PC, I1);
+	UML_MOV(block, mem(&m_core->intblock), 3);
 }
 
 
 void hyperstone_device::generate_frame(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	const uint16_t op = desc->opptr.w[0];
 
@@ -4835,7 +4835,7 @@ void hyperstone_device::generate_frame(drcuml_block *block, compiler_state *comp
 	int push_next;
 	UML_LABEL(block, push_next = compiler->m_labelnum++);
 	UML_ROLAND(block, I2, I0, 30, 0x3f);
-	UML_LOAD(block, I1, (void *)m_local_regs, I2, SIZE_DWORD, SCALE_x4);
+	UML_LOAD(block, I1, (void *)m_core->local_regs, I2, SIZE_DWORD, SCALE_x4);
 	UML_CALLH(block, *m_mem_write32);
 	UML_ADD(block, I0, I0, 4);
 	UML_ADD(block, I6, I6, 4);
@@ -4855,7 +4855,7 @@ void hyperstone_device::generate_frame(drcuml_block *block, compiler_state *comp
 template <hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::generate_call(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 	uint16_t imm_1 = READ_OP(desc->pc + 2);
@@ -4903,13 +4903,13 @@ void hyperstone_device::generate_call(drcuml_block *block, compiler_state *compi
 		if (src_code == SR_REGISTER)
 			UML_MOV(block, I2, 0);
 		else
-			UML_LOAD(block, I2, (void *)m_global_regs, src_code, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I2, (void *)m_core->global_regs, src_code, SIZE_DWORD, SCALE_x4);
 	}
 	else
 	{
 		UML_ADD(block, I4, I3, src_code);
 		UML_AND(block, I5, I4, 0x3f);
-		UML_LOAD(block, I2, (void *)m_local_regs, I5, SIZE_DWORD, SCALE_x4);
+		UML_LOAD(block, I2, (void *)m_core->local_regs, I5, SIZE_DWORD, SCALE_x4);
 	}
 
 	UML_AND(block, I4, DRC_PC, ~1);
@@ -4917,11 +4917,11 @@ void hyperstone_device::generate_call(drcuml_block *block, compiler_state *compi
 
 	UML_ADD(block, I1, I3, dst_code);
 	UML_AND(block, I6, I1, 0x3f);
-	UML_STORE(block, (void *)m_local_regs, I6, I4, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I6, I4, SIZE_DWORD, SCALE_x4);
 
 	UML_ADD(block, I4, I6, 1);
 	UML_AND(block, I5, I4, 0x3f);
-	UML_STORE(block, (void *)m_local_regs, I5, DRC_SR, SIZE_DWORD, SCALE_x4);
+	UML_STORE(block, (void *)m_core->local_regs, I5, DRC_SR, SIZE_DWORD, SCALE_x4);
 
 	UML_ROLINS(block, DRC_SR, I1, 25, 0xfe000000);
 	UML_ROLINS(block, DRC_SR, 6, 21, 0x01e00000);
@@ -4929,7 +4929,7 @@ void hyperstone_device::generate_call(drcuml_block *block, compiler_state *compi
 
 	UML_ADD(block, DRC_PC, I2, extra_s & ~1);
 
-	UML_MOV(block, mem(&m_intblock), 2);
+	UML_MOV(block, mem(&m_core->intblock), 2);
 
 	generate_branch(block, desc->targetpc);
 	//TODO: add interrupt locks, errors, ....
@@ -4939,7 +4939,7 @@ void hyperstone_device::generate_call(drcuml_block *block, compiler_state *compi
 
 void hyperstone_device::generate_trap_op(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1)); // TODO: with the latency it can change
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1)); // TODO: with the latency it can change
 
 	static const uint32_t conditions[16] = {
 		0, 0, 0, 0, N_MASK | Z_MASK, N_MASK | Z_MASK, N_MASK, N_MASK, C_MASK | Z_MASK, C_MASK | Z_MASK, C_MASK, C_MASK, Z_MASK, Z_MASK, V_MASK, 0
@@ -4972,7 +4972,7 @@ void hyperstone_device::generate_trap_op(drcuml_block *block, compiler_state *co
 
 void hyperstone_device::generate_extend(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc)
 {
-	UML_MOV(block, I7, mem(&m_clock_cycles_1));
+	UML_MOV(block, I7, mem(&m_core->clock_cycles_1));
 
 	uint16_t op = desc->opptr.w[0];
 
@@ -4989,11 +4989,11 @@ void hyperstone_device::generate_extend(drcuml_block *block, compiler_state *com
 
 	UML_ADD(block, I2, I3, src_code);
 	UML_AND(block, I2, I2, 0x3f);
-	UML_LOAD(block, I0, (void *)m_local_regs, I2, SIZE_DWORD, SCALE_x4); // I0: vals
+	UML_LOAD(block, I0, (void *)m_core->local_regs, I2, SIZE_DWORD, SCALE_x4); // I0: vals
 
 	UML_ADD(block, I2, I3, dst_code);
 	UML_AND(block, I2, I2, 0x3f);
-	UML_LOAD(block, I1, (void *)m_local_regs, I2, SIZE_DWORD, SCALE_x4); // I1: vald
+	UML_LOAD(block, I1, (void *)m_core->local_regs, I2, SIZE_DWORD, SCALE_x4); // I1: vald
 
 	switch (func)
 	{
@@ -5002,7 +5002,7 @@ void hyperstone_device::generate_extend(drcuml_block *block, compiler_state *com
 		case EMUL_N: // used in "N" type cpu
 		{
 			UML_MULU(block, I2, I3, I0, I1);
-			UML_STORE(block, (void *)m_global_regs, 15, I2, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, 15, I2, SIZE_DWORD, SCALE_x4);
 			break;
 		}
 
@@ -5013,8 +5013,8 @@ void hyperstone_device::generate_extend(drcuml_block *block, compiler_state *com
 				UML_MULU(block, I2, I3, I0, I1);
 			else
 				UML_MULS(block, I2, I3, I0, I1);
-			UML_STORE(block, (void *)m_global_regs, 14, I3, SIZE_DWORD, SCALE_x4);
-			UML_STORE(block, (void *)m_global_regs, 15, I2, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, 14, I3, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, 15, I2, SIZE_DWORD, SCALE_x4);
 			break;
 		}
 
@@ -5022,12 +5022,12 @@ void hyperstone_device::generate_extend(drcuml_block *block, compiler_state *com
 		case EMSUB: // signed multiply/substract, single word product difference
 		{
 			UML_MULS(block, I2, I3, I0, I1);
-			UML_LOAD(block, I3, (void *)m_global_regs, 15, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I3, (void *)m_core->global_regs, 15, SIZE_DWORD, SCALE_x4);
 			if (func == EMAC)
 				UML_ADD(block, I3, I3, I2);
 			else
 				UML_SUB(block, I3, I3, I2);
-			UML_STORE(block, (void *)m_global_regs, 15, I3, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, 15, I3, SIZE_DWORD, SCALE_x4);
 			break;
 		}
 
@@ -5037,17 +5037,17 @@ void hyperstone_device::generate_extend(drcuml_block *block, compiler_state *com
 			UML_DSEXT(block, I0, I0, SIZE_DWORD);
 			UML_DSEXT(block, I1, I1, SIZE_DWORD);
 			UML_DMULS(block, I2, I3, I0, I1);
-			UML_LOAD(block, I3, (void *)m_global_regs, 14, SIZE_DWORD, SCALE_x4);
-			UML_LOAD(block, I4, (void *)m_global_regs, 15, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I3, (void *)m_core->global_regs, 14, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I4, (void *)m_core->global_regs, 15, SIZE_DWORD, SCALE_x4);
 			UML_DSHL(block, I3, I3, 32);
 			UML_DOR(block, I3, I3, I4);
 			if (func == EMACD)
 				UML_DADD(block, I3, I3, I2);
 			else
 				UML_DSUB(block, I3, I3, I2);
-			UML_STORE(block, (void *)m_global_regs, 15, I3, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, 15, I3, SIZE_DWORD, SCALE_x4);
 			UML_DSHR(block, I3, I3, 32);
-			UML_STORE(block, (void *)m_global_regs, 14, I3, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, 14, I3, SIZE_DWORD, SCALE_x4);
 			break;
 		}
 
@@ -5061,9 +5061,9 @@ void hyperstone_device::generate_extend(drcuml_block *block, compiler_state *com
 			UML_SHR(block, I1, I1, 16);
 			UML_MULS(block, I0, I1, I0, I1);
 			UML_ADD(block, I0, I0, I2);
-			UML_LOAD(block, I1, (void *)m_global_regs, 15, SIZE_DWORD, SCALE_x4);
+			UML_LOAD(block, I1, (void *)m_core->global_regs, 15, SIZE_DWORD, SCALE_x4);
 			UML_ADD(block, I0, I0, I1);
-			UML_STORE(block, (void *)m_global_regs, 15, I0, SIZE_DWORD, SCALE_x4);
+			UML_STORE(block, (void *)m_core->global_regs, 15, I0, SIZE_DWORD, SCALE_x4);
 			break;
 		}
 
diff --git a/src/devices/cpu/e132xs/e132xsfe.cpp b/src/devices/cpu/e132xs/e132xsfe.cpp
index 040a2fa3fac..ec43a9d23d7 100644
--- a/src/devices/cpu/e132xs/e132xsfe.cpp
+++ b/src/devices/cpu/e132xs/e132xsfe.cpp
@@ -12,8 +12,8 @@
 #include "e132xsfe.h"
 #include "32xsdefs.h"
 
-#define FE_FP ((m_cpu->m_global_regs[1] & 0xfe000000) >> 25)
-#define FE_FL (m_cpu->m_fl_lut[((m_cpu->m_global_regs[1] >> 21) & 0xf)])
+#define FE_FP ((m_cpu->m_core->global_regs[1] & 0xfe000000) >> 25)
+#define FE_FL (m_cpu->m_core->fl_lut[((m_cpu->m_core->global_regs[1] >> 21) & 0xf)])
 #define FE_DST_CODE	((op & 0xf0) >> 4)
 #define FE_SRC_CODE	(op & 0x0f)
 #define SR_CODE		(1 << 1)
@@ -46,17 +46,17 @@ inline uint32_t e132xs_frontend::imm_length(opcode_desc &desc, uint16_t op)
 
 inline uint16_t e132xs_frontend::read_word(opcode_desc &desc)
 {
-	return m_cpu->m_direct->read_word(desc.physpc, m_cpu->m_opcodexor);
+	return m_cpu->m_direct->read_word(desc.physpc, m_cpu->m_core->opcodexor);
 }
 
 inline uint16_t e132xs_frontend::read_imm1(opcode_desc &desc)
 {
-	return m_cpu->m_direct->read_word(desc.physpc + 2, m_cpu->m_opcodexor);
+	return m_cpu->m_direct->read_word(desc.physpc + 2, m_cpu->m_core->opcodexor);
 }
 
 inline uint16_t e132xs_frontend::read_imm2(opcode_desc &desc)
 {
-	return m_cpu->m_direct->read_word(desc.physpc + 4, m_cpu->m_opcodexor);
+	return m_cpu->m_direct->read_word(desc.physpc + 4, m_cpu->m_core->opcodexor);
 }
 
 inline uint32_t e132xs_frontend::read_ldstxx_imm(opcode_desc &desc)
diff --git a/src/devices/cpu/e132xs/e132xsop.hxx b/src/devices/cpu/e132xs/e132xsop.hxx
index c85a0998e24..eb56e4cde0f 100644
--- a/src/devices/cpu/e132xs/e132xsop.hxx
+++ b/src/devices/cpu/e132xs/e132xsop.hxx
@@ -7,7 +7,7 @@ void hyperstone_device::hyperstone_chk()
 
 	const uint32_t fp = GET_FP;
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
-	const uint32_t dreg = DST_GLOBAL ? m_global_regs[DST_CODE] : m_local_regs[(DST_CODE + fp) & 0x3f];
+	const uint32_t dreg = DST_GLOBAL ? m_core->global_regs[DST_CODE] : m_core->local_regs[(DST_CODE + fp) & 0x3f];
 
 	if (SRC_GLOBAL && (src_code == SR_REGISTER))
 	{
@@ -16,12 +16,12 @@ void hyperstone_device::hyperstone_chk()
 	}
 	else
 	{
-		const uint32_t sreg = (SRC_GLOBAL ? m_global_regs : m_local_regs)[src_code];
+		const uint32_t sreg = (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[src_code];
 		if ((SRC_GLOBAL && (src_code == PC_REGISTER)) ? (dreg >= sreg) : (dreg > sreg))
 			execute_exception(get_trap_addr(TRAPNO_RANGE_ERROR));
 	}
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -35,8 +35,8 @@ void hyperstone_device::hyperstone_movd()
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + fp) & 0x3f);
 	const uint32_t dstf_code = DST_GLOBAL ? (dst_code + 1) : ((dst_code + 1) & 0x3f);
 
-	const uint32_t sreg = (SRC_GLOBAL ? m_global_regs : m_local_regs)[src_code];
-	const uint32_t sregf = (SRC_GLOBAL ? m_global_regs : m_local_regs)[srcf_code];
+	const uint32_t sreg = (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[src_code];
+	const uint32_t sregf = (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[srcf_code];
 
 	if (DST_GLOBAL && (dst_code == PC_REGISTER))
 	{
@@ -44,7 +44,7 @@ void hyperstone_device::hyperstone_movd()
 		if (SRC_GLOBAL && src_code < 2)
 		{
 			LOG("Denoted PC or SR in RET instruction. PC = %08X\n", PC);
-			m_icount -= m_clock_cycles_1;
+			m_core->icount -= m_core->clock_cycles_1;
 			return;
 		}
 
@@ -52,8 +52,8 @@ void hyperstone_device::hyperstone_movd()
 		const uint32_t old_l = SR & L_MASK;
 		PC = sreg & ~1;
 		SR = (sregf & 0xffe3ffff) | ((sreg & 0x01) << 18);
-		if (m_intblock < 1)
-			m_intblock = 1;
+		if (m_core->intblock < 1)
+			m_core->intblock = 1;
 
 		const uint32_t new_s = SR & S_MASK;
 		const uint32_t new_l = SR & L_MASK;
@@ -71,11 +71,11 @@ void hyperstone_device::hyperstone_movd()
 		for (; difference < 0; difference++)
 		{
 			SP -= 4;
-			m_local_regs[(SP & 0xfc) >> 2] = READ_W(SP);
+			m_core->local_regs[(SP & 0xfc) >> 2] = READ_W(SP);
 		}
 
 		//TODO: not 2!
-		m_icount -= m_clock_cycles_2;
+		m_core->icount -= m_core->clock_cycles_2;
 	}
 	else if (SRC_GLOBAL && (src_code == SR_REGISTER)) // Rd doesn't denote PC and Rs denotes SR
 	{
@@ -88,11 +88,11 @@ void hyperstone_device::hyperstone_movd()
 		}
 		else
 		{
-			m_local_regs[dst_code] = 0;
-			m_local_regs[dstf_code] = 0;
+			m_core->local_regs[dst_code] = 0;
+			m_core->local_regs[dstf_code] = 0;
 		}
 
-		m_icount -= m_clock_cycles_2;
+		m_core->icount -= m_core->clock_cycles_2;
 	}
 	else // Rd doesn't denote PC and Rs doesn't denote SR
 	{
@@ -108,11 +108,11 @@ void hyperstone_device::hyperstone_movd()
 		}
 		else
 		{
-			m_local_regs[dst_code] = sreg;
-			m_local_regs[dstf_code] = sregf;
+			m_core->local_regs[dst_code] = sreg;
+			m_core->local_regs[dstf_code] = sregf;
 		}
 
-		m_icount -= m_clock_cycles_2;
+		m_core->icount -= m_core->clock_cycles_2;
 	}
 }
 
@@ -129,13 +129,13 @@ void hyperstone_device::hyperstone_divsu()
 	if ((SRC_GLOBAL == DST_GLOBAL && (src_code == dst_code || src_code == dstf_code)) || (SRC_GLOBAL && src_code < 2))
 	{
 		LOG("Denoted the same register code or PC/SR as source in hyperstone_divu instruction. PC = %08X\n", PC);
-		m_icount -= 36 << m_clck_scale;
+		m_core->icount -= 36 << m_core->clck_scale;
 		return;
 	}
 
-	const uint32_t sreg = (SRC_GLOBAL ? m_global_regs : m_local_regs)[src_code];
-	const uint32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code];
-	const uint32_t dregf = (DST_GLOBAL ? m_global_regs : m_local_regs)[dstf_code];
+	const uint32_t sreg = (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[src_code];
+	const uint32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code];
+	const uint32_t dregf = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dstf_code];
 	const uint64_t dividend = concat_64(dreg, dregf);
 
 	if (sreg == 0 || (SIGNED && (dividend & 0x8000000000000000U)))
@@ -154,11 +154,11 @@ void hyperstone_device::hyperstone_divsu()
 		if (quotient == 0)
 			SR |= Z_MASK;
 		SR |= SIGN_TO_N(quotient);
-		(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] = SIGNED ? (uint32_t)((int64_t)dividend % (int32_t)sreg) : (dividend % sreg);
-		(DST_GLOBAL ? m_global_regs : m_local_regs)[dstf_code] = (uint32_t)quotient;
+		(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] = SIGNED ? (uint32_t)((int64_t)dividend % (int32_t)sreg) : (dividend % sreg);
+		(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dstf_code] = (uint32_t)quotient;
 	}
 
-	m_icount -= m_clock_cycles_36;
+	m_core->icount -= m_core->clock_cycles_36;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -190,11 +190,11 @@ void hyperstone_device::hyperstone_xm()
 	if ((SRC_GLOBAL && (src_code == SR_REGISTER)) || (DST_GLOBAL && (dst_code < 2)))
 	{
 		LOG("Denoted PC or SR in hyperstone_xm. PC = %08X\n", PC);
-		m_icount -= m_clock_cycles_1;
+		m_core->icount -= m_core->clock_cycles_1;
 		return;
 	}
 
-	uint32_t sreg = (SRC_GLOBAL ? m_global_regs : m_local_regs)[src_code];
+	uint32_t sreg = (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[src_code];
 
 	if (sub_type < 4)
 	{
@@ -208,9 +208,9 @@ void hyperstone_device::hyperstone_xm()
 		sreg <<= (sub_type - 4);
 	}
 
-	(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] = sreg;
+	(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] = sreg;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -218,7 +218,7 @@ void hyperstone_device::hyperstone_mask()
 {
 	const uint32_t extra_u = decode_const();
 	check_delay_PC();
-	const uint32_t dreg = (SRC_GLOBAL ? m_global_regs[SRC_CODE] : m_local_regs[(SRC_CODE + GET_FP) & 0x3f]) & extra_u;
+	const uint32_t dreg = (SRC_GLOBAL ? m_core->global_regs[SRC_CODE] : m_core->local_regs[(SRC_CODE + GET_FP) & 0x3f]) & extra_u;
 
 	if (dreg == 0)
 		SR |= Z_MASK;
@@ -228,9 +228,9 @@ void hyperstone_device::hyperstone_mask()
 	if (DST_GLOBAL)
 		set_global_register(DST_CODE, dreg);
 	else
-		m_local_regs[(DST_CODE + GET_FP) & 0x3f] = dreg;
+		m_core->local_regs[(DST_CODE + GET_FP) & 0x3f] = dreg;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -240,7 +240,7 @@ void hyperstone_device::hyperstone_sum()
 	check_delay_PC();
 	const uint32_t fp = GET_FP;
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
-	const uint32_t sreg = SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_global_regs[src_code]) : m_local_regs[src_code];
+	const uint32_t sreg = SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_core->global_regs[src_code]) : m_core->local_regs[src_code];
 
 	const uint64_t tmp = uint64_t(sreg) + uint64_t(extra_u);
 
@@ -257,10 +257,10 @@ void hyperstone_device::hyperstone_sum()
 	if (DST_GLOBAL)
 		set_global_register(DST_CODE, dreg);
 	else
-		m_local_regs[(DST_CODE + fp) & 0x3f] = dreg;
+		m_core->local_regs[(DST_CODE + fp) & 0x3f] = dreg;
 
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -272,7 +272,7 @@ void hyperstone_device::hyperstone_sums()
 
 	const uint32_t fp = GET_FP;
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
-	const int32_t sreg = int32_t(SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_global_regs[src_code]) : m_local_regs[src_code]);
+	const int32_t sreg = int32_t(SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_core->global_regs[src_code]) : m_core->local_regs[src_code]);
 
 	const int64_t tmp = int64_t(sreg) + int64_t(extra_s);
 
@@ -292,9 +292,9 @@ void hyperstone_device::hyperstone_sums()
 	if (DST_GLOBAL)
 		set_global_register(DST_CODE, res);
 	else
-		m_local_regs[(DST_CODE + fp) & 0x3f] = res;
+		m_core->local_regs[(DST_CODE + fp) & 0x3f] = res;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 
 	if ((SR & V_MASK) && src_code != SR_REGISTER)
 		execute_exception(get_trap_addr(TRAPNO_RANGE_ERROR));
@@ -310,8 +310,8 @@ void hyperstone_device::hyperstone_cmp()
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + fp) & 0x3f);
 
-	const uint32_t sreg = SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_global_regs[src_code]) : m_local_regs[src_code];
-	uint32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code];
+	const uint32_t sreg = SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_core->global_regs[src_code]) : m_core->local_regs[src_code];
+	uint32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code];
 
 	const uint64_t tmp = uint64_t(dreg) - uint64_t(sreg);
 
@@ -326,13 +326,13 @@ void hyperstone_device::hyperstone_cmp()
 	if (int32_t(dreg) < int32_t(sreg))
 		SR |= N_MASK;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
 void hyperstone_device::hyperstone_mov()
 {
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 
 	check_delay_PC();
 
@@ -346,7 +346,7 @@ void hyperstone_device::hyperstone_mov()
 	{
 		const uint32_t fp = GET_FP;
 		const uint32_t src_code = SRC_GLOBAL ? (SRC_CODE + (h ? 16 : 0)) : ((SRC_CODE + fp) & 0x3f);
-		const uint32_t sreg = SRC_GLOBAL ? ((WRITE_ONLY_REGMASK & (1 << src_code)) ? 0 : get_global_register(src_code)) : m_local_regs[src_code];
+		const uint32_t sreg = SRC_GLOBAL ? ((WRITE_ONLY_REGMASK & (1 << src_code)) ? 0 : get_global_register(src_code)) : m_core->local_regs[src_code];
 
 		SR &= ~(Z_MASK | N_MASK);
 		if (sreg == 0)
@@ -363,7 +363,7 @@ void hyperstone_device::hyperstone_mov()
 		}
 		else
 		{
-			m_local_regs[(DST_CODE + fp) & 0x3f] = sreg;
+			m_core->local_regs[(DST_CODE + fp) & 0x3f] = sreg;
 		}
 	}
 }
@@ -377,8 +377,8 @@ void hyperstone_device::hyperstone_add()
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + fp) & 0x3f);
 
-	const uint32_t sreg = SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_global_regs[src_code]) : m_local_regs[src_code];
-	uint32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code];
+	const uint32_t sreg = SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_core->global_regs[src_code]) : m_core->local_regs[src_code];
+	uint32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code];
 
 	const uint64_t tmp = uint64_t(sreg) + uint64_t(dreg);
 
@@ -402,10 +402,10 @@ void hyperstone_device::hyperstone_add()
 	}
 	else
 	{
-		m_local_regs[dst_code] = dreg;
+		m_core->local_regs[dst_code] = dreg;
 	}
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -417,8 +417,8 @@ void hyperstone_device::hyperstone_adds()
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + fp) & 0x3f);
 
-	const int32_t sreg = int32_t(SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_global_regs[src_code]) : m_local_regs[src_code]);
-	int32_t dreg = int32_t((DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code]);
+	const int32_t sreg = int32_t(SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_core->global_regs[src_code]) : m_core->local_regs[src_code]);
+	int32_t dreg = int32_t((DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code]);
 	const int64_t tmp = int64_t(sreg) + int64_t(dreg);
 
 	SR &= ~(V_MASK | Z_MASK | N_MASK);
@@ -437,9 +437,9 @@ void hyperstone_device::hyperstone_adds()
 	if (DST_GLOBAL)
 		set_global_register(dst_code, res);
 	else
-		m_local_regs[dst_code] = res;
+		m_core->local_regs[dst_code] = res;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 
 	if (SR & V_MASK)
 		execute_exception(get_trap_addr(TRAPNO_RANGE_ERROR));
@@ -456,15 +456,15 @@ void hyperstone_device::hyperstone_cmpb()
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + fp) & 0x3f);
 
-	const uint32_t sreg = (SRC_GLOBAL ? m_global_regs : m_local_regs)[src_code];
-	const uint32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code];
+	const uint32_t sreg = (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[src_code];
+	const uint32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code];
 
 	if (dreg & sreg)
 		SR &= ~Z_MASK;
 	else
 		SR |= Z_MASK;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -473,8 +473,8 @@ void hyperstone_device::hyperstone_andn()
 	check_delay_PC();
 
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + GET_FP) & 0x3f);
-	const uint32_t sreg = SRC_GLOBAL ? m_global_regs[SRC_CODE] : m_local_regs[(SRC_CODE + GET_FP) & 0x3f];
-	const uint32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] & ~sreg;
+	const uint32_t sreg = SRC_GLOBAL ? m_core->global_regs[SRC_CODE] : m_core->local_regs[(SRC_CODE + GET_FP) & 0x3f];
+	const uint32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] & ~sreg;
 
 	if (dreg == 0)
 		SR |= Z_MASK;
@@ -484,9 +484,9 @@ void hyperstone_device::hyperstone_andn()
 	if (DST_GLOBAL)
 		set_global_register(dst_code, dreg);
 	else
-		m_local_regs[dst_code] = dreg;
+		m_core->local_regs[dst_code] = dreg;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -495,8 +495,8 @@ void hyperstone_device::hyperstone_or()
 	check_delay_PC();
 
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + GET_FP) & 0x3f);
-	const uint32_t sreg = SRC_GLOBAL ? m_global_regs[SRC_CODE] : m_local_regs[(SRC_CODE + GET_FP) & 0x3f];
-	const uint32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] | sreg;
+	const uint32_t sreg = SRC_GLOBAL ? m_core->global_regs[SRC_CODE] : m_core->local_regs[(SRC_CODE + GET_FP) & 0x3f];
+	const uint32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] | sreg;
 
 	if (dreg == 0)
 		SR |= Z_MASK;
@@ -506,9 +506,9 @@ void hyperstone_device::hyperstone_or()
 	if (DST_GLOBAL)
 		set_global_register(dst_code, dreg);
 	else
-		m_local_regs[dst_code] = dreg;
+		m_core->local_regs[dst_code] = dreg;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -517,8 +517,8 @@ void hyperstone_device::hyperstone_xor()
 	check_delay_PC();
 
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + GET_FP) & 0x3f);
-	const uint32_t sreg = SRC_GLOBAL ? m_global_regs[SRC_CODE] : m_local_regs[(SRC_CODE + GET_FP) & 0x3f];
-	const uint32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] ^ sreg;
+	const uint32_t sreg = SRC_GLOBAL ? m_core->global_regs[SRC_CODE] : m_core->local_regs[(SRC_CODE + GET_FP) & 0x3f];
+	const uint32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] ^ sreg;
 
 	if (dreg == 0)
 		SR |= Z_MASK;
@@ -528,9 +528,9 @@ void hyperstone_device::hyperstone_xor()
 	if (DST_GLOBAL)
 		set_global_register(dst_code, dreg);
 	else
-		m_local_regs[dst_code] = dreg;
+		m_core->local_regs[dst_code] = dreg;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 
@@ -544,8 +544,8 @@ void hyperstone_device::hyperstone_subc()
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + fp) & 0x3f);
 
-	const uint32_t sreg = SRC_GLOBAL ? ((src_code == SR_REGISTER) ? 0 : m_global_regs[src_code]) : m_local_regs[src_code];
-	uint32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code];
+	const uint32_t sreg = SRC_GLOBAL ? ((src_code == SR_REGISTER) ? 0 : m_core->global_regs[src_code]) : m_core->local_regs[src_code];
+	uint32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code];
 	const uint32_t c = GET_C;
 
 	const uint64_t tmp = uint64_t(dreg) - (uint64_t(sreg) + uint64_t(c));
@@ -565,9 +565,9 @@ void hyperstone_device::hyperstone_subc()
 	if (DST_GLOBAL)
 		set_global_register(DST_CODE, dreg);
 	else
-		m_local_regs[dst_code] = dreg;
+		m_core->local_regs[dst_code] = dreg;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -575,7 +575,7 @@ void hyperstone_device::hyperstone_not()
 {
 	check_delay_PC();
 
-	const uint32_t dreg = ~(SRC_GLOBAL ? m_global_regs[SRC_CODE] : m_local_regs[(SRC_CODE + GET_FP) & 0x3f]);
+	const uint32_t dreg = ~(SRC_GLOBAL ? m_core->global_regs[SRC_CODE] : m_core->local_regs[(SRC_CODE + GET_FP) & 0x3f]);
 
 	if (dreg == 0)
 		SR |= Z_MASK;
@@ -585,9 +585,9 @@ void hyperstone_device::hyperstone_not()
 	if (DST_GLOBAL)
 		set_global_register(DST_CODE, dreg);
 	else
-		m_local_regs[(DST_CODE + GET_FP) & 0x3f] = dreg;
+		m_core->local_regs[(DST_CODE + GET_FP) & 0x3f] = dreg;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -599,8 +599,8 @@ void hyperstone_device::hyperstone_sub()
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + fp) & 0x3f);
 
-	const uint32_t sreg = SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_global_regs[src_code]) : m_local_regs[src_code];
-	uint32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code];
+	const uint32_t sreg = SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_core->global_regs[src_code]) : m_core->local_regs[src_code];
+	uint32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code];
 
 	const uint64_t tmp = uint64_t(dreg) - uint64_t(sreg);
 
@@ -623,10 +623,10 @@ void hyperstone_device::hyperstone_sub()
 	}
 	else
 	{
-		m_local_regs[dst_code] = dreg;
+		m_core->local_regs[dst_code] = dreg;
 	}
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -638,8 +638,8 @@ void hyperstone_device::hyperstone_subs()
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + fp) & 0x3f);
 
-	const int32_t sreg = int32_t(SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_global_regs[src_code]) : m_local_regs[src_code]);
-	int32_t dreg = int32_t((DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code]);
+	const int32_t sreg = int32_t(SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_core->global_regs[src_code]) : m_core->local_regs[src_code]);
+	int32_t dreg = int32_t((DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code]);
 	const int64_t tmp = int64_t(dreg) - int64_t(sreg);
 
 	SR &= ~(V_MASK | Z_MASK | N_MASK);
@@ -655,9 +655,9 @@ void hyperstone_device::hyperstone_subs()
 	if (DST_GLOBAL)
 		set_global_register(dst_code, dreg);
 	else
-		m_local_regs[dst_code] = dreg;
+		m_core->local_regs[dst_code] = dreg;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 
 	if (SR & V_MASK)
 		execute_exception(get_trap_addr(TRAPNO_RANGE_ERROR));
@@ -674,8 +674,8 @@ void hyperstone_device::hyperstone_addc()
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + fp) & 0x3f);
 
-	const uint32_t sreg = (SRC_GLOBAL ? m_global_regs : m_local_regs)[src_code];
-	uint32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code];
+	const uint32_t sreg = (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[src_code];
+	uint32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code];
 
 	const bool old_z = (SR & Z_MASK) != 0;
 	const uint32_t c = GET_C;
@@ -705,9 +705,9 @@ void hyperstone_device::hyperstone_addc()
 	if (DST_GLOBAL)
 		set_global_register(dst_code, dreg);
 	else
-		m_local_regs[dst_code] = dreg;
+		m_core->local_regs[dst_code] = dreg;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -716,8 +716,8 @@ void hyperstone_device::hyperstone_and()
 	check_delay_PC();
 
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + GET_FP) & 0x3f);
-	const uint32_t sreg = SRC_GLOBAL ? m_global_regs[SRC_CODE] : m_local_regs[(SRC_CODE + GET_FP) & 0x3f];
-	const uint32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] & sreg;
+	const uint32_t sreg = SRC_GLOBAL ? m_core->global_regs[SRC_CODE] : m_core->local_regs[(SRC_CODE + GET_FP) & 0x3f];
+	const uint32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] & sreg;
 
 	if (dreg == 0)
 		SR |= Z_MASK;
@@ -727,9 +727,9 @@ void hyperstone_device::hyperstone_and()
 	if (DST_GLOBAL)
 		set_global_register(dst_code, dreg);
 	else
-		m_local_regs[dst_code] = dreg;
+		m_core->local_regs[dst_code] = dreg;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -740,7 +740,7 @@ void hyperstone_device::hyperstone_neg()
 	const uint32_t fp = GET_FP;
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
 
-	const uint32_t sreg = SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_global_regs[src_code]) : m_local_regs[src_code];
+	const uint32_t sreg = SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_core->global_regs[src_code]) : m_core->local_regs[src_code];
 	const uint64_t tmp = -uint64_t(sreg);
 
 	SR &= ~(C_MASK | V_MASK | Z_MASK | N_MASK);
@@ -756,9 +756,9 @@ void hyperstone_device::hyperstone_neg()
 	if (DST_GLOBAL)
 		set_global_register(DST_CODE, dreg);
 	else
-		m_local_regs[(DST_CODE + fp) & 0x3f] = dreg;
+		m_core->local_regs[(DST_CODE + fp) & 0x3f] = dreg;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -769,7 +769,7 @@ void hyperstone_device::hyperstone_negs()
 	const uint32_t fp = GET_FP;
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
 
-	const int32_t sreg = int32_t(SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_global_regs[src_code]) : m_local_regs[src_code]);
+	const int32_t sreg = int32_t(SRC_GLOBAL ? ((src_code == SR_REGISTER) ? GET_C : m_core->global_regs[src_code]) : m_core->local_regs[src_code]);
 	const int64_t tmp = -int64_t(sreg);
 
 	SR &= ~(V_MASK | Z_MASK | N_MASK);
@@ -790,9 +790,9 @@ void hyperstone_device::hyperstone_negs()
 	if (DST_GLOBAL)
 		set_global_register(DST_CODE, res);
 	else
-		m_local_regs[(DST_CODE + fp) & 0x3f] = res;
+		m_core->local_regs[(DST_CODE + fp) & 0x3f] = res;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 
 	if (GET_V)
 		execute_exception(get_trap_addr(TRAPNO_RANGE_ERROR));
@@ -812,7 +812,7 @@ void hyperstone_device::hyperstone_cmpi()
 	if (!IMM_LONG)
 		imm = m_op & 0x0f;
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + GET_FP) & 0x3f);
-	const uint32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code];
+	const uint32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code];
 
 	SR &= ~(V_MASK | Z_MASK | N_MASK | C_MASK);
 
@@ -827,13 +827,13 @@ void hyperstone_device::hyperstone_cmpi()
 	if ((int32_t)dreg < (int32_t)imm)
 		SR |= N_MASK;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::imm_size IMM_LONG>
 void hyperstone_device::hyperstone_movi()
 {
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 
 	uint32_t imm;
 	if (IMM_LONG)
@@ -870,7 +870,7 @@ void hyperstone_device::hyperstone_movi()
 		}
 		else
 		{
-			m_local_regs[(DST_CODE + GET_FP) & 0x3f] = imm;
+			m_core->local_regs[(DST_CODE + GET_FP) & 0x3f] = imm;
 		}
 	}
 }
@@ -884,7 +884,7 @@ void hyperstone_device::hyperstone_addi()
 	check_delay_PC();
 
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + GET_FP) & 0x3f);
-	uint32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code];
+	uint32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code];
 
 	if (!N_OP_MASK)
 		imm = GET_C & (((SR & Z_MASK) ? 0 : 1) | (dreg & 0x01));
@@ -913,10 +913,10 @@ void hyperstone_device::hyperstone_addi()
 	}
 	else
 	{
-		m_local_regs[dst_code] = dreg;
+		m_core->local_regs[dst_code] = dreg;
 	}
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::imm_size IMM_LONG>
@@ -926,7 +926,7 @@ void hyperstone_device::hyperstone_addsi()
 		check_delay_PC();
 
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + GET_FP) & 0x3f);
-	const int32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code];
+	const int32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code];
 
 	int32_t imm;
 	if (N_OP_MASK)
@@ -969,9 +969,9 @@ void hyperstone_device::hyperstone_addsi()
 	if (DST_GLOBAL)
 		set_global_register(dst_code, res);
 	else
-		m_local_regs[dst_code] = res;
+		m_core->local_regs[dst_code] = res;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 
 	if (SR & V_MASK)
 		execute_exception(get_trap_addr(TRAPNO_RANGE_ERROR));
@@ -985,7 +985,7 @@ void hyperstone_device::hyperstone_cmpbi()
 	if (!IMM_LONG)
 		check_delay_PC();
 
-	const uint32_t dreg = DST_GLOBAL ? m_global_regs[DST_CODE] : m_local_regs[(DST_CODE + GET_FP) & 0x3f];
+	const uint32_t dreg = DST_GLOBAL ? m_core->global_regs[DST_CODE] : m_core->local_regs[(DST_CODE + GET_FP) & 0x3f];
 
 	const uint32_t n = N_VALUE;
 	if (n)
@@ -1031,7 +1031,7 @@ void hyperstone_device::hyperstone_cmpbi()
 			SR &= ~Z_MASK;
 	}
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::imm_size IMM_LONG>
@@ -1052,7 +1052,7 @@ void hyperstone_device::hyperstone_andni()
 	if (DST_GLOBAL)
 	{
 		const uint32_t dst_code = DST_CODE;
-		dreg = m_global_regs[dst_code] & ~imm;
+		dreg = m_core->global_regs[dst_code] & ~imm;
 
 		if (dreg == 0)
 			SR |= Z_MASK;
@@ -1064,8 +1064,8 @@ void hyperstone_device::hyperstone_andni()
 	else
 	{
 		const uint32_t dst_code = (DST_CODE + GET_FP) & 0x3f;
-		dreg = m_local_regs[dst_code] & ~imm;
-		m_local_regs[dst_code] = dreg;
+		dreg = m_core->local_regs[dst_code] & ~imm;
+		m_core->local_regs[dst_code] = dreg;
 
 		if (dreg == 0)
 			SR |= Z_MASK;
@@ -1073,7 +1073,7 @@ void hyperstone_device::hyperstone_andni()
 			SR &= ~Z_MASK;
 	}
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::imm_size IMM_LONG>
@@ -1091,7 +1091,7 @@ void hyperstone_device::hyperstone_ori()
 	if (DST_GLOBAL)
 	{
 		const uint32_t dst_code = DST_CODE;
-		const uint32_t dreg = m_global_regs[dst_code] | imm;
+		const uint32_t dreg = m_core->global_regs[dst_code] | imm;
 
 		if (dreg)
 			SR &= ~Z_MASK;
@@ -1103,7 +1103,7 @@ void hyperstone_device::hyperstone_ori()
 	else
 	{
 		const uint32_t dst_code = (DST_CODE + GET_FP) & 0x3f;
-		const uint32_t dreg = m_local_regs[dst_code] |= imm;
+		const uint32_t dreg = m_core->local_regs[dst_code] |= imm;
 
 		if (dreg)
 			SR &= ~Z_MASK;
@@ -1111,7 +1111,7 @@ void hyperstone_device::hyperstone_ori()
 			SR |= Z_MASK;
 	}
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::imm_size IMM_LONG>
@@ -1129,7 +1129,7 @@ void hyperstone_device::hyperstone_xori()
 	if (DST_GLOBAL)
 	{
 		const uint32_t dst_code = DST_CODE;
-		dreg = m_global_regs[dst_code] ^ imm;
+		dreg = m_core->global_regs[dst_code] ^ imm;
 
 		if (dreg)
 			SR &= ~Z_MASK;
@@ -1141,7 +1141,7 @@ void hyperstone_device::hyperstone_xori()
 	else
 	{
 		const uint32_t dst_code = (DST_CODE + GET_FP) & 0x3f;
-		dreg = m_local_regs[dst_code] ^= imm;
+		dreg = m_core->local_regs[dst_code] ^= imm;
 
 		if (dreg)
 			SR &= ~Z_MASK;
@@ -1149,7 +1149,7 @@ void hyperstone_device::hyperstone_xori()
 			SR |= Z_MASK;
 	}
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 
@@ -1162,8 +1162,8 @@ void hyperstone_device::hyperstone_shrdi()
 	const uint32_t code = DST_CODE;
 	const uint32_t dst_code = (code + fp) & 0x3f;
 	const uint32_t dstf_code = (code + 1 + fp) & 0x3f;
-	uint32_t high_order = m_local_regs[dst_code];
-	const uint32_t low_order  = m_local_regs[dstf_code];
+	uint32_t high_order = m_core->local_regs[dst_code];
+	const uint32_t low_order  = m_core->local_regs[dstf_code];
 
 	uint64_t val = concat_64(high_order, low_order);
 
@@ -1183,10 +1183,10 @@ void hyperstone_device::hyperstone_shrdi()
 		SR |= Z_MASK;
 	SR |= SIGN_TO_N(high_order);
 
-	m_local_regs[dst_code] = high_order;
-	m_local_regs[dstf_code] = extract_64lo(val);
+	m_core->local_regs[dst_code] = high_order;
+	m_core->local_regs[dstf_code] = extract_64lo(val);
 
-	m_icount -= m_clock_cycles_2;
+	m_core->icount -= m_core->clock_cycles_2;
 }
 
 
@@ -1202,15 +1202,15 @@ void hyperstone_device::hyperstone_shrd()
 
 	if (src_code == dst_code || src_code == dstf_code)
 	{
-		m_icount -= m_clock_cycles_2;
+		m_core->icount -= m_core->clock_cycles_2;
 		return;
 	}
 
-	uint64_t val = concat_64(m_local_regs[dst_code], m_local_regs[dstf_code]);
+	uint64_t val = concat_64(m_core->local_regs[dst_code], m_core->local_regs[dstf_code]);
 
 	SR &= ~(C_MASK | Z_MASK | N_MASK);
 
-	const uint32_t n = m_local_regs[src_code] & 0x1f;
+	const uint32_t n = m_core->local_regs[src_code] & 0x1f;
 
 	if (n)
 	{
@@ -1222,10 +1222,10 @@ void hyperstone_device::hyperstone_shrd()
 		SR |= Z_MASK;
 	SR |= SIGN64_TO_N(val);
 
-	m_local_regs[dst_code] = (uint32_t)(val >> 32);
-	m_local_regs[dstf_code] = (uint32_t)val;
+	m_core->local_regs[dst_code] = (uint32_t)(val >> 32);
+	m_core->local_regs[dstf_code] = (uint32_t)val;
 
-	m_icount -= m_clock_cycles_2;
+	m_core->icount -= m_core->clock_cycles_2;
 }
 
 void hyperstone_device::hyperstone_shr()
@@ -1234,8 +1234,8 @@ void hyperstone_device::hyperstone_shr()
 
 	const uint32_t fp = GET_FP;
 	const uint32_t dst_code = (DST_CODE + fp) & 0x3f;
-	const uint32_t n = m_local_regs[(SRC_CODE + fp) & 0x3f] & 0x1f;
-	uint32_t dreg = m_local_regs[dst_code];
+	const uint32_t n = m_core->local_regs[(SRC_CODE + fp) & 0x3f] & 0x1f;
+	uint32_t dreg = m_core->local_regs[dst_code];
 
 	SR &= ~(C_MASK | Z_MASK | N_MASK);
 
@@ -1248,9 +1248,9 @@ void hyperstone_device::hyperstone_shr()
 		SR |= Z_MASK;
 	SR |= SIGN_TO_N(dreg);
 
-	m_local_regs[dst_code] = dreg;
+	m_core->local_regs[dst_code] = dreg;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::shift_type HI_N>
@@ -1261,7 +1261,7 @@ void hyperstone_device::hyperstone_sardi()
 	const uint32_t dst_code = (DST_CODE + GET_FP) & 0x3f;
 	const uint32_t dstf_code = (dst_code + 1) & 0x3f;
 
-	uint64_t val = concat_64(m_local_regs[dst_code], m_local_regs[dstf_code]);
+	uint64_t val = concat_64(m_core->local_regs[dst_code], m_core->local_regs[dstf_code]);
 
 	SR &= ~(C_MASK | Z_MASK | N_MASK);
 
@@ -1279,12 +1279,12 @@ void hyperstone_device::hyperstone_sardi()
 
 	if (val == 0)
 		SR |= Z_MASK;
-	SR |= SIGN_TO_N(m_local_regs[dst_code]);
+	SR |= SIGN_TO_N(m_core->local_regs[dst_code]);
 
-	m_local_regs[dst_code] = (uint32_t)(val >> 32);
-	m_local_regs[dstf_code] = (uint32_t)val;
+	m_core->local_regs[dst_code] = (uint32_t)(val >> 32);
+	m_core->local_regs[dstf_code] = (uint32_t)val;
 
-	m_icount -= m_clock_cycles_2;
+	m_core->icount -= m_core->clock_cycles_2;
 }
 
 void hyperstone_device::hyperstone_sard()
@@ -1299,15 +1299,15 @@ void hyperstone_device::hyperstone_sard()
 
 	if (src_code == dst_code || src_code == dstf_code)
 	{
-		m_icount -= m_clock_cycles_2;
+		m_core->icount -= m_core->clock_cycles_2;
 		return;
 	}
 
-	uint64_t val = concat_64(m_local_regs[dst_code], m_local_regs[dstf_code]);
+	uint64_t val = concat_64(m_core->local_regs[dst_code], m_core->local_regs[dstf_code]);
 
 	SR &= ~(C_MASK | Z_MASK | N_MASK);
 
-	const uint32_t n = m_local_regs[src_code] & 0x1f;
+	const uint32_t n = m_core->local_regs[src_code] & 0x1f;
 
 	if (n)
 	{
@@ -1327,10 +1327,10 @@ void hyperstone_device::hyperstone_sard()
 		SR |= Z_MASK;
 	SR |= SIGN64_TO_N(val);
 
-	m_local_regs[dst_code] = (uint32_t)(val >> 32);
-	m_local_regs[dstf_code] = (uint32_t)val;
+	m_core->local_regs[dst_code] = (uint32_t)(val >> 32);
+	m_core->local_regs[dstf_code] = (uint32_t)val;
 
-	m_icount -= m_clock_cycles_2;
+	m_core->icount -= m_core->clock_cycles_2;
 }
 
 void hyperstone_device::hyperstone_sar()
@@ -1340,8 +1340,8 @@ void hyperstone_device::hyperstone_sar()
 	const uint32_t fp = GET_FP;
 	const uint32_t dst_code = (DST_CODE + fp) & 0x3f;
 
-	const uint32_t n = m_local_regs[(SRC_CODE + fp) & 0x3f] & 0x1f;
-	uint32_t ret = m_local_regs[dst_code];
+	const uint32_t n = m_core->local_regs[(SRC_CODE + fp) & 0x3f] & 0x1f;
+	uint32_t ret = m_core->local_regs[dst_code];
 
 	SR &= ~(C_MASK | Z_MASK | N_MASK);
 
@@ -1361,9 +1361,9 @@ void hyperstone_device::hyperstone_sar()
 		SR |= Z_MASK;
 	SR |= SIGN_TO_N(ret);
 
-	m_local_regs[dst_code] = ret;
+	m_core->local_regs[dst_code] = ret;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::shift_type HI_N>
@@ -1375,8 +1375,8 @@ void hyperstone_device::hyperstone_shldi()
 	const uint32_t code = DST_CODE;
 	const uint32_t dst_code = (code + fp) & 0x3f;
 	const uint32_t dstf_code = (code + 1 + fp) & 0x3f;
-	uint32_t high_order = m_local_regs[dst_code];
-	uint32_t low_order  = m_local_regs[dstf_code];
+	uint32_t high_order = m_core->local_regs[dst_code];
+	uint32_t low_order  = m_core->local_regs[dstf_code];
 
 	uint64_t val = concat_64(high_order, low_order);
 
@@ -1397,10 +1397,10 @@ void hyperstone_device::hyperstone_shldi()
 		SR |= Z_MASK;
 	SR |= SIGN64_TO_N(val);
 
-	m_local_regs[dst_code] = extract_64hi(val);
-	m_local_regs[dstf_code] = extract_64lo(val);
+	m_core->local_regs[dst_code] = extract_64hi(val);
+	m_core->local_regs[dstf_code] = extract_64lo(val);
 
-	m_icount -= m_clock_cycles_2;
+	m_core->icount -= m_core->clock_cycles_2;
 }
 
 void hyperstone_device::hyperstone_shld()
@@ -1417,18 +1417,18 @@ void hyperstone_device::hyperstone_shld()
 	if (src_code == dst_code || src_code == dstf_code)
 	{
 		LOG("Denoted same registers in hyperstone_shld. PC = %08X\n", PC);
-		m_icount -= m_clock_cycles_2;
+		m_core->icount -= m_core->clock_cycles_2;
 		return;
 	}
 
-	uint32_t high_order = m_local_regs[dst_code];
-	uint32_t low_order  = m_local_regs[dstf_code];
+	uint32_t high_order = m_core->local_regs[dst_code];
+	uint32_t low_order  = m_core->local_regs[dstf_code];
 
 	uint64_t val = concat_64(high_order, low_order);
 
 	SR &= ~(C_MASK | V_MASK | Z_MASK | N_MASK);
 
-	const uint32_t n = m_local_regs[src_code] & 0x1f;
+	const uint32_t n = m_core->local_regs[src_code] & 0x1f;
 	SR |= (n)?(((val<<(n-1))&0x8000000000000000ULL)?1:0):0;
 
 	const uint32_t tmp = high_order << n;
@@ -1443,10 +1443,10 @@ void hyperstone_device::hyperstone_shld()
 		SR |= Z_MASK;
 	SR |= SIGN64_TO_N(val);
 
-	m_local_regs[dst_code] = extract_64hi(val);
-	m_local_regs[dstf_code] = extract_64lo(val);
+	m_core->local_regs[dst_code] = extract_64hi(val);
+	m_core->local_regs[dstf_code] = extract_64lo(val);
 
-	m_icount -= m_clock_cycles_2;
+	m_core->icount -= m_core->clock_cycles_2;
 }
 
 void hyperstone_device::hyperstone_shl()
@@ -1457,8 +1457,8 @@ void hyperstone_device::hyperstone_shl()
 	uint32_t src_code = SRC_CODE + fp;
 	uint32_t dst_code = DST_CODE + fp;
 
-	uint32_t n    = m_local_regs[src_code & 0x3f] & 0x1f;
-	uint32_t base = m_local_regs[dst_code & 0x3f]; /* registers offset by frame pointer */
+	uint32_t n    = m_core->local_regs[src_code & 0x3f] & 0x1f;
+	uint32_t base = m_core->local_regs[dst_code & 0x3f]; /* registers offset by frame pointer */
 	uint64_t mask = ((((uint64_t)1) << (32 - n)) - 1) ^ 0xffffffff;
 
 	SR &= ~(C_MASK | V_MASK | Z_MASK | N_MASK);
@@ -1473,9 +1473,9 @@ void hyperstone_device::hyperstone_shl()
 		SR |= Z_MASK;
 	SR |= SIGN_TO_N(ret);
 
-	m_local_regs[dst_code & 0x3f] = ret;
+	m_core->local_regs[dst_code & 0x3f] = ret;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 void hyperstone_device::hyperstone_testlz()
@@ -1483,7 +1483,7 @@ void hyperstone_device::hyperstone_testlz()
 	check_delay_PC();
 
 	const uint32_t fp = GET_FP;
-	const uint32_t sreg = m_local_regs[(SRC_CODE + fp) & 0x3f];
+	const uint32_t sreg = m_core->local_regs[(SRC_CODE + fp) & 0x3f];
 	uint32_t zeros = 0;
 	for (uint32_t mask = 0x80000000; mask != 0; mask >>= 1 )
 	{
@@ -1493,9 +1493,9 @@ void hyperstone_device::hyperstone_testlz()
 			zeros++;
 	}
 
-	m_local_regs[(DST_CODE + fp) & 0x3f] = zeros;
+	m_core->local_regs[(DST_CODE + fp) & 0x3f] = zeros;
 
-	m_icount -= m_clock_cycles_2;
+	m_core->icount -= m_core->clock_cycles_2;
 }
 
 void hyperstone_device::hyperstone_rol()
@@ -1505,8 +1505,8 @@ void hyperstone_device::hyperstone_rol()
 	const uint32_t fp = GET_FP;
 	const uint32_t dst_code = (DST_CODE + fp) & 0x3f;
 
-	uint32_t n = m_local_regs[(SRC_CODE + fp) & 0x3f] & 0x1f;
-	uint32_t val = m_local_regs[dst_code];
+	uint32_t n = m_core->local_regs[(SRC_CODE + fp) & 0x3f] & 0x1f;
+	uint32_t val = m_core->local_regs[dst_code];
 
 #ifdef MISSIONCRAFT_FLAGS
 	const uint32_t base = val;
@@ -1528,9 +1528,9 @@ void hyperstone_device::hyperstone_rol()
 		SR |= Z_MASK;
 	SR |= SIGN_TO_N(val);
 
-	m_local_regs[dst_code] = val;
+	m_core->local_regs[dst_code] = val;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -1569,7 +1569,7 @@ void hyperstone_device::hyperstone_ldxx1()
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
 	const uint32_t srcf_code = SRC_GLOBAL ? (src_code + 1) : ((src_code + 1) & 0x3f);
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + fp) & 0x3f);
-	const uint32_t dreg = ((DST_GLOBAL && dst_code == SR_REGISTER) ? 0 : (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code]);
+	const uint32_t dreg = ((DST_GLOBAL && dst_code == SR_REGISTER) ? 0 : (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code]);
 
 	switch (sub_type)
 	{
@@ -1577,14 +1577,14 @@ void hyperstone_device::hyperstone_ldxx1()
 			if (SRC_GLOBAL)
 				set_global_register(src_code, (int32_t)(int8_t)READ_B(dreg + extra_s));
 			else
-				m_local_regs[src_code] = (int32_t)(int8_t)READ_B(dreg + extra_s);
+				m_core->local_regs[src_code] = (int32_t)(int8_t)READ_B(dreg + extra_s);
 			break;
 
 		case 1: // LDBU.D
 			if (SRC_GLOBAL)
 				set_global_register(src_code, READ_B(dreg + extra_s));
 			else
-				m_local_regs[src_code] = READ_B(dreg + extra_s);
+				m_core->local_regs[src_code] = READ_B(dreg + extra_s);
 			break;
 
 		case 2:
@@ -1598,9 +1598,9 @@ void hyperstone_device::hyperstone_ldxx1()
 			else
 			{
 				if (extra_s & 1)
-					m_local_regs[src_code] = (int32_t)(int16_t)READ_HW(dreg + (extra_s & ~1));
+					m_core->local_regs[src_code] = (int32_t)(int16_t)READ_HW(dreg + (extra_s & ~1));
 				else
-					m_local_regs[src_code] = READ_HW(dreg + (extra_s & ~1));
+					m_core->local_regs[src_code] = READ_HW(dreg + (extra_s & ~1));
 			}
 			break;
 
@@ -1611,7 +1611,7 @@ void hyperstone_device::hyperstone_ldxx1()
 					if (SRC_GLOBAL)
 						set_global_register(src_code, READ_W(dreg + extra_s));
 					else
-						m_local_regs[src_code] = READ_W(dreg + extra_s);
+						m_core->local_regs[src_code] = READ_W(dreg + extra_s);
 					break;
 				case 1: // LDD.D
 					if (SRC_GLOBAL)
@@ -1621,16 +1621,16 @@ void hyperstone_device::hyperstone_ldxx1()
 					}
 					else
 					{
-						m_local_regs[src_code] = READ_W(dreg + (extra_s & ~1));
-						m_local_regs[srcf_code] = READ_W(dreg + (extra_s & ~1) + 4);
+						m_core->local_regs[src_code] = READ_W(dreg + (extra_s & ~1));
+						m_core->local_regs[srcf_code] = READ_W(dreg + (extra_s & ~1) + 4);
 					}
-					m_icount -= m_clock_cycles_1; // extra cycle
+					m_core->icount -= m_core->clock_cycles_1; // extra cycle
 					break;
 				case 2: // LDW.IOD
 					if (SRC_GLOBAL)
 						set_global_register(src_code, IO_READ_W(dreg + (extra_s & ~3)));
 					else
-						m_local_regs[src_code] = IO_READ_W(dreg + (extra_s & ~3));
+						m_core->local_regs[src_code] = IO_READ_W(dreg + (extra_s & ~3));
 					break;
 				case 3: // LDD.IOD
 					if (SRC_GLOBAL)
@@ -1640,16 +1640,16 @@ void hyperstone_device::hyperstone_ldxx1()
 					}
 					else
 					{
-						m_local_regs[src_code] = IO_READ_W(dreg + (extra_s & ~3));
-						m_local_regs[srcf_code] = IO_READ_W(dreg + (extra_s & ~3) + 4);
+						m_core->local_regs[src_code] = IO_READ_W(dreg + (extra_s & ~3));
+						m_core->local_regs[srcf_code] = IO_READ_W(dreg + (extra_s & ~3) + 4);
 					}
-					m_icount -= m_clock_cycles_1; // extra cycle
+					m_core->icount -= m_core->clock_cycles_1; // extra cycle
 					break;
 			}
 			break;
 	}
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -1689,14 +1689,14 @@ void hyperstone_device::hyperstone_ldxx2()
 
 	if (DST_GLOBAL && dst_code < 2)
 	{
-		m_icount -= m_clock_cycles_1;
+		m_core->icount -= m_core->clock_cycles_1;
 		LOG("Denoted PC or SR in hyperstone_ldxx2. PC = %08X\n", PC);
 		return;
 	}
 
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : (SRC_CODE + fp) & 0x3f;
 	const uint32_t srcf_code = SRC_GLOBAL ? (src_code + 1) : ((src_code + 1) & 0x3f);
-	const uint32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code];
+	const uint32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code];
 
 	switch (sub_type)
 	{
@@ -1704,18 +1704,18 @@ void hyperstone_device::hyperstone_ldxx2()
 			if (SRC_GLOBAL)
 				set_global_register(src_code, (int32_t)(int8_t)READ_B(dreg));
 			else
-				m_local_regs[src_code] = (int32_t)(int8_t)READ_B(dreg);
+				m_core->local_regs[src_code] = (int32_t)(int8_t)READ_B(dreg);
 			if (DST_GLOBAL != SRC_GLOBAL || src_code != dst_code)
-				(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] += extra_s;
+				(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] += extra_s;
 			break;
 
 		case 1: // LDBU.N
 			if (SRC_GLOBAL)
 				set_global_register(src_code, READ_B(dreg));
 			else
-				m_local_regs[src_code] = READ_B(dreg);
+				m_core->local_regs[src_code] = READ_B(dreg);
 			if(DST_GLOBAL != SRC_GLOBAL || src_code != dst_code)
-				(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] += extra_s;
+				(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] += extra_s;
 			break;
 
 		case 2:
@@ -1729,13 +1729,13 @@ void hyperstone_device::hyperstone_ldxx2()
 			else
 			{
 				if (extra_s & 1) // LDHS.N
-					m_local_regs[src_code] = (int32_t)(int16_t)READ_HW(dreg);
+					m_core->local_regs[src_code] = (int32_t)(int16_t)READ_HW(dreg);
 				else // LDHU.N
-					m_local_regs[src_code] = READ_HW(dreg);
+					m_core->local_regs[src_code] = READ_HW(dreg);
 			}
 
 			if(DST_GLOBAL != SRC_GLOBAL || src_code != dst_code)
-				(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] += (extra_s & ~1);
+				(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] += (extra_s & ~1);
 			break;
 
 		case 3:
@@ -1745,9 +1745,9 @@ void hyperstone_device::hyperstone_ldxx2()
 					if (SRC_GLOBAL)
 						set_global_register(src_code, READ_W(dreg));
 					else
-						m_local_regs[src_code] = READ_W(dreg);
+						m_core->local_regs[src_code] = READ_W(dreg);
 					if(DST_GLOBAL != SRC_GLOBAL || src_code != dst_code)
-						(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] += extra_s;
+						(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] += extra_s;
 					break;
 				case 1: // LDD.N
 					if (SRC_GLOBAL)
@@ -1757,14 +1757,14 @@ void hyperstone_device::hyperstone_ldxx2()
 					}
 					else
 					{
-						m_local_regs[src_code] = READ_W(dreg);
-						m_local_regs[srcf_code] = READ_W(dreg + 4);
+						m_core->local_regs[src_code] = READ_W(dreg);
+						m_core->local_regs[srcf_code] = READ_W(dreg + 4);
 					}
 
 					if (DST_GLOBAL != SRC_GLOBAL || (src_code != dst_code && srcf_code != dst_code))
-						(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] += extra_s & ~1;
+						(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] += extra_s & ~1;
 
-					m_icount -= m_clock_cycles_1; // extra cycle
+					m_core->icount -= m_core->clock_cycles_1; // extra cycle
 					break;
 				case 2: // Reserved
 					LOG("Executed Reserved instruction in hyperstone_ldxx2. PC = %08X\n", PC);
@@ -1775,26 +1775,26 @@ void hyperstone_device::hyperstone_ldxx2()
 						if (dreg < SP)
 							set_global_register(src_code, READ_W(dreg));
 						else
-							set_global_register(src_code, m_local_regs[(dreg & 0xfc) >> 2]);
+							set_global_register(src_code, m_core->local_regs[(dreg & 0xfc) >> 2]);
 					}
 					else
 					{
 						if (dreg < SP)
-							m_local_regs[src_code] = READ_W(dreg);
+							m_core->local_regs[src_code] = READ_W(dreg);
 						else
-							m_local_regs[src_code] = m_local_regs[(dreg & 0xfc) >> 2];
+							m_core->local_regs[src_code] = m_core->local_regs[(dreg & 0xfc) >> 2];
 					}
 
 					if (DST_GLOBAL != SRC_GLOBAL || src_code != dst_code)
-						(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] += extra_s & ~3;
+						(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] += extra_s & ~3;
 
-					m_icount -= m_clock_cycles_2; // extra cycles
+					m_core->icount -= m_core->clock_cycles_2; // extra cycles
 					break;
 			}
 			break;
 	}
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -1832,8 +1832,8 @@ void hyperstone_device::hyperstone_stxx1()
 	const uint32_t fp = GET_FP;
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + fp) & 0x3f);
-	const uint32_t dreg = ((DST_GLOBAL && dst_code == SR_REGISTER) ? 0 : (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code]);
-	const uint32_t sreg = ((SRC_GLOBAL && src_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_global_regs : m_local_regs)[src_code]);
+	const uint32_t dreg = ((DST_GLOBAL && dst_code == SR_REGISTER) ? 0 : (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code]);
+	const uint32_t sreg = ((SRC_GLOBAL && src_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[src_code]);
 
 	switch (sub_type)
 	{
@@ -1860,11 +1860,11 @@ void hyperstone_device::hyperstone_stxx1()
 				case 1: // STD.D
 				{
 					const uint32_t srcf_code = SRC_GLOBAL ? (src_code + 1) : ((src_code + 1) & 0x3f);
-					const uint32_t sregf = ((SRC_GLOBAL && srcf_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_global_regs : m_local_regs)[srcf_code]);
+					const uint32_t sregf = ((SRC_GLOBAL && srcf_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[srcf_code]);
 					extra_s &= ~1;
 					WRITE_W(dreg + extra_s, sreg);
 					WRITE_W(dreg + extra_s + 4, sregf);
-					m_icount -= m_clock_cycles_1; // extra cycle
+					m_core->icount -= m_core->clock_cycles_1; // extra cycle
 					break;
 				}
 				case 2: // STW.IOD
@@ -1873,18 +1873,18 @@ void hyperstone_device::hyperstone_stxx1()
 				case 3: // STD.IOD
 				{
 					const uint32_t srcf_code = SRC_GLOBAL ? (src_code + 1) : ((src_code + 1) & 0x3f);
-					const uint32_t sregf = ((SRC_GLOBAL && srcf_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_global_regs : m_local_regs)[srcf_code]);
+					const uint32_t sregf = ((SRC_GLOBAL && srcf_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[srcf_code]);
 					extra_s &= ~3;
 					IO_WRITE_W(dreg + extra_s, sreg);
 					IO_WRITE_W(dreg + extra_s + 4, sregf);
-					m_icount -= m_clock_cycles_1; // extra cycle
+					m_core->icount -= m_core->clock_cycles_1; // extra cycle
 					break;
 				}
 			}
 			break;
 	}
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -1921,13 +1921,13 @@ void hyperstone_device::hyperstone_stxx2()
 
 	const uint32_t fp = GET_FP;
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
-	const uint32_t sreg = (SRC_GLOBAL && src_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_global_regs : m_local_regs)[src_code];
+	const uint32_t sreg = (SRC_GLOBAL && src_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[src_code];
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + fp) & 0x3f);
-	const uint32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code];
+	const uint32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code];
 
 	if (DST_GLOBAL && dst_code < 2)
 	{
-		m_icount -= m_clock_cycles_1;
+		m_core->icount -= m_core->clock_cycles_1;
 		return;
 	}
 
@@ -1936,17 +1936,17 @@ void hyperstone_device::hyperstone_stxx2()
 		case 0: // STBS.N
 			// TODO: missing trap on range error
 			WRITE_B(dreg, (uint8_t)sreg);
-			(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] += extra_s;
+			(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] += extra_s;
 			break;
 
 		case 1: // STBU.N
 			WRITE_B(dreg, (uint8_t)sreg);
-			(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] += extra_s;
+			(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] += extra_s;
 			break;
 
 		case 2: // STHS.N, STHU.N
 			WRITE_HW(dreg, (uint16_t)sreg);
-			(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] += extra_s & ~1;
+			(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] += extra_s & ~1;
 			// TODO: missing trap on range error with STHS.N
 			break;
 
@@ -1955,18 +1955,18 @@ void hyperstone_device::hyperstone_stxx2()
 			{
 				case 0: // STW.N
 					WRITE_W(dreg, sreg);
-					(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] += extra_s;
+					(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] += extra_s;
 					break;
 				case 1: // STD.N
 				{
 					WRITE_W(dreg, sreg);
-					(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] += extra_s & ~1;
+					(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] += extra_s & ~1;
 
 					const uint32_t srcf_code = SRC_GLOBAL ? (src_code + 1) : ((src_code + 1) & 0x3f);
-					const uint32_t sregf = (SRC_GLOBAL && srcf_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_global_regs : m_local_regs)[srcf_code];
+					const uint32_t sregf = (SRC_GLOBAL && srcf_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[srcf_code];
 					WRITE_W(dreg + 4, sregf);
 
-					m_icount -= m_clock_cycles_1; // extra cycle
+					m_core->icount -= m_core->clock_cycles_1; // extra cycle
 					break;
 				}
 				case 2: // Reserved
@@ -1976,17 +1976,17 @@ void hyperstone_device::hyperstone_stxx2()
 					if(dreg < SP)
 						WRITE_W(dreg, sreg);
 					else
-						m_local_regs[(dreg & 0xfc) >> 2] = sreg;
+						m_core->local_regs[(dreg & 0xfc) >> 2] = sreg;
 
-					(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] += (extra_s & ~3);
+					(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] += (extra_s & ~3);
 
-					m_icount -= m_clock_cycles_2; // extra cycles
+					m_core->icount -= m_core->clock_cycles_2; // extra cycles
 					break;
 			}
 			break;
 	}
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::shift_type HI_N, hyperstone_device::reg_bank DST_GLOBAL>
@@ -1995,7 +1995,7 @@ void hyperstone_device::hyperstone_shri()
 	check_delay_PC();
 
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + GET_FP) & 0x3f);
-	uint32_t val = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code];
+	uint32_t val = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code];
 
 	SR &= ~(C_MASK | Z_MASK | N_MASK);
 
@@ -2012,9 +2012,9 @@ void hyperstone_device::hyperstone_shri()
 	if (DST_GLOBAL)
 		set_global_register(dst_code, val);
 	else
-		m_local_regs[dst_code] = val;
+		m_core->local_regs[dst_code] = val;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::shift_type HI_N, hyperstone_device::reg_bank DST_GLOBAL>
@@ -2025,7 +2025,7 @@ void hyperstone_device::hyperstone_sari()
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + GET_FP) & 0x3f);
 
 	const uint32_t n = HI_N ? HI_N_VALUE : LO_N_VALUE;
-	uint32_t val = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code];
+	uint32_t val = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code];
 
 	SR &= ~(C_MASK | Z_MASK | N_MASK);
 
@@ -2048,9 +2048,9 @@ void hyperstone_device::hyperstone_sari()
 	if (DST_GLOBAL)
 		set_global_register(dst_code, val);
 	else
-		m_local_regs[dst_code] = val;
+		m_core->local_regs[dst_code] = val;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::shift_type HI_N, hyperstone_device::reg_bank DST_GLOBAL>
@@ -2059,7 +2059,7 @@ void hyperstone_device::hyperstone_shli()
 	check_delay_PC();
 
 	const uint32_t dst_code = DST_GLOBAL ? DST_CODE : ((DST_CODE + GET_FP) & 0x3f);
-	uint32_t val = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code];
+	uint32_t val = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code];
 
 	const uint32_t n = HI_N ? HI_N_VALUE : LO_N_VALUE;
 	SR &= ~(C_MASK | V_MASK | Z_MASK | N_MASK);
@@ -2082,9 +2082,9 @@ void hyperstone_device::hyperstone_shli()
 	if (DST_GLOBAL)
 		set_global_register(dst_code, val2);
 	else
-		m_local_regs[dst_code] = val2;
+		m_core->local_regs[dst_code] = val2;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL, hyperstone_device::sign_mode SIGNED>
@@ -2103,8 +2103,8 @@ void hyperstone_device::hyperstone_mulsu()
 		return;
 	}
 
-	const uint32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code];
-	const uint32_t sreg = (SRC_GLOBAL ? m_global_regs : m_local_regs)[src_code];
+	const uint32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code];
+	const uint32_t sreg = (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[src_code];
 	const uint64_t double_word = SIGNED ? (uint64_t)((int64_t)(int32_t)sreg * (int64_t)(int32_t)dreg) : ((uint64_t)sreg *(uint64_t)dreg);
 
 	const uint32_t high_order = (uint32_t)(double_word >> 32);
@@ -2114,14 +2114,14 @@ void hyperstone_device::hyperstone_mulsu()
 		SR |= Z_MASK;
 	SR |= SIGN_TO_N(high_order);
 
-	(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] = high_order;
-	(DST_GLOBAL ? m_global_regs : m_local_regs)[dstf_code] = (uint32_t)double_word;
+	(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] = high_order;
+	(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dstf_code] = (uint32_t)double_word;
 
-	m_icount -= m_clock_cycles_6;
+	m_core->icount -= m_core->clock_cycles_6;
 	if(SIGNED == IS_SIGNED && (sreg >= 0xffff8000 && sreg <= 0x7fff) && (dreg >= 0xffff8000 && dreg <= 0x7fff))
-		m_icount += m_clock_cycles_2;
+		m_core->icount += m_core->clock_cycles_2;
 	else if(SIGNED == IS_UNSIGNED && sreg <= 0xffff && dreg <= 0xffff)
-		m_icount += m_clock_cycles_2;
+		m_core->icount += m_core->clock_cycles_2;
 }
 
 template <hyperstone_device::shift_type HI_N, hyperstone_device::reg_bank DST_GLOBAL>
@@ -2134,7 +2134,7 @@ void hyperstone_device::hyperstone_set()
 
 	if (DST_GLOBAL && dst_code < 2)
 	{
-		m_icount -= m_clock_cycles_1;
+		m_core->icount -= m_core->clock_cycles_1;
 		return;
 	}
 
@@ -2148,9 +2148,9 @@ void hyperstone_device::hyperstone_set()
 				(C_MASK | Z_MASK), (C_MASK | Z_MASK), C_MASK, C_MASK, Z_MASK, Z_MASK, V_MASK, V_MASK };
 
 			if (SR & mask[n])
-				(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] = set_result[n];
+				(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] = set_result[n];
 			else
-				(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] = unset_result[n];
+				(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] = unset_result[n];
 		}
 		else
 		{
@@ -2161,7 +2161,7 @@ void hyperstone_device::hyperstone_set()
 	{
 		if (n == 0)
 		{
-			(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] = (SP & 0xfffffe00) | (GET_FP << 2) | (((SP & 0x100) && (SIGN_BIT(SR) == 0)) ? 1 : 0);
+			(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] = (SP & 0xfffffe00) | (GET_FP << 2) | (((SP & 0x100) && (SIGN_BIT(SR) == 0)) ? 1 : 0);
 		}
 		else if (n >= 2)
 		{
@@ -2171,9 +2171,9 @@ void hyperstone_device::hyperstone_set()
 				(C_MASK | Z_MASK), (C_MASK | Z_MASK), C_MASK, C_MASK, Z_MASK, Z_MASK, V_MASK, V_MASK };
 
 			if (SR & mask[n])
-				(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] = set_result[n];
+				(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] = set_result[n];
 			else
-				(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] = unset_result[n];
+				(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] = unset_result[n];
 		}
 		else
 		{
@@ -2181,7 +2181,7 @@ void hyperstone_device::hyperstone_set()
 		}
 	}
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank DST_GLOBAL, hyperstone_device::reg_bank SRC_GLOBAL>
@@ -2199,8 +2199,8 @@ void hyperstone_device::hyperstone_mul()
 		return;
 	}
 
-	const uint32_t dreg = (DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code];
-	const uint32_t sreg = (SRC_GLOBAL ? m_global_regs : m_local_regs)[src_code];
+	const uint32_t dreg = (DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code];
+	const uint32_t sreg = (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[src_code];
 	const uint32_t result = sreg * dreg;
 
 	SR &= ~(Z_MASK | N_MASK);
@@ -2208,12 +2208,12 @@ void hyperstone_device::hyperstone_mul()
 		SR |= Z_MASK;
 	SR |= SIGN_TO_N(result);
 
-	(DST_GLOBAL ? m_global_regs : m_local_regs)[dst_code] = result;
+	(DST_GLOBAL ? m_core->global_regs : m_core->local_regs)[dst_code] = result;
 
 	if (sreg < 0xffff8000 || sreg > 0x7fff || dreg < 0xffff8000 || dreg > 0x7fff)
-		m_icount -= 5 << m_clck_scale;
+		m_core->icount -= 5 << m_core->clck_scale;
 	else
-		m_icount -= 3 << m_clck_scale;
+		m_core->icount -= 3 << m_core->clck_scale;
 }
 
 void hyperstone_device::hyperstone_extend()
@@ -2225,23 +2225,23 @@ void hyperstone_device::hyperstone_extend()
 
 	//TODO: add locks, overflow error and other things
 	const uint32_t fp = GET_FP;
-	const uint32_t vals = m_local_regs[(SRC_CODE + fp) & 0x3f];
-	const uint32_t vald = m_local_regs[(DST_CODE + fp) & 0x3f];
+	const uint32_t vals = m_core->local_regs[(SRC_CODE + fp) & 0x3f];
+	const uint32_t vald = m_core->local_regs[(DST_CODE + fp) & 0x3f];
 
 	switch (func) // extended opcode
 	{
 		// signed or unsigned multiplication, single word product
 		case EMUL:
 		case EMUL_N: // used in "N" type cpu
-			m_global_regs[15] = (uint32_t)(vals * vald);
+			m_core->global_regs[15] = (uint32_t)(vals * vald);
 			break;
 
 		// unsigned multiplication, double word product
 		case EMULU:
 		{
 			const uint64_t result = (uint64_t)vals * (uint64_t)vald;
-			m_global_regs[14] = (uint32_t)(result >> 32);
-			m_global_regs[15] = (uint32_t)result;
+			m_core->global_regs[14] = (uint32_t)(result >> 32);
+			m_core->global_regs[15] = (uint32_t)result;
 			break;
 		}
 
@@ -2249,73 +2249,73 @@ void hyperstone_device::hyperstone_extend()
 		case EMULS:
 		{
 			const int64_t result = (int64_t)(int32_t)vals * (int64_t)(int32_t)vald;
-			m_global_regs[14] = (uint32_t)(result >> 32);
-			m_global_regs[15] = (uint32_t)result;
+			m_core->global_regs[14] = (uint32_t)(result >> 32);
+			m_core->global_regs[15] = (uint32_t)result;
 			break;
 		}
 
 		// signed multiply/add, single word product sum
 		case EMAC:
-			m_global_regs[15] += (int32_t)vals * (int32_t)vald;
+			m_core->global_regs[15] += (int32_t)vals * (int32_t)vald;
 			break;
 
 		// signed multiply/add, double word product sum
 		case EMACD:
 		{
-			int64_t result = (int64_t)concat_64(m_global_regs[14], m_global_regs[15]) + (int64_t)((int64_t)(int32_t)vals * (int64_t)(int32_t)vald);
-			m_global_regs[14] = (uint32_t)(result >> 32);
-			m_global_regs[15] = (uint32_t)result;
+			int64_t result = (int64_t)concat_64(m_core->global_regs[14], m_core->global_regs[15]) + (int64_t)((int64_t)(int32_t)vals * (int64_t)(int32_t)vald);
+			m_core->global_regs[14] = (uint32_t)(result >> 32);
+			m_core->global_regs[15] = (uint32_t)result;
 			break;
 		}
 
 		// signed multiply/substract, single word product difference
 		case EMSUB:
-			m_global_regs[15] = (int32_t)m_global_regs[15] - ((int32_t)vals * (int32_t)vald);
+			m_core->global_regs[15] = (int32_t)m_core->global_regs[15] - ((int32_t)vals * (int32_t)vald);
 			break;
 
 		// signed multiply/substract, double word product difference
 		case EMSUBD:
 		{
-			int64_t result = (int64_t)concat_64(m_global_regs[14], m_global_regs[15]) - (int64_t)((int64_t)(int32_t)vals * (int64_t)(int32_t)vald);
-			m_global_regs[14] = (uint32_t)(result >> 32);
-			m_global_regs[15] = (uint32_t)result;
+			int64_t result = (int64_t)concat_64(m_core->global_regs[14], m_core->global_regs[15]) - (int64_t)((int64_t)(int32_t)vals * (int64_t)(int32_t)vald);
+			m_core->global_regs[14] = (uint32_t)(result >> 32);
+			m_core->global_regs[15] = (uint32_t)result;
 			break;
 		}
 
 		// signed half-word multiply/add, single word product sum
 		case EHMAC:
-			m_global_regs[15] = (int32_t)m_global_regs[15] + ((int32_t)(vald >> 16) * (int32_t)(vals >> 16)) + ((int32_t)(vald & 0xffff) * (int32_t)(vals & 0xffff));
+			m_core->global_regs[15] = (int32_t)m_core->global_regs[15] + ((int32_t)(vald >> 16) * (int32_t)(vals >> 16)) + ((int32_t)(vald & 0xffff) * (int32_t)(vals & 0xffff));
 			break;
 
 		// signed half-word multiply/add, double word product sum
 		case EHMACD:
 		{
-			int64_t result = (int64_t)concat_64(m_global_regs[14], m_global_regs[15]) + (int64_t)((int64_t)(int32_t)(vald >> 16) * (int64_t)(int32_t)(vals >> 16)) + ((int64_t)(int32_t)(vald & 0xffff) * (int64_t)(int32_t)(vals & 0xffff));
-			m_global_regs[14] = (uint32_t)(result >> 32);
-			m_global_regs[15] = (uint32_t)result;
+			int64_t result = (int64_t)concat_64(m_core->global_regs[14], m_core->global_regs[15]) + (int64_t)((int64_t)(int32_t)(vald >> 16) * (int64_t)(int32_t)(vals >> 16)) + ((int64_t)(int32_t)(vald & 0xffff) * (int64_t)(int32_t)(vals & 0xffff));
+			m_core->global_regs[14] = (uint32_t)(result >> 32);
+			m_core->global_regs[15] = (uint32_t)result;
 			break;
 		}
 
 		// half-word complex multiply
 		case EHCMULD:
-			m_global_regs[14] = ((vald >> 16) * (vals >> 16    )) - ((vald & 0xffff) * (vals &  0xffff));
-			m_global_regs[15] = ((vald >> 16) * (vals &  0xffff)) + ((vald & 0xffff) * (vals >> 16    ));
+			m_core->global_regs[14] = ((vald >> 16) * (vals >> 16    )) - ((vald & 0xffff) * (vals &  0xffff));
+			m_core->global_regs[15] = ((vald >> 16) * (vals &  0xffff)) + ((vald & 0xffff) * (vals >> 16    ));
 			break;
 
 		// half-word complex multiply/add
 		case EHCMACD:
-			m_global_regs[14] += ((vald >> 16) * (vals >> 16    )) - ((vald & 0xffff) * (vals &  0xffff));
-			m_global_regs[15] += ((vald >> 16) * (vals &  0xffff)) + ((vald & 0xffff) * (vals >> 16    ));
+			m_core->global_regs[14] += ((vald >> 16) * (vals >> 16    )) - ((vald & 0xffff) * (vals &  0xffff));
+			m_core->global_regs[15] += ((vald >> 16) * (vals &  0xffff)) + ((vald & 0xffff) * (vals >> 16    ));
 			break;
 
 		// half-word (complex) add/substract
 		// Ls is not used and should denote the same register as Ld
 		case EHCSUMD:
 		{
-			const uint32_t r14 = m_global_regs[14];
-			const uint32_t r15 = m_global_regs[15];
-			m_global_regs[14] = (((vals >> 16) + r14) << 16) | (((vals & 0xffff) + r15) & 0xffff);
-			m_global_regs[15] = (((vals >> 16) - r14) << 16) | (((vals & 0xffff) - r15) & 0xffff);
+			const uint32_t r14 = m_core->global_regs[14];
+			const uint32_t r15 = m_core->global_regs[15];
+			m_core->global_regs[14] = (((vals >> 16) + r14) << 16) | (((vals & 0xffff) + r15) & 0xffff);
+			m_core->global_regs[15] = (((vals >> 16) - r14) << 16) | (((vals & 0xffff) - r15) & 0xffff);
 			break;
 		}
 
@@ -2323,10 +2323,10 @@ void hyperstone_device::hyperstone_extend()
 		// Ls is not used and should denote the same register as Ld
 		case EHCFFTD:
 		{
-			const uint32_t r14 = m_global_regs[14];
-			const uint32_t r15 = m_global_regs[15];
-			m_global_regs[14] = (((((vals & 0xffff0000) >> 16) + (r14 >> 15)) << 16) & 0xffff0000) | (((vals & 0xffff) + (r15 >> 15)) & 0xffff);
-			m_global_regs[15] = (((((vals & 0xffff0000) >> 16) - (r14 >> 15)) << 16) & 0xffff0000) | (((vals & 0xffff) - (r15 >> 15)) & 0xffff);
+			const uint32_t r14 = m_core->global_regs[14];
+			const uint32_t r15 = m_core->global_regs[15];
+			m_core->global_regs[14] = (((((vals & 0xffff0000) >> 16) + (r14 >> 15)) << 16) & 0xffff0000) | (((vals & 0xffff) + (r15 >> 15)) & 0xffff);
+			m_core->global_regs[15] = (((((vals & 0xffff0000) >> 16) - (r14 >> 15)) << 16) & 0xffff0000) | (((vals & 0xffff) - (r15 >> 15)) & 0xffff);
 			break;
 		}
 
@@ -2334,10 +2334,10 @@ void hyperstone_device::hyperstone_extend()
 		// Ls is not used and should denote the same register as Ld
 		case EHCFFTSD:
 		{
-			const uint32_t r14 = m_global_regs[14];
-			const uint32_t r15 = m_global_regs[15];
-			m_global_regs[14] = ((((((vals & 0xffff0000) >> 16) + (r14 >> 15)) >> 1) << 16) & 0xffff0000) | (((((vals & 0xffff) + (r15 >> 15)) >> 1) & 0xffff));
-			m_global_regs[15] = ((((((vals & 0xffff0000) >> 16) - (r14 >> 15)) >> 1) << 16) & 0xffff0000) | (((((vals & 0xffff) - (r15 >> 15)) >> 1) & 0xffff));
+			const uint32_t r14 = m_core->global_regs[14];
+			const uint32_t r15 = m_core->global_regs[15];
+			m_core->global_regs[14] = ((((((vals & 0xffff0000) >> 16) + (r14 >> 15)) >> 1) << 16) & 0xffff0000) | (((((vals & 0xffff) + (r15 >> 15)) >> 1) & 0xffff));
+			m_core->global_regs[15] = ((((((vals & 0xffff0000) >> 16) - (r14 >> 15)) >> 1) << 16) & 0xffff0000) | (((((vals & 0xffff) - (r15 >> 15)) >> 1) & 0xffff));
 			break;
 		}
 
@@ -2346,7 +2346,7 @@ void hyperstone_device::hyperstone_extend()
 			break;
 	}
 
-	m_icount -= m_clock_cycles_1; // TODO: with the latency it can change
+	m_core->icount -= m_core->clock_cycles_1; // TODO: with the latency it can change
 }
 
 
@@ -2356,10 +2356,10 @@ void hyperstone_device::hyperstone_ldwr()
 	check_delay_PC();
 	const uint32_t fp = GET_FP;
 	if (SRC_GLOBAL)
-		set_global_register(SRC_CODE, READ_W(m_local_regs[(DST_CODE + fp) & 0x3f]));
+		set_global_register(SRC_CODE, READ_W(m_core->local_regs[(DST_CODE + fp) & 0x3f]));
 	else
-		m_local_regs[(SRC_CODE + fp) & 0x3f] = READ_W(m_local_regs[(DST_CODE + fp) & 0x3f]);
-	m_icount -= m_clock_cycles_1;
+		m_core->local_regs[(SRC_CODE + fp) & 0x3f] = READ_W(m_core->local_regs[(DST_CODE + fp) & 0x3f]);
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank SRC_GLOBAL>
@@ -2369,7 +2369,7 @@ void hyperstone_device::hyperstone_lddr()
 
 	const uint32_t fp = GET_FP;
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
-	const uint32_t dreg = m_local_regs[(DST_CODE + fp) & 0x3f];
+	const uint32_t dreg = m_core->local_regs[(DST_CODE + fp) & 0x3f];
 
 	if (SRC_GLOBAL)
 	{
@@ -2378,11 +2378,11 @@ void hyperstone_device::hyperstone_lddr()
 	}
 	else
 	{
-		m_local_regs[src_code] = READ_W(dreg);
-		m_local_regs[(src_code + 1) & 0x3f] = READ_W(dreg + 4);
+		m_core->local_regs[src_code] = READ_W(dreg);
+		m_core->local_regs[(src_code + 1) & 0x3f] = READ_W(dreg + 4);
 	}
 
-	m_icount -= m_clock_cycles_2;
+	m_core->icount -= m_core->clock_cycles_2;
 }
 
 template <hyperstone_device::reg_bank SRC_GLOBAL>
@@ -2395,20 +2395,20 @@ void hyperstone_device::hyperstone_ldwp()
 
 	if (SRC_GLOBAL)
 	{
-		set_global_register(SRC_CODE, READ_W(m_local_regs[dst_code]));
-		m_local_regs[dst_code] += 4;
+		set_global_register(SRC_CODE, READ_W(m_core->local_regs[dst_code]));
+		m_core->local_regs[dst_code] += 4;
 	}
 	else
 	{
 		const uint32_t src_code = (SRC_CODE + fp) & 0x3f;
-		m_local_regs[src_code] = READ_W(m_local_regs[dst_code]);
+		m_core->local_regs[src_code] = READ_W(m_core->local_regs[dst_code]);
 		// post increment the destination register if it's different from the source one
 		// (needed by Hidden Catch)
 		if (src_code != dst_code)
-			m_local_regs[dst_code] += 4;
+			m_core->local_regs[dst_code] += 4;
 	}
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank SRC_GLOBAL>
@@ -2419,27 +2419,27 @@ void hyperstone_device::hyperstone_lddp()
 	const uint32_t fp = GET_FP;
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
 	const uint32_t dst_code = (DST_CODE + fp) & 0x3f;
-	const uint32_t dreg = m_local_regs[dst_code];
+	const uint32_t dreg = m_core->local_regs[dst_code];
 
 	if (SRC_GLOBAL)
 	{
 		set_global_register(src_code, READ_W(dreg));
 		set_global_register(src_code + 1, READ_W(dreg + 4));
-		m_local_regs[dst_code] += 8;
+		m_core->local_regs[dst_code] += 8;
 	}
 	else
 	{
 		const uint32_t srcf_code = (src_code + 1) & 0x3f;
-		m_local_regs[src_code] = READ_W(dreg);
-		m_local_regs[srcf_code] = READ_W(dreg + 4);
+		m_core->local_regs[src_code] = READ_W(dreg);
+		m_core->local_regs[srcf_code] = READ_W(dreg + 4);
 
 		// post increment the destination register if it's different from the source one
 		// and from the "next source" one
 		if (src_code != dst_code && srcf_code != dst_code)
-			m_local_regs[dst_code] += 8;
+			m_core->local_regs[dst_code] += 8;
 	}
 
-	m_icount -= m_clock_cycles_2;
+	m_core->icount -= m_core->clock_cycles_2;
 }
 
 template <hyperstone_device::reg_bank SRC_GLOBAL>
@@ -2449,10 +2449,10 @@ void hyperstone_device::hyperstone_stwr()
 
 	const uint32_t fp = GET_FP;
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
-	const uint32_t sreg = (SRC_GLOBAL && src_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_global_regs : m_local_regs)[src_code];
-	WRITE_W(m_local_regs[(DST_CODE + fp) & 0x3f], sreg);
+	const uint32_t sreg = (SRC_GLOBAL && src_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[src_code];
+	WRITE_W(m_core->local_regs[(DST_CODE + fp) & 0x3f], sreg);
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank SRC_GLOBAL>
@@ -2463,15 +2463,15 @@ void hyperstone_device::hyperstone_stdr()
 	const uint32_t fp = GET_FP;
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
 	const uint32_t srcf_code = SRC_GLOBAL ? (SRC_CODE + 1) : ((src_code + 1) & 0x3f);
-	const uint32_t sreg = (SRC_GLOBAL && src_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_global_regs : m_local_regs)[src_code];
-	const uint32_t sregf = (SRC_GLOBAL && src_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_global_regs : m_local_regs)[srcf_code];
+	const uint32_t sreg = (SRC_GLOBAL && src_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[src_code];
+	const uint32_t sregf = (SRC_GLOBAL && src_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[srcf_code];
 
-	const uint32_t dreg = m_local_regs[(DST_CODE + GET_FP) & 0x3f];
+	const uint32_t dreg = m_core->local_regs[(DST_CODE + GET_FP) & 0x3f];
 
 	WRITE_W(dreg, sreg);
 	WRITE_W(dreg + 4, sregf);
 
-	m_icount -= m_clock_cycles_2;
+	m_core->icount -= m_core->clock_cycles_2;
 }
 
 template <hyperstone_device::reg_bank SRC_GLOBAL>
@@ -2481,15 +2481,15 @@ void hyperstone_device::hyperstone_stwp()
 
 	const uint32_t fp = GET_FP;
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
-	const uint32_t sreg = (SRC_GLOBAL && src_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_global_regs : m_local_regs)[src_code];
+	const uint32_t sreg = (SRC_GLOBAL && src_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[src_code];
 
 	const uint32_t dst_code = (DST_CODE + fp) & 0x3f;
-	const uint32_t dreg = m_local_regs[dst_code];
+	const uint32_t dreg = m_core->local_regs[dst_code];
 
 	WRITE_W(dreg, sreg);
-	m_local_regs[dst_code] += 4;
+	m_core->local_regs[dst_code] += 4;
 
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank SRC_GLOBAL>
@@ -2500,20 +2500,20 @@ void hyperstone_device::hyperstone_stdp()
 	const uint32_t fp = GET_FP;
 	const uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
 	const uint32_t srcf_code = SRC_GLOBAL ? (src_code + 1) : ((src_code + 1) & 0x3f);
-	const uint32_t sreg = (SRC_GLOBAL && src_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_global_regs : m_local_regs)[src_code];
+	const uint32_t sreg = (SRC_GLOBAL && src_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[src_code];
 
 	const uint32_t dst_code = (DST_CODE + fp) & 0x3f;
-	const uint32_t dreg = m_local_regs[dst_code];
+	const uint32_t dreg = m_core->local_regs[dst_code];
 
 	WRITE_W(dreg, sreg);
 
-	m_local_regs[dst_code] += 8;
+	m_core->local_regs[dst_code] += 8;
 
-	const uint32_t sregf = (SRC_GLOBAL && srcf_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_global_regs : m_local_regs)[srcf_code];
+	const uint32_t sregf = (SRC_GLOBAL && srcf_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[srcf_code];
 
 	WRITE_W(dreg + 4, sregf);
 
-	m_icount -= m_clock_cycles_2;
+	m_core->icount -= m_core->clock_cycles_2;
 }
 
 template <hyperstone_device::branch_condition CONDITION, hyperstone_device::condition_set COND_SET>
@@ -2526,16 +2526,16 @@ void hyperstone_device::hyperstone_db()
 		{
 			const int32_t offset = decode_pcrel();
 			check_delay_PC();
-			m_delay_slot = 1;
-			m_delay_pc = PC + offset;
-			m_intblock = 3;
-			m_icount -= m_clock_cycles_2;
+			m_core->delay_slot = 1;
+			m_core->delay_pc = PC + offset;
+			m_core->intblock = 3;
+			m_core->icount -= m_core->clock_cycles_2;
 		}
 		else
 		{
 			ignore_pcrel();
 			check_delay_PC();
-			m_icount -= m_clock_cycles_1;
+			m_core->icount -= m_core->clock_cycles_1;
 		}
 	}
 	else
@@ -2544,16 +2544,16 @@ void hyperstone_device::hyperstone_db()
 		{
 			ignore_pcrel();
 			check_delay_PC();
-			m_icount -= m_clock_cycles_1;
+			m_core->icount -= m_core->clock_cycles_1;
 		}
 		else
 		{
 			const int32_t offset = decode_pcrel();
 			check_delay_PC();
-			m_delay_slot = 1;
-			m_delay_pc = PC + offset;
-			m_intblock = 3;
-			m_icount -= m_clock_cycles_2;
+			m_core->delay_slot = 1;
+			m_core->delay_pc = PC + offset;
+			m_core->intblock = 3;
+			m_core->icount -= m_core->clock_cycles_2;
 		}
 	}
 }
@@ -2563,11 +2563,11 @@ void hyperstone_device::hyperstone_dbr()
 	const int32_t offset = decode_pcrel();
 	check_delay_PC();
 
-	m_delay_slot = 1;
-	m_delay_pc = PC + offset;
-	m_intblock = 3;
+	m_core->delay_slot = 1;
+	m_core->delay_pc = PC + offset;
+	m_core->intblock = 3;
 
-	m_icount -= m_clock_cycles_2;
+	m_core->icount -= m_core->clock_cycles_2;
 }
 
 void hyperstone_device::hyperstone_frame()
@@ -2595,7 +2595,7 @@ void hyperstone_device::hyperstone_frame()
 
 		for (; difference < 0; difference++)
 		{
-			WRITE_W(SP, m_local_regs[(SP & 0xfc) >> 2]);
+			WRITE_W(SP, m_core->local_regs[(SP & 0xfc) >> 2]);
 			SP += 4;
 		}
 
@@ -2606,7 +2606,7 @@ void hyperstone_device::hyperstone_frame()
 	}
 
 	// TODO: More than 1 cycle!
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::reg_bank SRC_GLOBAL>
@@ -2648,14 +2648,14 @@ void hyperstone_device::hyperstone_call()
 	uint32_t src_code = SRC_GLOBAL ? SRC_CODE : ((SRC_CODE + fp) & 0x3f);
 	uint32_t dst_code = DST_CODE;
 
-	uint32_t sreg = (SRC_GLOBAL && src_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_global_regs : m_local_regs)[src_code];
+	uint32_t sreg = (SRC_GLOBAL && src_code == SR_REGISTER) ? 0 : (SRC_GLOBAL ? m_core->global_regs : m_core->local_regs)[src_code];
 
 	if (!DST_CODE)
 		dst_code = 16;
 
 	uint32_t dreg_index = dst_code + fp;
-	m_local_regs[dreg_index & 0x3f] = (PC & ~1) | GET_S;
-	m_local_regs[(dreg_index + 1) & 0x3f] = SR;
+	m_core->local_regs[dreg_index & 0x3f] = (PC & ~1) | GET_S;
+	m_core->local_regs[(dreg_index + 1) & 0x3f] = SR;
 
 	SET_FP(fp + dst_code);
 	SET_FL(6); //default value for call
@@ -2663,12 +2663,12 @@ void hyperstone_device::hyperstone_call()
 
 	PC = (extra_s & ~1) + sreg;
 
-	m_intblock = 2;
+	m_core->intblock = 2;
 
 	//TODO: add interrupt locks, errors, ....
 
 	// TODO: More than 1 cycle!
-	m_icount -= m_clock_cycles_1;
+	m_core->icount -= m_core->clock_cycles_1;
 }
 
 template <hyperstone_device::branch_condition CONDITION, hyperstone_device::condition_set COND_SET>
@@ -2685,7 +2685,7 @@ void hyperstone_device::hyperstone_b()
 		{
 			ignore_pcrel();
 			check_delay_PC();
-			m_icount -= m_clock_cycles_1;
+			m_core->icount -= m_core->clock_cycles_1;
 		}
 	}
 	else
@@ -2694,7 +2694,7 @@ void hyperstone_device::hyperstone_b()
 		{
 			ignore_pcrel();
 			check_delay_PC();
-			m_icount -= m_clock_cycles_1;
+			m_core->icount -= m_core->clock_cycles_1;
 		}
 		else
 		{