Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-06-30 16:00:01 +03:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

Add macros for alignment checking (nw)

Browse Source
This commit is contained in:
AJR 2016-01-30 13:25:32 -05:00
parent 37adee5d3e
commit 83e6738a0a
22 changed files with 144 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/devices/bus/ti99_peb/bwg.cpp
View File

@ -151,7 +151,7 @@ SETADDRESS_DBIN_MEMBER( snug_bwg_device::setaddress_dbin )
&& ((state==ASSERT_LINE && ((m_address & 0x1ff8)==0x1ff0)) // read
|| (state==CLEAR_LINE && ((m_address & 0x1ff8)==0x1ff8))); // write
m_WDsel = m_WDsel0 && ((m_address & 1)==0);
m_WDsel = m_WDsel0 && WORD_ALIGNED(m_address);
// Is the RTC selected on the card? (even addr)
m_RTCsel = m_inDsrArea && m_rtc_enabled && ((m_address & 0x1fe1)==0x1fe0);

4
src/devices/bus/ti99_peb/hfdc.cpp
View File

@ -232,7 +232,7 @@ READ8Z_MEMBER(myarc_hfdc_device::readz)
if (m_dip == CLEAR_LINE) *value = m_buffer_ram[(m_ram_page[bank]<<10) | (m_address & 0x03ff)];
if (TRACE_RAM)
{
if ((m_address & 1)==0) // only show even addresses with words
if (WORD_ALIGNED(m_address))
{
int valword = (((*value) << 8) | m_buffer_ram[(m_ram_page[bank]<<10) | ((m_address+1) & 0x03ff)])&0xffff;
logerror("%s: %04x[%02x] -> %04x\n", tag(), m_address & 0xffff, m_ram_page[bank], valword);
@ -246,7 +246,7 @@ READ8Z_MEMBER(myarc_hfdc_device::readz)
*value = m_dsrrom[(m_rom_page << 12) | (m_address & 0x0fff)];
if (TRACE_ROM)
{
if ((m_address & 1)==0) // only show even addresses with words
if (WORD_ALIGNED(m_address))
{
int valword = (((*value) << 8) | m_dsrrom[(m_rom_page << 12) | ((m_address + 1) & 0x0fff)])&0xffff;
logerror("%s: %04x[%02x] -> %04x\n", tag(), m_address & 0xffff, m_rom_page, valword);

6
src/devices/cpu/arm/arm.cpp
View File

@ -259,7 +259,7 @@ void arm_cpu_device::cpu_write32( int addr, UINT32 data )
{
/* Unaligned writes are treated as normal writes */
m_program->write_dword(addr&ADDRESS_MASK,data);
if (ARM_DEBUG_CORE && addr&3) logerror("%08x: Unaligned write %08x\n",R15,addr);
if (ARM_DEBUG_CORE && !DWORD_ALIGNED(addr)) logerror("%08x: Unaligned write %08x\n",R15,addr);
}
void arm_cpu_device::cpu_write8( int addr, UINT8 data )
@ -272,9 +272,9 @@ UINT32 arm_cpu_device::cpu_read32( int addr )
UINT32 result = m_program->read_dword(addr&ADDRESS_MASK);
/* Unaligned reads rotate the word, they never combine words */
if (addr&3)
if (!DWORD_ALIGNED(addr))
{
if (ARM_DEBUG_CORE && addr&1)
if (ARM_DEBUG_CORE && !WORD_ALIGNED(addr))
logerror("%08x: Unaligned byte read %08x\n",R15,addr);
if ((addr&3)==1)

8
src/devices/cpu/asap/asap.cpp
View File

@ -364,7 +364,7 @@ inline UINT8 asap_device::readbyte(offs_t address)
inline UINT16 asap_device::readword(offs_t address)
{
// aligned reads are easy
if (!(address & 1))
if (WORD_ALIGNED(address))
return m_program->read_word(address);
// misaligned reads are tricky
@ -379,7 +379,7 @@ inline UINT16 asap_device::readword(offs_t address)
inline UINT32 asap_device::readlong(offs_t address)
{
// aligned reads are easy
if (!(address & 3))
if (DWORD_ALIGNED(address))
return m_program->read_dword(address);
// misaligned reads are tricky
@ -405,7 +405,7 @@ inline void asap_device::writebyte(offs_t address, UINT8 data)
inline void asap_device::writeword(offs_t address, UINT16 data)
{
// aligned writes are easy
if (!(address & 1))
if (WORD_ALIGNED(address))
{
m_program->write_word(address, data);
return;
@ -429,7 +429,7 @@ inline void asap_device::writeword(offs_t address, UINT16 data)
inline void asap_device::writelong(offs_t address, UINT32 data)
{
// aligned writes are easy
if (!(address & 3))
if (DWORD_ALIGNED(address))
{
m_program->write_dword(address, data);
return;

12
src/devices/cpu/dsp32/dsp32.cpp
View File

@ -452,7 +452,8 @@ inline void dsp32c_device::WBYTE(offs_t addr, UINT8 data)
inline UINT16 dsp32c_device::RWORD(offs_t addr)
{
#if DETECT_MISALIGNED_MEMORY
if (addr & 1) fprintf(stderr, "Unaligned word read @ %06X, PC=%06X\n", addr, PC);
if (!WORD_ALIGNED(addr))
osd_printf_error("Unaligned word read @ %06X, PC=%06X\n", addr, PC);
#endif
return m_program->read_word(addr);
}
@ -460,7 +461,8 @@ inline UINT16 dsp32c_device::RWORD(offs_t addr)
inline UINT32 dsp32c_device::RLONG(offs_t addr)
{
#if DETECT_MISALIGNED_MEMORY
if (addr & 3) fprintf(stderr, "Unaligned long read @ %06X, PC=%06X\n", addr, PC);
if (!DWORD_ALIGNED(addr))
osd_printf_error("Unaligned long read @ %06X, PC=%06X\n", addr, PC);
#endif
return m_program->read_dword(addr);
}
@ -468,7 +470,8 @@ inline UINT32 dsp32c_device::RLONG(offs_t addr)
inline void dsp32c_device::WWORD(offs_t addr, UINT16 data)
{
#if DETECT_MISALIGNED_MEMORY
if (addr & 1) fprintf(stderr, "Unaligned word write @ %06X, PC=%06X\n", addr, PC);
if (!WORD_ALIGNED(addr))
osd_printf_error("Unaligned word write @ %06X, PC=%06X\n", addr, PC);
#endif
m_program->write_word(addr, data);
}
@ -476,7 +479,8 @@ inline void dsp32c_device::WWORD(offs_t addr, UINT16 data)
inline void dsp32c_device::WLONG(offs_t addr, UINT32 data)
{
#if DETECT_MISALIGNED_MEMORY
if (addr & 3) fprintf(stderr, "Unaligned long write @ %06X, PC=%06X\n", addr, PC);
if (!DWORD_ALIGNED(addr))
osd_printf_error("Unaligned long write @ %06X, PC=%06X\n", addr, PC);
#endif
m_program->write_dword(addr, data);
}

4
src/devices/cpu/hd61700/hd61700.cpp
View File

@ -2654,7 +2654,7 @@ void hd61700_cpu_device::execute_run()
}
//if is in the internal ROM align the pc
if ((m_fetch_addr&1) && m_pc < INT_ROM)
if (!WORD_ALIGNED(m_fetch_addr) && m_pc < INT_ROM)
set_pc((m_fetch_addr+1)>>1);
m_icount -= 3;
@ -2871,7 +2871,7 @@ inline void hd61700_cpu_device::check_optional_jr(UINT8 arg)
{
if (arg & 0x80)
{
if (m_pc < INT_ROM && !(m_fetch_addr&1)) read_op();
if (m_pc < INT_ROM && WORD_ALIGNED(m_fetch_addr)) read_op();
UINT8 arg1 = read_op();

20
src/devices/cpu/i386/i386priv.h
View File

@ -557,7 +557,7 @@ UINT16 i386_device::FETCH16()
UINT16 value;
UINT32 address = m_pc, error;
if( address & 0x1 ) { /* Unaligned read */
if( !WORD_ALIGNED(address) ) { /* Unaligned read */
value = (FETCH() << 0);
value |= (FETCH() << 8);
} else {
@ -575,7 +575,7 @@ UINT32 i386_device::FETCH32()
UINT32 value;
UINT32 address = m_pc, error;
if( m_pc & 0x3 ) { /* Unaligned read */
if( !DWORD_ALIGNED(m_pc) ) { /* Unaligned read */
value = (FETCH() << 0);
value |= (FETCH() << 8);
value |= (FETCH() << 16);
@ -607,7 +607,7 @@ UINT16 i386_device::READ16(UINT32 ea)
UINT16 value;
UINT32 address = ea, error;
if( ea & 0x1 ) { /* Unaligned read */
if( !WORD_ALIGNED(ea) ) { /* Unaligned read */
value = (READ8( address+0 ) << 0);
value |= (READ8( address+1 ) << 8);
} else {
@ -624,7 +624,7 @@ UINT32 i386_device::READ32(UINT32 ea)
UINT32 value;
UINT32 address = ea, error;
if( ea & 0x3 ) { /* Unaligned read */
if( !DWORD_ALIGNED(ea) ) { /* Unaligned read */
value = (READ8( address+0 ) << 0);
value |= (READ8( address+1 ) << 8);
value |= (READ8( address+2 ) << 16),
@ -644,7 +644,7 @@ UINT64 i386_device::READ64(UINT32 ea)
UINT64 value;
UINT32 address = ea, error;
if( ea & 0x7 ) { /* Unaligned read */
if( !QWORD_ALIGNED(ea) ) { /* Unaligned read */
value = (((UINT64) READ8( address+0 )) << 0);
value |= (((UINT64) READ8( address+1 )) << 8);
value |= (((UINT64) READ8( address+2 )) << 16);
@ -678,7 +678,7 @@ UINT16 i386_device::READ16PL0(UINT32 ea)
UINT16 value;
UINT32 address = ea, error;
if( ea & 0x1 ) { /* Unaligned read */
if( !WORD_ALIGNED(ea) ) { /* Unaligned read */
value = (READ8PL0( address+0 ) << 0);
value |= (READ8PL0( address+1 ) << 8);
} else {
@ -696,7 +696,7 @@ UINT32 i386_device::READ32PL0(UINT32 ea)
UINT32 value;
UINT32 address = ea, error;
if( ea & 0x3 ) { /* Unaligned read */
if( !DWORD_ALIGNED(ea) ) { /* Unaligned read */
value = (READ8PL0( address+0 ) << 0);
value |= (READ8PL0( address+1 ) << 8);
value |= (READ8PL0( address+2 ) << 16);
@ -732,7 +732,7 @@ void i386_device::WRITE16(UINT32 ea, UINT16 value)
{
UINT32 address = ea, error;
if( ea & 0x1 ) { /* Unaligned write */
if( !WORD_ALIGNED(ea) ) { /* Unaligned write */
WRITE8( address+0, value & 0xff );
WRITE8( address+1, (value >> 8) & 0xff );
} else {
@ -747,7 +747,7 @@ void i386_device::WRITE32(UINT32 ea, UINT32 value)
{
UINT32 address = ea, error;
if( ea & 0x3 ) { /* Unaligned write */
if( !DWORD_ALIGNED(ea) ) { /* Unaligned write */
WRITE8( address+0, value & 0xff );
WRITE8( address+1, (value >> 8) & 0xff );
WRITE8( address+2, (value >> 16) & 0xff );
@ -765,7 +765,7 @@ void i386_device::WRITE64(UINT32 ea, UINT64 value)
{
UINT32 address = ea, error;
if( ea & 0x7 ) { /* Unaligned write */
if( !QWORD_ALIGNED(ea) ) { /* Unaligned write */
WRITE8( address+0, value & 0xff );
WRITE8( address+1, (value >> 8) & 0xff );
WRITE8( address+2, (value >> 16) & 0xff );

4
src/devices/cpu/i8089/i8089.cpp
View File

@ -289,7 +289,7 @@ UINT16 i8089_device::read_word(bool space, offs_t address)
UINT16 data;
address_space *aspace = (space ? m_io : m_mem);
if (sysbus_width() && !(address & 1))
if (sysbus_width() && WORD_ALIGNED(address))
{
data = aspace->read_word(address);
}
@ -311,7 +311,7 @@ void i8089_device::write_word(bool space, offs_t address, UINT16 data)
{
address_space *aspace = (space ? m_io : m_mem);
if (sysbus_width() && !(address & 1))
if (sysbus_width() && WORD_ALIGNED(address))
{
aspace->write_word(address, data);
}

8
src/devices/cpu/i960/i960.cpp
View File

@ -26,7 +26,7 @@ i960_cpu_device::i960_cpu_device(const machine_config &mconfig, const char *tag,
UINT32 i960_cpu_device::i960_read_dword_unaligned(UINT32 address)
{
if (address & 3)
if (!DWORD_ALIGNED(address))
return m_program->read_byte(address) | m_program->read_byte(address+1)<<8 | m_program->read_byte(address+2)<<16 | m_program->read_byte(address+3)<<24;
else
return m_program->read_dword(address);
@ -34,7 +34,7 @@ UINT32 i960_cpu_device::i960_read_dword_unaligned(UINT32 address)
UINT16 i960_cpu_device::i960_read_word_unaligned(UINT32 address)
{
if (address & 1)
if (!WORD_ALIGNED(address))
return m_program->read_byte(address) | m_program->read_byte(address+1)<<8;
else
return m_program->read_word(address);
@ -42,7 +42,7 @@ UINT16 i960_cpu_device::i960_read_word_unaligned(UINT32 address)
void i960_cpu_device::i960_write_dword_unaligned(UINT32 address, UINT32 data)
{
if (address & 3)
if (!DWORD_ALIGNED(address))
{
m_program->write_byte(address, data & 0xff);
m_program->write_byte(address+1, (data>>8)&0xff);
@ -57,7 +57,7 @@ void i960_cpu_device::i960_write_dword_unaligned(UINT32 address, UINT32 data)
void i960_cpu_device::i960_write_word_unaligned(UINT32 address, UINT16 data)
{
if (address & 1)
if (!WORD_ALIGNED(address))
{
m_program->write_byte(address, data & 0xff);
m_program->write_byte(address+1, (data>>8)&0xff);

8
src/devices/cpu/m37710/m37710il.h
View File

@ -42,7 +42,7 @@ inline UINT32 m37710_cpu_device::m37710i_read_16_normal(UINT32 address)
inline UINT32 m37710_cpu_device::m37710i_read_16_immediate(UINT32 address)
{
if (address & 1)
if (!WORD_ALIGNED(address))
return m37710_read_8_immediate(address) | (m37710_read_8_immediate(address+1)<<8);
else
return m37710_read_16_immediate(address);
@ -65,7 +65,7 @@ inline void m37710_cpu_device::m37710i_write_16_direct(UINT32 address, UINT32 va
inline UINT32 m37710_cpu_device::m37710i_read_24_normal(UINT32 address)
{
if (address & 1)
if (!WORD_ALIGNED(address))
return m37710_read_8(address) | (m37710_read_16(address+1)<<8);
else
return m37710_read_16(address) | (m37710_read_8(address+2)<<16);
@ -73,7 +73,7 @@ inline UINT32 m37710_cpu_device::m37710i_read_24_normal(UINT32 address)
inline UINT32 m37710_cpu_device::m37710i_read_24_immediate(UINT32 address)
{
if (address & 1)
if (!WORD_ALIGNED(address))
return m37710_read_8_immediate(address) | (m37710_read_16_immediate(address+1)<<8);
else
return m37710_read_16_immediate(address) | (m37710_read_8_immediate(address+2)<<16);
@ -81,7 +81,7 @@ inline UINT32 m37710_cpu_device::m37710i_read_24_immediate(UINT32 address)
inline UINT32 m37710_cpu_device::m37710i_read_24_direct(UINT32 address)
{
if (address & 1)
if (!WORD_ALIGNED(address))
return m37710_read_8(address) | (m37710_read_16(address+1)<<8);
else
return m37710_read_16(address) | (m37710_read_8(address+2)<<16);

36
src/devices/cpu/m68000/m68kcpu.cpp
View File

@ -1383,7 +1383,7 @@ UINT16 m68000_base_device::readword_d32_mmu(offs_t address)
UINT32 address0 = pmmu_translate_addr(this, address);
if (mmu_tmp_buserror_occurred) {
return ~0;
} else if (!(address & 1)) {
} else if (WORD_ALIGNED(address)) {
return m_space->read_word(address0);
} else {
UINT32 address1 = pmmu_translate_addr(this, address + 1);
@ -1396,7 +1396,7 @@ UINT16 m68000_base_device::readword_d32_mmu(offs_t address)
}
}
if (!(address & 1))
if (WORD_ALIGNED(address))
return m_space->read_word(address);
result = m_space->read_byte(address) << 8;
return result | m_space->read_byte(address + 1);
@ -1410,7 +1410,7 @@ void m68000_base_device::writeword_d32_mmu(offs_t address, UINT16 data)
UINT32 address0 = pmmu_translate_addr(this, address);
if (mmu_tmp_buserror_occurred) {
return;
} else if (!(address & 1)) {
} else if (WORD_ALIGNED(address)) {
m_space->write_word(address0, data);
return;
} else {
@ -1425,7 +1425,7 @@ void m68000_base_device::writeword_d32_mmu(offs_t address, UINT16 data)
}
}
if (!(address & 1))
if (WORD_ALIGNED(address))
{
m_space->write_word(address, data);
return;
@ -1447,13 +1447,13 @@ UINT32 m68000_base_device::readlong_d32_mmu(offs_t address)
} else if ((address +3) & 0xfc) {
// not at page boundary; use default code
address = address0;
} else if (!(address & 3)) { // 0
} else if (DWORD_ALIGNED(address)) { // 0
return m_space->read_dword(address0);
} else {
UINT32 address2 = pmmu_translate_addr(this, address+2);
if (mmu_tmp_buserror_occurred) {
return ~0;
} else if (!(address & 1)) { // 2
} else if (WORD_ALIGNED(address)) { // 2
result = m_space->read_word(address0) << 16;
return result | m_space->read_word(address2);
} else {
@ -1470,9 +1470,9 @@ UINT32 m68000_base_device::readlong_d32_mmu(offs_t address)
}
}
if (!(address & 3))
if (DWORD_ALIGNED(address))
return m_space->read_dword(address);
else if (!(address & 1))
else if (WORD_ALIGNED(address))
{
result = m_space->read_word(address) << 16;
return result | m_space->read_word(address + 2);
@ -1493,14 +1493,14 @@ void m68000_base_device::writelong_d32_mmu(offs_t address, UINT32 data)
} else if ((address +3) & 0xfc) {
// not at page boundary; use default code
address = address0;
} else if (!(address & 3)) { // 0
} else if (DWORD_ALIGNED(address)) { // 0
m_space->write_dword(address0, data);
return;
} else {
UINT32 address2 = pmmu_translate_addr(this, address+2);
if (mmu_tmp_buserror_occurred) {
return;
} else if (!(address & 1)) { // 2
} else if (WORD_ALIGNED(address)) { // 2
m_space->write_word(address0, data >> 16);
m_space->write_word(address2, data);
return;
@ -1519,12 +1519,12 @@ void m68000_base_device::writelong_d32_mmu(offs_t address, UINT32 data)
}
}
if (!(address & 3))
if (DWORD_ALIGNED(address))
{
m_space->write_dword(address, data);
return;
}
else if (!(address & 1))
else if (WORD_ALIGNED(address))
{
m_space->write_word(address, data >> 16);
m_space->write_word(address + 2, data);
@ -1594,7 +1594,7 @@ UINT16 m68000_base_device::readword_d32_hmmu(offs_t address)
address = hmmu_translate_addr(this, address);
}
if (!(address & 1))
if (WORD_ALIGNED(address))
return m_space->read_word(address);
result = m_space->read_byte(address) << 8;
return result | m_space->read_byte(address + 1);
@ -1608,7 +1608,7 @@ void m68000_base_device::writeword_d32_hmmu(offs_t address, UINT16 data)
address = hmmu_translate_addr(this, address);
}
if (!(address & 1))
if (WORD_ALIGNED(address))
{
m_space->write_word(address, data);
return;
@ -1627,9 +1627,9 @@ UINT32 m68000_base_device::readlong_d32_hmmu(offs_t address)
address = hmmu_translate_addr(this, address);
}
if (!(address & 3))
if (DWORD_ALIGNED(address))
return m_space->read_dword(address);
else if (!(address & 1))
else if (WORD_ALIGNED(address))
{
result = m_space->read_word(address) << 16;
return result | m_space->read_word(address + 2);
@ -1647,12 +1647,12 @@ void m68000_base_device::writelong_d32_hmmu(offs_t address, UINT32 data)
address = hmmu_translate_addr(this, address);
}
if (!(address & 3))
if (DWORD_ALIGNED(address))
{
m_space->write_dword(address, data);
return;
}
else if (!(address & 1))
else if (WORD_ALIGNED(address))
{
m_space->write_word(address, data >> 16);
m_space->write_word(address + 2, data);

4
src/devices/cpu/m68000/m68kcpu.h
View File

@ -626,7 +626,7 @@ static inline unsigned int m68k_read_pcrelative_8(m68000_base_device *m68k, unsi
static inline unsigned int m68k_read_pcrelative_16(m68000_base_device *m68k, unsigned int address)
{
if(address & 1)
if (!WORD_ALIGNED(address))
return
(m68k->readimm16(address-1) << 8) |
(m68k->readimm16(address+1) >> 8);
@ -638,7 +638,7 @@ static inline unsigned int m68k_read_pcrelative_16(m68000_base_device *m68k, uns
static inline unsigned int m68k_read_pcrelative_32(m68000_base_device *m68k, unsigned int address)
{
if(address & 1)
if (!WORD_ALIGNED(address))
return
(m68k->readimm16(address-1) << 24) |
(m68k->readimm16(address+1) << 8) |

32
src/devices/cpu/se3208/se3208.cpp
View File

@ -54,27 +54,22 @@ se3208_device::se3208_device(const machine_config &mconfig, const char *tag, dev
UINT32 se3208_device::read_dword_unaligned(address_space &space, UINT32 address)
{
switch (address & 3)
{
case 0:
if (DWORD_ALIGNED(address))
return space.read_dword(address);
case 1:
case 2:
case 3:
printf("%08x: dword READ unaligned %08x\n", m_PC, address);
else
{
osd_printf_debug("%08x: dword READ unaligned %08x\n", m_PC, address);
#if ALLOW_UNALIGNED_DWORD_ACCESS
return space.read_byte(address) | space.read_byte(address + 1) << 8 | space.read_byte(address + 2) << 16 | space.read_byte(address + 3) << 24;
#else
return 0;
#endif
}
return 0;
}
UINT16 se3208_device::read_word_unaligned(address_space &space, UINT32 address)
{
if (address & 1)
if (!WORD_ALIGNED(address))
return space.read_byte(address) | space.read_byte(address+1)<<8;
else
return space.read_word(address);
@ -82,31 +77,24 @@ UINT16 se3208_device::read_word_unaligned(address_space &space, UINT32 address)
void se3208_device::write_dword_unaligned(address_space &space, UINT32 address, UINT32 data)
{
switch (address & 3)
{
case 0:
if (DWORD_ALIGNED(address))
space.write_dword(address, data);
break;
case 1:
case 2:
case 3:
else
{
#if ALLOW_UNALIGNED_DWORD_ACCESS
space.write_byte(address, data & 0xff);
space.write_byte(address + 1, (data >> 8) & 0xff);
space.write_byte(address + 2, (data >> 16) & 0xff);
space.write_byte(address + 3, (data >> 24) & 0xff);
#endif
printf("%08x: dword WRITE unaligned %08x\n", m_PC, address);
break;
osd_printf_debug("%08x: dword WRITE unaligned %08x\n", m_PC, address);
}
}
void se3208_device::write_word_unaligned(address_space &space, UINT32 address, UINT16 data)
{
if (address & 1)
if (!WORD_ALIGNED(address))
{
space.write_byte(address, data & 0xff);
space.write_byte(address+1, (data>>8)&0xff);

4
src/devices/video/i82730.cpp
View File

@ -128,7 +128,7 @@ UINT16 i82730_device::read_word(offs_t address)
{
UINT16 data;
if (sysbus_16bit() && !(address & 1))
if (sysbus_16bit() && WORD_ALIGNED(address))
{
data = m_program->read_word(address);
}
@ -148,7 +148,7 @@ void i82730_device::write_byte(offs_t address, UINT8 data)
void i82730_device::write_word(offs_t address, UINT16 data)
{
if (sysbus_16bit() && !(address & 1))
if (sysbus_16bit() && WORD_ALIGNED(address))
{
m_program->write_word(address, data);
}

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

@ -486,7 +486,7 @@ UINT16 debug_read_word(address_space &space, offs_t address, int apply_translati
address &= space.logbytemask();
/* if this is misaligned read, or if there are no word readers, just read two bytes */
if ((address & 1) != 0)
if (!WORD_ALIGNED(address))
{
UINT8 byte0 = debug_read_byte(space, address + 0, apply_translation);
UINT8 byte1 = debug_read_byte(space, address + 1, apply_translation);
@ -540,7 +540,7 @@ UINT32 debug_read_dword(address_space &space, offs_t address, int apply_translat
address &= space.logbytemask();
/* if this is misaligned read, or if there are no dword readers, just read two words */
if ((address & 3) != 0)
if (!DWORD_ALIGNED(address))
{
UINT16 word0 = debug_read_word(space, address + 0, apply_translation);
UINT16 word1 = debug_read_word(space, address + 2, apply_translation);
@ -594,7 +594,7 @@ UINT64 debug_read_qword(address_space &space, offs_t address, int apply_translat
address &= space.logbytemask();
/* if this is misaligned read, or if there are no qword readers, just read two dwords */
if ((address & 7) != 0)
if (!QWORD_ALIGNED(address))
{
UINT32 dword0 = debug_read_dword(space, address + 0, apply_translation);
UINT32 dword1 = debug_read_dword(space, address + 4, apply_translation);
@ -699,7 +699,7 @@ void debug_write_word(address_space &space, offs_t address, UINT16 data, int app
address &= space.logbytemask();
/* if this is a misaligned write, or if there are no word writers, just read two bytes */
if ((address & 1) != 0)
if (!WORD_ALIGNED(address))
{
if (space.endianness() == ENDIANNESS_LITTLE)
{
@ -751,7 +751,7 @@ void debug_write_dword(address_space &space, offs_t address, UINT32 data, int ap
address &= space.logbytemask();
/* if this is a misaligned write, or if there are no dword writers, just read two words */
if ((address & 3) != 0)
if (!DWORD_ALIGNED(address))
{
if (space.endianness() == ENDIANNESS_LITTLE)
{
@ -803,7 +803,7 @@ void debug_write_qword(address_space &space, offs_t address, UINT64 data, int ap
address &= space.logbytemask();
/* if this is a misaligned write, or if there are no qword writers, just read two dwords */
if ((address & 7) != 0)
if (!QWORD_ALIGNED(address))
{
if (space.endianness() == ENDIANNESS_LITTLE)
{
@ -966,7 +966,7 @@ UINT64 debug_read_opcode(address_space &space, offs_t address, int size)
case 2:
result = space.direct().read_word(address & ~1, addrxor);
if ((address & 1) != 0)
if (!WORD_ALIGNED(address))
{
result2 = space.direct().read_word((address & ~1) + 2, addrxor);
if (space.endianness() == ENDIANNESS_LITTLE)
@ -979,7 +979,7 @@ UINT64 debug_read_opcode(address_space &space, offs_t address, int size)
case 4:
result = space.direct().read_dword(address & ~3, addrxor);
if ((address & 3) != 0)
if (!DWORD_ALIGNED(address))
{
result2 = space.direct().read_dword((address & ~3) + 4, addrxor);
if (space.endianness() == ENDIANNESS_LITTLE)
@ -992,7 +992,7 @@ UINT64 debug_read_opcode(address_space &space, offs_t address, int size)
case 8:
result = space.direct().read_qword(address & ~7, addrxor);
if ((address & 7) != 0)
if (!QWORD_ALIGNED(address))
{
result2 = space.direct().read_qword((address & ~7) + 8, addrxor);
if (space.endianness() == ENDIANNESS_LITTLE)

12
src/emu/luaengine.cpp
View File

@ -505,21 +505,21 @@ int lua_engine::lua_addr_space::l_mem_read(lua_State *L)
mem_content = sp.read_byte(address);
break;
case 16:
if ((address & 1) == 0) {
if (WORD_ALIGNED(address)) {
mem_content = sp.read_word(address);
} else {
mem_content = sp.read_word_unaligned(address);
}
break;
case 32:
if ((address & 3) == 0) {
if (DWORD_ALIGNED(address)) {
mem_content = sp.read_dword(address);
} else {
mem_content = sp.read_dword_unaligned(address);
}
break;
case 64:
if ((address & 7) == 0) {
if (QWORD_ALIGNED(address)) {
mem_content = sp.read_qword(address);
} else {
mem_content = sp.read_qword_unaligned(address);
@ -558,21 +558,21 @@ int lua_engine::lua_addr_space::l_mem_write(lua_State *L)
sp.write_byte(address, val);
break;
case 16:
if ((address & 1) == 0) {
if (WORD_ALIGNED(address)) {
sp.write_word(address, val);
} else {
sp.read_word_unaligned(address, val);
}
break;
case 32:
if ((address & 3) == 0) {
if (DWORD_ALIGNED(address)) {
sp.write_dword(address, val);
} else {
sp.write_dword_unaligned(address, val);
}
break;
case 64:
if ((address & 7) == 0) {
if (QWORD_ALIGNED(address)) {
sp.write_qword(address, val);
} else {
sp.write_qword_unaligned(address, val);

86
src/emu/memory.cpp
View File

@ -896,9 +896,9 @@ public:
printf(" read_byte = "); printf("%02X\n", result8 = read_byte(address)); assert(result8 == expected8);
// validate word accesses (if aligned)
if (address % 2 == 0) { printf(" read_word = "); printf("%04X\n", result16 = read_word(address)); assert(result16 == expected16); }
if (address % 2 == 0) { printf(" read_word (0xff00) = "); printf("%04X\n", result16 = read_word(address, 0xff00)); assert((result16 & 0xff00) == (expected16 & 0xff00)); }
if (address % 2 == 0) { printf(" (0x00ff) = "); printf("%04X\n", result16 = read_word(address, 0x00ff)); assert((result16 & 0x00ff) == (expected16 & 0x00ff)); }
if (WORD_ALIGNED(address)) { printf(" read_word = "); printf("%04X\n", result16 = read_word(address)); assert(result16 == expected16); }
if (WORD_ALIGNED(address)) { printf(" read_word (0xff00) = "); printf("%04X\n", result16 = read_word(address, 0xff00)); assert((result16 & 0xff00) == (expected16 & 0xff00)); }
if (WORD_ALIGNED(address)) { printf(" (0x00ff) = "); printf("%04X\n", result16 = read_word(address, 0x00ff)); assert((result16 & 0x00ff) == (expected16 & 0x00ff)); }
// validate unaligned word accesses
printf(" read_word_unaligned = "); printf("%04X\n", result16 = read_word_unaligned(address)); assert(result16 == expected16);
@ -906,15 +906,15 @@ public:
printf(" (0x00ff) = "); printf("%04X\n", result16 = read_word_unaligned(address, 0x00ff)); assert((result16 & 0x00ff) == (expected16 & 0x00ff));
// validate dword acceses (if aligned)
if (address % 4 == 0) { printf(" read_dword = "); printf("%08X\n", result32 = read_dword(address)); assert(result32 == expected32); }
if (address % 4 == 0) { printf(" read_dword (0xff000000) = "); printf("%08X\n", result32 = read_dword(address, 0xff000000)); assert((result32 & 0xff000000) == (expected32 & 0xff000000)); }
if (address % 4 == 0) { printf(" (0x00ff0000) = "); printf("%08X\n", result32 = read_dword(address, 0x00ff0000)); assert((result32 & 0x00ff0000) == (expected32 & 0x00ff0000)); }
if (address % 4 == 0) { printf(" (0x0000ff00) = "); printf("%08X\n", result32 = read_dword(address, 0x0000ff00)); assert((result32 & 0x0000ff00) == (expected32 & 0x0000ff00)); }
if (address % 4 == 0) { printf(" (0x000000ff) = "); printf("%08X\n", result32 = read_dword(address, 0x000000ff)); assert((result32 & 0x000000ff) == (expected32 & 0x000000ff)); }
if (address % 4 == 0) { printf(" (0xffff0000) = "); printf("%08X\n", result32 = read_dword(address, 0xffff0000)); assert((result32 & 0xffff0000) == (expected32 & 0xffff0000)); }
if (address % 4 == 0) { printf(" (0x0000ffff) = "); printf("%08X\n", result32 = read_dword(address, 0x0000ffff)); assert((result32 & 0x0000ffff) == (expected32 & 0x0000ffff)); }
if (address % 4 == 0) { printf(" (0xffffff00) = "); printf("%08X\n", result32 = read_dword(address, 0xffffff00)); assert((result32 & 0xffffff00) == (expected32 & 0xffffff00)); }
if (address % 4 == 0) { printf(" (0x00ffffff) = "); printf("%08X\n", result32 = read_dword(address, 0x00ffffff)); assert((result32 & 0x00ffffff) == (expected32 & 0x00ffffff)); }
if (DWORD_ALIGNED(address)) { printf(" read_dword = "); printf("%08X\n", result32 = read_dword(address)); assert(result32 == expected32); }
if (DWORD_ALIGNED(address)) { printf(" read_dword (0xff000000) = "); printf("%08X\n", result32 = read_dword(address, 0xff000000)); assert((result32 & 0xff000000) == (expected32 & 0xff000000)); }
if (DWORD_ALIGNED(address)) { printf(" (0x00ff0000) = "); printf("%08X\n", result32 = read_dword(address, 0x00ff0000)); assert((result32 & 0x00ff0000) == (expected32 & 0x00ff0000)); }
if (DWORD_ALIGNED(address)) { printf(" (0x0000ff00) = "); printf("%08X\n", result32 = read_dword(address, 0x0000ff00)); assert((result32 & 0x0000ff00) == (expected32 & 0x0000ff00)); }
if (DWORD_ALIGNED(address)) { printf(" (0x000000ff) = "); printf("%08X\n", result32 = read_dword(address, 0x000000ff)); assert((result32 & 0x000000ff) == (expected32 & 0x000000ff)); }
if (DWORD_ALIGNED(address)) { printf(" (0xffff0000) = "); printf("%08X\n", result32 = read_dword(address, 0xffff0000)); assert((result32 & 0xffff0000) == (expected32 & 0xffff0000)); }
if (DWORD_ALIGNED(address)) { printf(" (0x0000ffff) = "); printf("%08X\n", result32 = read_dword(address, 0x0000ffff)); assert((result32 & 0x0000ffff) == (expected32 & 0x0000ffff)); }
if (DWORD_ALIGNED(address)) { printf(" (0xffffff00) = "); printf("%08X\n", result32 = read_dword(address, 0xffffff00)); assert((result32 & 0xffffff00) == (expected32 & 0xffffff00)); }
if (DWORD_ALIGNED(address)) { printf(" (0x00ffffff) = "); printf("%08X\n", result32 = read_dword(address, 0x00ffffff)); assert((result32 & 0x00ffffff) == (expected32 & 0x00ffffff)); }
// validate unaligned dword accesses
printf(" read_dword_unaligned = "); printf("%08X\n", result32 = read_dword_unaligned(address)); assert(result32 == expected32);
@ -928,37 +928,37 @@ public:
printf(" (0x00ffffff) = "); printf("%08X\n", result32 = read_dword_unaligned(address, 0x00ffffff)); assert((result32 & 0x00ffffff) == (expected32 & 0x00ffffff));
// validate qword acceses (if aligned)
if (address % 8 == 0) { printf(" read_qword = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address), 16)); assert(result64 == expected64); }
if (address % 8 == 0) { printf(" read_qword (0xff00000000000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0xff00000000000000)), 16)); assert((result64 & U64(0xff00000000000000)) == (expected64 & U64(0xff00000000000000))); }
if (address % 8 == 0) { printf(" (0x00ff000000000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00ff000000000000)), 16)); assert((result64 & U64(0x00ff000000000000)) == (expected64 & U64(0x00ff000000000000))); }
if (address % 8 == 0) { printf(" (0x0000ff0000000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x0000ff0000000000)), 16)); assert((result64 & U64(0x0000ff0000000000)) == (expected64 & U64(0x0000ff0000000000))); }
if (address % 8 == 0) { printf(" (0x000000ff00000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x000000ff00000000)), 16)); assert((result64 & U64(0x000000ff00000000)) == (expected64 & U64(0x000000ff00000000))); }
if (address % 8 == 0) { printf(" (0x00000000ff000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00000000ff000000)), 16)); assert((result64 & U64(0x00000000ff000000)) == (expected64 & U64(0x00000000ff000000))); }
if (address % 8 == 0) { printf(" (0x0000000000ff0000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x0000000000ff0000)), 16)); assert((result64 & U64(0x0000000000ff0000)) == (expected64 & U64(0x0000000000ff0000))); }
if (address % 8 == 0) { printf(" (0x000000000000ff00) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x000000000000ff00)), 16)); assert((result64 & U64(0x000000000000ff00)) == (expected64 & U64(0x000000000000ff00))); }
if (address % 8 == 0) { printf(" (0x00000000000000ff) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00000000000000ff)), 16)); assert((result64 & U64(0x00000000000000ff)) == (expected64 & U64(0x00000000000000ff))); }
if (address % 8 == 0) { printf(" (0xffff000000000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0xffff000000000000)), 16)); assert((result64 & U64(0xffff000000000000)) == (expected64 & U64(0xffff000000000000))); }
if (address % 8 == 0) { printf(" (0x0000ffff00000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x0000ffff00000000)), 16)); assert((result64 & U64(0x0000ffff00000000)) == (expected64 & U64(0x0000ffff00000000))); }
if (address % 8 == 0) { printf(" (0x00000000ffff0000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00000000ffff0000)), 16)); assert((result64 & U64(0x00000000ffff0000)) == (expected64 & U64(0x00000000ffff0000))); }
if (address % 8 == 0) { printf(" (0x000000000000ffff) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x000000000000ffff)), 16)); assert((result64 & U64(0x000000000000ffff)) == (expected64 & U64(0x000000000000ffff))); }
if (address % 8 == 0) { printf(" (0xffffff0000000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0xffffff0000000000)), 16)); assert((result64 & U64(0xffffff0000000000)) == (expected64 & U64(0xffffff0000000000))); }
if (address % 8 == 0) { printf(" (0x0000ffffff000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x0000ffffff000000)), 16)); assert((result64 & U64(0x0000ffffff000000)) == (expected64 & U64(0x0000ffffff000000))); }
if (address % 8 == 0) { printf(" (0x000000ffffff0000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x000000ffffff0000)), 16)); assert((result64 & U64(0x000000ffffff0000)) == (expected64 & U64(0x000000ffffff0000))); }
if (address % 8 == 0) { printf(" (0x0000000000ffffff) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x0000000000ffffff)), 16)); assert((result64 & U64(0x0000000000ffffff)) == (expected64 & U64(0x0000000000ffffff))); }
if (address % 8 == 0) { printf(" (0xffffffff00000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0xffffffff00000000)), 16)); assert((result64 & U64(0xffffffff00000000)) == (expected64 & U64(0xffffffff00000000))); }
if (address % 8 == 0) { printf(" (0x00ffffffff000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00ffffffff000000)), 16)); assert((result64 & U64(0x00ffffffff000000)) == (expected64 & U64(0x00ffffffff000000))); }
if (address % 8 == 0) { printf(" (0x0000ffffffff0000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x0000ffffffff0000)), 16)); assert((result64 & U64(0x0000ffffffff0000)) == (expected64 & U64(0x0000ffffffff0000))); }
if (address % 8 == 0) { printf(" (0x000000ffffffff00) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x000000ffffffff00)), 16)); assert((result64 & U64(0x000000ffffffff00)) == (expected64 & U64(0x000000ffffffff00))); }
if (address % 8 == 0) { printf(" (0x00000000ffffffff) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00000000ffffffff)), 16)); assert((result64 & U64(0x00000000ffffffff)) == (expected64 & U64(0x00000000ffffffff))); }
if (address % 8 == 0) { printf(" (0xffffffffff000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0xffffffffff000000)), 16)); assert((result64 & U64(0xffffffffff000000)) == (expected64 & U64(0xffffffffff000000))); }
if (address % 8 == 0) { printf(" (0x00ffffffffff0000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00ffffffffff0000)), 16)); assert((result64 & U64(0x00ffffffffff0000)) == (expected64 & U64(0x00ffffffffff0000))); }
if (address % 8 == 0) { printf(" (0x0000ffffffffff00) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x0000ffffffffff00)), 16)); assert((result64 & U64(0x0000ffffffffff00)) == (expected64 & U64(0x0000ffffffffff00))); }
if (address % 8 == 0) { printf(" (0x000000ffffffffff) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x000000ffffffffff)), 16)); assert((result64 & U64(0x000000ffffffffff)) == (expected64 & U64(0x000000ffffffffff))); }
if (address % 8 == 0) { printf(" (0xffffffffffff0000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0xffffffffffff0000)), 16)); assert((result64 & U64(0xffffffffffff0000)) == (expected64 & U64(0xffffffffffff0000))); }
if (address % 8 == 0) { printf(" (0x00ffffffffffff00) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00ffffffffffff00)), 16)); assert((result64 & U64(0x00ffffffffffff00)) == (expected64 & U64(0x00ffffffffffff00))); }
if (address % 8 == 0) { printf(" (0x0000ffffffffffff) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x0000ffffffffffff)), 16)); assert((result64 & U64(0x0000ffffffffffff)) == (expected64 & U64(0x0000ffffffffffff))); }
if (address % 8 == 0) { printf(" (0xffffffffffffff00) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0xffffffffffffff00)), 16)); assert((result64 & U64(0xffffffffffffff00)) == (expected64 & U64(0xffffffffffffff00))); }
if (address % 8 == 0) { printf(" (0x00ffffffffffffff) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00ffffffffffffff)), 16)); assert((result64 & U64(0x00ffffffffffffff)) == (expected64 & U64(0x00ffffffffffffff))); }
if (QWORD_ALIGNED(address)) { printf(" read_qword = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address), 16)); assert(result64 == expected64); }
if (QWORD_ALIGNED(address)) { printf(" read_qword (0xff00000000000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0xff00000000000000)), 16)); assert((result64 & U64(0xff00000000000000)) == (expected64 & U64(0xff00000000000000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x00ff000000000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00ff000000000000)), 16)); assert((result64 & U64(0x00ff000000000000)) == (expected64 & U64(0x00ff000000000000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x0000ff0000000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x0000ff0000000000)), 16)); assert((result64 & U64(0x0000ff0000000000)) == (expected64 & U64(0x0000ff0000000000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x000000ff00000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x000000ff00000000)), 16)); assert((result64 & U64(0x000000ff00000000)) == (expected64 & U64(0x000000ff00000000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x00000000ff000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00000000ff000000)), 16)); assert((result64 & U64(0x00000000ff000000)) == (expected64 & U64(0x00000000ff000000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x0000000000ff0000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x0000000000ff0000)), 16)); assert((result64 & U64(0x0000000000ff0000)) == (expected64 & U64(0x0000000000ff0000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x000000000000ff00) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x000000000000ff00)), 16)); assert((result64 & U64(0x000000000000ff00)) == (expected64 & U64(0x000000000000ff00))); }
if (QWORD_ALIGNED(address)) { printf(" (0x00000000000000ff) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00000000000000ff)), 16)); assert((result64 & U64(0x00000000000000ff)) == (expected64 & U64(0x00000000000000ff))); }
if (QWORD_ALIGNED(address)) { printf(" (0xffff000000000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0xffff000000000000)), 16)); assert((result64 & U64(0xffff000000000000)) == (expected64 & U64(0xffff000000000000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x0000ffff00000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x0000ffff00000000)), 16)); assert((result64 & U64(0x0000ffff00000000)) == (expected64 & U64(0x0000ffff00000000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x00000000ffff0000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00000000ffff0000)), 16)); assert((result64 & U64(0x00000000ffff0000)) == (expected64 & U64(0x00000000ffff0000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x000000000000ffff) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x000000000000ffff)), 16)); assert((result64 & U64(0x000000000000ffff)) == (expected64 & U64(0x000000000000ffff))); }
if (QWORD_ALIGNED(address)) { printf(" (0xffffff0000000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0xffffff0000000000)), 16)); assert((result64 & U64(0xffffff0000000000)) == (expected64 & U64(0xffffff0000000000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x0000ffffff000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x0000ffffff000000)), 16)); assert((result64 & U64(0x0000ffffff000000)) == (expected64 & U64(0x0000ffffff000000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x000000ffffff0000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x000000ffffff0000)), 16)); assert((result64 & U64(0x000000ffffff0000)) == (expected64 & U64(0x000000ffffff0000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x0000000000ffffff) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x0000000000ffffff)), 16)); assert((result64 & U64(0x0000000000ffffff)) == (expected64 & U64(0x0000000000ffffff))); }
if (QWORD_ALIGNED(address)) { printf(" (0xffffffff00000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0xffffffff00000000)), 16)); assert((result64 & U64(0xffffffff00000000)) == (expected64 & U64(0xffffffff00000000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x00ffffffff000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00ffffffff000000)), 16)); assert((result64 & U64(0x00ffffffff000000)) == (expected64 & U64(0x00ffffffff000000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x0000ffffffff0000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x0000ffffffff0000)), 16)); assert((result64 & U64(0x0000ffffffff0000)) == (expected64 & U64(0x0000ffffffff0000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x000000ffffffff00) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x000000ffffffff00)), 16)); assert((result64 & U64(0x000000ffffffff00)) == (expected64 & U64(0x000000ffffffff00))); }
if (QWORD_ALIGNED(address)) { printf(" (0x00000000ffffffff) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00000000ffffffff)), 16)); assert((result64 & U64(0x00000000ffffffff)) == (expected64 & U64(0x00000000ffffffff))); }
if (QWORD_ALIGNED(address)) { printf(" (0xffffffffff000000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0xffffffffff000000)), 16)); assert((result64 & U64(0xffffffffff000000)) == (expected64 & U64(0xffffffffff000000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x00ffffffffff0000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00ffffffffff0000)), 16)); assert((result64 & U64(0x00ffffffffff0000)) == (expected64 & U64(0x00ffffffffff0000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x0000ffffffffff00) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x0000ffffffffff00)), 16)); assert((result64 & U64(0x0000ffffffffff00)) == (expected64 & U64(0x0000ffffffffff00))); }
if (QWORD_ALIGNED(address)) { printf(" (0x000000ffffffffff) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x000000ffffffffff)), 16)); assert((result64 & U64(0x000000ffffffffff)) == (expected64 & U64(0x000000ffffffffff))); }
if (QWORD_ALIGNED(address)) { printf(" (0xffffffffffff0000) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0xffffffffffff0000)), 16)); assert((result64 & U64(0xffffffffffff0000)) == (expected64 & U64(0xffffffffffff0000))); }
if (QWORD_ALIGNED(address)) { printf(" (0x00ffffffffffff00) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00ffffffffffff00)), 16)); assert((result64 & U64(0x00ffffffffffff00)) == (expected64 & U64(0x00ffffffffffff00))); }
if (QWORD_ALIGNED(address)) { printf(" (0x0000ffffffffffff) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x0000ffffffffffff)), 16)); assert((result64 & U64(0x0000ffffffffffff)) == (expected64 & U64(0x0000ffffffffffff))); }
if (QWORD_ALIGNED(address)) { printf(" (0xffffffffffffff00) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0xffffffffffffff00)), 16)); assert((result64 & U64(0xffffffffffffff00)) == (expected64 & U64(0xffffffffffffff00))); }
if (QWORD_ALIGNED(address)) { printf(" (0x00ffffffffffffff) = "); printf("%s\n", core_i64_hex_format(result64 = read_qword(address, U64(0x00ffffffffffffff)), 16)); assert((result64 & U64(0x00ffffffffffffff)) == (expected64 & U64(0x00ffffffffffffff))); }
// validate unaligned qword accesses
printf(" read_qword_unaligned = "); printf("%s\n", core_i64_hex_format(result64 = read_qword_unaligned(address), 16)); assert(result64 == expected64);

6
src/emu/memory.h
View File

@ -866,6 +866,12 @@ private:
#define DWORD_XOR_LE(a) ((a) ^ NATIVE_ENDIAN_VALUE_LE_BE(0,4))
// helpers for checking address alignment
#define WORD_ALIGNED(a) (((a) & 1) == 0)
#define DWORD_ALIGNED(a) (((a) & 3) == 0)
#define QWORD_ALIGNED(a) (((a) & 7) == 0)
//**************************************************************************
// INLINE FUNCTIONS

4
src/mame/drivers/cobra.cpp
View File

@ -2128,7 +2128,7 @@ void cobra_renderer::gfx_reset()
UINT32 cobra_renderer::gfx_read_gram(UINT32 address)
{
if (address & 3)
if (!DWORD_ALIGNED(address))
{
printf("gfx_read_gram: %08X, not dword aligned!\n", address);
return 0;
@ -2186,7 +2186,7 @@ void cobra_renderer::gfx_write_gram(UINT32 address, UINT32 mask, UINT32 data)
}
}
if (address & 3)
if (!DWORD_ALIGNED(address))
{
printf("gfx_write_gram: %08X, %08X, not dword aligned!\n", address, data);
return;

4
src/mame/drivers/magictg.cpp
View File

@ -601,8 +601,8 @@ WRITE32_MEMBER( magictg_state::f0_w )
UINT32 dst_addr = m_dma_ch[ch].dst_addr;
//device_t *voodoo = dst_addr > 0xa000000 voodoo0 : voodoo1;
assert((src_addr & 3) == 0);
assert((dst_addr & 3) == 0);
assert(DWORD_ALIGNED(src_addr));
assert(DWORD_ALIGNED(dst_addr));
while (m_dma_ch[ch].count > 3)
{

2
src/mame/machine/n64.cpp
View File

@ -2089,7 +2089,7 @@ void n64_periphs::si_dma_tick()
void n64_periphs::pif_dma(int direction)
{
if (si_dram_addr & 0x3)
if (!DWORD_ALIGNED(si_dram_addr))
{
fatalerror("pif_dma: si_dram_addr unaligned: %08X\n", si_dram_addr);
}

6
src/mame/video/seibuspi.cpp
View File

@ -111,7 +111,7 @@ WRITE32_MEMBER(seibuspi_state::tilemap_dma_start_w)
int dma_length_real = (m_video_dma_length + 1) * 2; // ideally we should be using this, let's check if we have to:
if (m_video_dma_length != 0 && dma_length_user != dma_length_real)
popmessage("Tile LEN %X %X, contact MAMEdev", dma_length_user, dma_length_real); // shouldn't happen
else if ((m_video_dma_address & 3) != 0 || (m_video_dma_length & 3) != 3 || (m_video_dma_address + dma_length_user) > 0x40000)
else if (!DWORD_ALIGNED(m_video_dma_address) || (m_video_dma_length & 3) != 3 || (m_video_dma_address + dma_length_user) > 0x40000)
popmessage("Tile DMA %X %X, contact MAMEdev", m_video_dma_address, m_video_dma_length); // shouldn't happen
if (m_video_dma_address < 0x800)
logerror("tilemap_dma_start_w in I/O area: %X\n", m_video_dma_address);
@ -198,7 +198,7 @@ WRITE32_MEMBER(seibuspi_state::palette_dma_start_w)
int dma_length = (m_video_dma_length + 1) * 2;
// safety check
if ((m_video_dma_address & 3) != 0 || (m_video_dma_length & 3) != 3 || dma_length > m_palette_ram_size || (m_video_dma_address + dma_length) > 0x40000)
if (!DWORD_ALIGNED(m_video_dma_address) || (m_video_dma_length & 3) != 3 || dma_length > m_palette_ram_size || (m_video_dma_address + dma_length) > 0x40000)
popmessage("Pal DMA %X %X, contact MAMEdev", m_video_dma_address, m_video_dma_length); // shouldn't happen
if (m_video_dma_address < 0x800)
logerror("palette_dma_start_w in I/O area: %X\n", m_video_dma_address);
@ -219,7 +219,7 @@ WRITE32_MEMBER(seibuspi_state::palette_dma_start_w)
WRITE16_MEMBER(seibuspi_state::sprite_dma_start_w)
{
// safety check
if ((m_video_dma_address & 3) != 0 || (m_video_dma_address + m_sprite_ram_size) > 0x40000)
if (!DWORD_ALIGNED(m_video_dma_address) || (m_video_dma_address + m_sprite_ram_size) > 0x40000)
popmessage("Sprite DMA %X, contact MAMEdev", m_video_dma_address); // shouldn't happen
if (m_video_dma_address < 0x800)
logerror("sprite_dma_start_w in I/O area: %X\n", m_video_dma_address);