/***************************************************************************
memory.h
Functions which handle the CPU memory accesses.
Copyright Nicola Salmoria and the MAME Team.
Visit http://mamedev.org for licensing and usage restrictions.
***************************************************************************/
#pragma once
#ifndef __MEMORY_H__
#define __MEMORY_H__
#include "mamecore.h"
#include "devintrf.h"
#include "tokenize.h"
/***************************************************************************
CONSTANTS
***************************************************************************/
/* address spaces */
enum
{
ADDRESS_SPACE_PROGRAM = 0, /* program address space */
ADDRESS_SPACE_DATA, /* data address space */
ADDRESS_SPACE_IO, /* I/O address space */
ADDRESS_SPACES /* maximum number of address spaces */
};
/* static data access handler constants */
enum
{
STATIC_INVALID = 0, /* invalid - should never be used */
STATIC_BANK1 = 1, /* first memory bank */
/* entries 1-32 are for fixed banks 1-32 specified by the driver */
/* entries 33-67 are for dynamically allocated internal banks */
STATIC_BANKMAX = 67, /* last memory bank */
STATIC_RAM, /* RAM - reads/writes map to dynamic banks */
STATIC_ROM, /* ROM - reads = RAM; writes = UNMAP */
STATIC_NOP, /* NOP - reads = unmapped value; writes = no-op */
STATIC_UNMAP, /* unmapped - same as NOP except we log errors */
STATIC_COUNT /* total number of static handlers */
};
/* address map tokens */
enum
{
ADDRMAP_TOKEN_INVALID,
ADDRMAP_TOKEN_START,
ADDRMAP_TOKEN_END,
ADDRMAP_TOKEN_INCLUDE,
ADDRMAP_TOKEN_GLOBAL_MASK,
ADDRMAP_TOKEN_UNMAP_VALUE,
ADDRMAP_TOKEN_RANGE,
ADDRMAP_TOKEN_MASK,
ADDRMAP_TOKEN_MIRROR,
ADDRMAP_TOKEN_READ,
ADDRMAP_TOKEN_WRITE,
ADDRMAP_TOKEN_DEVICE_READ,
ADDRMAP_TOKEN_DEVICE_WRITE,
ADDRMAP_TOKEN_READ_PORT,
ADDRMAP_TOKEN_REGION,
ADDRMAP_TOKEN_SHARE,
ADDRMAP_TOKEN_BASEPTR,
ADDRMAP_TOKEN_BASE_MEMBER,
ADDRMAP_TOKEN_SIZEPTR,
ADDRMAP_TOKEN_SIZE_MEMBER
};
/***************************************************************************
TYPE DEFINITIONS
***************************************************************************/
/* handler_data is an opaque type used to hold information about a particular handler */
typedef struct _handler_data handler_data;
/* offsets and addresses are 32-bit (for now...) */
typedef UINT32 offs_t;
/* opcode base adjustment handler */
typedef offs_t (*opbase_handler_func) (ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t address);
/* machine read/write handlers */
typedef UINT8 (*read8_machine_func) (ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t offset);
typedef void (*write8_machine_func) (ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data);
typedef UINT16 (*read16_machine_func) (ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask);
typedef void (*write16_machine_func)(ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask);
typedef UINT32 (*read32_machine_func) (ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask);
typedef void (*write32_machine_func)(ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, ATTR_UNUSED UINT32 mem_mask);
typedef UINT64 (*read64_machine_func) (ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 mem_mask);
typedef void (*write64_machine_func)(ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask);
/* device read/write handlers */
typedef UINT8 (*read8_device_func) (ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset);
typedef void (*write8_device_func) (ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data);
typedef UINT16 (*read16_device_func) (ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask);
typedef void (*write16_device_func)(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask);
typedef UINT32 (*read32_device_func) (ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask);
typedef void (*write32_device_func)(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, ATTR_UNUSED UINT32 mem_mask);
typedef UINT64 (*read64_device_func) (ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 mem_mask);
typedef void (*write64_device_func)(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask);
/* data_accessors is a struct with accessors of all flavors */
typedef struct _data_accessors data_accessors;
struct _data_accessors
{
void (*change_pc)(offs_t byteaddress);
UINT8 (*read_byte)(offs_t byteaddress);
UINT16 (*read_word)(offs_t byteaddress);
UINT32 (*read_dword)(offs_t byteaddress);
UINT32 (*read_dword_masked)(offs_t byteaddress, UINT32 mask);
UINT64 (*read_qword)(offs_t byteaddress);
UINT64 (*read_qword_masked)(offs_t byteaddress, UINT64 mask);
void (*write_byte)(offs_t byteaddress, UINT8 data);
void (*write_word)(offs_t byteaddress, UINT16 data);
void (*write_dword)(offs_t byteaddress, UINT32 data);
void (*write_dword_masked)(offs_t byteaddress, UINT32 data, UINT32 mask);
void (*write_qword)(offs_t byteaddress, UINT64 data);
void (*write_qword_masked)(offs_t byteaddress, UINT64 data, UINT64 mask);
};
/* read_handler is a union of all the different read handler types */
typedef union _read_handler read_handler;
union _read_handler
{
genf * generic; /* generic function pointer */
read8_machine_func mhandler8; /* 8-bit machine read handler */
read16_machine_func mhandler16; /* 16-bit machine read handler */
read32_machine_func mhandler32; /* 32-bit machine read handler */
read64_machine_func mhandler64; /* 64-bit machine read handler */
read8_device_func dhandler8; /* 8-bit device read handler */
read16_device_func dhandler16; /* 16-bit device read handler */
read32_device_func dhandler32; /* 32-bit device read handler */
read64_device_func dhandler64; /* 64-bit device read handler */
};
/* write_handler is a union of all the different write handler types */
typedef union _write_handler write_handler;
union _write_handler
{
genf * generic; /* generic function pointer */
write8_machine_func mhandler8; /* 8-bit machine write handler */
write16_machine_func mhandler16; /* 16-bit machine write handler */
write32_machine_func mhandler32; /* 32-bit machine write handler */
write64_machine_func mhandler64; /* 64-bit machine write handler */
write8_device_func dhandler8; /* 8-bit device write handler */
write16_device_func dhandler16; /* 16-bit device write handler */
write32_device_func dhandler32; /* 32-bit device write handler */
write64_device_func dhandler64; /* 64-bit device write handler */
};
/* memory_handler is a union of all read and write handler types */
typedef union _memory_handler memory_handler;
union _memory_handler
{
genf * generic; /* generic function pointer */
read_handler read; /* read handler union */
write_handler write; /* write handler union */
};
/* address_map_entry is a linked list element describing one address range in a map */
typedef struct _address_map_entry address_map_entry;
struct _address_map_entry
{
address_map_entry * next; /* pointer to the next entry */
offs_t addrstart; /* start address */
offs_t addrend; /* end address */
offs_t addrmirror; /* mirror bits */
offs_t addrmask; /* mask bits */
read_handler read; /* read handler callback */
const char * read_name; /* read handler callback name */
device_type read_devtype; /* read device type for device references */
const char * read_devtag; /* read tag for the relevant device */
write_handler write; /* write handler callback */
const char * write_name; /* write handler callback name */
device_type write_devtype; /* read device type for device references */
const char * write_devtag; /* read tag for the relevant device */
UINT32 share; /* index of a shared memory block */
void ** baseptr; /* receives pointer to memory (optional) */
size_t * sizeptr; /* receives size of area in bytes (optional) */
UINT32 baseptroffs_plus1; /* offset of base pointer within driver_data, plus 1 */
UINT32 sizeptroffs_plus1; /* offset of size pointer within driver_data, plus 1 */
UINT32 region; /* region containing the memory backing this entry */
offs_t region_offs; /* offset within the region */
void * memory; /* pointer to memory backing this entry */
offs_t bytestart; /* byte-adjusted start address */
offs_t byteend; /* byte-adjusted end address */
offs_t bytemirror; /* byte-adjusted mirror bits */
offs_t bytemask; /* byte-adjusted mask bits */
};
/* address_map holds global map parameters plus the head of the list of entries */
typedef struct _address_map address_map;
struct _address_map
{
UINT8 spacenum; /* space number of the map */
UINT8 databits; /* data bits represented by the map */
UINT8 unmapval; /* unmapped memory value */
offs_t globalmask; /* global mask */
address_map_entry * entrylist; /* list of entries */
};
/* address_space holds live information about an address space */
typedef struct _address_space address_space;
struct _address_space
{
offs_t bytemask; /* byte-adjusted address mask */
UINT8 * readlookup; /* read table lookup */
UINT8 * writelookup; /* write table lookup */
handler_data * readhandlers; /* read handlers */
handler_data * writehandlers; /* write handlers */
const data_accessors * accessors; /* pointers to the data access handlers */
};
/* addrmap_token is a union of all types for a generic address map */
typedef union _addrmap_token addrmap_token;
union _addrmap_token
{
TOKEN_COMMON_FIELDS
const addrmap_token * tokenptr;
read_handler read; /* generic read handlers */
write_handler write; /* generic write handlers */
device_type devtype; /* device type */
UINT8 ** memptr; /* memory pointer */
size_t * sizeptr; /* size pointer */
};
/* addrmap8_token is a union of all types for an 8-bit address map */
typedef union _addrmap8_token addrmap8_token;
union _addrmap8_token
{
TOKEN_COMMON_FIELDS
const addrmap_token * tokenptr;
read8_machine_func mread; /* pointer to native machine read handler */
write8_machine_func mwrite; /* pointer to native machine write handler */
read8_device_func dread; /* pointer to native device read handler */
write8_device_func dwrite; /* pointer to native device write handler */
read_handler read; /* generic read handlers */
write_handler write; /* generic write handlers */
device_type devtype; /* device type */
UINT8 ** memptr; /* memory pointer */
size_t * sizeptr; /* size pointer */
};
/* addrmap16_token is a union of all types for a 16-bit address map */
typedef union _addrmap16_token addrmap16_token;
union _addrmap16_token
{
TOKEN_COMMON_FIELDS
const addrmap_token * tokenptr;
read16_machine_func mread; /* pointer to native read handler */
write16_machine_func mwrite; /* pointer to native write handler */
read16_device_func dread; /* pointer to native device read handler */
write16_device_func dwrite; /* pointer to native device write handler */
read8_machine_func mread8; /* pointer to 8-bit machine read handler */
write8_machine_func mwrite8; /* pointer to 8-bit machine write handler */
read_handler read; /* generic read handlers */
write_handler write; /* generic write handlers */
device_type devtype; /* device type */
UINT16 ** memptr; /* memory pointer */
size_t * sizeptr; /* size pointer */
};
/* addrmap32_token is a union of all types for a 32-bit address map */
typedef union _addrmap32_token addrmap32_token;
union _addrmap32_token
{
TOKEN_COMMON_FIELDS
const addrmap_token * tokenptr;
read32_machine_func mread; /* pointer to native read handler */
write32_machine_func mwrite; /* pointer to native write handler */
read32_device_func dread; /* pointer to native device read handler */
write32_device_func dwrite; /* pointer to native device write handler */
read8_machine_func mread8; /* pointer to 8-bit machine read handler */
write8_machine_func mwrite8; /* pointer to 8-bit machine write handler */
read16_machine_func mread16; /* pointer to 16-bit machine read handler */
write16_machine_func mwrite16; /* pointer to 16-bit machine write handler */
read_handler read; /* generic read handlers */
write_handler write; /* generic write handlers */
device_type devtype; /* device type */
UINT32 ** memptr; /* memory pointer */
size_t * sizeptr; /* size pointer */
};
/* addrmap64_token is a union of all types for a 64-bit address map */
typedef union _addrmap64_token addrmap64_token;
union _addrmap64_token
{
TOKEN_COMMON_FIELDS
const addrmap_token * tokenptr;
read64_machine_func mread; /* pointer to native read handler */
write64_machine_func mwrite; /* pointer to native write handler */
read64_device_func dread; /* pointer to native device read handler */
write64_device_func dwrite; /* pointer to native device write handler */
read8_machine_func mread8; /* pointer to 8-bit machine read handler */
write8_machine_func mwrite8; /* pointer to 8-bit machine write handler */
read16_machine_func mread16; /* pointer to 16-bit machine read handler */
write16_machine_func mwrite16; /* pointer to 16-bit machine write handler */
read32_machine_func mread32; /* pointer to 32-bit machine read handler */
write32_machine_func mwrite32; /* pointer to 32-bit machine write handler */
read_handler read; /* generic read handlers */
write_handler write; /* generic write handlers */
device_type devtype; /* device type */
UINT64 ** memptr; /* memory pointer */
size_t * sizeptr; /* size pointer */
};
/***************************************************************************
MACROS
***************************************************************************/
/* opcode base adjustment handler function macro */
#define OPBASE_HANDLER(name) offs_t name(ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t address)
/* machine read/write handler function macros */
#define READ8_HANDLER(name) UINT8 name(ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t offset)
#define WRITE8_HANDLER(name) void name(ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data)
#define READ16_HANDLER(name) UINT16 name(ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask)
#define WRITE16_HANDLER(name) void name(ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask)
#define READ32_HANDLER(name) UINT32 name(ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask)
#define WRITE32_HANDLER(name) void name(ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, ATTR_UNUSED UINT32 mem_mask)
#define READ64_HANDLER(name) UINT64 name(ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 mem_mask)
#define WRITE64_HANDLER(name) void name(ATTR_UNUSED running_machine *machine, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask)
/* device read/write handler function macros */
#define READ8_DEVICE_HANDLER(name) UINT8 name(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset)
#define WRITE8_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data)
#define READ16_DEVICE_HANDLER(name) UINT16 name(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask)
#define WRITE16_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask)
#define READ32_DEVICE_HANDLER(name) UINT32 name(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask)
#define WRITE32_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, ATTR_UNUSED UINT32 mem_mask)
#define READ64_DEVICE_HANDLER(name) UINT64 name(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 mem_mask)
#define WRITE64_DEVICE_HANDLER(name) void name(ATTR_UNUSED device_config *device, ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask)
/* static memory handler (SMH) macros that can be used in place of read/write handlers */
#define SMH_RAM ((void *)STATIC_RAM)
#define SMH_ROM ((void *)STATIC_ROM)
#define SMH_NOP ((void *)STATIC_NOP)
#define SMH_UNMAP ((void *)STATIC_UNMAP)
#define SMH_BANK(n) ((void *)(STATIC_BANK1 + (n) - 1))
#define SMH_BANK1 SMH_BANK(1)
#define SMH_BANK2 SMH_BANK(2)
#define SMH_BANK3 SMH_BANK(3)
#define SMH_BANK4 SMH_BANK(4)
#define SMH_BANK5 SMH_BANK(5)
#define SMH_BANK6 SMH_BANK(6)
#define SMH_BANK7 SMH_BANK(7)
#define SMH_BANK8 SMH_BANK(8)
#define SMH_BANK9 SMH_BANK(9)
#define SMH_BANK10 SMH_BANK(10)
#define SMH_BANK11 SMH_BANK(11)
#define SMH_BANK12 SMH_BANK(12)
#define SMH_BANK13 SMH_BANK(13)
#define SMH_BANK14 SMH_BANK(14)
#define SMH_BANK15 SMH_BANK(15)
#define SMH_BANK16 SMH_BANK(16)
#define SMH_BANK17 SMH_BANK(17)
#define SMH_BANK18 SMH_BANK(18)
#define SMH_BANK19 SMH_BANK(19)
#define SMH_BANK20 SMH_BANK(20)
#define SMH_BANK21 SMH_BANK(21)
#define SMH_BANK22 SMH_BANK(22)
#define SMH_BANK23 SMH_BANK(23)
#define SMH_BANK24 SMH_BANK(24)
#define SMH_BANK25 SMH_BANK(25)
#define SMH_BANK26 SMH_BANK(26)
#define SMH_BANK27 SMH_BANK(27)
#define SMH_BANK28 SMH_BANK(28)
#define SMH_BANK29 SMH_BANK(29)
#define SMH_BANK30 SMH_BANK(30)
#define SMH_BANK31 SMH_BANK(31)
#define SMH_BANK32 SMH_BANK(32)
/* helper macro for merging data with the memory mask */
#define COMBINE_DATA(varptr) (*(varptr) = (*(varptr) & mem_mask) | (data & ~mem_mask))
/* 16-bit memory access tests */
#define ACCESSING_LSB16 ((mem_mask & 0x00ff) == 0)
#define ACCESSING_MSB16 ((mem_mask & 0xff00) == 0)
#define ACCESSING_LSB ACCESSING_LSB16
#define ACCESSING_MSB ACCESSING_MSB16
/* 32-bit memory access tests */
#define ACCESSING_LSW32 ((mem_mask & 0x0000ffff) == 0)
#define ACCESSING_MSW32 ((mem_mask & 0xffff0000) == 0)
#define ACCESSING_LSB32 ((mem_mask & 0x000000ff) == 0)
#define ACCESSING_MSB32 ((mem_mask & 0xff000000) == 0)
/* bank switching for CPU cores */
#define change_pc(byteaddress) memory_set_opbase(byteaddress)
/* opcode range safety check */
#define address_is_unsafe(A) ((UNEXPECTED((A) < opcode_memory_min) || UNEXPECTED((A) > opcode_memory_max)))
/* unsafe opcode and opcode argument reading */
#define cpu_opptr_unsafe(A) ((void *)&opcode_base[(A) & opcode_mask])
#define cpu_readop_unsafe(A) (opcode_base[(A) & opcode_mask])
#define cpu_readop16_unsafe(A) (*(UINT16 *)&opcode_base[(A) & opcode_mask])
#define cpu_readop32_unsafe(A) (*(UINT32 *)&opcode_base[(A) & opcode_mask])
#define cpu_readop64_unsafe(A) (*(UINT64 *)&opcode_base[(A) & opcode_mask])
#define cpu_readop_arg_unsafe(A) (opcode_arg_base[(A) & opcode_mask])
#define cpu_readop_arg16_unsafe(A) (*(UINT16 *)&opcode_arg_base[(A) & opcode_mask])
#define cpu_readop_arg32_unsafe(A) (*(UINT32 *)&opcode_arg_base[(A) & opcode_mask])
#define cpu_readop_arg64_unsafe(A) (*(UINT64 *)&opcode_arg_base[(A) & opcode_mask])
/* wrappers for dynamic read handler installation */
#define memory_install_read_handler(cpu, space, start, end, mask, mirror, handler) \
_memory_install_read_handler(cpu, space, start, end, mask, mirror, handler, #handler)
#define memory_install_read8_handler(cpu, space, start, end, mask, mirror, handler) \
_memory_install_read8_handler(cpu, space, start, end, mask, mirror, handler, #handler)
#define memory_install_read16_handler(cpu, space, start, end, mask, mirror, handler) \
_memory_install_read16_handler(cpu, space, start, end, mask, mirror, handler, #handler)
#define memory_install_read32_handler(cpu, space, start, end, mask, mirror, handler) \
_memory_install_read32_handler(cpu, space, start, end, mask, mirror, handler, #handler)
#define memory_install_read64_handler(cpu, space, start, end, mask, mirror, handler) \
_memory_install_read64_handler(cpu, space, start, end, mask, mirror, handler, #handler)
/* wrappers for dynamic write handler installation */
#define memory_install_write_handler(cpu, space, start, end, mask, mirror, handler) \
_memory_install_write_handler(cpu, space, start, end, mask, mirror, handler, #handler)
#define memory_install_write8_handler(cpu, space, start, end, mask, mirror, handler) \
_memory_install_write8_handler(cpu, space, start, end, mask, mirror, handler, #handler)
#define memory_install_write16_handler(cpu, space, start, end, mask, mirror, handler) \
_memory_install_write16_handler(cpu, space, start, end, mask, mirror, handler, #handler)
#define memory_install_write32_handler(cpu, space, start, end, mask, mirror, handler) \
_memory_install_write32_handler(cpu, space, start, end, mask, mirror, handler, #handler)
#define memory_install_write64_handler(cpu, space, start, end, mask, mirror, handler) \
_memory_install_write64_handler(cpu, space, start, end, mask, mirror, handler, #handler)
/* wrappers for dynamic read/write handler installation */
#define memory_install_readwrite_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) \
_memory_install_readwrite_handler(cpu, space, start, end, mask, mirror, rhandler, whandler, #rhandler, #whandler)
#define memory_install_readwrite8_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) \
_memory_install_readwrite8_handler(cpu, space, start, end, mask, mirror, rhandler, whandler, #rhandler, #whandler)
#define memory_install_readwrite16_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) \
_memory_install_readwrite16_handler(cpu, space, start, end, mask, mirror, rhandler, whandler, #rhandler, #whandler)
#define memory_install_readwrite32_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) \
_memory_install_readwrite32_handler(cpu, space, start, end, mask, mirror, rhandler, whandler, #rhandler, #whandler)
#define memory_install_readwrite64_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) \
_memory_install_readwrite64_handler(cpu, space, start, end, mask, mirror, rhandler, whandler, #rhandler, #whandler)
/* macros for accessing bytes and words within larger chunks */
#ifdef LSB_FIRST
#define BYTE_XOR_BE(a) ((a) ^ 1) /* read/write a byte to a 16-bit space */
#define BYTE_XOR_LE(a) (a)
#define BYTE4_XOR_BE(a) ((a) ^ 3) /* read/write a byte to a 32-bit space */
#define BYTE4_XOR_LE(a) (a)
#define WORD_XOR_BE(a) ((a) ^ 2) /* read/write a word to a 32-bit space */
#define WORD_XOR_LE(a) (a)
#define BYTE8_XOR_BE(a) ((a) ^ 7) /* read/write a byte to a 64-bit space */
#define BYTE8_XOR_LE(a) (a)
#define WORD2_XOR_BE(a) ((a) ^ 6) /* read/write a word to a 64-bit space */
#define WORD2_XOR_LE(a) (a)
#define DWORD_XOR_BE(a) ((a) ^ 4) /* read/write a dword to a 64-bit space */
#define DWORD_XOR_LE(a) (a)
#else
#define BYTE_XOR_BE(a) (a)
#define BYTE_XOR_LE(a) ((a) ^ 1) /* read/write a byte to a 16-bit space */
#define BYTE4_XOR_BE(a) (a)
#define BYTE4_XOR_LE(a) ((a) ^ 3) /* read/write a byte to a 32-bit space */
#define WORD_XOR_BE(a) (a)
#define WORD_XOR_LE(a) ((a) ^ 2) /* read/write a word to a 32-bit space */
#define BYTE8_XOR_BE(a) (a)
#define BYTE8_XOR_LE(a) ((a) ^ 7) /* read/write a byte to a 64-bit space */
#define WORD2_XOR_BE(a) (a)
#define WORD2_XOR_LE(a) ((a) ^ 6) /* read/write a word to a 64-bit space */
#define DWORD_XOR_BE(a) (a)
#define DWORD_XOR_LE(a) ((a) ^ 4) /* read/write a dword to a 64-bit space */
#endif
/***************************************************************************
ADDRESS MAP MACROS
***************************************************************************/
/* so that "0" can be used for unneeded address maps */
#define address_map_0 NULL
/* start/end tags for the address map */
#define ADDRESS_MAP_START(_name, _space, _bits) \
const addrmap##_bits##_token address_map_##_name[] = { \
TOKEN_UINT32_PACK3(ADDRMAP_TOKEN_START, 8, _space, 8, _bits, 8),
#define ADDRESS_MAP_END \
TOKEN_UINT32_PACK1(ADDRMAP_TOKEN_END, 8) };
/* use this to declare external references to an address map */
#define ADDRESS_MAP_EXTERN(_name, _bits) \
extern const addrmap##_bits##_token address_map_##_name[]
/* global controls */
#define ADDRESS_MAP_GLOBAL_MASK(_mask) \
TOKEN_UINT64_PACK2(ADDRMAP_TOKEN_GLOBAL_MASK, 8, _mask, 32),
#define ADDRESS_MAP_UNMAP_LOW \
TOKEN_UINT32_PACK2(ADDRMAP_TOKEN_UNMAP_VALUE, 8, 0, 1),
#define ADDRESS_MAP_UNMAP_HIGH \
TOKEN_UINT32_PACK2(ADDRMAP_TOKEN_UNMAP_VALUE, 8, 1, 1),
/* importing data from other address maps */
#define AM_IMPORT_FROM(_name) \
TOKEN_UINT32_PACK1(ADDRMAP_TOKEN_INCLUDE, 8), \
TOKEN_PTR(tokenptr, address_map_##_name),
/* address ranges */
#define AM_RANGE(_start, _end) \
TOKEN_UINT32_PACK1(ADDRMAP_TOKEN_RANGE, 8), \
TOKEN_UINT64_PACK2(_start, 32, _end, 32),
#define AM_MASK(_mask) \
TOKEN_UINT64_PACK2(ADDRMAP_TOKEN_MASK, 8, _mask, 32),
#define AM_MIRROR(_mirror) \
TOKEN_UINT64_PACK2(ADDRMAP_TOKEN_MIRROR, 8, _mirror, 32),
#define AM_READ(_handler) \
TOKEN_UINT32_PACK1(ADDRMAP_TOKEN_READ, 8), \
TOKEN_PTR(mread, _handler), \
TOKEN_STRING(#_handler),
#define AM_WRITE(_handler) \
TOKEN_UINT32_PACK1(ADDRMAP_TOKEN_WRITE, 8), \
TOKEN_PTR(mwrite, _handler), \
TOKEN_STRING(#_handler),
#define AM_DEVREAD(_type, _tag, _handler) \
TOKEN_UINT32_PACK1(ADDRMAP_TOKEN_DEVICE_READ, 8), \
TOKEN_PTR(dread, _handler), \
TOKEN_STRING(#_handler), \
TOKEN_PTR(devtype, _type), \
TOKEN_STRING(_tag),
#define AM_DEVWRITE(_type, _tag, _handler) \
TOKEN_UINT32_PACK1(ADDRMAP_TOKEN_DEVICE_WRITE, 8), \
TOKEN_PTR(dwrite, _handler), \
TOKEN_STRING(#_handler), \
TOKEN_PTR(devtype, _type), \
TOKEN_STRING(_tag),
#define AM_READ_PORT(_tag) \
TOKEN_UINT32_PACK1(ADDRMAP_TOKEN_READ_PORT, 8), \
TOKEN_STRING(_tag),
#define AM_REGION(_region, _offs) \
TOKEN_UINT64_PACK3(ADDRMAP_TOKEN_REGION, 8, _region, 24, _offs, 32),
#define AM_SHARE(_index) \
TOKEN_UINT32_PACK2(ADDRMAP_TOKEN_SHARE, 8, _index, 24),
#define AM_BASE(_base) \
TOKEN_UINT32_PACK1(ADDRMAP_TOKEN_BASEPTR, 8), \
TOKEN_PTR(memptr, _base),
#define AM_BASE_MEMBER(_struct, _member) \
TOKEN_UINT32_PACK2(ADDRMAP_TOKEN_BASE_MEMBER, 8, offsetof(_struct, _member), 24),
#define AM_SIZE(_size) \
TOKEN_UINT32_PACK1(ADDRMAP_TOKEN_SIZEPTR, 8), \
TOKEN_PTR(sizeptr, _size),
#define AM_SIZE_MEMBER(_struct, _member) \
TOKEN_UINT32_PACK2(ADDRMAP_TOKEN_SIZE_MEMBER, 8, offsetof(_struct, _member), 24),
/* common shortcuts */
#define AM_READWRITE(_read,_write) AM_READ(_read) AM_WRITE(_write)
#define AM_DEVREADWRITE(_type,_tag,_read,_write) AM_DEVREAD(_type,_tag,_read) AM_DEVWRITE(_type,_tag,_write)
#define AM_ROM AM_READ(SMH_ROM)
#define AM_RAM AM_READWRITE(SMH_RAM, SMH_RAM)
#define AM_WRITEONLY AM_WRITE(SMH_RAM)
#define AM_UNMAP AM_READWRITE(SMH_UNMAP, SMH_UNMAP)
#define AM_ROMBANK(_bank) AM_READ(SMH_BANK(_bank))
#define AM_RAMBANK(_bank) AM_READWRITE(SMH_BANK(_bank), SMH_BANK(_bank))
#define AM_NOP AM_READWRITE(SMH_NOP, SMH_NOP)
#define AM_READNOP AM_READ(SMH_NOP)
#define AM_WRITENOP AM_WRITE(SMH_NOP)
/***************************************************************************
GLOBAL VARIABLES
***************************************************************************/
extern UINT8 opcode_entry; /* current entry for opcode fetching */
extern UINT8 * opcode_base; /* opcode ROM base */
extern UINT8 * opcode_arg_base; /* opcode RAM base */
extern offs_t opcode_mask; /* mask to apply to the opcode address */
extern offs_t opcode_memory_min; /* opcode memory minimum */
extern offs_t opcode_memory_max; /* opcode memory maximum */
extern address_space active_address_space[]; /* address spaces */
extern const char *const address_space_names[ADDRESS_SPACES];
/***************************************************************************
FUNCTION PROTOTYPES FOR CORE MEMORY FUNCTIONS
***************************************************************************/
/* ----- core system operations ----- */
/* initialize the memory system */
void memory_init(running_machine *machine);
/* set the current memory context */
void memory_set_context(int activecpu);
/* get a pointer to the set of memory accessor functions based on the address space,
databus width, and endianness */
const data_accessors *memory_get_accessors(int spacenum, int databits, int endianness);
/* ----- address maps ----- */
/* build and allocate an address map for a CPU's address space */
address_map *address_map_alloc(const machine_config *drv, int cpunum, int spacenum);
/* release allocated memory for an address map */
void address_map_free(address_map *map);
/* return a pointer to the constructed address map for a CPU's address space */
const address_map *memory_get_address_map(int cpunum, int spacenum);
/* ----- opcode base control ----- */
/* registers an address range as having a decrypted data pointer */
void memory_set_decrypted_region(int cpunum, offs_t addrstart, offs_t addrend, void *base);
/* register a handler for opcode base changes on a given CPU */
opbase_handler_func memory_set_opbase_handler(int cpunum, opbase_handler_func function);
/* called by CPU cores to update the opcode base for the given address */
void memory_set_opbase(offs_t byteaddress);
/* return a base pointer to memory */
void * memory_get_read_ptr(int cpunum, int spacenum, offs_t byteaddress);
void * memory_get_write_ptr(int cpunum, int spacenum, offs_t byteaddress);
void * memory_get_op_ptr(int cpunum, offs_t byteaddress, int arg);
/* memory banking */
void memory_configure_bank(int banknum, int startentry, int numentries, void *base, offs_t stride);
void memory_configure_bank_decrypted(int banknum, int startentry, int numentries, void *base, offs_t stride);
void memory_set_bank(int banknum, int entrynum);
int memory_get_bank(int banknum);
void memory_set_bankptr(int banknum, void *base);
/* debugging */
void memory_set_debugger_access(int debugger);
void memory_set_log_unmap(int spacenum, int log);
int memory_get_log_unmap(int spacenum);
/* dynamic address space mapping */
void * _memory_install_read_handler (int cpunum, int spacenum, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, FPTR handler, const char *handler_name);
UINT8 * _memory_install_read8_handler (int cpunum, int spacenum, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_machine_func handler, const char *handler_name);
UINT16 * _memory_install_read16_handler (int cpunum, int spacenum, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read16_machine_func handler, const char *handler_name);
UINT32 * _memory_install_read32_handler (int cpunum, int spacenum, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read32_machine_func handler, const char *handler_name);
UINT64 * _memory_install_read64_handler (int cpunum, int spacenum, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read64_machine_func handler, const char *handler_name);
void * _memory_install_write_handler (int cpunum, int spacenum, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, FPTR handler, const char *handler_name);
UINT8 * _memory_install_write8_handler (int cpunum, int spacenum, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, write8_machine_func handler, const char *handler_name);
UINT16 * _memory_install_write16_handler(int cpunum, int spacenum, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, write16_machine_func handler, const char *handler_name);
UINT32 * _memory_install_write32_handler(int cpunum, int spacenum, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, write32_machine_func handler, const char *handler_name);
UINT64 * _memory_install_write64_handler(int cpunum, int spacenum, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, write64_machine_func handler, const char *handler_name);
void * _memory_install_readwrite_handler (int cpunum, int spacenum, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, FPTR rhandler, FPTR whandler, const char *rhandler_name, const char *whandler_name);
UINT8 * _memory_install_readwrite8_handler (int cpunum, int spacenum, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_machine_func rhandler, write8_machine_func whandler, const char *rhandler_name, const char *whandler_name);
UINT16 * _memory_install_readwrite16_handler(int cpunum, int spacenum, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read16_machine_func rhandler, write16_machine_func whandler, const char *rhandler_name, const char *whandler_name);
UINT32 * _memory_install_readwrite32_handler(int cpunum, int spacenum, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read32_machine_func rhandler, write32_machine_func whandler, const char *rhandler_name, const char *whandler_name);
UINT64 * _memory_install_readwrite64_handler(int cpunum, int spacenum, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read64_machine_func rhandler, write64_machine_func whandler, const char *rhandler_name, const char *whandler_name);
/* memory debugging */
void memory_dump(FILE *file);
const char *memory_get_handler_string(int read0_or_write1, int cpunum, int spacenum, offs_t byteaddress);
/***************************************************************************
HELPER MACROS AND INLINES
***************************************************************************/
/* generic memory access */
INLINE UINT8 program_read_byte (offs_t byteaddress) { return (*active_address_space[ADDRESS_SPACE_PROGRAM].accessors->read_byte)(byteaddress); }
INLINE UINT16 program_read_word (offs_t byteaddress) { return (*active_address_space[ADDRESS_SPACE_PROGRAM].accessors->read_word)(byteaddress); }
INLINE UINT32 program_read_dword(offs_t byteaddress) { return (*active_address_space[ADDRESS_SPACE_PROGRAM].accessors->read_dword)(byteaddress); }
INLINE UINT64 program_read_qword(offs_t byteaddress) { return (*active_address_space[ADDRESS_SPACE_PROGRAM].accessors->read_qword)(byteaddress); }
INLINE void program_write_byte (offs_t byteaddress, UINT8 data) { (*active_address_space[ADDRESS_SPACE_PROGRAM].accessors->write_byte)(byteaddress, data); }
INLINE void program_write_word (offs_t byteaddress, UINT16 data) { (*active_address_space[ADDRESS_SPACE_PROGRAM].accessors->write_word)(byteaddress, data); }
INLINE void program_write_dword(offs_t byteaddress, UINT32 data) { (*active_address_space[ADDRESS_SPACE_PROGRAM].accessors->write_dword)(byteaddress, data); }
INLINE void program_write_qword(offs_t byteaddress, UINT64 data) { (*active_address_space[ADDRESS_SPACE_PROGRAM].accessors->write_qword)(byteaddress, data); }
INLINE UINT8 data_read_byte (offs_t byteaddress) { return (*active_address_space[ADDRESS_SPACE_DATA].accessors->read_byte)(byteaddress); }
INLINE UINT16 data_read_word (offs_t byteaddress) { return (*active_address_space[ADDRESS_SPACE_DATA].accessors->read_word)(byteaddress); }
INLINE UINT32 data_read_dword(offs_t byteaddress) { return (*active_address_space[ADDRESS_SPACE_DATA].accessors->read_dword)(byteaddress); }
INLINE UINT64 data_read_qword(offs_t byteaddress) { return (*active_address_space[ADDRESS_SPACE_DATA].accessors->read_qword)(byteaddress); }
INLINE void data_write_byte (offs_t byteaddress, UINT8 data) { (*active_address_space[ADDRESS_SPACE_DATA].accessors->write_byte)(byteaddress, data); }
INLINE void data_write_word (offs_t byteaddress, UINT16 data) { (*active_address_space[ADDRESS_SPACE_DATA].accessors->write_word)(byteaddress, data); }
INLINE void data_write_dword(offs_t byteaddress, UINT32 data) { (*active_address_space[ADDRESS_SPACE_DATA].accessors->write_dword)(byteaddress, data); }
INLINE void data_write_qword(offs_t byteaddress, UINT64 data) { (*active_address_space[ADDRESS_SPACE_DATA].accessors->write_qword)(byteaddress, data); }
INLINE UINT8 io_read_byte (offs_t byteaddress) { return (*active_address_space[ADDRESS_SPACE_IO].accessors->read_byte)(byteaddress); }
INLINE UINT16 io_read_word (offs_t byteaddress) { return (*active_address_space[ADDRESS_SPACE_IO].accessors->read_word)(byteaddress); }
INLINE UINT32 io_read_dword(offs_t byteaddress) { return (*active_address_space[ADDRESS_SPACE_IO].accessors->read_dword)(byteaddress); }
INLINE UINT64 io_read_qword(offs_t byteaddress) { return (*active_address_space[ADDRESS_SPACE_IO].accessors->read_qword)(byteaddress); }
INLINE void io_write_byte (offs_t byteaddress, UINT8 data) { (*active_address_space[ADDRESS_SPACE_IO].accessors->write_byte)(byteaddress, data); }
INLINE void io_write_word (offs_t byteaddress, UINT16 data) { (*active_address_space[ADDRESS_SPACE_IO].accessors->write_word)(byteaddress, data); }
INLINE void io_write_dword(offs_t byteaddress, UINT32 data) { (*active_address_space[ADDRESS_SPACE_IO].accessors->write_dword)(byteaddress, data); }
INLINE void io_write_qword(offs_t byteaddress, UINT64 data) { (*active_address_space[ADDRESS_SPACE_IO].accessors->write_qword)(byteaddress, data); }
/* safe opcode and opcode argument reading */
UINT8 cpu_readop_safe(offs_t byteaddress);
UINT16 cpu_readop16_safe(offs_t byteaddress);
UINT32 cpu_readop32_safe(offs_t byteaddress);
UINT64 cpu_readop64_safe(offs_t byteaddress);
UINT8 cpu_readop_arg_safe(offs_t byteaddress);
UINT16 cpu_readop_arg16_safe(offs_t byteaddress);
UINT32 cpu_readop_arg32_safe(offs_t byteaddress);
UINT64 cpu_readop_arg64_safe(offs_t byteaddress);
/* opcode and opcode argument reading */
INLINE void * cpu_opptr(offs_t byteaddress) { if (address_is_unsafe(byteaddress)) { memory_set_opbase(byteaddress); } return cpu_opptr_unsafe(byteaddress); }
INLINE UINT8 cpu_readop(offs_t byteaddress) { if (address_is_unsafe(byteaddress)) { memory_set_opbase(byteaddress); } return cpu_readop_unsafe(byteaddress); }
INLINE UINT16 cpu_readop16(offs_t byteaddress) { if (address_is_unsafe(byteaddress)) { memory_set_opbase(byteaddress); } return cpu_readop16_unsafe(byteaddress); }
INLINE UINT32 cpu_readop32(offs_t byteaddress) { if (address_is_unsafe(byteaddress)) { memory_set_opbase(byteaddress); } return cpu_readop32_unsafe(byteaddress); }
INLINE UINT64 cpu_readop64(offs_t byteaddress) { if (address_is_unsafe(byteaddress)) { memory_set_opbase(byteaddress); } return cpu_readop64_unsafe(byteaddress); }
INLINE UINT8 cpu_readop_arg(offs_t byteaddress) { if (address_is_unsafe(byteaddress)) { memory_set_opbase(byteaddress); } return cpu_readop_arg_unsafe(byteaddress); }
INLINE UINT16 cpu_readop_arg16(offs_t byteaddress) { if (address_is_unsafe(byteaddress)) { memory_set_opbase(byteaddress); } return cpu_readop_arg16_unsafe(byteaddress); }
INLINE UINT32 cpu_readop_arg32(offs_t byteaddress) { if (address_is_unsafe(byteaddress)) { memory_set_opbase(byteaddress); } return cpu_readop_arg32_unsafe(byteaddress); }
INLINE UINT64 cpu_readop_arg64(offs_t byteaddress) { if (address_is_unsafe(byteaddress)) { memory_set_opbase(byteaddress); } return cpu_readop_arg64_unsafe(byteaddress); }
/***************************************************************************
FUNCTION PROTOTYPES FOR CORE READ/WRITE ROUTINES
***************************************************************************/
/* declare program address space handlers */
UINT8 program_read_byte_8(offs_t address);
void program_write_byte_8(offs_t address, UINT8 data);
UINT8 program_read_byte_16be(offs_t address);
UINT16 program_read_word_16be(offs_t address);
void program_write_byte_16be(offs_t address, UINT8 data);
void program_write_word_16be(offs_t address, UINT16 data);
UINT8 program_read_byte_16le(offs_t address);
UINT16 program_read_word_16le(offs_t address);
void program_write_byte_16le(offs_t address, UINT8 data);
void program_write_word_16le(offs_t address, UINT16 data);
UINT8 program_read_byte_32be(offs_t address);
UINT16 program_read_word_32be(offs_t address);
UINT32 program_read_dword_32be(offs_t address);
UINT32 program_read_masked_32be(offs_t address, UINT32 mem_mask);
void program_write_byte_32be(offs_t address, UINT8 data);
void program_write_word_32be(offs_t address, UINT16 data);
void program_write_dword_32be(offs_t address, UINT32 data);
void program_write_masked_32be(offs_t address, UINT32 data, UINT32 mem_mask);
UINT8 program_read_byte_32le(offs_t address);
UINT16 program_read_word_32le(offs_t address);
UINT32 program_read_dword_32le(offs_t address);
UINT32 program_read_masked_32le(offs_t address, UINT32 mem_mask);
void program_write_byte_32le(offs_t address, UINT8 data);
void program_write_word_32le(offs_t address, UINT16 data);
void program_write_dword_32le(offs_t address, UINT32 data);
void program_write_masked_32le(offs_t address, UINT32 data, UINT32 mem_mask);
UINT8 program_read_byte_64be(offs_t address);
UINT16 program_read_word_64be(offs_t address);
UINT32 program_read_dword_64be(offs_t address);
UINT64 program_read_qword_64be(offs_t address);
UINT64 program_read_masked_64be(offs_t address, UINT64 mem_mask);
void program_write_byte_64be(offs_t address, UINT8 data);
void program_write_word_64be(offs_t address, UINT16 data);
void program_write_dword_64be(offs_t address, UINT32 data);
void program_write_qword_64be(offs_t address, UINT64 data);
void program_write_masked_64be(offs_t address, UINT64 data, UINT64 mem_mask);
UINT8 program_read_byte_64le(offs_t address);
UINT16 program_read_word_64le(offs_t address);
UINT32 program_read_dword_64le(offs_t address);
UINT64 program_read_qword_64le(offs_t address);
UINT64 program_read_masked_64le(offs_t address, UINT64 mem_mask);
void program_write_byte_64le(offs_t address, UINT8 data);
void program_write_word_64le(offs_t address, UINT16 data);
void program_write_dword_64le(offs_t address, UINT32 data);
void program_write_qword_64le(offs_t address, UINT64 data);
void program_write_masked_64le(offs_t address, UINT64 data, UINT64 mem_mask);
/* declare data address space handlers */
UINT8 data_read_byte_8(offs_t address);
void data_write_byte_8(offs_t address, UINT8 data);
UINT8 data_read_byte_16be(offs_t address);
UINT16 data_read_word_16be(offs_t address);
void data_write_byte_16be(offs_t address, UINT8 data);
void data_write_word_16be(offs_t address, UINT16 data);
UINT8 data_read_byte_16le(offs_t address);
UINT16 data_read_word_16le(offs_t address);
void data_write_byte_16le(offs_t address, UINT8 data);
void data_write_word_16le(offs_t address, UINT16 data);
UINT8 data_read_byte_32be(offs_t address);
UINT16 data_read_word_32be(offs_t address);
UINT32 data_read_dword_32be(offs_t address);
UINT32 data_read_masked_32be(offs_t address, UINT32 mem_mask);
void data_write_byte_32be(offs_t address, UINT8 data);
void data_write_word_32be(offs_t address, UINT16 data);
void data_write_dword_32be(offs_t address, UINT32 data);
void data_write_masked_32be(offs_t address, UINT32 data, UINT32 mem_mask);
UINT8 data_read_byte_32le(offs_t address);
UINT16 data_read_word_32le(offs_t address);
UINT32 data_read_dword_32le(offs_t address);
UINT32 data_read_masked_32le(offs_t address, UINT32 mem_mask);
void data_write_byte_32le(offs_t address, UINT8 data);
void data_write_word_32le(offs_t address, UINT16 data);
void data_write_dword_32le(offs_t address, UINT32 data);
void data_write_masked_32le(offs_t address, UINT32 data, UINT32 mem_mask);
UINT8 data_read_byte_64be(offs_t address);
UINT16 data_read_word_64be(offs_t address);
UINT32 data_read_dword_64be(offs_t address);
UINT64 data_read_qword_64be(offs_t address);
UINT64 data_read_masked_64be(offs_t address, UINT64 mem_mask);
void data_write_byte_64be(offs_t address, UINT8 data);
void data_write_word_64be(offs_t address, UINT16 data);
void data_write_dword_64be(offs_t address, UINT32 data);
void data_write_qword_64be(offs_t address, UINT64 data);
void data_write_masked_64be(offs_t address, UINT64 data, UINT64 mem_mask);
UINT8 data_read_byte_64le(offs_t address);
UINT16 data_read_word_64le(offs_t address);
UINT32 data_read_dword_64le(offs_t address);
UINT64 data_read_qword_64le(offs_t address);
UINT64 data_read_masked_64le(offs_t address, UINT64 mem_mask);
void data_write_byte_64le(offs_t address, UINT8 data);
void data_write_word_64le(offs_t address, UINT16 data);
void data_write_dword_64le(offs_t address, UINT32 data);
void data_write_qword_64le(offs_t address, UINT64 data);
void data_write_masked_64le(offs_t address, UINT64 data, UINT64 mem_mask);
/* declare I/O address space handlers */
UINT8 io_read_byte_8(offs_t address);
void io_write_byte_8(offs_t address, UINT8 data);
UINT8 io_read_byte_16be(offs_t address);
UINT16 io_read_word_16be(offs_t address);
void io_write_byte_16be(offs_t address, UINT8 data);
void io_write_word_16be(offs_t address, UINT16 data);
UINT8 io_read_byte_16le(offs_t address);
UINT16 io_read_word_16le(offs_t address);
void io_write_byte_16le(offs_t address, UINT8 data);
void io_write_word_16le(offs_t address, UINT16 data);
UINT8 io_read_byte_32be(offs_t address);
UINT16 io_read_word_32be(offs_t address);
UINT32 io_read_dword_32be(offs_t address);
UINT32 io_read_masked_32be(offs_t address, UINT32 mem_mask);
void io_write_byte_32be(offs_t address, UINT8 data);
void io_write_word_32be(offs_t address, UINT16 data);
void io_write_dword_32be(offs_t address, UINT32 data);
void io_write_masked_32be(offs_t address, UINT32 data, UINT32 mem_mask);
UINT8 io_read_byte_32le(offs_t address);
UINT16 io_read_word_32le(offs_t address);
UINT32 io_read_dword_32le(offs_t address);
UINT32 io_read_masked_32le(offs_t address, UINT32 mem_mask);
void io_write_byte_32le(offs_t address, UINT8 data);
void io_write_word_32le(offs_t address, UINT16 data);
void io_write_dword_32le(offs_t address, UINT32 data);
void io_write_masked_32le(offs_t address, UINT32 data, UINT32 mem_mask);
UINT8 io_read_byte_64be(offs_t address);
UINT16 io_read_word_64be(offs_t address);
UINT32 io_read_dword_64be(offs_t address);
UINT64 io_read_qword_64be(offs_t address);
UINT64 io_read_masked_64be(offs_t address, UINT64 mem_mask);
void io_write_byte_64be(offs_t address, UINT8 data);
void io_write_word_64be(offs_t address, UINT16 data);
void io_write_dword_64be(offs_t address, UINT32 data);
void io_write_qword_64be(offs_t address, UINT64 data);
void io_write_masked_64be(offs_t address, UINT64 data, UINT64 mem_mask);
UINT8 io_read_byte_64le(offs_t address);
UINT16 io_read_word_64le(offs_t address);
UINT32 io_read_dword_64le(offs_t address);
UINT64 io_read_qword_64le(offs_t address);
UINT64 io_read_masked_64le(offs_t address, UINT64 mem_mask);
void io_write_byte_64le(offs_t address, UINT8 data);
void io_write_word_64le(offs_t address, UINT16 data);
void io_write_dword_64le(offs_t address, UINT32 data);
void io_write_qword_64le(offs_t address, UINT64 data);
void io_write_masked_64le(offs_t address, UINT64 data, UINT64 mem_mask);
#endif /* __MEMORY_H__ */