diff options
Diffstat (limited to 'src/emu/memory.h')
-rw-r--r-- | src/emu/memory.h | 1166 |
1 files changed, 1166 insertions, 0 deletions
diff --git a/src/emu/memory.h b/src/emu/memory.h new file mode 100644 index 00000000000..ffe03d46136 --- /dev/null +++ b/src/emu/memory.h @@ -0,0 +1,1166 @@ +/*************************************************************************** + + memory.h + + Functions which handle the CPU memory accesses. + + Copyright (c) 1996-2007, 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" + + + +/*************************************************************************** + PARAMETERS +***************************************************************************/ + +#ifdef MAME_DEBUG +#define CPUREADOP_SAFETY_NONE 0 +#define CPUREADOP_SAFETY_PARTIAL 0 +#define CPUREADOP_SAFETY_FULL 1 +#elif defined(MESS) +#define CPUREADOP_SAFETY_NONE 0 +#define CPUREADOP_SAFETY_PARTIAL 1 +#define CPUREADOP_SAFETY_FULL 0 +#else +#define CPUREADOP_SAFETY_NONE 1 +#define CPUREADOP_SAFETY_PARTIAL 0 +#define CPUREADOP_SAFETY_FULL 0 +#endif + + + +/*************************************************************************** + BASIC TYPE DEFINITIONS +***************************************************************************/ + +/* ----- typedefs for data and offset types ----- */ +typedef UINT32 offs_t; + +/* ----- typedefs for the various common data access handlers ----- */ +typedef UINT8 (*read8_handler) (ATTR_UNUSED offs_t offset); +typedef void (*write8_handler) (ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data); +typedef UINT16 (*read16_handler) (ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask); +typedef void (*write16_handler)(ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask); +typedef UINT32 (*read32_handler) (ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask); +typedef void (*write32_handler)(ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, ATTR_UNUSED UINT32 mem_mask); +typedef UINT64 (*read64_handler) (ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 mem_mask); +typedef void (*write64_handler)(ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask); +typedef offs_t (*opbase_handler) (ATTR_UNUSED offs_t address); + +/* ----- this struct contains pointers to the live read/write routines ----- */ +struct _data_accessors +{ + UINT8 (*read_byte)(offs_t offset); + UINT16 (*read_word)(offs_t offset); + UINT32 (*read_dword)(offs_t offset); + UINT64 (*read_qword)(offs_t offset); + + void (*write_byte)(offs_t offset, UINT8 data); + void (*write_word)(offs_t offset, UINT16 data); + void (*write_dword)(offs_t offset, UINT32 data); + void (*write_qword)(offs_t offset, UINT64 data); +}; +typedef struct _data_accessors data_accessors; + + + +/*************************************************************************** + BASIC MACROS +***************************************************************************/ + +/* ----- macros for declaring the various common data access handlers ----- */ +#define READ8_HANDLER(name) UINT8 name(ATTR_UNUSED offs_t offset) +#define WRITE8_HANDLER(name) void name(ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT8 data) +#define READ16_HANDLER(name) UINT16 name(ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 mem_mask) +#define WRITE16_HANDLER(name) void name(ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT16 data, ATTR_UNUSED UINT16 mem_mask) +#define READ32_HANDLER(name) UINT32 name(ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 mem_mask) +#define WRITE32_HANDLER(name) void name(ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT32 data, ATTR_UNUSED UINT32 mem_mask) +#define READ64_HANDLER(name) UINT64 name(ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 mem_mask) +#define WRITE64_HANDLER(name) void name(ATTR_UNUSED offs_t offset, ATTR_UNUSED UINT64 data, ATTR_UNUSED UINT64 mem_mask) +#define OPBASE_HANDLER(name) offs_t name(ATTR_UNUSED offs_t address) + +/* ----- 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 ARRAY CONSTANTS +**************************************************************************** + These apply to values in the array of read/write handlers that is + declared within each driver. +***************************************************************************/ + +/* ----- definitions for the flags in the address maps ----- */ +#define AM_FLAGS_EXTENDED 0x01 /* this is an extended entry with the below flags in the start field */ +#define AM_FLAGS_MATCH_MASK 0x02 /* this entry should have the start/end pair treated as a match/mask pair */ +#define AM_FLAGS_END 0x04 /* this is the terminating entry in the array */ + +/* ----- definitions for the extended flags in the address maps ----- */ +#define AMEF_SPECIFIES_SPACE 0x00000001 /* set if the address space is specified */ +#define AMEF_SPECIFIES_ABITS 0x00000002 /* set if the number of address space bits is specified */ +#define AMEF_SPECIFIES_DBITS 0x00000004 /* set if the databus width is specified */ +#define AMEF_SPECIFIES_UNMAP 0x00000008 /* set if the unmap value is specified */ + +/* ----- definitions for specifying the address space in the extended flags ----- */ +#define AMEF_SPACE_SHIFT 8 /* shift to get at the address space */ +#define AMEF_SPACE_MASK (0x0f << AMEF_SPACE_SHIFT) /* mask to get at the address space */ +#define AMEF_SPACE(x) (((x) << AMEF_SPACE_SHIFT) | AMEF_SPECIFIES_SPACE) /* specifies a given address space */ + +/* ----- definitions for specifying the address bus width in the extended flags ----- */ +#define AMEF_ABITS_SHIFT 12 /* shift to get the address bits count */ +#define AMEF_ABITS_MASK (0x3f << AMEF_ABITS_SHIFT) /* mask to get at the address bits count */ +#define AMEF_ABITS(n) (((n) << AMEF_ABITS_SHIFT) | AMEF_SPECIFIES_ABITS) /* specifies a given number of address */ + +/* ----- definitions for specifying the data bus width in the extended flags ----- */ +#define AMEF_DBITS_SHIFT 18 /* shift to get the data bits count */ +#define AMEF_DBITS_MASK (0x07 << AMEF_DBITS_SHIFT) /* mask to get at the data bits count */ +#define AMEF_DBITS(n) ((((n)/8-1) << AMEF_DBITS_SHIFT) | AMEF_SPECIFIES_DBITS) /* specifies a given data bus width */ + +/* ----- definitions for specifying the unmap value in the extended flags ----- */ +#define AMEF_UNMAP_SHIFT 21 /* shift to get the unmap value */ +#define AMEF_UNMAP_MASK (1 << AMEF_UNMAP_SHIFT) /* mask to get at the unmap value */ +#define AMEF_UNMAP(x) (((x) << AMEF_UNMAP_SHIFT) | AMEF_SPECIFIES_UNMAP) /* specifies a given unmap value */ + +/* ----- static data access handler constants ----- */ +#define STATIC_INVALID 0 /* invalid - should never be used */ +#define STATIC_BANK1 1 /* banked memory #1 */ +#define STATIC_BANK2 2 /* banked memory #2 */ +#define STATIC_BANK3 3 /* banked memory #3 */ +#define STATIC_BANK4 4 /* banked memory #4 */ +#define STATIC_BANK5 5 /* banked memory #5 */ +#define STATIC_BANK6 6 /* banked memory #6 */ +#define STATIC_BANK7 7 /* banked memory #7 */ +#define STATIC_BANK8 8 /* banked memory #8 */ +#define STATIC_BANK9 9 /* banked memory #9 */ +#define STATIC_BANK10 10 /* banked memory #10 */ +#define STATIC_BANK11 11 /* banked memory #11 */ +#define STATIC_BANK12 12 /* banked memory #12 */ +#define STATIC_BANK13 13 /* banked memory #13 */ +#define STATIC_BANK14 14 /* banked memory #14 */ +#define STATIC_BANK15 15 /* banked memory #15 */ +#define STATIC_BANK16 16 /* banked memory #16 */ +#define STATIC_BANK17 17 /* banked memory #17 */ +#define STATIC_BANK18 18 /* banked memory #18 */ +#define STATIC_BANK19 19 /* banked memory #19 */ +#define STATIC_BANK20 20 /* banked memory #20 */ +#define STATIC_BANK21 21 /* banked memory #21 */ +#define STATIC_BANK22 22 /* banked memory #22 */ +#define STATIC_BANK23 23 /* banked memory #23 */ +#define STATIC_BANK24 24 /* banked memory #24 */ +#define STATIC_BANK25 25 /* banked memory #25 */ +#define STATIC_BANK26 26 /* banked memory #26 */ +#define STATIC_BANK27 27 /* banked memory #27 */ +#define STATIC_BANK28 28 /* banked memory #28 */ +#define STATIC_BANK29 29 /* banked memory #29 */ +#define STATIC_BANK30 30 /* banked memory #30 */ +#define STATIC_BANK31 31 /* banked memory #31 */ +#define STATIC_BANK32 32 /* banked memory #32 */ +/* entries 33-67 are reserved for dynamically allocated internal banks */ +#define STATIC_RAM 68 /* RAM - standard reads/writes */ +#define STATIC_ROM 69 /* ROM - standard reads, no writes */ +#define STATIC_NOP 70 /* unmapped - all unmapped memory goes here */ +#define STATIC_UNMAP 71 /* unmapped - all unmapped memory goes here */ +#define STATIC_COUNT 72 /* total number of static handlers */ + +/* ----- banking constants ----- */ +#define MAX_BANKS 66 /* maximum number of banks */ +#define MAX_BANK_ENTRIES 256 /* maximum number of possible bank values */ +#define MAX_EXPLICIT_BANKS 32 /* maximum number of explicitly-defined banks */ +#define STATIC_BANKMAX (STATIC_RAM - 1) /* handler constant of last bank */ + + + +/*************************************************************************** + STATIC ENTRY CONSTANTS +**************************************************************************** + The first 32 entries in the address lookup table are reserved for + "static" handlers. These are internal handlers for RAM, ROM, banks, + and unmapped areas in the address space. The following definitions + are the properly-casted versions of the STATIC_ constants above. +***************************************************************************/ + +/* 8-bit reads */ +#define MRA8_BANK1 ((read8_handler)STATIC_BANK1) +#define MRA8_BANK2 ((read8_handler)STATIC_BANK2) +#define MRA8_BANK3 ((read8_handler)STATIC_BANK3) +#define MRA8_BANK4 ((read8_handler)STATIC_BANK4) +#define MRA8_BANK5 ((read8_handler)STATIC_BANK5) +#define MRA8_BANK6 ((read8_handler)STATIC_BANK6) +#define MRA8_BANK7 ((read8_handler)STATIC_BANK7) +#define MRA8_BANK8 ((read8_handler)STATIC_BANK8) +#define MRA8_BANK9 ((read8_handler)STATIC_BANK9) +#define MRA8_BANK10 ((read8_handler)STATIC_BANK10) +#define MRA8_BANK11 ((read8_handler)STATIC_BANK11) +#define MRA8_BANK12 ((read8_handler)STATIC_BANK12) +#define MRA8_BANK13 ((read8_handler)STATIC_BANK13) +#define MRA8_BANK14 ((read8_handler)STATIC_BANK14) +#define MRA8_BANK15 ((read8_handler)STATIC_BANK15) +#define MRA8_BANK16 ((read8_handler)STATIC_BANK16) +#define MRA8_BANK17 ((read8_handler)STATIC_BANK17) +#define MRA8_BANK18 ((read8_handler)STATIC_BANK18) +#define MRA8_BANK19 ((read8_handler)STATIC_BANK19) +#define MRA8_BANK20 ((read8_handler)STATIC_BANK20) +#define MRA8_BANK21 ((read8_handler)STATIC_BANK21) +#define MRA8_BANK22 ((read8_handler)STATIC_BANK22) +#define MRA8_BANK23 ((read8_handler)STATIC_BANK23) +#define MRA8_BANK24 ((read8_handler)STATIC_BANK24) +#define MRA8_BANK25 ((read8_handler)STATIC_BANK25) +#define MRA8_BANK26 ((read8_handler)STATIC_BANK26) +#define MRA8_BANK27 ((read8_handler)STATIC_BANK27) +#define MRA8_BANK28 ((read8_handler)STATIC_BANK28) +#define MRA8_BANK29 ((read8_handler)STATIC_BANK29) +#define MRA8_BANK30 ((read8_handler)STATIC_BANK30) +#define MRA8_BANK31 ((read8_handler)STATIC_BANK31) +#define MRA8_BANK32 ((read8_handler)STATIC_BANK32) +#define MRA8_RAM ((read8_handler)STATIC_RAM) +#define MRA8_ROM ((read8_handler)STATIC_ROM) +#define MRA8_NOP ((read8_handler)STATIC_NOP) +#define MRA8_UNMAP ((read8_handler)STATIC_UNMAP) + +/* 8-bit writes */ +#define MWA8_BANK1 ((write8_handler)STATIC_BANK1) +#define MWA8_BANK2 ((write8_handler)STATIC_BANK2) +#define MWA8_BANK3 ((write8_handler)STATIC_BANK3) +#define MWA8_BANK4 ((write8_handler)STATIC_BANK4) +#define MWA8_BANK5 ((write8_handler)STATIC_BANK5) +#define MWA8_BANK6 ((write8_handler)STATIC_BANK6) +#define MWA8_BANK7 ((write8_handler)STATIC_BANK7) +#define MWA8_BANK8 ((write8_handler)STATIC_BANK8) +#define MWA8_BANK9 ((write8_handler)STATIC_BANK9) +#define MWA8_BANK10 ((write8_handler)STATIC_BANK10) +#define MWA8_BANK11 ((write8_handler)STATIC_BANK11) +#define MWA8_BANK12 ((write8_handler)STATIC_BANK12) +#define MWA8_BANK13 ((write8_handler)STATIC_BANK13) +#define MWA8_BANK14 ((write8_handler)STATIC_BANK14) +#define MWA8_BANK15 ((write8_handler)STATIC_BANK15) +#define MWA8_BANK16 ((write8_handler)STATIC_BANK16) +#define MWA8_BANK17 ((write8_handler)STATIC_BANK17) +#define MWA8_BANK18 ((write8_handler)STATIC_BANK18) +#define MWA8_BANK19 ((write8_handler)STATIC_BANK19) +#define MWA8_BANK20 ((write8_handler)STATIC_BANK20) +#define MWA8_BANK21 ((write8_handler)STATIC_BANK21) +#define MWA8_BANK22 ((write8_handler)STATIC_BANK22) +#define MWA8_BANK23 ((write8_handler)STATIC_BANK23) +#define MWA8_BANK24 ((write8_handler)STATIC_BANK24) +#define MWA8_BANK25 ((write8_handler)STATIC_BANK25) +#define MWA8_BANK26 ((write8_handler)STATIC_BANK26) +#define MWA8_BANK27 ((write8_handler)STATIC_BANK27) +#define MWA8_BANK28 ((write8_handler)STATIC_BANK28) +#define MWA8_BANK29 ((write8_handler)STATIC_BANK29) +#define MWA8_BANK30 ((write8_handler)STATIC_BANK30) +#define MWA8_BANK31 ((write8_handler)STATIC_BANK31) +#define MWA8_BANK32 ((write8_handler)STATIC_BANK32) +#define MWA8_RAM ((write8_handler)STATIC_RAM) +#define MWA8_ROM ((write8_handler)STATIC_ROM) +#define MWA8_NOP ((write8_handler)STATIC_NOP) +#define MWA8_UNMAP ((write8_handler)STATIC_UNMAP) + +/* 16-bit reads */ +#define MRA16_BANK1 ((read16_handler)STATIC_BANK1) +#define MRA16_BANK2 ((read16_handler)STATIC_BANK2) +#define MRA16_BANK3 ((read16_handler)STATIC_BANK3) +#define MRA16_BANK4 ((read16_handler)STATIC_BANK4) +#define MRA16_BANK5 ((read16_handler)STATIC_BANK5) +#define MRA16_BANK6 ((read16_handler)STATIC_BANK6) +#define MRA16_BANK7 ((read16_handler)STATIC_BANK7) +#define MRA16_BANK8 ((read16_handler)STATIC_BANK8) +#define MRA16_BANK9 ((read16_handler)STATIC_BANK9) +#define MRA16_BANK10 ((read16_handler)STATIC_BANK10) +#define MRA16_BANK11 ((read16_handler)STATIC_BANK11) +#define MRA16_BANK12 ((read16_handler)STATIC_BANK12) +#define MRA16_BANK13 ((read16_handler)STATIC_BANK13) +#define MRA16_BANK14 ((read16_handler)STATIC_BANK14) +#define MRA16_BANK15 ((read16_handler)STATIC_BANK15) +#define MRA16_BANK16 ((read16_handler)STATIC_BANK16) +#define MRA16_BANK17 ((read16_handler)STATIC_BANK17) +#define MRA16_BANK18 ((read16_handler)STATIC_BANK18) +#define MRA16_BANK19 ((read16_handler)STATIC_BANK19) +#define MRA16_BANK20 ((read16_handler)STATIC_BANK20) +#define MRA16_BANK21 ((read16_handler)STATIC_BANK21) +#define MRA16_BANK22 ((read16_handler)STATIC_BANK22) +#define MRA16_BANK23 ((read16_handler)STATIC_BANK23) +#define MRA16_BANK24 ((read16_handler)STATIC_BANK24) +#define MRA16_BANK25 ((read16_handler)STATIC_BANK25) +#define MRA16_BANK26 ((read16_handler)STATIC_BANK26) +#define MRA16_BANK27 ((read16_handler)STATIC_BANK27) +#define MRA16_BANK28 ((read16_handler)STATIC_BANK28) +#define MRA16_BANK29 ((read16_handler)STATIC_BANK29) +#define MRA16_BANK30 ((read16_handler)STATIC_BANK30) +#define MRA16_BANK31 ((read16_handler)STATIC_BANK31) +#define MRA16_BANK32 ((read16_handler)STATIC_BANK32) +#define MRA16_RAM ((read16_handler)STATIC_RAM) +#define MRA16_ROM ((read16_handler)STATIC_ROM) +#define MRA16_NOP ((read16_handler)STATIC_NOP) +#define MRA16_UNMAP ((read16_handler)STATIC_UNMAP) + +/* 16-bit writes */ +#define MWA16_BANK1 ((write16_handler)STATIC_BANK1) +#define MWA16_BANK2 ((write16_handler)STATIC_BANK2) +#define MWA16_BANK3 ((write16_handler)STATIC_BANK3) +#define MWA16_BANK4 ((write16_handler)STATIC_BANK4) +#define MWA16_BANK5 ((write16_handler)STATIC_BANK5) +#define MWA16_BANK6 ((write16_handler)STATIC_BANK6) +#define MWA16_BANK7 ((write16_handler)STATIC_BANK7) +#define MWA16_BANK8 ((write16_handler)STATIC_BANK8) +#define MWA16_BANK9 ((write16_handler)STATIC_BANK9) +#define MWA16_BANK10 ((write16_handler)STATIC_BANK10) +#define MWA16_BANK11 ((write16_handler)STATIC_BANK11) +#define MWA16_BANK12 ((write16_handler)STATIC_BANK12) +#define MWA16_BANK13 ((write16_handler)STATIC_BANK13) +#define MWA16_BANK14 ((write16_handler)STATIC_BANK14) +#define MWA16_BANK15 ((write16_handler)STATIC_BANK15) +#define MWA16_BANK16 ((write16_handler)STATIC_BANK16) +#define MWA16_BANK17 ((write16_handler)STATIC_BANK17) +#define MWA16_BANK18 ((write16_handler)STATIC_BANK18) +#define MWA16_BANK19 ((write16_handler)STATIC_BANK19) +#define MWA16_BANK20 ((write16_handler)STATIC_BANK20) +#define MWA16_BANK21 ((write16_handler)STATIC_BANK21) +#define MWA16_BANK22 ((write16_handler)STATIC_BANK22) +#define MWA16_BANK23 ((write16_handler)STATIC_BANK23) +#define MWA16_BANK24 ((write16_handler)STATIC_BANK24) +#define MWA16_BANK25 ((write16_handler)STATIC_BANK25) +#define MWA16_BANK26 ((write16_handler)STATIC_BANK26) +#define MWA16_BANK27 ((write16_handler)STATIC_BANK27) +#define MWA16_BANK28 ((write16_handler)STATIC_BANK28) +#define MWA16_BANK29 ((write16_handler)STATIC_BANK29) +#define MWA16_BANK30 ((write16_handler)STATIC_BANK30) +#define MWA16_BANK31 ((write16_handler)STATIC_BANK31) +#define MWA16_BANK32 ((write16_handler)STATIC_BANK32) +#define MWA16_RAM ((write16_handler)STATIC_RAM) +#define MWA16_ROM ((write16_handler)STATIC_ROM) +#define MWA16_NOP ((write16_handler)STATIC_NOP) +#define MWA16_UNMAP ((write16_handler)STATIC_UNMAP) + +/* 32-bit reads */ +#define MRA32_BANK1 ((read32_handler)STATIC_BANK1) +#define MRA32_BANK2 ((read32_handler)STATIC_BANK2) +#define MRA32_BANK3 ((read32_handler)STATIC_BANK3) +#define MRA32_BANK4 ((read32_handler)STATIC_BANK4) +#define MRA32_BANK5 ((read32_handler)STATIC_BANK5) +#define MRA32_BANK6 ((read32_handler)STATIC_BANK6) +#define MRA32_BANK7 ((read32_handler)STATIC_BANK7) +#define MRA32_BANK8 ((read32_handler)STATIC_BANK8) +#define MRA32_BANK9 ((read32_handler)STATIC_BANK9) +#define MRA32_BANK10 ((read32_handler)STATIC_BANK10) +#define MRA32_BANK11 ((read32_handler)STATIC_BANK11) +#define MRA32_BANK12 ((read32_handler)STATIC_BANK12) +#define MRA32_BANK13 ((read32_handler)STATIC_BANK13) +#define MRA32_BANK14 ((read32_handler)STATIC_BANK14) +#define MRA32_BANK15 ((read32_handler)STATIC_BANK15) +#define MRA32_BANK16 ((read32_handler)STATIC_BANK16) +#define MRA32_BANK17 ((read32_handler)STATIC_BANK17) +#define MRA32_BANK18 ((read32_handler)STATIC_BANK18) +#define MRA32_BANK19 ((read32_handler)STATIC_BANK19) +#define MRA32_BANK20 ((read32_handler)STATIC_BANK20) +#define MRA32_BANK21 ((read32_handler)STATIC_BANK21) +#define MRA32_BANK22 ((read32_handler)STATIC_BANK22) +#define MRA32_BANK23 ((read32_handler)STATIC_BANK23) +#define MRA32_BANK24 ((read32_handler)STATIC_BANK24) +#define MRA32_BANK25 ((read32_handler)STATIC_BANK25) +#define MRA32_BANK26 ((read32_handler)STATIC_BANK26) +#define MRA32_BANK27 ((read32_handler)STATIC_BANK27) +#define MRA32_BANK28 ((read32_handler)STATIC_BANK28) +#define MRA32_BANK29 ((read32_handler)STATIC_BANK29) +#define MRA32_BANK30 ((read32_handler)STATIC_BANK30) +#define MRA32_BANK31 ((read32_handler)STATIC_BANK31) +#define MRA32_BANK32 ((read32_handler)STATIC_BANK32) +#define MRA32_RAM ((read32_handler)STATIC_RAM) +#define MRA32_ROM ((read32_handler)STATIC_ROM) +#define MRA32_NOP ((read32_handler)STATIC_NOP) +#define MRA32_UNMAP ((read32_handler)STATIC_UNMAP) + +/* 32-bit writes */ +#define MWA32_BANK1 ((write32_handler)STATIC_BANK1) +#define MWA32_BANK2 ((write32_handler)STATIC_BANK2) +#define MWA32_BANK3 ((write32_handler)STATIC_BANK3) +#define MWA32_BANK4 ((write32_handler)STATIC_BANK4) +#define MWA32_BANK5 ((write32_handler)STATIC_BANK5) +#define MWA32_BANK6 ((write32_handler)STATIC_BANK6) +#define MWA32_BANK7 ((write32_handler)STATIC_BANK7) +#define MWA32_BANK8 ((write32_handler)STATIC_BANK8) +#define MWA32_BANK9 ((write32_handler)STATIC_BANK9) +#define MWA32_BANK10 ((write32_handler)STATIC_BANK10) +#define MWA32_BANK11 ((write32_handler)STATIC_BANK11) +#define MWA32_BANK12 ((write32_handler)STATIC_BANK12) +#define MWA32_BANK13 ((write32_handler)STATIC_BANK13) +#define MWA32_BANK14 ((write32_handler)STATIC_BANK14) +#define MWA32_BANK15 ((write32_handler)STATIC_BANK15) +#define MWA32_BANK16 ((write32_handler)STATIC_BANK16) +#define MWA32_BANK17 ((write32_handler)STATIC_BANK17) +#define MWA32_BANK18 ((write32_handler)STATIC_BANK18) +#define MWA32_BANK19 ((write32_handler)STATIC_BANK19) +#define MWA32_BANK20 ((write32_handler)STATIC_BANK20) +#define MWA32_BANK21 ((write32_handler)STATIC_BANK21) +#define MWA32_BANK22 ((write32_handler)STATIC_BANK22) +#define MWA32_BANK23 ((write32_handler)STATIC_BANK23) +#define MWA32_BANK24 ((write32_handler)STATIC_BANK24) +#define MWA32_BANK25 ((write32_handler)STATIC_BANK25) +#define MWA32_BANK26 ((write32_handler)STATIC_BANK26) +#define MWA32_BANK27 ((write32_handler)STATIC_BANK27) +#define MWA32_BANK28 ((write32_handler)STATIC_BANK28) +#define MWA32_BANK29 ((write32_handler)STATIC_BANK29) +#define MWA32_BANK30 ((write32_handler)STATIC_BANK30) +#define MWA32_BANK31 ((write32_handler)STATIC_BANK31) +#define MWA32_BANK32 ((write32_handler)STATIC_BANK32) +#define MWA32_RAM ((write32_handler)STATIC_RAM) +#define MWA32_ROM ((write32_handler)STATIC_ROM) +#define MWA32_NOP ((write32_handler)STATIC_NOP) +#define MWA32_UNMAP ((write32_handler)STATIC_UNMAP) + +/* 64-bit reads */ +#define MRA64_BANK1 ((read64_handler)STATIC_BANK1) +#define MRA64_BANK2 ((read64_handler)STATIC_BANK2) +#define MRA64_BANK3 ((read64_handler)STATIC_BANK3) +#define MRA64_BANK4 ((read64_handler)STATIC_BANK4) +#define MRA64_BANK5 ((read64_handler)STATIC_BANK5) +#define MRA64_BANK6 ((read64_handler)STATIC_BANK6) +#define MRA64_BANK7 ((read64_handler)STATIC_BANK7) +#define MRA64_BANK8 ((read64_handler)STATIC_BANK8) +#define MRA64_BANK9 ((read64_handler)STATIC_BANK9) +#define MRA64_BANK10 ((read64_handler)STATIC_BANK10) +#define MRA64_BANK11 ((read64_handler)STATIC_BANK11) +#define MRA64_BANK12 ((read64_handler)STATIC_BANK12) +#define MRA64_BANK13 ((read64_handler)STATIC_BANK13) +#define MRA64_BANK14 ((read64_handler)STATIC_BANK14) +#define MRA64_BANK15 ((read64_handler)STATIC_BANK15) +#define MRA64_BANK16 ((read64_handler)STATIC_BANK16) +#define MRA64_BANK17 ((read64_handler)STATIC_BANK17) +#define MRA64_BANK18 ((read64_handler)STATIC_BANK18) +#define MRA64_BANK19 ((read64_handler)STATIC_BANK19) +#define MRA64_BANK20 ((read64_handler)STATIC_BANK20) +#define MRA64_BANK21 ((read64_handler)STATIC_BANK21) +#define MRA64_BANK22 ((read64_handler)STATIC_BANK22) +#define MRA64_BANK23 ((read64_handler)STATIC_BANK23) +#define MRA64_BANK24 ((read64_handler)STATIC_BANK24) +#define MRA64_BANK25 ((read64_handler)STATIC_BANK25) +#define MRA64_BANK26 ((read64_handler)STATIC_BANK26) +#define MRA64_BANK27 ((read64_handler)STATIC_BANK27) +#define MRA64_BANK28 ((read64_handler)STATIC_BANK28) +#define MRA64_BANK29 ((read64_handler)STATIC_BANK29) +#define MRA64_BANK30 ((read64_handler)STATIC_BANK30) +#define MRA64_BANK31 ((read64_handler)STATIC_BANK31) +#define MRA64_BANK32 ((read64_handler)STATIC_BANK32) +#define MRA64_RAM ((read64_handler)STATIC_RAM) +#define MRA64_ROM ((read64_handler)STATIC_ROM) +#define MRA64_NOP ((read64_handler)STATIC_NOP) +#define MRA64_UNMAP ((read64_handler)STATIC_UNMAP) + +/* 64-bit writes */ +#define MWA64_BANK1 ((write64_handler)STATIC_BANK1) +#define MWA64_BANK2 ((write64_handler)STATIC_BANK2) +#define MWA64_BANK3 ((write64_handler)STATIC_BANK3) +#define MWA64_BANK4 ((write64_handler)STATIC_BANK4) +#define MWA64_BANK5 ((write64_handler)STATIC_BANK5) +#define MWA64_BANK6 ((write64_handler)STATIC_BANK6) +#define MWA64_BANK7 ((write64_handler)STATIC_BANK7) +#define MWA64_BANK8 ((write64_handler)STATIC_BANK8) +#define MWA64_BANK9 ((write64_handler)STATIC_BANK9) +#define MWA64_BANK10 ((write64_handler)STATIC_BANK10) +#define MWA64_BANK11 ((write64_handler)STATIC_BANK11) +#define MWA64_BANK12 ((write64_handler)STATIC_BANK12) +#define MWA64_BANK13 ((write64_handler)STATIC_BANK13) +#define MWA64_BANK14 ((write64_handler)STATIC_BANK14) +#define MWA64_BANK15 ((write64_handler)STATIC_BANK15) +#define MWA64_BANK16 ((write64_handler)STATIC_BANK16) +#define MWA64_BANK17 ((write64_handler)STATIC_BANK17) +#define MWA64_BANK18 ((write64_handler)STATIC_BANK18) +#define MWA64_BANK19 ((write64_handler)STATIC_BANK19) +#define MWA64_BANK20 ((write64_handler)STATIC_BANK20) +#define MWA64_BANK21 ((write64_handler)STATIC_BANK21) +#define MWA64_BANK22 ((write64_handler)STATIC_BANK22) +#define MWA64_BANK23 ((write64_handler)STATIC_BANK23) +#define MWA64_BANK24 ((write64_handler)STATIC_BANK24) +#define MWA64_BANK25 ((write64_handler)STATIC_BANK25) +#define MWA64_BANK26 ((write64_handler)STATIC_BANK26) +#define MWA64_BANK27 ((write64_handler)STATIC_BANK27) +#define MWA64_BANK28 ((write64_handler)STATIC_BANK28) +#define MWA64_BANK29 ((write64_handler)STATIC_BANK29) +#define MWA64_BANK30 ((write64_handler)STATIC_BANK30) +#define MWA64_BANK31 ((write64_handler)STATIC_BANK31) +#define MWA64_BANK32 ((write64_handler)STATIC_BANK32) +#define MWA64_RAM ((write64_handler)STATIC_RAM) +#define MWA64_ROM ((write64_handler)STATIC_ROM) +#define MWA64_NOP ((write64_handler)STATIC_NOP) +#define MWA64_UNMAP ((write64_handler)STATIC_UNMAP) + + + +/*************************************************************************** + ADDRESS SPACE ARRAY TYPE DEFINITIONS +**************************************************************************** + Note that the data access handlers are not passed the actual address + where the operation takes place, but the offset from the beginning + of the block they are assigned to. This makes handling of mirror + addresses easier, and makes the handlers a bit more "object oriented". + If you handler needs to read/write the main memory area, provide a + "base" pointer: it will be initialized by the main engine to point to + the beginning of the memory block assigned to the handler. You may + also provide a pointer to "size": it will be set to the length of + the memory area processed by the handler. +***************************************************************************/ + +typedef struct _handler_data handler_data; + +/* ----- a union of all the different read handler types ----- */ +typedef union _read_handlers read_handlers; +union _read_handlers +{ + genf * handler; + read8_handler handler8; + read16_handler handler16; + read32_handler handler32; + read64_handler handler64; +}; + +/* ----- a union of all the different write handler types ----- */ +typedef union _write_handlers write_handlers; +union _write_handlers +{ + genf * handler; + write8_handler handler8; + write16_handler handler16; + write32_handler handler32; + write64_handler handler64; +}; + +/* ----- a generic address map type ----- */ +typedef struct _address_map address_map; +struct _address_map +{ + UINT32 flags; /* flags and additional info about this entry */ + offs_t start, end; /* start/end (or mask/match) values */ + offs_t mirror; /* mirror bits */ + offs_t mask; /* mask bits */ + read_handlers read; /* read handler callback */ + const char * read_name; /* read handler callback name */ + write_handlers write; /* write handler callback */ + const char * write_name; /* write handler callback name */ + void * memory; /* pointer to memory backing this entry */ + UINT32 share; /* index of a shared memory block */ + void ** base; /* receives pointer to memory (optional) */ + size_t * size; /* receives size of area in bytes (optional) */ + UINT32 region; /* region containing the memory backing this entry */ + offs_t region_offs; /* offset within the region */ +}; + +/* ----- structs to contain internal data ----- */ +typedef struct _address_space address_space; +struct _address_space +{ + offs_t addrmask; /* address mask */ + UINT8 * readlookup; /* read table lookup */ + UINT8 * writelookup; /* write table lookup */ + handler_data * readhandlers; /* read handlers */ + handler_data * writehandlers; /* write handlers */ + data_accessors * accessors; /* pointers to the data access handlers */ +}; + + + +/*************************************************************************** + ADDRESS MAP ARRAY CONSTRUCTORS +***************************************************************************/ + +void construct_address_map(address_map *map, const machine_config *drv, int cpunum, int spacenum); + +/* ----- a typedef for pointers to these functions ----- */ +typedef address_map *(*construct_map_t)(address_map *map); + +/* use this to declare external references to a machine driver */ +#define ADDRESS_MAP_EXTERN(_name) \ +address_map *construct_map_##_name(address_map *map) \ + +/* ----- macros for starting, ending, and setting map flags ----- */ +#define ADDRESS_MAP_START(_name,_space,_bits) \ +address_map *construct_map_##_name(address_map *map) \ +{ \ + extern read##_bits##_handler port_tag_to_handler##_bits(const char *); \ + typedef read##_bits##_handler _rh_t; \ + typedef write##_bits##_handler _wh_t; \ + _rh_t read; \ + _wh_t write; \ + _rh_t (*port_tag_to_handler)(const char *) = port_tag_to_handler##_bits; \ + UINT##_bits **base; \ + \ + (void)read; (void)write; (void)base; \ + (void)port_tag_to_handler; \ + map->flags = AM_FLAGS_EXTENDED; \ + map->start = AMEF_DBITS(_bits) | AMEF_SPACE(_space); \ + +#define ADDRESS_MAP_FLAGS(_flags) \ + map++; \ + map->flags = AM_FLAGS_EXTENDED; \ + map->start = (_flags); \ + +#define ADDRESS_MAP_END \ + map++; \ + map->flags = AM_FLAGS_END; \ + return map; \ +} \ + +/* ----- each map entry begins with one of these ----- */ +#define AM_RANGE(_start,_end) \ + map++; \ + map->flags = 0; \ + map->start = (_start); \ + map->end = (_end); \ + +#define AM_SPACE(_match,_mask) \ + map++; \ + map->flags = AM_FLAGS_MATCH_MASK; \ + map->start = (_match); \ + map->end = (_mask); \ + +/* ----- these are optional entries after each map entry ----- */ +#define AM_MASK(_mask) \ + map->mask = (_mask); \ + +#define AM_MIRROR(_mirror) \ + map->mirror = (_mirror); \ + +#define AM_READ(_handler) \ + map->read.handler = (genf *)(read = _handler); \ + map->read_name = #_handler; \ + +#define AM_READ_PORT(_tag) \ + AM_READ((*port_tag_to_handler)(_tag)) + +#define AM_WRITE(_handler) \ + map->write.handler = (genf *)(write = _handler); \ + map->write_name = #_handler; \ + +#define AM_REGION(_region, _offs) \ + map->region = (_region); \ + map->region_offs = (_offs); \ + +#define AM_SHARE(_index) \ + map->share = _index; \ + +#define AM_BASE(_base) \ + map->base = (void **)(base = _base); \ + +#define AM_BASE_MEMBER(_struct, _member) \ + if (Machine != NULL && Machine->driver_data != NULL) \ + map->base = (void **)(base = &((_struct *)Machine->driver_data)->_member);\ + +#define AM_SIZE(_size) \ + map->size = _size; \ + +#define AM_SIZE_MEMBER(_struct, _member) \ + if (Machine != NULL && Machine->driver_data != NULL) \ + map->size = &((_struct *)Machine->driver_data)->(_member); \ + +/* ----- common shortcuts ----- */ +#define AM_READWRITE(_read,_write) AM_READ(_read) AM_WRITE(_write) +#define AM_ROM AM_READ((_rh_t)STATIC_ROM) +#define AM_RAM AM_READWRITE((_rh_t)STATIC_RAM, (_wh_t)STATIC_RAM) +#define AM_UNMAP AM_READWRITE((_rh_t)STATIC_UNMAP, (_wh_t)STATIC_UNMAP) +#define AM_ROMBANK(_bank) AM_READ((_rh_t)(STATIC_BANK1 + (_bank) - 1)) +#define AM_RAMBANK(_bank) AM_READWRITE((_rh_t)(STATIC_BANK1 + (_bank) - 1), (_wh_t)(STATIC_BANK1 + (_bank) - 1)) +#define AM_NOP AM_READWRITE((_rh_t)STATIC_NOP, (_wh_t)STATIC_NOP) +#define AM_READNOP AM_READ((_rh_t)STATIC_NOP) +#define AM_WRITENOP AM_WRITE((_wh_t)STATIC_NOP) + + + +/*************************************************************************** + ADDRESS MAP ARRAY HELPER MACROS +***************************************************************************/ + +/* ----- macros for identifying address map struct markers ----- */ +#define IS_AMENTRY_EXTENDED(ma) (((ma)->flags & AM_FLAGS_EXTENDED) != 0) +#define IS_AMENTRY_MATCH_MASK(ma) (((ma)->flags & AM_FLAGS_MATCH_MASK) != 0) +#define IS_AMENTRY_END(ma) (((ma)->flags & AM_FLAGS_END) != 0) + +#define AM_EXTENDED_FLAGS(ma) ((ma)->start) + + + +/*************************************************************************** + ADDRESS MAP LOOKUP CONSTANTS +***************************************************************************/ + +/* ----- address spaces ----- */ +#define ADDRESS_SPACES 3 /* maximum number of address spaces */ +#define ADDRESS_SPACE_PROGRAM 0 /* program address space */ +#define ADDRESS_SPACE_DATA 1 /* data address space */ +#define ADDRESS_SPACE_IO 2 /* I/O address space */ + +extern const char *address_space_names[ADDRESS_SPACES]; + +/* ----- address map lookup table definitions ----- */ +#define SUBTABLE_COUNT 64 /* number of slots reserved for subtables */ +#define SUBTABLE_BASE (256-SUBTABLE_COUNT) /* first index of a subtable */ +#define ENTRY_COUNT (SUBTABLE_BASE) /* number of legitimate (non-subtable) entries */ +#define SUBTABLE_ALLOC 8 /* number of subtables to allocate at a time */ + +/* ----- bit counts ----- */ +#define LEVEL1_BITS 18 /* number of address bits in the level 1 table */ +#define LEVEL2_BITS (32 - LEVEL1_BITS) /* number of address bits in the level 2 table */ + +/* ----- other address map constants ----- */ +#define MAX_ADDRESS_MAP_SIZE 256 /* maximum entries in an address map */ +#define MAX_MEMORY_BLOCKS 1024 /* maximum memory blocks we can track */ +#define MAX_SHARED_POINTERS 256 /* maximum number of shared pointers in memory maps */ +#define MEMORY_BLOCK_SIZE 65536 /* size of allocated memory blocks */ + + + +/*************************************************************************** + ADDRESS MAP LOOKUP MACROS +***************************************************************************/ + +/* ----- table lookup helpers ----- */ +#define LEVEL1_INDEX(a) ((a) >> LEVEL2_BITS) +#define LEVEL2_INDEX(e,a) ((1 << LEVEL1_BITS) + (((e) - SUBTABLE_BASE) << LEVEL2_BITS) + ((a) & ((1 << LEVEL2_BITS) - 1))) + + + +/*************************************************************************** + 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); + + + +/*************************************************************************** + FUNCTION PROTOTYPES FOR CORE MEMORY FUNCTIONS +***************************************************************************/ + +/* ----- memory setup function ----- */ +void memory_init(running_machine *machine); +void memory_set_context(int activecpu); + +/* ----- address map functions ----- */ +const address_map *memory_get_map(int cpunum, int spacenum); + +/* ----- opcode base control ---- */ +opbase_handler memory_set_opbase_handler(int cpunum, opbase_handler function); +void memory_set_opbase(offs_t offset); + +/* ----- separate opcode/data encryption helper ---- */ +void memory_set_decrypted_region(int cpunum, offs_t start, offs_t end, void *base); + +/* ----- return a base pointer to memory ---- */ +void * memory_get_read_ptr(int cpunum, int spacenum, offs_t offset); +void * memory_get_write_ptr(int cpunum, int spacenum, offs_t offset); +void * memory_get_op_ptr(int cpunum, offs_t offset, 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); +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 start, offs_t end, offs_t mask, offs_t mirror, FPTR handler, const char *handler_name); +UINT8 * _memory_install_read8_handler (int cpunum, int spacenum, offs_t start, offs_t end, offs_t mask, offs_t mirror, read8_handler handler, const char *handler_name); +UINT16 * _memory_install_read16_handler (int cpunum, int spacenum, offs_t start, offs_t end, offs_t mask, offs_t mirror, read16_handler handler, const char *handler_name); +UINT32 * _memory_install_read32_handler (int cpunum, int spacenum, offs_t start, offs_t end, offs_t mask, offs_t mirror, read32_handler handler, const char *handler_name); +UINT64 * _memory_install_read64_handler (int cpunum, int spacenum, offs_t start, offs_t end, offs_t mask, offs_t mirror, read64_handler handler, const char *handler_name); +void * _memory_install_write_handler (int cpunum, int spacenum, offs_t start, offs_t end, offs_t mask, offs_t mirror, FPTR handler, const char *handler_name); +UINT8 * _memory_install_write8_handler (int cpunum, int spacenum, offs_t start, offs_t end, offs_t mask, offs_t mirror, write8_handler handler, const char *handler_name); +UINT16 * _memory_install_write16_handler(int cpunum, int spacenum, offs_t start, offs_t end, offs_t mask, offs_t mirror, write16_handler handler, const char *handler_name); +UINT32 * _memory_install_write32_handler(int cpunum, int spacenum, offs_t start, offs_t end, offs_t mask, offs_t mirror, write32_handler handler, const char *handler_name); +UINT64 * _memory_install_write64_handler(int cpunum, int spacenum, offs_t start, offs_t end, offs_t mask, offs_t mirror, write64_handler handler, const char *handler_name); + +void * _memory_install_read_matchmask_handler (int cpunum, int spacenum, offs_t matchval, offs_t maskval, offs_t mask, offs_t mirror, FPTR handler, const char *handler_name); +UINT8 * _memory_install_read8_matchmask_handler (int cpunum, int spacenum, offs_t matchval, offs_t maskval, offs_t mask, offs_t mirror, read8_handler handler, const char *handler_name); +UINT16 * _memory_install_read16_matchmask_handler (int cpunum, int spacenum, offs_t matchval, offs_t maskval, offs_t mask, offs_t mirror, read16_handler handler, const char *handler_name); +UINT32 * _memory_install_read32_matchmask_handler (int cpunum, int spacenum, offs_t matchval, offs_t maskval, offs_t mask, offs_t mirror, read32_handler handler, const char *handler_name); +UINT64 * _memory_install_read64_matchmask_handler (int cpunum, int spacenum, offs_t matchval, offs_t maskval, offs_t mask, offs_t mirror, read64_handler handler, const char *handler_name); +void * _memory_install_write_matchmask_handler (int cpunum, int spacenum, offs_t matchval, offs_t maskval, offs_t mask, offs_t mirror, FPTR handler, const char *handler_name); +UINT8 * _memory_install_write8_matchmask_handler (int cpunum, int spacenum, offs_t matchval, offs_t maskval, offs_t mask, offs_t mirror, write8_handler handler, const char *handler_name); +UINT16 * _memory_install_write16_matchmask_handler(int cpunum, int spacenum, offs_t matchval, offs_t maskval, offs_t mask, offs_t mirror, write16_handler handler, const char *handler_name); +UINT32 * _memory_install_write32_matchmask_handler(int cpunum, int spacenum, offs_t matchval, offs_t maskval, offs_t mask, offs_t mirror, write32_handler handler, const char *handler_name); +UINT64 * _memory_install_write64_matchmask_handler(int cpunum, int spacenum, offs_t matchval, offs_t maskval, offs_t mask, offs_t mirror, write64_handler handler, const char *handler_name); + +/* ----- memory debugging ----- */ +void memory_dump(FILE *file); +const char *memory_get_handler_string(int read0_or_write1, int cpunum, int spacenum, offs_t offset); + + + +/*************************************************************************** + 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 */ +#define construct_map_0 NULL + + + +/*************************************************************************** + HELPER MACROS AND INLINES +***************************************************************************/ + +/* ----- 16/32-bit memory accessing ----- */ +#define COMBINE_DATA(varptr) (*(varptr) = (*(varptr) & mem_mask) | (data & ~mem_mask)) + +/* ----- 16-bit memory accessing ----- */ +#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 accessing ----- */ +#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) + +/* ----- opcode range safety checks ----- */ +#if CPUREADOP_SAFETY_NONE +#define address_is_unsafe(A) (0) +#elif CPUREADOP_SAFETY_PARTIAL +#define address_is_unsafe(A) (UNEXPECTED((A) > opcode_memory_max)) +#elif CPUREADOP_SAFETY_FULL +#define address_is_unsafe(A) ((UNEXPECTED((A) < opcode_memory_min) || UNEXPECTED((A) > opcode_memory_max))) +#else +#error Must set either CPUREADOP_SAFETY_NONE, CPUREADOP_SAFETY_PARTIAL or CPUREADOP_SAFETY_FULL +#endif + +/* ----- dynamic memory 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) + +#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) + +#define memory_install_readwrite_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) \ + _memory_install_read_handler(cpu, space, start, end, mask, mirror, rhandler, #rhandler); \ + _memory_install_write_handler(cpu, space, start, end, mask, mirror, whandler, #whandler) +#define memory_install_readwrite8_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) \ + _memory_install_read8_handler(cpu, space, start, end, mask, mirror, rhandler, #rhandler); \ + _memory_install_write8_handler(cpu, space, start, end, mask, mirror, whandler, #whandler) +#define memory_install_readwrite16_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) \ + _memory_install_read16_handler(cpu, space, start, end, mask, mirror, rhandler, #rhandler); \ + _memory_install_write16_handler(cpu, space, start, end, mask, mirror, whandler, #whandler) +#define memory_install_readwrite32_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) \ + _memory_install_read32_handler(cpu, space, start, end, mask, mirror, rhandler, #rhandler); \ + _memory_install_write32_handler(cpu, space, start, end, mask, mirror, whandler, #whandler) +#define memory_install_readwrite64_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) \ + _memory_install_read64_handler(cpu, space, start, end, mask, mirror, rhandler, #rhandler); \ + _memory_install_write64_handler(cpu, space, start, end, mask, mirror, whandler, #whandler) + +#define memory_install_read_matchmask_handler(cpu, space, start, end, mask, mirror, handler) \ + _memory_install_read_matchmask_handler(cpu, space, start, end, mask, mirror, handler, #handler) +#define memory_install_read8_matchmask_handler(cpu, space, start, end, mask, mirror, handler) \ + _memory_install_read8_matchmask_handler(cpu, space, start, end, mask, mirror, handler, #handler) +#define memory_install_read16_matchmask_handler(cpu, space, start, end, mask, mirror, handler) \ + _memory_install_read16_matchmask_handler(cpu, space, start, end, mask, mirror, handler, #handler) +#define memory_install_read32_matchmask_handler(cpu, space, start, end, mask, mirror, handler) \ + _memory_install_read32_matchmask_handler(cpu, space, start, end, mask, mirror, handler, #handler) +#define memory_install_read64_matchmask_handler(cpu, space, start, end, mask, mirror, handler) \ + _memory_install_read64_matchmask_handler(cpu, space, start, end, mask, mirror, handler, #handler) + +#define memory_install_write_matchmask_handler(cpu, space, start, end, mask, mirror, handler) \ + _memory_install_write_matchmask_handler(cpu, space, start, end, mask, mirror, handler, #handler) +#define memory_install_write8_matchmask_handler(cpu, space, start, end, mask, mirror, handler) \ + _memory_install_write8_matchmask_handler(cpu, space, start, end, mask, mirror, handler, #handler) +#define memory_install_write16_matchmask_handler(cpu, space, start, end, mask, mirror, handler) \ + _memory_install_write16_matchmask_handler(cpu, space, start, end, mask, mirror, handler, #handler) +#define memory_install_write32_matchmask_handler(cpu, space, start, end, mask, mirror, handler) \ + _memory_install_write32_matchmask_handler(cpu, space, start, end, mask, mirror, handler, #handler) +#define memory_install_write64_matchmask_handler(cpu, space, start, end, mask, mirror, handler) \ + _memory_install_write64_matchmask_handler(cpu, space, start, end, mask, mirror, handler, #handler) + +/* ----- generic memory access ----- */ +INLINE UINT8 program_read_byte (offs_t offset) { return (*active_address_space[ADDRESS_SPACE_PROGRAM].accessors->read_byte)(offset); } +INLINE UINT16 program_read_word (offs_t offset) { return (*active_address_space[ADDRESS_SPACE_PROGRAM].accessors->read_word)(offset); } +INLINE UINT32 program_read_dword(offs_t offset) { return (*active_address_space[ADDRESS_SPACE_PROGRAM].accessors->read_dword)(offset); } +INLINE UINT64 program_read_qword(offs_t offset) { return (*active_address_space[ADDRESS_SPACE_PROGRAM].accessors->read_qword)(offset); } + +INLINE void program_write_byte (offs_t offset, UINT8 data) { (*active_address_space[ADDRESS_SPACE_PROGRAM].accessors->write_byte)(offset, data); } +INLINE void program_write_word (offs_t offset, UINT16 data) { (*active_address_space[ADDRESS_SPACE_PROGRAM].accessors->write_word)(offset, data); } +INLINE void program_write_dword(offs_t offset, UINT32 data) { (*active_address_space[ADDRESS_SPACE_PROGRAM].accessors->write_dword)(offset, data); } +INLINE void program_write_qword(offs_t offset, UINT64 data) { (*active_address_space[ADDRESS_SPACE_PROGRAM].accessors->write_qword)(offset, data); } + +INLINE UINT8 data_read_byte (offs_t offset) { return (*active_address_space[ADDRESS_SPACE_DATA].accessors->read_byte)(offset); } +INLINE UINT16 data_read_word (offs_t offset) { return (*active_address_space[ADDRESS_SPACE_DATA].accessors->read_word)(offset); } +INLINE UINT32 data_read_dword(offs_t offset) { return (*active_address_space[ADDRESS_SPACE_DATA].accessors->read_dword)(offset); } +INLINE UINT64 data_read_qword(offs_t offset) { return (*active_address_space[ADDRESS_SPACE_DATA].accessors->read_qword)(offset); } + +INLINE void data_write_byte (offs_t offset, UINT8 data) { (*active_address_space[ADDRESS_SPACE_DATA].accessors->write_byte)(offset, data); } +INLINE void data_write_word (offs_t offset, UINT16 data) { (*active_address_space[ADDRESS_SPACE_DATA].accessors->write_word)(offset, data); } +INLINE void data_write_dword(offs_t offset, UINT32 data) { (*active_address_space[ADDRESS_SPACE_DATA].accessors->write_dword)(offset, data); } +INLINE void data_write_qword(offs_t offset, UINT64 data) { (*active_address_space[ADDRESS_SPACE_DATA].accessors->write_qword)(offset, data); } + +INLINE UINT8 io_read_byte (offs_t offset) { return (*active_address_space[ADDRESS_SPACE_IO].accessors->read_byte)(offset); } +INLINE UINT16 io_read_word (offs_t offset) { return (*active_address_space[ADDRESS_SPACE_IO].accessors->read_word)(offset); } +INLINE UINT32 io_read_dword(offs_t offset) { return (*active_address_space[ADDRESS_SPACE_IO].accessors->read_dword)(offset); } +INLINE UINT64 io_read_qword(offs_t offset) { return (*active_address_space[ADDRESS_SPACE_IO].accessors->read_qword)(offset); } + +INLINE void io_write_byte (offs_t offset, UINT8 data) { (*active_address_space[ADDRESS_SPACE_IO].accessors->write_byte)(offset, data); } +INLINE void io_write_word (offs_t offset, UINT16 data) { (*active_address_space[ADDRESS_SPACE_IO].accessors->write_word)(offset, data); } +INLINE void io_write_dword(offs_t offset, UINT32 data) { (*active_address_space[ADDRESS_SPACE_IO].accessors->write_dword)(offset, data); } +INLINE void io_write_qword(offs_t offset, UINT64 data) { (*active_address_space[ADDRESS_SPACE_IO].accessors->write_qword)(offset, data); } + +/* ----- safe opcode and opcode argument reading ----- */ +UINT8 cpu_readop_safe(offs_t offset); +UINT16 cpu_readop16_safe(offs_t offset); +UINT32 cpu_readop32_safe(offs_t offset); +UINT64 cpu_readop64_safe(offs_t offset); +UINT8 cpu_readop_arg_safe(offs_t offset); +UINT16 cpu_readop_arg16_safe(offs_t offset); +UINT32 cpu_readop_arg32_safe(offs_t offset); +UINT64 cpu_readop_arg64_safe(offs_t offset); + +/* ----- 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]) + +/* ----- opcode and opcode argument reading ----- */ +INLINE void * cpu_opptr(offs_t A) { if (address_is_unsafe(A)) { memory_set_opbase(A); } return cpu_opptr_unsafe(A); } +INLINE UINT8 cpu_readop(offs_t A) { if (address_is_unsafe(A)) { memory_set_opbase(A); } return cpu_readop_unsafe(A); } +INLINE UINT16 cpu_readop16(offs_t A) { if (address_is_unsafe(A)) { memory_set_opbase(A); } return cpu_readop16_unsafe(A); } +INLINE UINT32 cpu_readop32(offs_t A) { if (address_is_unsafe(A)) { memory_set_opbase(A); } return cpu_readop32_unsafe(A); } +INLINE UINT64 cpu_readop64(offs_t A) { if (address_is_unsafe(A)) { memory_set_opbase(A); } return cpu_readop64_unsafe(A); } +INLINE UINT8 cpu_readop_arg(offs_t A) { if (address_is_unsafe(A)) { memory_set_opbase(A); } return cpu_readop_arg_unsafe(A); } +INLINE UINT16 cpu_readop_arg16(offs_t A) { if (address_is_unsafe(A)) { memory_set_opbase(A); } return cpu_readop_arg16_unsafe(A); } +INLINE UINT32 cpu_readop_arg32(offs_t A) { if (address_is_unsafe(A)) { memory_set_opbase(A); } return cpu_readop_arg32_unsafe(A); } +INLINE UINT64 cpu_readop_arg64(offs_t A) { if (address_is_unsafe(A)) { memory_set_opbase(A); } return cpu_readop_arg64_unsafe(A); } + +/* ----- bank switching for CPU cores ----- */ +#define change_pc(pc) \ +do { \ + if (active_address_space[ADDRESS_SPACE_PROGRAM].readlookup[LEVEL1_INDEX((pc) & active_address_space[ADDRESS_SPACE_PROGRAM].addrmask)] != opcode_entry) \ + memory_set_opbase(pc); \ +} while (0) \ + +/* ----- forces the next branch to generate a call to the opbase handler ----- */ +#define catch_nextBranch() (opcode_entry = 0xff) + + +#endif /* __MEMORY_H__ */ |