mirror of
https://github.com/holub/mame
synced 2025-05-18 19:49:35 +03:00
Remove a level of indirection when calling m68000 memory handlers.
This commit is contained in:
Aaron Giles
parent
98630a96d7
commit
a86a4c3684
@ -940,273 +940,266 @@ void m68k_set_encrypted_opcode_range(running_device *device, offs_t start, offs_
|
||||
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
|
||||
****************************************************************************/
|
||||
|
||||
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 (memory_decrypted_read_byte(space, addr) << 8) | (memory_decrypted_read_byte(space, addr + 1));
|
||||
return (m_direct->read_decrypted_byte(address) << 8) | (m_direct->read_decrypted_byte(address + 1));
|
||||
}
|
||||
|
||||
/* interface for 20/22-bit address bus, 8-bit data bus (68008) */
|
||||
static const m68k_memory_interface interface_d8 =
|
||||
void m68k_memory_interface::init8(address_space &space)
|
||||
{
|
||||
0,
|
||||
m68008_read_immediate_16,
|
||||
memory_read_byte,
|
||||
memory_read_word,
|
||||
memory_read_dword,
|
||||
memory_write_byte,
|
||||
memory_write_word,
|
||||
memory_write_dword
|
||||
};
|
||||
m_space = &space;
|
||||
m_direct = &space.direct();
|
||||
m_cpustate = get_safe_token(&space.device());
|
||||
opcode_xor = 0;
|
||||
|
||||
readimm16 = m68k_readimm16_delegate(m68k_readimm16_proto_delegate::create_member(m68k_memory_interface, m68008_read_immediate_16), *this);
|
||||
read8 = m68k_read8_delegate(m68k_read8_proto_delegate::create_member(address_space, read_byte), space);
|
||||
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
|
||||
****************************************************************************/
|
||||
|
||||
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 memory_decrypted_read_word(space, (address) ^ m68k->memory.opcode_xor);
|
||||
return m_direct->read_decrypted_word((address) ^ 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) */
|
||||
static const m68k_memory_interface interface_d16 =
|
||||
void m68k_memory_interface::init16(address_space &space)
|
||||
{
|
||||
0,
|
||||
simple_read_immediate_16,
|
||||
memory_read_byte,
|
||||
memory_read_word,
|
||||
memory_read_dword,
|
||||
memory_write_byte,
|
||||
memory_write_word,
|
||||
memory_write_dword
|
||||
};
|
||||
m_space = &space;
|
||||
m_direct = &space.direct();
|
||||
m_cpustate = get_safe_token(&space.device());
|
||||
opcode_xor = 0;
|
||||
|
||||
readimm16 = m68k_readimm16_delegate(m68k_readimm16_proto_delegate::create_member(m68k_memory_interface, simple_read_immediate_16), *this);
|
||||
read8 = m68k_read8_delegate(m68k_read8_proto_delegate::create_member(address_space, read_byte), space);
|
||||
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
|
||||
****************************************************************************/
|
||||
|
||||
/* 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;
|
||||
|
||||
if (!(address & 1))
|
||||
return space->read_word(address);
|
||||
result = space->read_byte(address) << 8;
|
||||
return result | space->read_byte(address + 1);
|
||||
return m_space->read_word(address);
|
||||
result = m_space->read_byte(address) << 8;
|
||||
return result | m_space->read_byte(address + 1);
|
||||
}
|
||||
|
||||
/* 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))
|
||||
{
|
||||
space->write_word(address, data);
|
||||
m_space->write_word(address, data);
|
||||
return;
|
||||
}
|
||||
space->write_byte(address, data >> 8);
|
||||
space->write_byte(address + 1, data);
|
||||
m_space->write_byte(address, data >> 8);
|
||||
m_space->write_byte(address + 1, data);
|
||||
}
|
||||
|
||||
/* 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;
|
||||
|
||||
if (!(address & 3))
|
||||
return space->read_dword(address);
|
||||
return m_space->read_dword(address);
|
||||
else if (!(address & 1))
|
||||
{
|
||||
result = space->read_word(address) << 16;
|
||||
return result | space->read_word(address + 2);
|
||||
result = m_space->read_word(address) << 16;
|
||||
return result | m_space->read_word(address + 2);
|
||||
}
|
||||
result = space->read_byte(address) << 24;
|
||||
result |= space->read_word(address + 1) << 8;
|
||||
return result | space->read_byte(address + 3);
|
||||
result = m_space->read_byte(address) << 24;
|
||||
result |= m_space->read_word(address + 1) << 8;
|
||||
return result | m_space->read_byte(address + 3);
|
||||
}
|
||||
|
||||
/* 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))
|
||||
{
|
||||
space->write_dword(address, data);
|
||||
m_space->write_dword(address, data);
|
||||
return;
|
||||
}
|
||||
else if (!(address & 1))
|
||||
{
|
||||
space->write_word(address, data >> 16);
|
||||
space->write_word(address + 2, data);
|
||||
m_space->write_word(address, data >> 16);
|
||||
m_space->write_word(address + 2, data);
|
||||
return;
|
||||
}
|
||||
space->write_byte(address, data >> 24);
|
||||
space->write_word(address + 1, data >> 8);
|
||||
space->write_byte(address + 3, data);
|
||||
m_space->write_byte(address, data >> 24);
|
||||
m_space->write_word(address + 1, data >> 8);
|
||||
m_space->write_byte(address + 3, data);
|
||||
}
|
||||
|
||||
/* 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),
|
||||
read_immediate_16,
|
||||
memory_read_byte,
|
||||
readword_d32,
|
||||
readlong_d32,
|
||||
memory_write_byte,
|
||||
writeword_d32,
|
||||
writelong_d32
|
||||
};
|
||||
m_space = &space;
|
||||
m_direct = &space.direct();
|
||||
m_cpustate = get_safe_token(&space.device());
|
||||
opcode_xor = WORD_XOR_BE(0);
|
||||
|
||||
readimm16 = m68k_readimm16_delegate(m68k_readimm16_proto_delegate::create_member(m68k_memory_interface, read_immediate_16), *this);
|
||||
read8 = m68k_read8_delegate(m68k_read8_proto_delegate::create_member(address_space, read_byte), space);
|
||||
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) */
|
||||
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 (m68k->pmmu_enabled)
|
||||
if (m_cpustate->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 (m68k->pmmu_enabled)
|
||||
if (m_cpustate->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 (m68k->pmmu_enabled)
|
||||
if (m_cpustate->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) */
|
||||
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;
|
||||
|
||||
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))
|
||||
return space->read_word(address);
|
||||
result = space->read_byte(address) << 8;
|
||||
return result | space->read_byte(address + 1);
|
||||
return m_space->read_word(address);
|
||||
result = m_space->read_byte(address) << 8;
|
||||
return result | m_space->read_byte(address + 1);
|
||||
}
|
||||
|
||||
/* 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 (m68k->pmmu_enabled)
|
||||
if (m_cpustate->pmmu_enabled)
|
||||
{
|
||||
address = pmmu_translate_addr(m68k, address);
|
||||
address = pmmu_translate_addr(m_cpustate, address);
|
||||
}
|
||||
|
||||
if (!(address & 1))
|
||||
{
|
||||
space->write_word(address, data);
|
||||
m_space->write_word(address, data);
|
||||
return;
|
||||
}
|
||||
space->write_byte(address, data >> 8);
|
||||
space->write_byte(address + 1, data);
|
||||
m_space->write_byte(address, data >> 8);
|
||||
m_space->write_byte(address + 1, data);
|
||||
}
|
||||
|
||||
/* 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;
|
||||
|
||||
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))
|
||||
return space->read_dword(address);
|
||||
return m_space->read_dword(address);
|
||||
else if (!(address & 1))
|
||||
{
|
||||
result = space->read_word(address) << 16;
|
||||
return result | space->read_word(address + 2);
|
||||
result = m_space->read_word(address) << 16;
|
||||
return result | m_space->read_word(address + 2);
|
||||
}
|
||||
result = space->read_byte(address) << 24;
|
||||
result |= space->read_word(address + 1) << 8;
|
||||
return result | space->read_byte(address + 3);
|
||||
result = m_space->read_byte(address) << 24;
|
||||
result |= m_space->read_word(address + 1) << 8;
|
||||
return result | m_space->read_byte(address + 3);
|
||||
}
|
||||
|
||||
/* 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 (m68k->pmmu_enabled)
|
||||
if (m_cpustate->pmmu_enabled)
|
||||
{
|
||||
address = pmmu_translate_addr(m68k, address);
|
||||
address = pmmu_translate_addr(m_cpustate, address);
|
||||
}
|
||||
|
||||
if (!(address & 3))
|
||||
{
|
||||
space->write_dword(address, data);
|
||||
m_space->write_dword(address, data);
|
||||
return;
|
||||
}
|
||||
else if (!(address & 1))
|
||||
{
|
||||
space->write_word(address, data >> 16);
|
||||
space->write_word(address + 2, data);
|
||||
m_space->write_word(address, data >> 16);
|
||||
m_space->write_word(address + 2, data);
|
||||
return;
|
||||
}
|
||||
space->write_byte(address, data >> 24);
|
||||
space->write_word(address + 1, data >> 8);
|
||||
space->write_byte(address + 3, data);
|
||||
m_space->write_byte(address, data >> 24);
|
||||
m_space->write_word(address + 1, data >> 8);
|
||||
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),
|
||||
read_immediate_16_mmu,
|
||||
read_byte_32_mmu,
|
||||
readword_d32_mmu,
|
||||
readlong_d32_mmu,
|
||||
write_byte_32_mmu,
|
||||
writeword_d32_mmu,
|
||||
writelong_d32_mmu
|
||||
};
|
||||
m_space = &space;
|
||||
m_direct = &space.direct();
|
||||
m_cpustate = get_safe_token(&space.device());
|
||||
opcode_xor = WORD_XOR_BE(0);
|
||||
|
||||
readimm16 = m68k_readimm16_delegate(m68k_readimm16_proto_delegate::create_member(m68k_memory_interface, read_immediate_16_mmu), *this);
|
||||
read8 = m68k_read8_delegate(m68k_read8_proto_delegate::create_member(m68k_memory_interface, read_byte_32_mmu), *this);
|
||||
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)
|
||||
@ -1301,7 +1294,11 @@ static CPU_INIT( m68000 )
|
||||
|
||||
m68k->cpu_type = CPU_TYPE_000;
|
||||
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->cyc_instruction = m68ki_cycles[0];
|
||||
m68k->cyc_exception = m68ki_exception_cycle_table[0];
|
||||
@ -1346,7 +1343,11 @@ static CPU_INIT( m68008 )
|
||||
|
||||
m68k->cpu_type = CPU_TYPE_008;
|
||||
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->cyc_instruction = m68ki_cycles[0];
|
||||
m68k->cyc_exception = m68ki_exception_cycle_table[0];
|
||||
@ -1395,7 +1396,11 @@ static CPU_INIT( m68010 )
|
||||
|
||||
m68k->cpu_type = CPU_TYPE_010;
|
||||
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->cyc_instruction = m68ki_cycles[1];
|
||||
m68k->cyc_exception = m68ki_exception_cycle_table[1];
|
||||
@ -1440,7 +1445,11 @@ static CPU_INIT( m68020 )
|
||||
|
||||
m68k->cpu_type = CPU_TYPE_020;
|
||||
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->cyc_instruction = m68ki_cycles[2];
|
||||
m68k->cyc_exception = m68ki_exception_cycle_table[2];
|
||||
@ -1488,7 +1497,11 @@ static CPU_INIT( m68020pmmu )
|
||||
CPU_INIT_CALL(m68020);
|
||||
|
||||
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 )
|
||||
@ -1517,7 +1530,11 @@ static CPU_INIT( m68ec020 )
|
||||
|
||||
m68k->cpu_type = CPU_TYPE_EC020;
|
||||
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->cyc_instruction = m68ki_cycles[2];
|
||||
m68k->cyc_exception = m68ki_exception_cycle_table[2];
|
||||
@ -1564,7 +1581,11 @@ static CPU_INIT( m68030 )
|
||||
|
||||
m68k->cpu_type = CPU_TYPE_030;
|
||||
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->cyc_instruction = m68ki_cycles[3];
|
||||
m68k->cyc_exception = m68ki_exception_cycle_table[3];
|
||||
@ -1617,7 +1638,11 @@ static CPU_INIT( m68ec030 )
|
||||
|
||||
m68k->cpu_type = CPU_TYPE_EC030;
|
||||
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->cyc_instruction = m68ki_cycles[3];
|
||||
m68k->cyc_exception = m68ki_exception_cycle_table[3];
|
||||
@ -1661,7 +1686,11 @@ static CPU_INIT( m68040 )
|
||||
|
||||
m68k->cpu_type = CPU_TYPE_040;
|
||||
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->cyc_instruction = m68ki_cycles[4];
|
||||
m68k->cyc_exception = m68ki_exception_cycle_table[4];
|
||||
@ -1713,7 +1742,11 @@ static CPU_INIT( m68ec040 )
|
||||
|
||||
m68k->cpu_type = CPU_TYPE_EC040;
|
||||
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->cyc_instruction = m68ki_cycles[4];
|
||||
m68k->cyc_exception = m68ki_exception_cycle_table[4];
|
||||
@ -1757,7 +1790,11 @@ static CPU_INIT( m68lc040 )
|
||||
|
||||
m68k->cpu_type = CPU_TYPE_LC040;
|
||||
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->cyc_instruction = m68ki_cycles[4];
|
||||
m68k->cyc_exception = m68ki_exception_cycle_table[4];
|
||||
|
||||
@ -535,17 +535,59 @@ union _fp_reg
|
||||
|
||||
/* Redirect memory calls */
|
||||
|
||||
typedef struct _m68k_memory_interface m68k_memory_interface;
|
||||
struct _m68k_memory_interface
|
||||
typedef proto_delegate_1param<UINT8, offs_t> m68k_read8_proto_delegate;
|
||||
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
|
||||
UINT16 (*readimm16)(address_space *, offs_t); // Immediate read 16 bit
|
||||
UINT8 (*read8)(address_space *, offs_t); // Normal read 8 bit
|
||||
UINT16 (*read16)(address_space *, offs_t); // Normal read 16 bit
|
||||
UINT32 (*read32)(address_space *, offs_t); // Normal read 32 bit
|
||||
void (*write8)(address_space *, offs_t, UINT8); // Write 8 bit
|
||||
void (*write16)(address_space *, offs_t, UINT16); // Write 16 bit
|
||||
void (*write32)(address_space *, offs_t, UINT32); // Write 32 bit
|
||||
m68k_readimm16_delegate readimm16; // Immediate read 16 bit
|
||||
m68k_read8_delegate read8;
|
||||
m68k_read16_delegate read16;
|
||||
m68k_read32_delegate read32;
|
||||
m68k_write8_delegate write8;
|
||||
m68k_write16_delegate write16;
|
||||
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
|
||||
@ -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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
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)
|
||||
@ -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)
|
||||
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)
|
||||
{
|
||||
(m68k->memory.write16)(m68k->program, address+2, value>>16);
|
||||
(m68k->memory.write16)(m68k->program, address, value&0xffff);
|
||||
m68k->memory.write16(address+2, value>>16, 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)
|
||||
{
|
||||
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);
|
||||
REG_PC += 2;
|
||||
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;
|
||||
}
|
||||
|
||||
@ -851,17 +893,17 @@ INLINE UINT32 m68ki_read_imm_32(m68ki_cpu_core *m68k)
|
||||
if(REG_PC != m68k->pref_addr)
|
||||
{
|
||||
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);
|
||||
REG_PC += 2;
|
||||
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));
|
||||
REG_PC += 2;
|
||||
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;
|
||||
}
|
||||
@ -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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
@ -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);
|
||||
}
|
||||
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)
|
||||
{
|
||||
@ -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);
|
||||
}
|
||||
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)
|
||||
{
|
||||
(*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)
|
||||
{
|
||||
@ -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);
|
||||
}
|
||||
(*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)
|
||||
{
|
||||
@ -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);
|
||||
}
|
||||
(*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
|
||||
@ -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);
|
||||
}
|
||||
(*m68k->memory.write16)(m68k->program, address+2, value>>16);
|
||||
(*m68k->memory.write16)(m68k->program, address, value&0xffff);
|
||||
m68k->memory.write16(address+2, value>>16, 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)
|
||||
{
|
||||
(*m68k->memory.read8)(m68k->program, 0x00ffff01);
|
||||
m68k->memory.read8(0x00ffff01);
|
||||
m68k->stopped = STOP_LEVEL_HALT;
|
||||
return;
|
||||
}
|
||||
|
||||
@ -124,9 +124,9 @@
|
||||
#endif
|
||||
|
||||
// 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 bind_member(_class, _member) bind_member_name(_class, _member, #_class "::" #_member)
|
||||
#define bind_static(_class, _func) _bind_static<_class, &_func>(#_func)
|
||||
#define create_member_name(_class, _member, _name) _create_member<_class, &_class::_member>(_name)
|
||||
#define create_member(_class, _member) _create_member<_class, &_class::_member>(#_class "::" #_member)
|
||||
#define create_static(_class, _func) _crate_static<_class, &_func>(#_func)
|
||||
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user