summaryrefslogtreecommitdiffstatshomepage
diff options
context:
space:
mode:
-rw-r--r--src/devices/bus/ti99_peb/bwg.cpp2
-rw-r--r--src/devices/bus/ti99_peb/hfdc.cpp4
-rw-r--r--src/devices/cpu/arm/arm.cpp6
-rw-r--r--src/devices/cpu/asap/asap.cpp8
-rw-r--r--src/devices/cpu/dsp32/dsp32.cpp12
-rw-r--r--src/devices/cpu/hd61700/hd61700.cpp4
-rw-r--r--src/devices/cpu/i386/i386priv.h20
-rw-r--r--src/devices/cpu/i8089/i8089.cpp4
-rw-r--r--src/devices/cpu/i960/i960.cpp8
-rw-r--r--src/devices/cpu/m37710/m37710il.h8
-rw-r--r--src/devices/cpu/m68000/m68kcpu.cpp36
-rw-r--r--src/devices/cpu/m68000/m68kcpu.h4
-rw-r--r--src/devices/cpu/se3208/se3208.cpp32
-rw-r--r--src/devices/video/i82730.cpp4
-rw-r--r--src/emu/debug/debugcpu.cpp18
-rw-r--r--src/emu/luaengine.cpp12
-rw-r--r--src/emu/memory.cpp86
-rw-r--r--src/emu/memory.h6
-rw-r--r--src/mame/drivers/cobra.cpp4
-rw-r--r--src/mame/drivers/magictg.cpp4
-rw-r--r--src/mame/machine/n64.cpp2
-rw-r--r--src/mame/video/seibuspi.cpp6
22 files changed, 144 insertions, 146 deletions
diff --git a/src/devices/bus/ti99_peb/bwg.cpp b/src/devices/bus/ti99_peb/bwg.cpp
index 4085dcfe230..4716ccedf8a 100644
--- a/src/devices/bus/ti99_peb/bwg.cpp
+++ b/src/devices/bus/ti99_peb/bwg.cpp
@@ -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);
diff --git a/src/devices/bus/ti99_peb/hfdc.cpp b/src/devices/bus/ti99_peb/hfdc.cpp
index c3e4779c1ef..46ca7a1b819 100644
--- a/src/devices/bus/ti99_peb/hfdc.cpp
+++ b/src/devices/bus/ti99_peb/hfdc.cpp
@@ -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);
diff --git a/src/devices/cpu/arm/arm.cpp b/src/devices/cpu/arm/arm.cpp
index 41724668f53..34dc1635639 100644
--- a/src/devices/cpu/arm/arm.cpp
+++ b/src/devices/cpu/arm/arm.cpp
@@ -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)
diff --git a/src/devices/cpu/asap/asap.cpp b/src/devices/cpu/asap/asap.cpp
index c22d0cdcee2..b369ab6d07b 100644
--- a/src/devices/cpu/asap/asap.cpp
+++ b/src/devices/cpu/asap/asap.cpp
@@ -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;
diff --git a/src/devices/cpu/dsp32/dsp32.cpp b/src/devices/cpu/dsp32/dsp32.cpp
index f060e81d13c..98640f7d1b4 100644
--- a/src/devices/cpu/dsp32/dsp32.cpp
+++ b/src/devices/cpu/dsp32/dsp32.cpp
@@ -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);
}
diff --git a/src/devices/cpu/hd61700/hd61700.cpp b/src/devices/cpu/hd61700/hd61700.cpp
index c786c7235ba..4e8d2c6590d 100644
--- a/src/devices/cpu/hd61700/hd61700.cpp
+++ b/src/devices/cpu/hd61700/hd61700.cpp
@@ -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();
diff --git a/src/devices/cpu/i386/i386priv.h b/src/devices/cpu/i386/i386priv.h
index 9913d851fa2..fa7ae0d4945 100644
--- a/src/devices/cpu/i386/i386priv.h
+++ b/src/devices/cpu/i386/i386priv.h
@@ -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 );
diff --git a/src/devices/cpu/i8089/i8089.cpp b/src/devices/cpu/i8089/i8089.cpp
index 22494cfdd2f..ade9e4f768b 100644
--- a/src/devices/cpu/i8089/i8089.cpp
+++ b/src/devices/cpu/i8089/i8089.cpp
@@ -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);
}
diff --git a/src/devices/cpu/i960/i960.cpp b/src/devices/cpu/i960/i960.cpp
index 224b844387c..f754445379b 100644
--- a/src/devices/cpu/i960/i960.cpp
+++ b/src/devices/cpu/i960/i960.cpp
@@ -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);
diff --git a/src/devices/cpu/m37710/m37710il.h b/src/devices/cpu/m37710/m37710il.h
index ffc1aed0a7a..eb79f0fddd6 100644
--- a/src/devices/cpu/m37710/m37710il.h
+++ b/src/devices/cpu/m37710/m37710il.h
@@ -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);
diff --git a/src/devices/cpu/m68000/m68kcpu.cpp b/src/devices/cpu/m68000/m68kcpu.cpp
index dc7e0b14a6f..aaa1db079cf 100644
--- a/src/devices/cpu/m68000/m68kcpu.cpp
+++ b/src/devices/cpu/m68000/m68kcpu.cpp
@@ -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);
diff --git a/src/devices/cpu/m68000/m68kcpu.h b/src/devices/cpu/m68000/m68kcpu.h
index 5cec889e002..7860298988f 100644
--- a/src/devices/cpu/m68000/m68kcpu.h
+++ b/src/devices/cpu/m68000/m68kcpu.h
@@ -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) |
diff --git a/src/devices/cpu/se3208/se3208.cpp b/src/devices/cpu/se3208/se3208.cpp
index 011cc103909..45c4c38cc86 100644
--- a/src/devices/cpu/se3208/se3208.cpp
+++ b/src/devices/cpu/se3208/se3208.cpp
@@ -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);
diff --git a/src/devices/video/i82730.cpp b/src/devices/video/i82730.cpp
index d344c7006ef..8cd78863df3 100644
--- a/src/devices/video/i82730.cpp
+++ b/src/devices/video/i82730.cpp
@@ -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);
}
diff --git a/src/emu/debug/debugcpu.cpp b/src/emu/debug/debugcpu.cpp
index 82c175251fe..293657b1f45 100644
--- a/src/emu/debug/debugcpu.cpp
+++ b/src/emu/debug/debugcpu.cpp
@@ -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)
diff --git a/src/emu/luaengine.cpp b/src/emu/luaengine.cpp
index f1d12757ed7..f8ec7023bc6 100644
--- a/src/emu/luaengine.cpp
+++ b/src/emu/luaengine.cpp
@@ -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);
diff --git a/src/emu/memory.cpp b/src/emu/memory.cpp
index 598ffab9ac6..656c00fd626 100644
--- a/src/emu/memory.cpp
+++ b/src/emu/memory.cpp
@@ -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);
diff --git a/src/emu/memory.h b/src/emu/memory.h
index 3b46ac33449..34a060a51b6 100644
--- a/src/emu/memory.h
+++ b/src/emu/memory.h
@@ -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
diff --git a/src/mame/drivers/cobra.cpp b/src/mame/drivers/cobra.cpp
index 848862363b2..8062af06612 100644
--- a/src/mame/drivers/cobra.cpp
+++ b/src/mame/drivers/cobra.cpp
@@ -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;
diff --git a/src/mame/drivers/magictg.cpp b/src/mame/drivers/magictg.cpp
index 63b0df20394..0235da41a9a 100644
--- a/src/mame/drivers/magictg.cpp
+++ b/src/mame/drivers/magictg.cpp
@@ -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)
{
diff --git a/src/mame/machine/n64.cpp b/src/mame/machine/n64.cpp
index a3e256a080c..5f0d8a6b4d2 100644
--- a/src/mame/machine/n64.cpp
+++ b/src/mame/machine/n64.cpp
@@ -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);
}
diff --git a/src/mame/video/seibuspi.cpp b/src/mame/video/seibuspi.cpp
index cb267167789..42e683c70b2 100644
--- a/src/mame/video/seibuspi.cpp
+++ b/src/mame/video/seibuspi.cpp
@@ -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);