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

Remove a level of indirection when calling m68000 memory handlers.

Browse Source
This commit is contained in:
Aaron Giles 2010-08-19 14:04:49 +00:00
parent 98630a96d7
commit a86a4c3684
3 changed files with 257 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

325
src/emu/cpu/m68000/m68kcpu.c
View File

@ -940,273 +940,266 @@ void m68k_set_encrypted_opcode_range(running_device *device, offs_t start, offs_
m68k->encrypted_end = end; m68k->encrypted_end = end;
} }
static UINT8 memory_read_byte(address_space *space, offs_t address) { return space->read_byte(address); }
static void memory_write_byte(address_space *space, offs_t address, UINT8 data) { space->write_byte(address, data); }
static UINT16 memory_read_word(address_space *space, offs_t address) { return space->read_word(address); }
static void memory_write_word(address_space *space, offs_t address, UINT16 data) { space->write_word(address, data); }
static UINT32 memory_read_dword(address_space *space, offs_t address) { return space->read_dword(address); }
static void memory_write_dword(address_space *space, offs_t address, UINT32 data) { space->write_dword(address, data); }
/**************************************************************************** /****************************************************************************
* 8-bit data memory interface * 8-bit data memory interface
****************************************************************************/ ****************************************************************************/
static UINT16 m68008_read_immediate_16(address_space *space, offs_t address) UINT16 m68k_memory_interface::m68008_read_immediate_16(offs_t address)
{ {
offs_t addr = address; return (m_direct->read_decrypted_byte(address) << 8) | (m_direct->read_decrypted_byte(address + 1));
return (memory_decrypted_read_byte(space, addr) << 8) | (memory_decrypted_read_byte(space, addr + 1));
} }
/* interface for 20/22-bit address bus, 8-bit data bus (68008) */ void m68k_memory_interface::init8(address_space &space)
static const m68k_memory_interface interface_d8 =
{ {
0, m_space = &space;
m68008_read_immediate_16, m_direct = &space.direct();
memory_read_byte, m_cpustate = get_safe_token(&space.device());
memory_read_word, opcode_xor = 0;
memory_read_dword,
memory_write_byte, readimm16 = m68k_readimm16_delegate(m68k_readimm16_proto_delegate::create_member(m68k_memory_interface, m68008_read_immediate_16), *this);
memory_write_word, read8 = m68k_read8_delegate(m68k_read8_proto_delegate::create_member(address_space, read_byte), space);
memory_write_dword read16 = m68k_read16_delegate(m68k_read16_proto_delegate::create_member(address_space, read_word), space);
}; read32 = m68k_read32_delegate(m68k_read32_proto_delegate::create_member(address_space, read_dword), space);
write8 = m68k_write8_delegate(m68k_write8_proto_delegate::create_member(address_space, write_byte), space);
write16 = m68k_write16_delegate(m68k_write16_proto_delegate::create_member(address_space, write_word), space);
write32 = m68k_write32_delegate(m68k_write32_proto_delegate::create_member(address_space, write_dword), space);
}
/**************************************************************************** /****************************************************************************
* 16-bit data memory interface * 16-bit data memory interface
****************************************************************************/ ****************************************************************************/
static UINT16 read_immediate_16(address_space *space, offs_t address) UINT16 m68k_memory_interface::read_immediate_16(offs_t address)
{ {
m68ki_cpu_core *m68k = get_safe_token(space->cpu); return m_direct->read_decrypted_word((address) ^ opcode_xor);
return memory_decrypted_read_word(space, (address) ^ m68k->memory.opcode_xor);
} }
static UINT16 simple_read_immediate_16(address_space *space, offs_t address) UINT16 m68k_memory_interface::simple_read_immediate_16(offs_t address)
{ {
return memory_decrypted_read_word(space, address); return m_direct->read_decrypted_word(address);
} }
/* interface for 24-bit address bus, 16-bit data bus (68000, 68010) */ void m68k_memory_interface::init16(address_space &space)
static const m68k_memory_interface interface_d16 =
{ {
0, m_space = &space;
simple_read_immediate_16, m_direct = &space.direct();
memory_read_byte, m_cpustate = get_safe_token(&space.device());
memory_read_word, opcode_xor = 0;
memory_read_dword,
memory_write_byte, readimm16 = m68k_readimm16_delegate(m68k_readimm16_proto_delegate::create_member(m68k_memory_interface, simple_read_immediate_16), *this);
memory_write_word, read8 = m68k_read8_delegate(m68k_read8_proto_delegate::create_member(address_space, read_byte), space);
memory_write_dword read16 = m68k_read16_delegate(m68k_read16_proto_delegate::create_member(address_space, read_word), space);
}; read32 = m68k_read32_delegate(m68k_read32_proto_delegate::create_member(address_space, read_dword), space);
write8 = m68k_write8_delegate(m68k_write8_proto_delegate::create_member(address_space, write_byte), space);
write16 = m68k_write16_delegate(m68k_write16_proto_delegate::create_member(address_space, write_word), space);
write32 = m68k_write32_delegate(m68k_write32_proto_delegate::create_member(address_space, write_dword), space);
}
/**************************************************************************** /****************************************************************************
* 32-bit data memory interface * 32-bit data memory interface
****************************************************************************/ ****************************************************************************/
/* potentially misaligned 16-bit reads with a 32-bit data bus (and 24-bit address bus) */ /* potentially misaligned 16-bit reads with a 32-bit data bus (and 24-bit address bus) */
static UINT16 readword_d32(address_space *space, offs_t address) UINT16 m68k_memory_interface::readword_d32(offs_t address, UINT16 mask)
{ {
UINT16 result; UINT16 result;
if (!(address & 1)) if (!(address & 1))
return space->read_word(address); return m_space->read_word(address);
result = space->read_byte(address) << 8; result = m_space->read_byte(address) << 8;
return result | space->read_byte(address + 1); return result | m_space->read_byte(address + 1);
} }
/* potentially misaligned 16-bit writes with a 32-bit data bus (and 24-bit address bus) */ /* potentially misaligned 16-bit writes with a 32-bit data bus (and 24-bit address bus) */
static void writeword_d32(address_space *space, offs_t address, UINT16 data) void m68k_memory_interface::writeword_d32(offs_t address, UINT16 data, UINT16 mask)
{ {
if (!(address & 1)) if (!(address & 1))
{ {
space->write_word(address, data); m_space->write_word(address, data);
return; return;
} }
space->write_byte(address, data >> 8); m_space->write_byte(address, data >> 8);
space->write_byte(address + 1, data); m_space->write_byte(address + 1, data);
} }
/* potentially misaligned 32-bit reads with a 32-bit data bus (and 24-bit address bus) */ /* potentially misaligned 32-bit reads with a 32-bit data bus (and 24-bit address bus) */
static UINT32 readlong_d32(address_space *space, offs_t address) UINT32 m68k_memory_interface::readlong_d32(offs_t address, UINT32 mask)
{ {
UINT32 result; UINT32 result;
if (!(address & 3)) if (!(address & 3))
return space->read_dword(address); return m_space->read_dword(address);
else if (!(address & 1)) else if (!(address & 1))
{ {
result = space->read_word(address) << 16; result = m_space->read_word(address) << 16;
return result | space->read_word(address + 2); return result | m_space->read_word(address + 2);
} }
result = space->read_byte(address) << 24; result = m_space->read_byte(address) << 24;
result |= space->read_word(address + 1) << 8; result |= m_space->read_word(address + 1) << 8;
return result | space->read_byte(address + 3); return result | m_space->read_byte(address + 3);
} }
/* potentially misaligned 32-bit writes with a 32-bit data bus (and 24-bit address bus) */ /* potentially misaligned 32-bit writes with a 32-bit data bus (and 24-bit address bus) */
static void writelong_d32(address_space *space, offs_t address, UINT32 data) void m68k_memory_interface::writelong_d32(offs_t address, UINT32 data, UINT32 mask)
{ {
if (!(address & 3)) if (!(address & 3))
{ {
space->write_dword(address, data); m_space->write_dword(address, data);
return; return;
} }
else if (!(address & 1)) else if (!(address & 1))
{ {
space->write_word(address, data >> 16); m_space->write_word(address, data >> 16);
space->write_word(address + 2, data); m_space->write_word(address + 2, data);
return; return;
} }
space->write_byte(address, data >> 24); m_space->write_byte(address, data >> 24);
space->write_word(address + 1, data >> 8); m_space->write_word(address + 1, data >> 8);
space->write_byte(address + 3, data); m_space->write_byte(address + 3, data);
} }
/* interface for 32-bit data bus (68EC020, 68020) */ /* interface for 32-bit data bus (68EC020, 68020) */
static const m68k_memory_interface interface_d32 = void m68k_memory_interface::init32(address_space &space)
{ {
WORD_XOR_BE(0), m_space = &space;
read_immediate_16, m_direct = &space.direct();
memory_read_byte, m_cpustate = get_safe_token(&space.device());
readword_d32, opcode_xor = WORD_XOR_BE(0);
readlong_d32,
memory_write_byte, readimm16 = m68k_readimm16_delegate(m68k_readimm16_proto_delegate::create_member(m68k_memory_interface, read_immediate_16), *this);
writeword_d32, read8 = m68k_read8_delegate(m68k_read8_proto_delegate::create_member(address_space, read_byte), space);
writelong_d32 read16 = m68k_read16_delegate(m68k_read16_proto_delegate::create_member(m68k_memory_interface, readword_d32), *this);
}; read32 = m68k_read32_delegate(m68k_read32_proto_delegate::create_member(m68k_memory_interface, readlong_d32), *this);
write8 = m68k_write8_delegate(m68k_write8_proto_delegate::create_member(address_space, write_byte), space);
write16 = m68k_write16_delegate(m68k_write16_proto_delegate::create_member(m68k_memory_interface, writeword_d32), *this);
write32 = m68k_write32_delegate(m68k_write32_proto_delegate::create_member(m68k_memory_interface, writelong_d32), *this);
}
/* interface for 32-bit data bus with PMMU (68EC020, 68020) */ /* interface for 32-bit data bus with PMMU (68EC020, 68020) */
static UINT8 read_byte_32_mmu(address_space *space, offs_t address) UINT8 m68k_memory_interface::read_byte_32_mmu(offs_t address)
{ {
m68ki_cpu_core *m68k = get_safe_token(space->cpu); if (m_cpustate->pmmu_enabled)
if (m68k->pmmu_enabled)
{ {
address = pmmu_translate_addr(m68k, address); address = pmmu_translate_addr(m_cpustate, address);
} }
return space->read_byte(address); return m_space->read_byte(address);
} }
static void write_byte_32_mmu(address_space *space, offs_t address, UINT8 data) void m68k_memory_interface::write_byte_32_mmu(offs_t address, UINT8 data)
{ {
m68ki_cpu_core *m68k = get_safe_token(space->cpu); if (m_cpustate->pmmu_enabled)
if (m68k->pmmu_enabled)
{ {
address = pmmu_translate_addr(m68k, address); address = pmmu_translate_addr(m_cpustate, address);
} }
space->write_byte(address, data); m_space->write_byte(address, data);
} }
static UINT16 read_immediate_16_mmu(address_space *space, offs_t address) UINT16 m68k_memory_interface::read_immediate_16_mmu(offs_t address)
{ {
m68ki_cpu_core *m68k = get_safe_token(space->cpu); if (m_cpustate->pmmu_enabled)
if (m68k->pmmu_enabled)
{ {
address = pmmu_translate_addr(m68k, address); address = pmmu_translate_addr(m_cpustate, address);
} }
return memory_decrypted_read_word(space, (address) ^ m68k->memory.opcode_xor); return memory_decrypted_read_word(m_space, (address) ^ m_cpustate->memory.opcode_xor);
} }
/* potentially misaligned 16-bit reads with a 32-bit data bus (and 24-bit address bus) */ /* potentially misaligned 16-bit reads with a 32-bit data bus (and 24-bit address bus) */
static UINT16 readword_d32_mmu(address_space *space, offs_t address) UINT16 m68k_memory_interface::readword_d32_mmu(offs_t address, UINT16 mask)
{ {
m68ki_cpu_core *m68k = get_safe_token(space->cpu);
UINT16 result; UINT16 result;
if (m68k->pmmu_enabled) if (m_cpustate->pmmu_enabled)
{ {
address = pmmu_translate_addr(m68k, address); address = pmmu_translate_addr(m_cpustate, address);
} }
if (!(address & 1)) if (!(address & 1))
return space->read_word(address); return m_space->read_word(address);
result = space->read_byte(address) << 8; result = m_space->read_byte(address) << 8;
return result | space->read_byte(address + 1); return result | m_space->read_byte(address + 1);
} }
/* potentially misaligned 16-bit writes with a 32-bit data bus (and 24-bit address bus) */ /* potentially misaligned 16-bit writes with a 32-bit data bus (and 24-bit address bus) */
static void writeword_d32_mmu(address_space *space, offs_t address, UINT16 data) void m68k_memory_interface::writeword_d32_mmu(offs_t address, UINT16 data, UINT16 mask)
{ {
m68ki_cpu_core *m68k = get_safe_token(space->cpu); if (m_cpustate->pmmu_enabled)
if (m68k->pmmu_enabled)
{ {
address = pmmu_translate_addr(m68k, address); address = pmmu_translate_addr(m_cpustate, address);
} }
if (!(address & 1)) if (!(address & 1))
{ {
space->write_word(address, data); m_space->write_word(address, data);
return; return;
} }
space->write_byte(address, data >> 8); m_space->write_byte(address, data >> 8);
space->write_byte(address + 1, data); m_space->write_byte(address + 1, data);
} }
/* potentially misaligned 32-bit reads with a 32-bit data bus (and 24-bit address bus) */ /* potentially misaligned 32-bit reads with a 32-bit data bus (and 24-bit address bus) */
static UINT32 readlong_d32_mmu(address_space *space, offs_t address) UINT32 m68k_memory_interface::readlong_d32_mmu(offs_t address, UINT32 mask)
{ {
m68ki_cpu_core *m68k = get_safe_token(space->cpu);
UINT32 result; UINT32 result;
if (m68k->pmmu_enabled) if (m_cpustate->pmmu_enabled)
{ {
address = pmmu_translate_addr(m68k, address); address = pmmu_translate_addr(m_cpustate, address);
} }
if (!(address & 3)) if (!(address & 3))
return space->read_dword(address); return m_space->read_dword(address);
else if (!(address & 1)) else if (!(address & 1))
{ {
result = space->read_word(address) << 16; result = m_space->read_word(address) << 16;
return result | space->read_word(address + 2); return result | m_space->read_word(address + 2);
} }
result = space->read_byte(address) << 24; result = m_space->read_byte(address) << 24;
result |= space->read_word(address + 1) << 8; result |= m_space->read_word(address + 1) << 8;
return result | space->read_byte(address + 3); return result | m_space->read_byte(address + 3);
} }
/* potentially misaligned 32-bit writes with a 32-bit data bus (and 24-bit address bus) */ /* potentially misaligned 32-bit writes with a 32-bit data bus (and 24-bit address bus) */
static void writelong_d32_mmu(address_space *space, offs_t address, UINT32 data) void m68k_memory_interface::writelong_d32_mmu(offs_t address, UINT32 data, UINT32 mask)
{ {
m68ki_cpu_core *m68k = get_safe_token(space->cpu); if (m_cpustate->pmmu_enabled)
if (m68k->pmmu_enabled)
{ {
address = pmmu_translate_addr(m68k, address); address = pmmu_translate_addr(m_cpustate, address);
} }
if (!(address & 3)) if (!(address & 3))
{ {
space->write_dword(address, data); m_space->write_dword(address, data);
return; return;
} }
else if (!(address & 1)) else if (!(address & 1))
{ {
space->write_word(address, data >> 16); m_space->write_word(address, data >> 16);
space->write_word(address + 2, data); m_space->write_word(address + 2, data);
return; return;
} }
space->write_byte(address, data >> 24); m_space->write_byte(address, data >> 24);
space->write_word(address + 1, data >> 8); m_space->write_word(address + 1, data >> 8);
space->write_byte(address + 3, data); m_space->write_byte(address + 3, data);
} }
static const m68k_memory_interface interface_d32_mmu = void m68k_memory_interface::init32mmu(address_space &space)
{ {
WORD_XOR_BE(0), m_space = &space;
read_immediate_16_mmu, m_direct = &space.direct();
read_byte_32_mmu, m_cpustate = get_safe_token(&space.device());
readword_d32_mmu, opcode_xor = WORD_XOR_BE(0);
readlong_d32_mmu,
write_byte_32_mmu, readimm16 = m68k_readimm16_delegate(m68k_readimm16_proto_delegate::create_member(m68k_memory_interface, read_immediate_16_mmu), *this);
writeword_d32_mmu, read8 = m68k_read8_delegate(m68k_read8_proto_delegate::create_member(m68k_memory_interface, read_byte_32_mmu), *this);
writelong_d32_mmu read16 = m68k_read16_delegate(m68k_read16_proto_delegate::create_member(m68k_memory_interface, readword_d32_mmu), *this);
}; read32 = m68k_read32_delegate(m68k_read32_proto_delegate::create_member(m68k_memory_interface, readlong_d32_mmu), *this);
write8 = m68k_write8_delegate(m68k_write8_proto_delegate::create_member(m68k_memory_interface, write_byte_32_mmu), *this);
write16 = m68k_write16_delegate(m68k_write16_proto_delegate::create_member(m68k_memory_interface, writeword_d32_mmu), *this);
write32 = m68k_write32_delegate(m68k_write32_proto_delegate::create_member(m68k_memory_interface, writelong_d32_mmu), *this);
}
void m68k_set_reset_callback(running_device *device, m68k_reset_func callback) void m68k_set_reset_callback(running_device *device, m68k_reset_func callback)
@ -1301,7 +1294,11 @@ static CPU_INIT( m68000 )
m68k->cpu_type = CPU_TYPE_000; m68k->cpu_type = CPU_TYPE_000;
m68k->dasm_type = M68K_CPU_TYPE_68000; m68k->dasm_type = M68K_CPU_TYPE_68000;
m68k->memory = interface_d16; // hack alert: we use placement new to ensure we are properly initialized
// because we live in the device state which is allocated as bytes
// remove me when we have a real C++ device
new(&m68k->memory) m68k_memory_interface;
m68k->memory.init16(*m68k->program);
m68k->sr_mask = 0xa71f; /* T1 -- S -- -- I2 I1 I0 -- -- -- X N Z V C */ m68k->sr_mask = 0xa71f; /* T1 -- S -- -- I2 I1 I0 -- -- -- X N Z V C */
m68k->cyc_instruction = m68ki_cycles[0]; m68k->cyc_instruction = m68ki_cycles[0];
m68k->cyc_exception = m68ki_exception_cycle_table[0]; m68k->cyc_exception = m68ki_exception_cycle_table[0];
@ -1346,7 +1343,11 @@ static CPU_INIT( m68008 )
m68k->cpu_type = CPU_TYPE_008; m68k->cpu_type = CPU_TYPE_008;
m68k->dasm_type = M68K_CPU_TYPE_68008; m68k->dasm_type = M68K_CPU_TYPE_68008;
m68k->memory = interface_d8; // hack alert: we use placement new to ensure we are properly initialized
// because we live in the device state which is allocated as bytes
// remove me when we have a real C++ device
new(&m68k->memory) m68k_memory_interface;
m68k->memory.init8(*m68k->program);
m68k->sr_mask = 0xa71f; /* T1 -- S -- -- I2 I1 I0 -- -- -- X N Z V C */ m68k->sr_mask = 0xa71f; /* T1 -- S -- -- I2 I1 I0 -- -- -- X N Z V C */
m68k->cyc_instruction = m68ki_cycles[0]; m68k->cyc_instruction = m68ki_cycles[0];
m68k->cyc_exception = m68ki_exception_cycle_table[0]; m68k->cyc_exception = m68ki_exception_cycle_table[0];
@ -1395,7 +1396,11 @@ static CPU_INIT( m68010 )
m68k->cpu_type = CPU_TYPE_010; m68k->cpu_type = CPU_TYPE_010;
m68k->dasm_type = M68K_CPU_TYPE_68010; m68k->dasm_type = M68K_CPU_TYPE_68010;
m68k->memory = interface_d16; // hack alert: we use placement new to ensure we are properly initialized
// because we live in the device state which is allocated as bytes
// remove me when we have a real C++ device
new(&m68k->memory) m68k_memory_interface;
m68k->memory.init16(*m68k->program);
m68k->sr_mask = 0xa71f; /* T1 -- S -- -- I2 I1 I0 -- -- -- X N Z V C */ m68k->sr_mask = 0xa71f; /* T1 -- S -- -- I2 I1 I0 -- -- -- X N Z V C */
m68k->cyc_instruction = m68ki_cycles[1]; m68k->cyc_instruction = m68ki_cycles[1];
m68k->cyc_exception = m68ki_exception_cycle_table[1]; m68k->cyc_exception = m68ki_exception_cycle_table[1];
@ -1440,7 +1445,11 @@ static CPU_INIT( m68020 )
m68k->cpu_type = CPU_TYPE_020; m68k->cpu_type = CPU_TYPE_020;
m68k->dasm_type = M68K_CPU_TYPE_68020; m68k->dasm_type = M68K_CPU_TYPE_68020;
m68k->memory = interface_d32; // hack alert: we use placement new to ensure we are properly initialized
// because we live in the device state which is allocated as bytes
// remove me when we have a real C++ device
new(&m68k->memory) m68k_memory_interface;
m68k->memory.init32(*m68k->program);
m68k->sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */ m68k->sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */
m68k->cyc_instruction = m68ki_cycles[2]; m68k->cyc_instruction = m68ki_cycles[2];
m68k->cyc_exception = m68ki_exception_cycle_table[2]; m68k->cyc_exception = m68ki_exception_cycle_table[2];
@ -1488,7 +1497,11 @@ static CPU_INIT( m68020pmmu )
CPU_INIT_CALL(m68020); CPU_INIT_CALL(m68020);
m68k->has_pmmu = 1; m68k->has_pmmu = 1;
m68k->memory = interface_d32_mmu; // hack alert: we use placement new to ensure we are properly initialized
// because we live in the device state which is allocated as bytes
// remove me when we have a real C++ device
new(&m68k->memory) m68k_memory_interface;
m68k->memory.init32mmu(*m68k->program);
} }
CPU_GET_INFO( m68020pmmu ) CPU_GET_INFO( m68020pmmu )
@ -1517,7 +1530,11 @@ static CPU_INIT( m68ec020 )
m68k->cpu_type = CPU_TYPE_EC020; m68k->cpu_type = CPU_TYPE_EC020;
m68k->dasm_type = M68K_CPU_TYPE_68EC020; m68k->dasm_type = M68K_CPU_TYPE_68EC020;
m68k->memory = interface_d32; // hack alert: we use placement new to ensure we are properly initialized
// because we live in the device state which is allocated as bytes
// remove me when we have a real C++ device
new(&m68k->memory) m68k_memory_interface;
m68k->memory.init32(*m68k->program);
m68k->sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */ m68k->sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */
m68k->cyc_instruction = m68ki_cycles[2]; m68k->cyc_instruction = m68ki_cycles[2];
m68k->cyc_exception = m68ki_exception_cycle_table[2]; m68k->cyc_exception = m68ki_exception_cycle_table[2];
@ -1564,7 +1581,11 @@ static CPU_INIT( m68030 )
m68k->cpu_type = CPU_TYPE_030; m68k->cpu_type = CPU_TYPE_030;
m68k->dasm_type = M68K_CPU_TYPE_68030; m68k->dasm_type = M68K_CPU_TYPE_68030;
m68k->memory = interface_d32_mmu; // hack alert: we use placement new to ensure we are properly initialized
// because we live in the device state which is allocated as bytes
// remove me when we have a real C++ device
new(&m68k->memory) m68k_memory_interface;
m68k->memory.init32mmu(*m68k->program);
m68k->sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */ m68k->sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */
m68k->cyc_instruction = m68ki_cycles[3]; m68k->cyc_instruction = m68ki_cycles[3];
m68k->cyc_exception = m68ki_exception_cycle_table[3]; m68k->cyc_exception = m68ki_exception_cycle_table[3];
@ -1617,7 +1638,11 @@ static CPU_INIT( m68ec030 )
m68k->cpu_type = CPU_TYPE_EC030; m68k->cpu_type = CPU_TYPE_EC030;
m68k->dasm_type = M68K_CPU_TYPE_68EC030; m68k->dasm_type = M68K_CPU_TYPE_68EC030;
m68k->memory = interface_d32; // hack alert: we use placement new to ensure we are properly initialized
// because we live in the device state which is allocated as bytes
// remove me when we have a real C++ device
new(&m68k->memory) m68k_memory_interface;
m68k->memory.init32(*m68k->program);
m68k->sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */ m68k->sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */
m68k->cyc_instruction = m68ki_cycles[3]; m68k->cyc_instruction = m68ki_cycles[3];
m68k->cyc_exception = m68ki_exception_cycle_table[3]; m68k->cyc_exception = m68ki_exception_cycle_table[3];
@ -1661,7 +1686,11 @@ static CPU_INIT( m68040 )
m68k->cpu_type = CPU_TYPE_040; m68k->cpu_type = CPU_TYPE_040;
m68k->dasm_type = M68K_CPU_TYPE_68040; m68k->dasm_type = M68K_CPU_TYPE_68040;
m68k->memory = interface_d32_mmu; // hack alert: we use placement new to ensure we are properly initialized
// because we live in the device state which is allocated as bytes
// remove me when we have a real C++ device
new(&m68k->memory) m68k_memory_interface;
m68k->memory.init32mmu(*m68k->program);
m68k->sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */ m68k->sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */
m68k->cyc_instruction = m68ki_cycles[4]; m68k->cyc_instruction = m68ki_cycles[4];
m68k->cyc_exception = m68ki_exception_cycle_table[4]; m68k->cyc_exception = m68ki_exception_cycle_table[4];
@ -1713,7 +1742,11 @@ static CPU_INIT( m68ec040 )
m68k->cpu_type = CPU_TYPE_EC040; m68k->cpu_type = CPU_TYPE_EC040;
m68k->dasm_type = M68K_CPU_TYPE_68EC040; m68k->dasm_type = M68K_CPU_TYPE_68EC040;
m68k->memory = interface_d32; // hack alert: we use placement new to ensure we are properly initialized
// because we live in the device state which is allocated as bytes
// remove me when we have a real C++ device
new(&m68k->memory) m68k_memory_interface;
m68k->memory.init32(*m68k->program);
m68k->sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */ m68k->sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */
m68k->cyc_instruction = m68ki_cycles[4]; m68k->cyc_instruction = m68ki_cycles[4];
m68k->cyc_exception = m68ki_exception_cycle_table[4]; m68k->cyc_exception = m68ki_exception_cycle_table[4];
@ -1757,7 +1790,11 @@ static CPU_INIT( m68lc040 )
m68k->cpu_type = CPU_TYPE_LC040; m68k->cpu_type = CPU_TYPE_LC040;
m68k->dasm_type = M68K_CPU_TYPE_68LC040; m68k->dasm_type = M68K_CPU_TYPE_68LC040;
m68k->memory = interface_d32; // hack alert: we use placement new to ensure we are properly initialized
// because we live in the device state which is allocated as bytes
// remove me when we have a real C++ device
new(&m68k->memory) m68k_memory_interface;
m68k->memory.init32(*m68k->program);
m68k->sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */ m68k->sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */
m68k->cyc_instruction = m68ki_cycles[4]; m68k->cyc_instruction = m68ki_cycles[4];
m68k->cyc_exception = m68ki_exception_cycle_table[4]; m68k->cyc_exception = m68ki_exception_cycle_table[4];

104
src/emu/cpu/m68000/m68kcpu.h
View File

@ -535,17 +535,59 @@ union _fp_reg
/* Redirect memory calls */ /* Redirect memory calls */
typedef struct _m68k_memory_interface m68k_memory_interface; typedef proto_delegate_1param<UINT8, offs_t> m68k_read8_proto_delegate;
struct _m68k_memory_interface typedef proto_delegate_1param<UINT16, offs_t> m68k_readimm16_proto_delegate;
typedef proto_delegate_2param<UINT16, offs_t, UINT16> m68k_read16_proto_delegate;
typedef proto_delegate_2param<UINT32, offs_t, UINT32> m68k_read32_proto_delegate;
typedef proto_delegate_2param<void, offs_t, UINT8> m68k_write8_proto_delegate;
typedef proto_delegate_3param<void, offs_t, UINT16, UINT16> m68k_write16_proto_delegate;
typedef proto_delegate_3param<void, offs_t, UINT32, UINT32> m68k_write32_proto_delegate;
typedef delegate_1param<UINT8, offs_t> m68k_read8_delegate;
typedef delegate_1param<UINT16, offs_t> m68k_readimm16_delegate;
typedef delegate_2param<UINT16, offs_t, UINT16> m68k_read16_delegate;
typedef delegate_2param<UINT32, offs_t, UINT32> m68k_read32_delegate;
typedef delegate_2param<void, offs_t, UINT8> m68k_write8_delegate;
typedef delegate_3param<void, offs_t, UINT16, UINT16> m68k_write16_delegate;
typedef delegate_3param<void, offs_t, UINT32, UINT32> m68k_write32_delegate;
class m68k_memory_interface : public bindable_object
{ {
public:
void init8(address_space &space);
void init16(address_space &space);
void init32(address_space &space);
void init32mmu(address_space &space);
offs_t opcode_xor; // Address Calculation offs_t opcode_xor; // Address Calculation
UINT16 (*readimm16)(address_space *, offs_t); // Immediate read 16 bit m68k_readimm16_delegate readimm16; // Immediate read 16 bit
UINT8 (*read8)(address_space *, offs_t); // Normal read 8 bit m68k_read8_delegate read8;
UINT16 (*read16)(address_space *, offs_t); // Normal read 16 bit m68k_read16_delegate read16;
UINT32 (*read32)(address_space *, offs_t); // Normal read 32 bit m68k_read32_delegate read32;
void (*write8)(address_space *, offs_t, UINT8); // Write 8 bit m68k_write8_delegate write8;
void (*write16)(address_space *, offs_t, UINT16); // Write 16 bit m68k_write16_delegate write16;
void (*write32)(address_space *, offs_t, UINT32); // Write 32 bit m68k_write32_delegate write32;
private:
UINT16 m68008_read_immediate_16(offs_t address);
UINT16 read_immediate_16(offs_t address);
UINT16 simple_read_immediate_16(offs_t address);
UINT16 readword_d32(offs_t address, UINT16 mask);
void writeword_d32(offs_t address, UINT16 data, UINT16 mask);
UINT32 readlong_d32(offs_t address, UINT32 mask);
void writelong_d32(offs_t address, UINT32 data, UINT32 mask);
UINT8 read_byte_32_mmu(offs_t address);
void write_byte_32_mmu(offs_t address, UINT8 data);
UINT16 read_immediate_16_mmu(offs_t address);
UINT16 readword_d32_mmu(offs_t address, UINT16 mask);
void writeword_d32_mmu(offs_t address, UINT16 data, UINT16 mask);
UINT32 readlong_d32_mmu(offs_t address, UINT32 mask);
void writelong_d32_mmu(offs_t address, UINT32 data, UINT32 mask);
address_space *m_space;
direct_read_data *m_direct;
m68ki_cpu_core *m_cpustate;
}; };
struct _m68ki_cpu_core struct _m68ki_cpu_core
@ -779,23 +821,23 @@ char* m68ki_disassemble_quick(unsigned int pc, unsigned int cpu_type);
INLINE unsigned int m68k_read_immediate_32(m68ki_cpu_core *m68k, unsigned int address) INLINE unsigned int m68k_read_immediate_32(m68ki_cpu_core *m68k, unsigned int address)
{ {
return ((*m68k->memory.readimm16)(m68k->program, address) << 16) | (*m68k->memory.readimm16)(m68k->program, address + 2); return (m68k->memory.readimm16(address) << 16) | m68k->memory.readimm16(address + 2);
} }
INLINE unsigned int m68k_read_pcrelative_8(m68ki_cpu_core *m68k, unsigned int address) INLINE unsigned int m68k_read_pcrelative_8(m68ki_cpu_core *m68k, unsigned int address)
{ {
if (address >= m68k->encrypted_start && address < m68k->encrypted_end) if (address >= m68k->encrypted_start && address < m68k->encrypted_end)
return (((*m68k->memory.readimm16)(m68k->program, address&~1)>>(8*(1-(address & 1))))&0xff); return ((m68k->memory.readimm16(address&~1)>>(8*(1-(address & 1))))&0xff);
return (*m68k->memory.read8)(m68k->program, address); return m68k->memory.read8(address);
} }
INLINE unsigned int m68k_read_pcrelative_16(m68ki_cpu_core *m68k, unsigned int address) INLINE unsigned int m68k_read_pcrelative_16(m68ki_cpu_core *m68k, unsigned int address)
{ {
if (address >= m68k->encrypted_start && address < m68k->encrypted_end) if (address >= m68k->encrypted_start && address < m68k->encrypted_end)
return (*m68k->memory.readimm16)(m68k->program, address); return m68k->memory.readimm16(address);
return (*m68k->memory.read16)(m68k->program, address); return m68k->memory.read16(address, 0xffff);
} }
INLINE unsigned int m68k_read_pcrelative_32(m68ki_cpu_core *m68k, unsigned int address) INLINE unsigned int m68k_read_pcrelative_32(m68ki_cpu_core *m68k, unsigned int address)
@ -803,7 +845,7 @@ INLINE unsigned int m68k_read_pcrelative_32(m68ki_cpu_core *m68k, unsigned int a
if (address >= m68k->encrypted_start && address < m68k->encrypted_end) if (address >= m68k->encrypted_start && address < m68k->encrypted_end)
return m68k_read_immediate_32(m68k, address); return m68k_read_immediate_32(m68k, address);
return (*m68k->memory.read32)(m68k->program, address); return m68k->memory.read32(address, 0xffffffff);
} }
@ -814,8 +856,8 @@ INLINE unsigned int m68k_read_pcrelative_32(m68ki_cpu_core *m68k, unsigned int a
*/ */
INLINE void m68kx_write_memory_32_pd(m68ki_cpu_core *m68k, unsigned int address, unsigned int value) INLINE void m68kx_write_memory_32_pd(m68ki_cpu_core *m68k, unsigned int address, unsigned int value)
{ {
(m68k->memory.write16)(m68k->program, address+2, value>>16); m68k->memory.write16(address+2, value>>16, 0xffff);
(m68k->memory.write16)(m68k->program, address, value&0xffff); m68k->memory.write16(address, value&0xffff, 0xffff);
} }
@ -833,12 +875,12 @@ INLINE UINT32 m68ki_read_imm_16(m68ki_cpu_core *m68k)
if(REG_PC != m68k->pref_addr) if(REG_PC != m68k->pref_addr)
{ {
m68k->pref_addr = REG_PC; m68k->pref_addr = REG_PC;
m68k->pref_data = (*m68k->memory.readimm16)(m68k->program, m68k->pref_addr); m68k->pref_data = m68k->memory.readimm16(m68k->pref_addr);
} }
result = MASK_OUT_ABOVE_16(m68k->pref_data); result = MASK_OUT_ABOVE_16(m68k->pref_data);
REG_PC += 2; REG_PC += 2;
m68k->pref_addr = REG_PC; m68k->pref_addr = REG_PC;
m68k->pref_data = (*m68k->memory.readimm16)(m68k->program, m68k->pref_addr); m68k->pref_data = m68k->memory.readimm16(m68k->pref_addr);
return result; return result;
} }
@ -851,17 +893,17 @@ INLINE UINT32 m68ki_read_imm_32(m68ki_cpu_core *m68k)
if(REG_PC != m68k->pref_addr) if(REG_PC != m68k->pref_addr)
{ {
m68k->pref_addr = REG_PC; m68k->pref_addr = REG_PC;
m68k->pref_data = (*m68k->memory.readimm16)(m68k->program, m68k->pref_addr); m68k->pref_data = m68k->memory.readimm16(m68k->pref_addr);
} }
temp_val = MASK_OUT_ABOVE_16(m68k->pref_data); temp_val = MASK_OUT_ABOVE_16(m68k->pref_data);
REG_PC += 2; REG_PC += 2;
m68k->pref_addr = REG_PC; m68k->pref_addr = REG_PC;
m68k->pref_data = (*m68k->memory.readimm16)(m68k->program, m68k->pref_addr); m68k->pref_data = m68k->memory.readimm16(m68k->pref_addr);
temp_val = MASK_OUT_ABOVE_32((temp_val << 16) | MASK_OUT_ABOVE_16(m68k->pref_data)); temp_val = MASK_OUT_ABOVE_32((temp_val << 16) | MASK_OUT_ABOVE_16(m68k->pref_data));
REG_PC += 2; REG_PC += 2;
m68k->pref_addr = REG_PC; m68k->pref_addr = REG_PC;
m68k->pref_data = (*m68k->memory.readimm16)(m68k->program, m68k->pref_addr); m68k->pref_data = m68k->memory.readimm16(m68k->pref_addr);
return temp_val; return temp_val;
} }
@ -878,7 +920,7 @@ INLINE UINT32 m68ki_read_imm_32(m68ki_cpu_core *m68k)
*/ */
INLINE UINT32 m68ki_read_8_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc) INLINE UINT32 m68ki_read_8_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc)
{ {
return (*m68k->memory.read8)(m68k->program, address); return m68k->memory.read8(address);
} }
INLINE UINT32 m68ki_read_16_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc) INLINE UINT32 m68ki_read_16_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc)
{ {
@ -886,7 +928,7 @@ INLINE UINT32 m68ki_read_16_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc)
{ {
m68ki_check_address_error(m68k, address, MODE_READ, fc); m68ki_check_address_error(m68k, address, MODE_READ, fc);
} }
return (*m68k->memory.read16)(m68k->program, address); return m68k->memory.read16(address, 0xffff);
} }
INLINE UINT32 m68ki_read_32_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc) INLINE UINT32 m68ki_read_32_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc)
{ {
@ -894,12 +936,12 @@ INLINE UINT32 m68ki_read_32_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc)
{ {
m68ki_check_address_error(m68k, address, MODE_READ, fc); m68ki_check_address_error(m68k, address, MODE_READ, fc);
} }
return (*m68k->memory.read32)(m68k->program, address); return m68k->memory.read32(address, 0xffffffff);
} }
INLINE void m68ki_write_8_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, UINT32 value) INLINE void m68ki_write_8_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, UINT32 value)
{ {
(*m68k->memory.write8)(m68k->program, address, value); m68k->memory.write8(address, value);
} }
INLINE void m68ki_write_16_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, UINT32 value) INLINE void m68ki_write_16_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, UINT32 value)
{ {
@ -907,7 +949,7 @@ INLINE void m68ki_write_16_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, U
{ {
m68ki_check_address_error(m68k, address, MODE_WRITE, fc); m68ki_check_address_error(m68k, address, MODE_WRITE, fc);
} }
(*m68k->memory.write16)(m68k->program, address, value); m68k->memory.write16(address, value, 0xffff);
} }
INLINE void m68ki_write_32_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, UINT32 value) INLINE void m68ki_write_32_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, UINT32 value)
{ {
@ -915,7 +957,7 @@ INLINE void m68ki_write_32_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, U
{ {
m68ki_check_address_error(m68k, address, MODE_WRITE, fc); m68ki_check_address_error(m68k, address, MODE_WRITE, fc);
} }
(*m68k->memory.write32)(m68k->program, address, value); m68k->memory.write32(address, value, 0xffffffff);
} }
/* Special call to simulate undocumented 68k behavior when move.l with a /* Special call to simulate undocumented 68k behavior when move.l with a
@ -929,8 +971,8 @@ INLINE void m68ki_write_32_pd_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc
{ {
m68ki_check_address_error(m68k, address, MODE_WRITE, fc); m68ki_check_address_error(m68k, address, MODE_WRITE, fc);
} }
(*m68k->memory.write16)(m68k->program, address+2, value>>16); m68k->memory.write16(address+2, value>>16, 0xffff);
(*m68k->memory.write16)(m68k->program, address, value&0xffff); m68k->memory.write16(address, value&0xffff, 0xffff);
} }
@ -1682,7 +1724,7 @@ INLINE void m68ki_exception_address_error(m68ki_cpu_core *m68k)
*/ */
if(m68k->run_mode == RUN_MODE_BERR_AERR_RESET) if(m68k->run_mode == RUN_MODE_BERR_AERR_RESET)
{ {
(*m68k->memory.read8)(m68k->program, 0x00ffff01); m68k->memory.read8(0x00ffff01);
m68k->stopped = STOP_LEVEL_HALT; m68k->stopped = STOP_LEVEL_HALT;
return; return;
} }

6
src/emu/delegate.h
View File

@ -124,9 +124,9 @@
#endif #endif
// nicer macros to hide the template gobblety-gook and to pass the names // nicer macros to hide the template gobblety-gook and to pass the names
#define bind_member_name(_class, _member, _name) _bind_member<_class, &_class::_member>(_name) #define create_member_name(_class, _member, _name) _create_member<_class, &_class::_member>(_name)
#define bind_member(_class, _member) bind_member_name(_class, _member, #_class "::" #_member) #define create_member(_class, _member) _create_member<_class, &_class::_member>(#_class "::" #_member)
#define bind_static(_class, _func) _bind_static<_class, &_func>(#_func) #define create_static(_class, _func) _crate_static<_class, &_func>(#_func)