Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-23 00:39:36 +03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Renamed flipendian -> swapendian, as I spent minutes trying to find the functions to tell to another person who spent minutes trying to find the functions, and we refer to such functions as swapping just about everywhere else in the codebase, nw

Browse Source
This commit is contained in:
mooglyguy 2018-11-05 19:11:18 +01:00
parent 884465327b
commit 13247311f6
19 changed files with 103 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/devices/bus/lpci/pci.cpp
View File

@ -208,18 +208,18 @@ WRITE32_MEMBER( pci_bus_device::write )
READ64_MEMBER(pci_bus_device::read_64be)
{
uint64_t result = 0;
mem_mask = flipendian_int64(mem_mask);
mem_mask = swapendian_int64(mem_mask);
if (ACCESSING_BITS_0_31)
result |= (uint64_t)read(space, offset * 2 + 0, mem_mask >> 0) << 0;
if (ACCESSING_BITS_32_63)
result |= (uint64_t)read(space, offset * 2 + 1, mem_mask >> 32) << 32;
return flipendian_int64(result);
return swapendian_int64(result);
}
WRITE64_MEMBER(pci_bus_device::write_64be)
{
data = flipendian_int64(data);
mem_mask = flipendian_int64(mem_mask);
data = swapendian_int64(data);
mem_mask = swapendian_int64(mem_mask);
if (ACCESSING_BITS_0_31)
write(space, offset * 2 + 0, data >> 0, mem_mask >> 0);
if (ACCESSING_BITS_32_63)

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

@ -1083,13 +1083,13 @@ int drcbe_c::execute(code_handle &entry)
case MAKE_OPCODE_SHORT(OP_BSWAP, 4, 0): // BSWAP dst,src
temp32 = PARAM1;
PARAM0 = flipendian_int32(temp32);
PARAM0 = swapendian_int32(temp32);
break;
case MAKE_OPCODE_SHORT(OP_BSWAP, 4, 1):
temp32 = PARAM1;
flags = FLAGS32_NZ(temp32);
PARAM0 = flipendian_int32(temp32);
PARAM0 = swapendian_int32(temp32);
break;
case MAKE_OPCODE_SHORT(OP_SHL, 4, 0): // SHL dst,src,count[,f]
@ -1702,13 +1702,13 @@ int drcbe_c::execute(code_handle &entry)
case MAKE_OPCODE_SHORT(OP_BSWAP, 8, 0): // DBSWAP dst,src
temp64 = DPARAM1;
DPARAM0 = flipendian_int64(temp64);
DPARAM0 = swapendian_int64(temp64);
break;
case MAKE_OPCODE_SHORT(OP_BSWAP, 8, 1):
temp64 = DPARAM1;
flags = FLAGS64_NZ(temp64);
DPARAM0 = flipendian_int64(temp64);
DPARAM0 = swapendian_int64(temp64);
break;
case MAKE_OPCODE_SHORT(OP_SHL, 8, 0): // DSHL dst,src,count[,f]

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

@ -647,9 +647,9 @@ void uml::instruction::simplify()
if (m_param[1].is_immediate())
{
if (m_size == 4)
convert_to_mov_immediate(flipendian_int32(m_param[1].immediate()));
convert_to_mov_immediate(swapendian_int32(m_param[1].immediate()));
else if (m_size == 8)
convert_to_mov_immediate(flipendian_int64(m_param[1].immediate()));
convert_to_mov_immediate(swapendian_int64(m_param[1].immediate()));
}
break;

6
src/devices/machine/gt64xxx.cpp
View File

@ -673,7 +673,7 @@ READ32_MEMBER (gt64xxx_device::cpu_if_r)
break;
}
if (m_be) result = flipendian_int32(result);
if (m_be) result = swapendian_int32(result);
return result;
}
@ -681,8 +681,8 @@ READ32_MEMBER (gt64xxx_device::cpu_if_r)
WRITE32_MEMBER(gt64xxx_device::cpu_if_w)
{
if (m_be) {
data = flipendian_int32(data);
mem_mask = flipendian_int32(mem_mask);
data = swapendian_int32(data);
mem_mask = swapendian_int32(mem_mask);
}
uint32_t oldata = m_reg[offset];

8
src/devices/machine/lpci.cpp
View File

@ -205,18 +205,18 @@ WRITE32_MEMBER( pci_bus_legacy_device::write )
READ64_MEMBER(pci_bus_legacy_device::read_64be)
{
uint64_t result = 0;
mem_mask = flipendian_int64(mem_mask);
mem_mask = swapendian_int64(mem_mask);
if (ACCESSING_BITS_0_31)
result |= (uint64_t)read(space, offset * 2 + 0, mem_mask >> 0) << 0;
if (ACCESSING_BITS_32_63)
result |= (uint64_t)read(space, offset * 2 + 1, mem_mask >> 32) << 32;
return flipendian_int64(result);
return swapendian_int64(result);
}
WRITE64_MEMBER(pci_bus_legacy_device::write_64be)
{
data = flipendian_int64(data);
mem_mask = flipendian_int64(mem_mask);
data = swapendian_int64(data);
mem_mask = swapendian_int64(mem_mask);
if (ACCESSING_BITS_0_31)
write(space, offset * 2 + 0, data >> 0, mem_mask >> 0);
if (ACCESSING_BITS_32_63)

4
src/devices/machine/wd33c93.cpp
View File

@ -21,8 +21,10 @@
#define LOG_COMMANDS (1 << 2)
#define LOG_ERRORS (1 << 3)
#define LOG_MISC (1 << 4)
#define LOG_REGS (LOG_READS | LOG_WRITES)
#define LOG_ALL (LOG_REGS | LOG_COMMANDS | LOG_ERRORS | LOG_MISC)
#define VERBOSE (0)
#define VERBOSE (LOG_ALL)
#include "logmacro.h"

16
src/devices/video/voodoo.cpp
View File

@ -2929,8 +2929,8 @@ int32_t voodoo_device::lfb_direct_w(offs_t offset, uint32_t data, uint32_t mem_m
/* byte swizzling */
if (LFBMODE_BYTE_SWIZZLE_WRITES(reg[lfbMode].u))
{
data = flipendian_int32(data);
mem_mask = flipendian_int32(mem_mask);
data = swapendian_int32(data);
mem_mask = swapendian_int32(mem_mask);
}
/* word swapping */
@ -2977,8 +2977,8 @@ int32_t voodoo_device::lfb_w(voodoo_device* vd, offs_t offset, uint32_t data, ui
/* byte swizzling */
if (LFBMODE_BYTE_SWIZZLE_WRITES(vd->reg[lfbMode].u))
{
data = flipendian_int32(data);
mem_mask = flipendian_int32(mem_mask);
data = swapendian_int32(data);
mem_mask = swapendian_int32(mem_mask);
}
/* word swapping */
@ -3441,7 +3441,7 @@ int32_t voodoo_device::texture_w(voodoo_device *vd, offs_t offset, uint32_t data
/* swizzle the data */
if (TEXLOD_TDATA_SWIZZLE(t->reg[tLOD].u))
data = flipendian_int32(data);
data = swapendian_int32(data);
if (TEXLOD_TDATA_SWAP(t->reg[tLOD].u))
data = (data >> 16) | (data << 16);
@ -3700,7 +3700,7 @@ WRITE32_MEMBER( voodoo_device::voodoo_w )
{
/* check for byte swizzling (bit 18) */
if (offset & 0x40000/4)
data = flipendian_int32(data);
data = swapendian_int32(data);
cmdfifo_w(this, &fbi.cmdfifo[0], offset & 0xffff, data);
g_profiler.stop();
return;
@ -3722,7 +3722,7 @@ WRITE32_MEMBER( voodoo_device::voodoo_w )
/* if not, we might be byte swizzled (bit 20) */
else if (offset & 0x100000/4)
data = flipendian_int32(data);
data = swapendian_int32(data);
}
/* check the access behavior; note that the table works even if the */
@ -4120,7 +4120,7 @@ static uint32_t lfb_r(voodoo_device *vd, offs_t offset, bool lfb_3d)
/* byte swizzling */
if (LFBMODE_BYTE_SWIZZLE_READS(vd->reg[lfbMode].u))
data = flipendian_int32(data);
data = swapendian_int32(data);
if (LOG_LFB) vd->logerror("VOODOO.%d.LFB:read (%d,%d) = %08X\n", vd->index, x, y, data);
return data;

6
src/emu/save.cpp
View File

@ -902,19 +902,19 @@ void state_entry::flip_data()
case 2:
data16 = (u16 *)m_data;
for (count = 0; count < m_typecount; count++)
data16[count] = flipendian_int16(data16[count]);
data16[count] = swapendian_int16(data16[count]);
break;
case 4:
data32 = (u32 *)m_data;
for (count = 0; count < m_typecount; count++)
data32[count] = flipendian_int32(data32[count]);
data32[count] = swapendian_int32(data32[count]);
break;
case 8:
data64 = (u64 *)m_data;
for (count = 0; count < m_typecount; count++)
data64[count] = flipendian_int64(data64[count]);
data64[count] = swapendian_int64(data64[count]);
break;
}
}

8
src/lib/formats/cassimg.cpp
View File

@ -468,13 +468,13 @@ cassette_image::error cassette_get_samples(cassette_image *cassette, int channel
case 2:
word = interpolate16(sum);
if (waveform_flags & CASSETTE_WAVEFORM_ENDIAN_FLIP)
word = flipendian_int16(word);
word = swapendian_int16(word);
*((int16_t *) dest_ptr) = word;
break;
case 4:
dword = sum;
if (waveform_flags & CASSETTE_WAVEFORM_ENDIAN_FLIP)
dword = flipendian_int32(dword);
dword = swapendian_int32(dword);
*((int32_t *) dest_ptr) = dword;
break;
}
@ -539,13 +539,13 @@ cassette_image::error cassette_put_samples(cassette_image *cassette, int channel
case 2:
word = *((int16_t *) source_ptr);
if (waveform_flags & CASSETTE_WAVEFORM_ENDIAN_FLIP)
word = flipendian_int16(word);
word = swapendian_int16(word);
dest_value = extrapolate16(word);
break;
case 4:
dword = *((int32_t *) source_ptr);
if (waveform_flags & CASSETTE_WAVEFORM_ENDIAN_FLIP)
dword = flipendian_int32(dword);
dword = swapendian_int32(dword);
dest_value = dword;
break;
default:

16
src/lib/util/cdrom.cpp
View File

@ -1269,16 +1269,16 @@ chd_error cdrom_parse_metadata(chd_file *chd, cdrom_toc *toc)
/* TODO: I don't know why sometimes the data is one endian and sometimes another */
if (toc->numtrks > CD_MAX_TRACKS)
{
toc->numtrks = flipendian_int32(toc->numtrks);
toc->numtrks = swapendian_int32(toc->numtrks);
for (i = 0; i < CD_MAX_TRACKS; i++)
{
toc->tracks[i].trktype = flipendian_int32(toc->tracks[i].trktype);
toc->tracks[i].subtype = flipendian_int32(toc->tracks[i].subtype);
toc->tracks[i].datasize = flipendian_int32(toc->tracks[i].datasize);
toc->tracks[i].subsize = flipendian_int32(toc->tracks[i].subsize);
toc->tracks[i].frames = flipendian_int32(toc->tracks[i].frames);
toc->tracks[i].padframes = flipendian_int32(toc->tracks[i].padframes);
toc->tracks[i].extraframes = flipendian_int32(toc->tracks[i].extraframes);
toc->tracks[i].trktype = swapendian_int32(toc->tracks[i].trktype);
toc->tracks[i].subtype = swapendian_int32(toc->tracks[i].subtype);
toc->tracks[i].datasize = swapendian_int32(toc->tracks[i].datasize);
toc->tracks[i].subsize = swapendian_int32(toc->tracks[i].subsize);
toc->tracks[i].frames = swapendian_int32(toc->tracks[i].frames);
toc->tracks[i].padframes = swapendian_int32(toc->tracks[i].padframes);
toc->tracks[i].extraframes = swapendian_int32(toc->tracks[i].extraframes);
}
}

8
src/lib/util/unicode.cpp
View File

@ -198,9 +198,9 @@ int uchar_from_utf16f(char32_t *uchar, const char16_t *utf16char, size_t count)
{
char16_t buf[2] = {0};
if (count > 0)
buf[0] = flipendian_int16(utf16char[0]);
buf[0] = swapendian_int16(utf16char[0]);
if (count > 1)
buf[1] = flipendian_int16(utf16char[1]);
buf[1] = swapendian_int16(utf16char[1]);
return uchar_from_utf16(uchar, buf, count);
}
@ -348,9 +348,9 @@ int utf16f_from_uchar(char16_t *utf16string, size_t count, char32_t uchar)
rc = utf16_from_uchar(buf, count, uchar);
if (rc >= 1)
utf16string[0] = flipendian_int16(buf[0]);
utf16string[0] = swapendian_int16(buf[0]);
if (rc >= 2)
utf16string[1] = flipendian_int16(buf[1]);
utf16string[1] = swapendian_int16(buf[1]);
return rc;
}

10
src/mame/audio/hng64.cpp
View File

@ -73,15 +73,15 @@ WRITE32_MEMBER(hng64_state::hng64_soundram_w)
/* swap data around.. keep the v53 happy */
data = data32 >> 16;
data = flipendian_int16(data);
data = swapendian_int16(data);
mem_mask = mem_mask32 >> 16;
mem_mask = flipendian_int16(mem_mask);
mem_mask = swapendian_int16(mem_mask);
COMBINE_DATA(&m_soundram[offset * 2 + 0]);
data = data32 & 0xffff;
data = flipendian_int16(data);
data = swapendian_int16(data);
mem_mask = mem_mask32 & 0xffff;
mem_mask = flipendian_int16(mem_mask);
mem_mask = swapendian_int16(mem_mask);
COMBINE_DATA(&m_soundram[offset * 2 + 1]);
if (DUMP_SOUNDPRG)
@ -108,7 +108,7 @@ READ32_MEMBER(hng64_state::hng64_soundram_r)
uint16_t datalo = m_soundram[offset * 2 + 0];
uint16_t datahi = m_soundram[offset * 2 + 1];
return flipendian_int16(datahi) | (flipendian_int16(datalo) << 16);
return swapendian_int16(datahi) | (swapendian_int16(datalo) << 16);
}
WRITE32_MEMBER( hng64_state::hng64_soundcpu_enable_w )

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

@ -571,8 +571,8 @@ WRITE32_MEMBER( magictg_state::f0_w )
offset *= 4;
data = flipendian_int32(data);
mem_mask = flipendian_int32(mem_mask);
data = swapendian_int32(data);
mem_mask = swapendian_int32(mem_mask);
ch = ((offset >> 2) & 3) - 1;
@ -617,7 +617,7 @@ WRITE32_MEMBER( magictg_state::f0_w )
while (m_dma_ch[ch].count > 3)
{
uint32_t src_dword = flipendian_int32(space.read_dword(src_addr));
uint32_t src_dword = swapendian_int32(space.read_dword(src_addr));
space.write_dword(dst_addr, src_dword);
src_addr += 4;
dst_addr += 4;
@ -627,7 +627,7 @@ WRITE32_MEMBER( magictg_state::f0_w )
// FIXME!
if (m_dma_ch[ch].count & 3)
{
uint32_t src_dword = flipendian_int32(space.read_dword(src_addr));
uint32_t src_dword = swapendian_int32(space.read_dword(src_addr));
uint32_t dst_dword = space.read_dword(dst_addr);
uint32_t mask = 0xffffffff >> ((m_dma_ch[ch].count & 3) << 3);
@ -678,19 +678,19 @@ READ32_MEMBER( magictg_state::f0_r )
case 0xcf8:
{
val = m_pci->read(space, 0, flipendian_int32(mem_mask));
val = m_pci->read(space, 0, swapendian_int32(mem_mask));
break;
}
case 0xcfc:
{
val = m_pci->read(space, 1, flipendian_int32(mem_mask));
val = m_pci->read(space, 1, swapendian_int32(mem_mask));
break;
}
// default:
// osd_printf_debug("R: %.8x\n", 0x0f000000 + offset);
}
return flipendian_int32(val);
return swapendian_int32(val);
}

42
src/mame/drivers/model3.cpp
View File

@ -911,7 +911,7 @@ WRITE64_MEMBER(model3_state::mpc105_addr_w)
{
if (ACCESSING_BITS_32_63)
{
uint32_t d = flipendian_int32((uint32_t)(data >> 32));
uint32_t d = swapendian_int32((uint32_t)(data >> 32));
m_mpc105_addr = data >> 32;
m_pci_bus = (d >> 16) & 0xff;
@ -924,22 +924,22 @@ WRITE64_MEMBER(model3_state::mpc105_addr_w)
READ64_MEMBER(model3_state::mpc105_data_r)
{
if(m_pci_device == 0) {
return ((uint64_t)(flipendian_int32(m_mpc105_regs[(m_pci_reg/2)+1])) << 32) |
((uint64_t)(flipendian_int32(m_mpc105_regs[(m_pci_reg/2)+0])));
return ((uint64_t)(swapendian_int32(m_mpc105_regs[(m_pci_reg/2)+1])) << 32) |
((uint64_t)(swapendian_int32(m_mpc105_regs[(m_pci_reg/2)+0])));
}
return flipendian_int32(pci_device_get_reg());
return swapendian_int32(pci_device_get_reg());
}
WRITE64_MEMBER(model3_state::mpc105_data_w)
{
if(m_pci_device == 0) {
m_mpc105_regs[(m_pci_reg/2)+1] = flipendian_int32((uint32_t)(data >> 32));
m_mpc105_regs[(m_pci_reg/2)+0] = flipendian_int32((uint32_t)(data));
m_mpc105_regs[(m_pci_reg/2)+1] = swapendian_int32((uint32_t)(data >> 32));
m_mpc105_regs[(m_pci_reg/2)+0] = swapendian_int32((uint32_t)(data));
return;
}
if (ACCESSING_BITS_0_31)
{
pci_device_set_reg(flipendian_int32((uint32_t)data));
pci_device_set_reg(swapendian_int32((uint32_t)data));
}
}
@ -987,7 +987,7 @@ WRITE64_MEMBER(model3_state::mpc106_addr_w)
{
if (ACCESSING_BITS_32_63)
{
uint32_t d = flipendian_int32((uint32_t)(data >> 32));
uint32_t d = swapendian_int32((uint32_t)(data >> 32));
if (((d >> 8) & 0xffffff) == 0x800000)
{
@ -1008,29 +1008,29 @@ WRITE64_MEMBER(model3_state::mpc106_addr_w)
READ64_MEMBER(model3_state::mpc106_data_r)
{
if(m_pci_device == 0) {
return ((uint64_t)(flipendian_int32(m_mpc106_regs[(m_pci_reg/2)+1])) << 32) |
((uint64_t)(flipendian_int32(m_mpc106_regs[(m_pci_reg/2)+0])));
return ((uint64_t)(swapendian_int32(m_mpc106_regs[(m_pci_reg/2)+1])) << 32) |
((uint64_t)(swapendian_int32(m_mpc106_regs[(m_pci_reg/2)+0])));
}
if (ACCESSING_BITS_32_63)
{
return (uint64_t)(flipendian_int32(pci_device_get_reg())) << 32;
return (uint64_t)(swapendian_int32(pci_device_get_reg())) << 32;
}
else
{
return (uint64_t)(flipendian_int32(pci_device_get_reg()));
return (uint64_t)(swapendian_int32(pci_device_get_reg()));
}
}
WRITE64_MEMBER(model3_state::mpc106_data_w)
{
if(m_pci_device == 0) {
m_mpc106_regs[(m_pci_reg/2)+1] = flipendian_int32((uint32_t)(data >> 32));
m_mpc106_regs[(m_pci_reg/2)+0] = flipendian_int32((uint32_t)(data));
m_mpc106_regs[(m_pci_reg/2)+1] = swapendian_int32((uint32_t)(data >> 32));
m_mpc106_regs[(m_pci_reg/2)+0] = swapendian_int32((uint32_t)(data));
return;
}
if (ACCESSING_BITS_0_31)
{
pci_device_set_reg(flipendian_int32((uint32_t)data));
pci_device_set_reg(swapendian_int32((uint32_t)data));
}
}
@ -1132,7 +1132,7 @@ WRITE64_MEMBER(model3_state::scsi_w)
uint32_t model3_state::scsi_fetch(uint32_t dsp)
{
const uint32_t result = m_maincpu->space(AS_PROGRAM).read_dword(dsp);
return flipendian_int32(result);
return swapendian_int32(result);
}
void model3_state::scsi_irq_callback(int state)
@ -1167,18 +1167,18 @@ WRITE64_MEMBER(model3_state::real3d_dma_w)
{
case 0:
if(ACCESSING_BITS_32_63) { /* DMA source address */
m_dma_source = flipendian_int32((uint32_t)(data >> 32));
m_dma_source = swapendian_int32((uint32_t)(data >> 32));
return;
}
if(ACCESSING_BITS_0_31) { /* DMA destination address */
m_dma_dest = flipendian_int32((uint32_t)(data));
m_dma_dest = swapendian_int32((uint32_t)(data));
return;
}
break;
case 1:
if(ACCESSING_BITS_32_63) /* DMA length */
{
int length = flipendian_int32((uint32_t)(data >> 32)) * 4;
int length = swapendian_int32((uint32_t)(data >> 32)) * 4;
if (m_dma_endian & 0x80)
{
real3d_dma_callback(m_dma_source, m_dma_dest, length, 0);
@ -1207,9 +1207,9 @@ WRITE64_MEMBER(model3_state::real3d_dma_w)
break;
case 2:
if(ACCESSING_BITS_32_63) { /* DMA command */
uint32_t cmd = flipendian_int32((uint32_t)(data >> 32));
uint32_t cmd = swapendian_int32((uint32_t)(data >> 32));
if(cmd & 0x20000000) {
m_dma_data = flipendian_int32(m_real3d_device_id); /* (PCI Vendor & Device ID) */
m_dma_data = swapendian_int32(m_real3d_device_id); /* (PCI Vendor & Device ID) */
}
else if(cmd & 0x80000000) {
m_dma_status ^= 0xffffffff;

6
src/mame/drivers/namcona1.cpp
View File

@ -603,7 +603,7 @@ void xday2_namcona2_state::xday2_main_map(address_map &map)
READ16_MEMBER(namcona1_state::na1mcu_shared_r)
{
uint16_t data = flipendian_int16(m_workram[offset]);
uint16_t data = swapendian_int16(m_workram[offset]);
#if 0
if (offset >= 0x70000/2)
@ -616,8 +616,8 @@ READ16_MEMBER(namcona1_state::na1mcu_shared_r)
WRITE16_MEMBER(namcona1_state::na1mcu_shared_w)
{
mem_mask = flipendian_int16(mem_mask);
data = flipendian_int16(data);
mem_mask = swapendian_int16(mem_mask);
data = swapendian_int16(data);
COMBINE_DATA(&m_workram[offset]);
}

12
src/mame/drivers/viper.cpp
View File

@ -600,20 +600,20 @@ static inline void write64le_with_32le_device_handler(write32_delegate handler,
static inline uint64_t read64be_with_32le_device_handler(read32_delegate handler, address_space &space, offs_t offset, uint64_t mem_mask)
{
mem_mask = flipendian_int64(mem_mask);
mem_mask = swapendian_int64(mem_mask);
uint64_t result = 0;
if (ACCESSING_BITS_0_31)
result = (uint64_t)(handler)(space, offset * 2, mem_mask & 0xffffffff);
if (ACCESSING_BITS_32_63)
result |= (uint64_t)(handler)(space, offset * 2 + 1, mem_mask >> 32) << 32;
return flipendian_int64(result);
return swapendian_int64(result);
}
static inline void write64be_with_32le_device_handler(write32_delegate handler, address_space &space, offs_t offset, uint64_t data, uint64_t mem_mask)
{
data = flipendian_int64(data);
mem_mask = flipendian_int64(mem_mask);
data = swapendian_int64(data);
mem_mask = swapendian_int64(mem_mask);
if (ACCESSING_BITS_0_31)
handler(space, offset * 2, data & 0xffffffff, mem_mask & 0xffffffff);
if (ACCESSING_BITS_32_63)
@ -1050,7 +1050,7 @@ READ32_MEMBER(viper_state::epic_r)
}
}
return flipendian_int32(ret);
return swapendian_int32(ret);
}
WRITE32_MEMBER(viper_state::epic_w)
@ -1058,7 +1058,7 @@ WRITE32_MEMBER(viper_state::epic_w)
int reg;
reg = offset * 4;
data = flipendian_int32(data);
data = swapendian_int32(data);
#if VIPER_DEBUG_EPIC_REGS
if (reg != 0x600b0) // interrupt clearing is spammy

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

@ -25,7 +25,7 @@ WRITE16_MEMBER(pushman_state::pushman_mcu_comm_w)
switch (offset & 0x01)
{
case 0:
m_host_latch = flipendian_int16(data);
m_host_latch = swapendian_int16(data);
break;
case 1:
m_mcu->pd_w(space, 0, data & 0x00ff);

24
src/osd/osdcomm.h
View File

@ -95,19 +95,19 @@ template <typename T, typename U> using equivalent_array_t = typename equivalent
#define EQUIVALENT_ARRAY(a, T) equivalent_array_t<T, std::remove_reference_t<decltype(a)> >
/* Macros for normalizing data into big or little endian formats */
constexpr uint16_t flipendian_int16(uint16_t val) { return (val << 8) | (val >> 8); }
constexpr uint16_t swapendian_int16(uint16_t val) { return (val << 8) | (val >> 8); }
constexpr uint32_t flipendian_int32_partial16(uint32_t val) { return ((val << 8) & 0xFF00FF00U) | ((val >> 8) & 0x00FF00FFU); }
constexpr uint32_t flipendian_int32(uint32_t val) { return (flipendian_int32_partial16(val) << 16) | (flipendian_int32_partial16(val) >> 16); }
constexpr uint32_t swapendian_int32_partial16(uint32_t val) { return ((val << 8) & 0xFF00FF00U) | ((val >> 8) & 0x00FF00FFU); }
constexpr uint32_t swapendian_int32(uint32_t val) { return (swapendian_int32_partial16(val) << 16) | (swapendian_int32_partial16(val) >> 16); }
constexpr uint64_t flipendian_int64_partial16(uint64_t val) { return ((val << 8) & 0xFF00FF00FF00FF00U) | ((val >> 8) & 0x00FF00FF00FF00FFU); }
constexpr uint64_t flipendian_int64_partial32(uint64_t val) { return ((flipendian_int64_partial16(val) << 16) & 0xFFFF0000FFFF0000U) | ((flipendian_int64_partial16(val) >> 16) & 0x0000FFFF0000FFFFU); }
constexpr uint64_t flipendian_int64(uint64_t val) { return (flipendian_int64_partial32(val) << 32) | (flipendian_int64_partial32(val) >> 32); }
constexpr uint64_t swapendian_int64_partial16(uint64_t val) { return ((val << 8) & 0xFF00FF00FF00FF00U) | ((val >> 8) & 0x00FF00FF00FF00FFU); }
constexpr uint64_t swapendian_int64_partial32(uint64_t val) { return ((swapendian_int64_partial16(val) << 16) & 0xFFFF0000FFFF0000U) | ((swapendian_int64_partial16(val) >> 16) & 0x0000FFFF0000FFFFU); }
constexpr uint64_t swapendian_int64(uint64_t val) { return (swapendian_int64_partial32(val) << 32) | (swapendian_int64_partial32(val) >> 32); }
#ifdef LSB_FIRST
constexpr uint16_t big_endianize_int16(uint16_t x) { return flipendian_int16(x); }
constexpr uint32_t big_endianize_int32(uint32_t x) { return flipendian_int32(x); }
constexpr uint64_t big_endianize_int64(uint64_t x) { return flipendian_int64(x); }
constexpr uint16_t big_endianize_int16(uint16_t x) { return swapendian_int16(x); }
constexpr uint32_t big_endianize_int32(uint32_t x) { return swapendian_int32(x); }
constexpr uint64_t big_endianize_int64(uint64_t x) { return swapendian_int64(x); }
constexpr uint16_t little_endianize_int16(uint16_t x) { return x; }
constexpr uint32_t little_endianize_int32(uint32_t x) { return x; }
constexpr uint64_t little_endianize_int64(uint64_t x) { return x; }
@ -115,9 +115,9 @@ constexpr uint64_t little_endianize_int64(uint64_t x) { return x; }
constexpr uint16_t big_endianize_int16(uint16_t x) { return x; }
constexpr uint32_t big_endianize_int32(uint32_t x) { return x; }
constexpr uint64_t big_endianize_int64(uint64_t x) { return x; }
constexpr uint16_t little_endianize_int16(uint16_t x) { return flipendian_int16(x); }
constexpr uint32_t little_endianize_int32(uint32_t x) { return flipendian_int32(x); }
constexpr uint64_t little_endianize_int64(uint64_t x) { return flipendian_int64(x); }
constexpr uint16_t little_endianize_int16(uint16_t x) { return swapendian_int16(x); }
constexpr uint32_t little_endianize_int32(uint32_t x) { return swapendian_int32(x); }
constexpr uint64_t little_endianize_int64(uint64_t x) { return swapendian_int64(x); }
#endif /* LSB_FIRST */
#ifdef _MSC_VER

2
src/tools/imgtool/modules/cybiko.cpp
View File

@ -116,7 +116,7 @@ static uint16_t page_buffer_calc_checksum_2( uint8_t *buffer)
val ^= buffer_read_16_be( buffer + 0);
val ^= buffer_read_16_be( buffer + 2);
val ^= buffer_read_16_be( buffer + 4);
return flipendian_int16(val);
return swapendian_int16(val);
}
static int page_buffer_verify( uint8_t *buffer, uint32_t size, int block_type)