Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-24 14:56:21 +03:00
Code Issues Actions 7 Packages Projects Releases Wiki Activity

debug: Simplify now obsolete and buggy memory access code [O. Galibert]

Browse Source
This commit is contained in:
Olivier Galibert 2018-05-11 02:00:33 +09:00
parent 4c24f25845
commit 74301434ae
1 changed files with 24 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
src/emu/debug/debugcpu.cpp
View File

@ -482,40 +482,21 @@ void debugger_cpu::write_byte(address_space &space, offs_t address, u8 data, boo
void debugger_cpu::write_word(address_space &space, offs_t address, u16 data, bool apply_translation) void debugger_cpu::write_word(address_space &space, offs_t address, u16 data, bool apply_translation)
{ {
device_memory_interface &memory = space.device().memory();
/* mask against the logical byte mask */ /* mask against the logical byte mask */
address &= space.logaddrmask(); address &= space.logaddrmask();
/* if this is a misaligned write, or if there are no word writers, just read two bytes */
if (!WORD_ALIGNED(address))
{
if (space.endianness() == ENDIANNESS_LITTLE)
{
write_byte(space, address + 0, data >> 0, apply_translation);
write_byte(space, address + 1, data >> 8, apply_translation);
}
else
{
write_byte(space, address + 0, data >> 8, apply_translation);
write_byte(space, address + 1, data >> 0, apply_translation);
}
}
/* otherwise, this proceeds like the byte case */
else
{
device_memory_interface &memory = space.device().memory();
/* translate if necessary; if not mapped, we're done */ /* translate if necessary; if not mapped, we're done */
if (apply_translation && !memory.translate(space.spacenum(), TRANSLATE_WRITE_DEBUG, address)) if (apply_translation && !memory.translate(space.spacenum(), TRANSLATE_WRITE_DEBUG, address))
; ;
/* otherwise, call the byte reading function for the translated address */ /* otherwise, call the byte reading function for the translated address */
else else
space.write_word(address, data); space.write_word_unaligned(address, data);
m_memory_modified = true; m_memory_modified = true;
} }
}
/*------------------------------------------------- /*-------------------------------------------------
@ -525,40 +506,21 @@ void debugger_cpu::write_word(address_space &space, offs_t address, u16 data, bo
void debugger_cpu::write_dword(address_space &space, offs_t address, u32 data, bool apply_translation) void debugger_cpu::write_dword(address_space &space, offs_t address, u32 data, bool apply_translation)
{ {
device_memory_interface &memory = space.device().memory();
/* mask against the logical byte mask */ /* mask against the logical byte mask */
address &= space.logaddrmask(); address &= space.logaddrmask();
/* if this is a misaligned write, or if there are no dword writers, just read two words */
if (!DWORD_ALIGNED(address))
{
if (space.endianness() == ENDIANNESS_LITTLE)
{
write_word(space, address + 0, data >> 0, apply_translation);
write_word(space, address + 2, data >> 16, apply_translation);
}
else
{
write_word(space, address + 0, data >> 16, apply_translation);
write_word(space, address + 2, data >> 0, apply_translation);
}
}
/* otherwise, this proceeds like the byte case */
else
{
device_memory_interface &memory = space.device().memory();
/* translate if necessary; if not mapped, we're done */ /* translate if necessary; if not mapped, we're done */
if (apply_translation && !memory.translate(space.spacenum(), TRANSLATE_WRITE_DEBUG, address)) if (apply_translation && !memory.translate(space.spacenum(), TRANSLATE_WRITE_DEBUG, address))
; ;
/* otherwise, call the byte reading function for the translated address */ /* otherwise, call the byte reading function for the translated address */
else else
space.write_dword(address, data); space.write_dword_unaligned(address, data);
m_memory_modified = true; m_memory_modified = true;
} }
}
/*------------------------------------------------- /*-------------------------------------------------
@ -568,40 +530,21 @@ void debugger_cpu::write_dword(address_space &space, offs_t address, u32 data, b
void debugger_cpu::write_qword(address_space &space, offs_t address, u64 data, bool apply_translation) void debugger_cpu::write_qword(address_space &space, offs_t address, u64 data, bool apply_translation)
{ {
device_memory_interface &memory = space.device().memory();
/* mask against the logical byte mask */ /* mask against the logical byte mask */
address &= space.logaddrmask(); address &= space.logaddrmask();
/* if this is a misaligned write, or if there are no qword writers, just read two dwords */
if (!QWORD_ALIGNED(address))
{
if (space.endianness() == ENDIANNESS_LITTLE)
{
write_dword(space, address + 0, data >> 0, apply_translation);
write_dword(space, address + 4, data >> 32, apply_translation);
}
else
{
write_dword(space, address + 0, data >> 32, apply_translation);
write_dword(space, address + 4, data >> 0, apply_translation);
}
}
/* otherwise, this proceeds like the byte case */
else
{
device_memory_interface &memory = space.device().memory();
/* translate if necessary; if not mapped, we're done */ /* translate if necessary; if not mapped, we're done */
if (apply_translation && !memory.translate(space.spacenum(), TRANSLATE_WRITE_DEBUG, address)) if (apply_translation && !memory.translate(space.spacenum(), TRANSLATE_WRITE_DEBUG, address))
; ;
/* otherwise, call the byte reading function for the translated address */ /* otherwise, call the byte reading function for the translated address */
else else
space.write_qword(address, data); space.write_qword_unaligned(address, data);
m_memory_modified = true; m_memory_modified = true;
} }
}
/*------------------------------------------------- /*-------------------------------------------------
@ -635,19 +578,6 @@ u64 debugger_cpu::read_opcode(address_space &space, offs_t address, int size)
/* keep in logical range */ /* keep in logical range */
address &= space.logaddrmask(); address &= space.logaddrmask();
/* if we're bigger than the address bus, break into smaller pieces */
if (size > space.data_width() / 8)
{
int halfsize = size / 2;
u64 r0 = read_opcode(space, address + 0, halfsize);
u64 r1 = read_opcode(space, address + halfsize, halfsize);
if (space.endianness() == ENDIANNESS_LITTLE)
return r0 | (r1 << (8 * halfsize));
else
return r1 | (r0 << (8 * halfsize));
}
/* translate to physical first */ /* translate to physical first */
if (!memory.translate(space.spacenum(), TRANSLATE_FETCH_DEBUG, address)) if (!memory.translate(space.spacenum(), TRANSLATE_FETCH_DEBUG, address))
return result; return result;