Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-29 00:53:09 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Internal memory system shuffling. Address maps initialized internally

Browse Source 
now call the same installation handlers that drivers do for dynamic
installation. Cleaned up some parameter ordering and error detection.
This commit is contained in:
Aaron Giles 2009-12-06 08:18:34 +00:00
parent 0be7db3893
commit 98484d44b0
4 changed files with 279 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/emu/debug/debugcmd.c
View File

@ -1791,8 +1791,9 @@ static void execute_cheatinit(running_machine *machine, int ref, int params, con
/* disable double share regions */ /* disable double share regions */
if (entry->share != NULL) if (entry->share != NULL)
for (i = 0; i < region_count; i++) for (i = 0; i < region_count; i++)
if (strcmp(cheat_region[i].share,entry->share)==0) if (cheat_region[i].share != NULL)
cheat_region[region_count].disabled = TRUE; if (strcmp(cheat_region[i].share, entry->share)==0)
cheat_region[region_count].disabled = TRUE;
region_count++; region_count++;
} }
@ -1808,7 +1809,7 @@ static void execute_cheatinit(running_machine *machine, int ref, int params, con
/* force region to the specified range */ /* force region to the specified range */
cheat_region[region_count].offset = memory_address_to_byte(space, offset) & space->bytemask;; cheat_region[region_count].offset = memory_address_to_byte(space, offset) & space->bytemask;;
cheat_region[region_count].endoffset = memory_address_to_byte(space, offset + length - 1) & space->bytemask;; cheat_region[region_count].endoffset = memory_address_to_byte(space, offset + length - 1) & space->bytemask;;
cheat_region[region_count].share = 0; cheat_region[region_count].share = NULL;
cheat_region[region_count].disabled = FALSE; cheat_region[region_count].disabled = FALSE;
region_count++; region_count++;
} }

392
src/emu/memory.c
View File

@ -330,6 +330,8 @@ struct _subtable_data
struct _memory_private struct _memory_private
{ {
UINT8 initialized; /* have we completed initialization? */
const address_space * spacelist; /* list of address spaces */ const address_space * spacelist; /* list of address spaces */
UINT8 * bank_ptr[STATIC_COUNT]; /* array of bank pointers */ UINT8 * bank_ptr[STATIC_COUNT]; /* array of bank pointers */
@ -399,13 +401,12 @@ static void memory_exit(running_machine *machine);
static void map_detokenize(memory_private *memdata, address_map *map, const game_driver *driver, const char *devtag, const addrmap_token *tokens); static void map_detokenize(memory_private *memdata, address_map *map, const game_driver *driver, const char *devtag, const addrmap_token *tokens);
/* memory mapping helpers */ /* memory mapping helpers */
static void space_map_range_private(address_space *space, read_or_write readorwrite, int handlerbits, int handlerunitmask, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, genf *handler, void *object, const char *handler_name);
static void space_map_range(address_space *space, read_or_write readorwrite, int handlerbits, int handlerunitmask, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, genf *handler, void *object, const char *handler_name); static void space_map_range(address_space *space, read_or_write readorwrite, int handlerbits, int handlerunitmask, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, genf *handler, void *object, const char *handler_name);
static void *space_find_backing_memory(const address_space *space, offs_t byteaddress); static void *space_find_backing_memory(const address_space *space, offs_t addrstart, offs_t addrend);
static int space_needs_backing_store(const address_space *space, const address_map_entry *entry); static int space_needs_backing_store(const address_space *space, const address_map_entry *entry);
/* banking helpers */ /* banking helpers */
static void *bank_find_or_allocate(const address_space *space, const char *tag, offs_t bytestart, offs_t byteend, read_or_write readorwrite); static void *bank_find_or_allocate(const address_space *space, const char *tag, offs_t addrstart, offs_t addrend, read_or_write readorwrite);
static STATE_POSTLOAD( bank_reattach ); static STATE_POSTLOAD( bank_reattach );
/* table management */ /* table management */
@ -820,6 +821,9 @@ void memory_init(running_machine *machine)
/* dump the final memory configuration */ /* dump the final memory configuration */
mem_dump(machine); mem_dump(machine);
/* we are now initialized */
memdata->initialized = TRUE;
} }
@ -1234,17 +1238,19 @@ void memory_set_bankptr(running_machine *machine, const char *tag, void *base)
if present if present
-------------------------------------------------*/ -------------------------------------------------*/
void *_memory_install_handler(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, FPTR rhandler, FPTR whandler, const char *rhandler_name, const char *whandler_name) void *_memory_install_handler(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, FPTR rhandler, FPTR whandler)
{ {
address_space *spacerw = (address_space *)space; address_space *spacerw = (address_space *)space;
if (rhandler >= STATIC_COUNT || whandler >= STATIC_COUNT) if (rhandler >= STATIC_COUNT)
fatalerror("fatal: can only use static banks with memory_install_handler()"); fatalerror("Attempted to install non-static read handler via memory_install_handler() in space %s of device '%s'\n", space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (whandler >= STATIC_COUNT)
fatalerror("Attempted to install non-static write handler via memory_install_handler() in space %s of device '%s'\n", space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (rhandler != 0) if (rhandler != 0)
space_map_range(spacerw, ROW_READ, spacerw->dbits, 0, addrstart, addrend, addrmask, addrmirror, (genf *)(FPTR)rhandler, spacerw, rhandler_name); space_map_range(spacerw, ROW_READ, spacerw->dbits, 0, addrstart, addrend, addrmask, addrmirror, (genf *)(FPTR)rhandler, spacerw, NULL);
if (whandler != 0) if (whandler != 0)
space_map_range(spacerw, ROW_WRITE, spacerw->dbits, 0, addrstart, addrend, addrmask, addrmirror, (genf *)(FPTR)whandler, spacerw, whandler_name); space_map_range(spacerw, ROW_WRITE, spacerw->dbits, 0, addrstart, addrend, addrmask, addrmirror, (genf *)(FPTR)whandler, spacerw, NULL);
mem_dump(space->machine); mem_dump(space->machine);
return space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart)); return space_find_backing_memory(spacerw, addrstart, addrend);
} }
@ -1253,15 +1259,19 @@ void *_memory_install_handler(const address_space *space, offs_t addrstart, offs
explicitly for 8-bit handlers explicitly for 8-bit handlers
-------------------------------------------------*/ -------------------------------------------------*/
UINT8 *_memory_install_handler8(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_space_func rhandler, write8_space_func whandler, const char *rhandler_name, const char *whandler_name) UINT8 *_memory_install_handler8(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_space_func rhandler, const char *rhandler_name, write8_space_func whandler, const char *whandler_name, int handlerunitmask)
{ {
address_space *spacerw = (address_space *)space; address_space *spacerw = (address_space *)space;
if (rhandler != NULL && (FPTR)rhandler < STATIC_COUNT)
fatalerror("Attempted to install invalid read handler in space %s of device '%s'\n", space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (whandler != NULL && (FPTR)whandler < STATIC_COUNT)
fatalerror("Attempted to install invalid write handler in space %s of device '%s'\n", space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (rhandler != NULL) if (rhandler != NULL)
space_map_range(spacerw, ROW_READ, 8, 0, addrstart, addrend, addrmask, addrmirror, (genf *)rhandler, spacerw, rhandler_name); space_map_range(spacerw, ROW_READ, 8, handlerunitmask, addrstart, addrend, addrmask, addrmirror, (genf *)rhandler, spacerw, rhandler_name);
if (whandler != NULL) if (whandler != NULL)
space_map_range(spacerw, ROW_WRITE, 8, 0, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, spacerw, whandler_name); space_map_range(spacerw, ROW_WRITE, 8, handlerunitmask, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, spacerw, whandler_name);
mem_dump(space->machine); mem_dump(space->machine);
return (UINT8 *)space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart)); return (UINT8 *)space_find_backing_memory(spacerw, addrstart, addrend);
} }
@ -1270,15 +1280,19 @@ UINT8 *_memory_install_handler8(const address_space *space, offs_t addrstart, of
explicitly for 16-bit handlers explicitly for 16-bit handlers
-------------------------------------------------*/ -------------------------------------------------*/
UINT16 *_memory_install_handler16(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read16_space_func rhandler, write16_space_func whandler, const char *rhandler_name, const char *whandler_name) UINT16 *_memory_install_handler16(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read16_space_func rhandler, const char *rhandler_name, write16_space_func whandler, const char *whandler_name, int handlerunitmask)
{ {
address_space *spacerw = (address_space *)space; address_space *spacerw = (address_space *)space;
if (rhandler != NULL && (FPTR)rhandler < STATIC_COUNT)
fatalerror("Attempted to install invalid read handler in space %s of device '%s'\n", space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (whandler != NULL && (FPTR)whandler < STATIC_COUNT)
fatalerror("Attempted to install invalid write handler in space %s of device '%s'\n", space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (rhandler != NULL) if (rhandler != NULL)
space_map_range(spacerw, ROW_READ, 16, 0, addrstart, addrend, addrmask, addrmirror, (genf *)rhandler, spacerw, rhandler_name); space_map_range(spacerw, ROW_READ, 16, handlerunitmask, addrstart, addrend, addrmask, addrmirror, (genf *)rhandler, spacerw, rhandler_name);
if (whandler != NULL) if (whandler != NULL)
space_map_range(spacerw, ROW_WRITE, 16, 0, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, spacerw, whandler_name); space_map_range(spacerw, ROW_WRITE, 16, handlerunitmask, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, spacerw, whandler_name);
mem_dump(space->machine); mem_dump(space->machine);
return (UINT16 *)space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart)); return (UINT16 *)space_find_backing_memory(spacerw, addrstart, addrend);
} }
@ -1287,15 +1301,19 @@ UINT16 *_memory_install_handler16(const address_space *space, offs_t addrstart,
explicitly for 32-bit handlers explicitly for 32-bit handlers
-------------------------------------------------*/ -------------------------------------------------*/
UINT32 *_memory_install_handler32(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read32_space_func rhandler, write32_space_func whandler, const char *rhandler_name, const char *whandler_name) UINT32 *_memory_install_handler32(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read32_space_func rhandler, const char *rhandler_name, write32_space_func whandler, const char *whandler_name, int handlerunitmask)
{ {
address_space *spacerw = (address_space *)space; address_space *spacerw = (address_space *)space;
if (rhandler != NULL && (FPTR)rhandler < STATIC_COUNT)
fatalerror("Attempted to install invalid read handler in space %s of device '%s'\n", space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (whandler != NULL && (FPTR)whandler < STATIC_COUNT)
fatalerror("Attempted to install invalid write handler in space %s of device '%s'\n", space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (rhandler != NULL) if (rhandler != NULL)
space_map_range(spacerw, ROW_READ, 32, 0, addrstart, addrend, addrmask, addrmirror, (genf *)rhandler, spacerw, rhandler_name); space_map_range(spacerw, ROW_READ, 32, handlerunitmask, addrstart, addrend, addrmask, addrmirror, (genf *)rhandler, spacerw, rhandler_name);
if (whandler != NULL) if (whandler != NULL)
space_map_range(spacerw, ROW_WRITE, 32, 0, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, spacerw, whandler_name); space_map_range(spacerw, ROW_WRITE, 32, handlerunitmask, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, spacerw, whandler_name);
mem_dump(space->machine); mem_dump(space->machine);
return (UINT32 *)space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart)); return (UINT32 *)space_find_backing_memory(spacerw, addrstart, addrend);
} }
@ -1304,36 +1322,19 @@ UINT32 *_memory_install_handler32(const address_space *space, offs_t addrstart,
explicitly for 64-bit handlers explicitly for 64-bit handlers
-------------------------------------------------*/ -------------------------------------------------*/
UINT64 *_memory_install_handler64(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read64_space_func rhandler, write64_space_func whandler, const char *rhandler_name, const char *whandler_name) UINT64 *_memory_install_handler64(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read64_space_func rhandler, const char *rhandler_name, write64_space_func whandler, const char *whandler_name, int handlerunitmask)
{ {
address_space *spacerw = (address_space *)space; address_space *spacerw = (address_space *)space;
if (rhandler != NULL && (FPTR)rhandler < STATIC_COUNT)
fatalerror("Attempted to install invalid read handler in space %s of device '%s'\n", space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (whandler != NULL && (FPTR)whandler < STATIC_COUNT)
fatalerror("Attempted to install invalid write handler in space %s of device '%s'\n", space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (rhandler != NULL) if (rhandler != NULL)
space_map_range(spacerw, ROW_READ, 64, 0, addrstart, addrend, addrmask, addrmirror, (genf *)rhandler, spacerw, rhandler_name); space_map_range(spacerw, ROW_READ, 64, handlerunitmask, addrstart, addrend, addrmask, addrmirror, (genf *)rhandler, spacerw, rhandler_name);
if (whandler != NULL) if (whandler != NULL)
space_map_range(spacerw, ROW_WRITE, 64, 0, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, spacerw, whandler_name); space_map_range(spacerw, ROW_WRITE, 64, handlerunitmask, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, spacerw, whandler_name);
mem_dump(space->machine); mem_dump(space->machine);
return (UINT64 *)space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart)); return (UINT64 *)space_find_backing_memory(spacerw, addrstart, addrend);
}
/*-------------------------------------------------
_memory_install_device_handler - install a new
device memory handler into the given address
space, returning a pointer to the memory
backing it, if present
-------------------------------------------------*/
void *_memory_install_device_handler(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, FPTR rhandler, FPTR whandler, const char *rhandler_name, const char *whandler_name)
{
address_space *spacerw = (address_space *)space;
if (rhandler >= STATIC_COUNT || whandler >= STATIC_COUNT)
fatalerror("fatal: can only use static banks with memory_install_device_handler()");
if (rhandler != 0)
space_map_range(spacerw, ROW_READ, spacerw->dbits, 0, addrstart, addrend, addrmask, addrmirror, (genf *)(FPTR)rhandler, (void *)device, rhandler_name);
if (whandler != 0)
space_map_range(spacerw, ROW_WRITE, spacerw->dbits, 0, addrstart, addrend, addrmask, addrmirror, (genf *)(FPTR)whandler, (void *)device, whandler_name);
mem_dump(space->machine);
return space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart));
} }
@ -1342,15 +1343,19 @@ void *_memory_install_device_handler(const address_space *space, const device_co
but explicitly for 8-bit handlers but explicitly for 8-bit handlers
-------------------------------------------------*/ -------------------------------------------------*/
UINT8 *_memory_install_device_handler8(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_device_func rhandler, write8_device_func whandler, const char *rhandler_name, const char *whandler_name) UINT8 *_memory_install_device_handler8(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_device_func rhandler, const char *rhandler_name, write8_device_func whandler, const char *whandler_name, int handlerunitmask)
{ {
address_space *spacerw = (address_space *)space; address_space *spacerw = (address_space *)space;
if (rhandler != NULL && (FPTR)rhandler < STATIC_COUNT)
fatalerror("Attempted to install invalid read handler for device '%s' in space %s of device '%s'\n", device->tag, space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (whandler != NULL && (FPTR)whandler < STATIC_COUNT)
fatalerror("Attempted to install invalid write handler for device '%s' in space %s of device '%s'\n", device->tag, space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (rhandler != NULL) if (rhandler != NULL)
space_map_range(spacerw, ROW_READ, 8, 0, addrstart, addrend, addrmask, addrmirror, (genf *)rhandler, (void *)device, rhandler_name); space_map_range(spacerw, ROW_READ, 8, handlerunitmask, addrstart, addrend, addrmask, addrmirror, (genf *)rhandler, (void *)device, rhandler_name);
if (whandler != NULL) if (whandler != NULL)
space_map_range(spacerw, ROW_WRITE, 8, 0, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, (void *)device, whandler_name); space_map_range(spacerw, ROW_WRITE, 8, handlerunitmask, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, (void *)device, whandler_name);
mem_dump(space->machine); mem_dump(space->machine);
return (UINT8 *)space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart)); return (UINT8 *)space_find_backing_memory(spacerw, addrstart, addrend);
} }
@ -1359,15 +1364,19 @@ UINT8 *_memory_install_device_handler8(const address_space *space, const device_
above but explicitly for 16-bit handlers above but explicitly for 16-bit handlers
-------------------------------------------------*/ -------------------------------------------------*/
UINT16 *_memory_install_device_handler16(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read16_device_func rhandler, write16_device_func whandler, const char *rhandler_name, const char *whandler_name) UINT16 *_memory_install_device_handler16(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read16_device_func rhandler, const char *rhandler_name, write16_device_func whandler, const char *whandler_name, int handlerunitmask)
{ {
address_space *spacerw = (address_space *)space; address_space *spacerw = (address_space *)space;
if (rhandler != NULL && (FPTR)rhandler < STATIC_COUNT)
fatalerror("Attempted to install invalid read handler for device '%s' in space %s of device '%s'\n", device->tag, space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (whandler != NULL && (FPTR)whandler < STATIC_COUNT)
fatalerror("Attempted to install invalid write handler for device '%s' in space %s of device '%s'\n", device->tag, space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (rhandler != NULL) if (rhandler != NULL)
space_map_range(spacerw, ROW_READ, 16, 0, addrstart, addrend, addrmask, addrmirror, (genf *)rhandler, (void *)device, rhandler_name); space_map_range(spacerw, ROW_READ, 16, handlerunitmask, addrstart, addrend, addrmask, addrmirror, (genf *)rhandler, (void *)device, rhandler_name);
if (whandler != NULL) if (whandler != NULL)
space_map_range(spacerw, ROW_WRITE, 16, 0, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, (void *)device, whandler_name); space_map_range(spacerw, ROW_WRITE, 16, handlerunitmask, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, (void *)device, whandler_name);
mem_dump(space->machine); mem_dump(space->machine);
return (UINT16 *)space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart)); return (UINT16 *)space_find_backing_memory(spacerw, addrstart, addrend);
} }
@ -1376,15 +1385,19 @@ UINT16 *_memory_install_device_handler16(const address_space *space, const devic
above but explicitly for 32-bit handlers above but explicitly for 32-bit handlers
-------------------------------------------------*/ -------------------------------------------------*/
UINT32 *_memory_install_device_handler32(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read32_device_func rhandler, write32_device_func whandler, const char *rhandler_name, const char *whandler_name) UINT32 *_memory_install_device_handler32(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read32_device_func rhandler, const char *rhandler_name, write32_device_func whandler, const char *whandler_name, int handlerunitmask)
{ {
address_space *spacerw = (address_space *)space; address_space *spacerw = (address_space *)space;
if (rhandler != NULL && (FPTR)rhandler < STATIC_COUNT)
fatalerror("Attempted to install invalid read handler for device '%s' in space %s of device '%s'\n", device->tag, space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (whandler != NULL && (FPTR)whandler < STATIC_COUNT)
fatalerror("Attempted to install invalid write handler for device '%s' in space %s of device '%s'\n", device->tag, space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (rhandler != NULL) if (rhandler != NULL)
space_map_range(spacerw, ROW_READ, 32, 0, addrstart, addrend, addrmask, addrmirror, (genf *)rhandler, (void *)device, rhandler_name); space_map_range(spacerw, ROW_READ, 32, handlerunitmask, addrstart, addrend, addrmask, addrmirror, (genf *)rhandler, (void *)device, rhandler_name);
if (whandler != NULL) if (whandler != NULL)
space_map_range(spacerw, ROW_WRITE, 32, 0, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, (void *)device, whandler_name); space_map_range(spacerw, ROW_WRITE, 32, handlerunitmask, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, (void *)device, whandler_name);
mem_dump(space->machine); mem_dump(space->machine);
return (UINT32 *)space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart)); return (UINT32 *)space_find_backing_memory(spacerw, addrstart, addrend);
} }
@ -1393,15 +1406,19 @@ UINT32 *_memory_install_device_handler32(const address_space *space, const devic
above but explicitly for 64-bit handlers above but explicitly for 64-bit handlers
-------------------------------------------------*/ -------------------------------------------------*/
UINT64 *_memory_install_device_handler64(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read64_device_func rhandler, write64_device_func whandler, const char *rhandler_name, const char *whandler_name) UINT64 *_memory_install_device_handler64(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read64_device_func rhandler, const char *rhandler_name, write64_device_func whandler, const char *whandler_name, int handlerunitmask)
{ {
address_space *spacerw = (address_space *)space; address_space *spacerw = (address_space *)space;
if (rhandler != NULL && (FPTR)rhandler < STATIC_COUNT)
fatalerror("Attempted to install invalid read handler for device '%s' in space %s of device '%s'\n", device->tag, space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (whandler != NULL && (FPTR)whandler < STATIC_COUNT)
fatalerror("Attempted to install invalid write handler for device '%s' in space %s of device '%s'\n", device->tag, space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
if (rhandler != NULL) if (rhandler != NULL)
space_map_range(spacerw, ROW_READ, 64, 0, addrstart, addrend, addrmask, addrmirror, (genf *)rhandler, (void *)device, rhandler_name); space_map_range(spacerw, ROW_READ, 64, handlerunitmask, addrstart, addrend, addrmask, addrmirror, (genf *)rhandler, (void *)device, rhandler_name);
if (whandler != NULL) if (whandler != NULL)
space_map_range(spacerw, ROW_WRITE, 64, 0, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, (void *)device, whandler_name); space_map_range(spacerw, ROW_WRITE, 64, handlerunitmask, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, (void *)device, whandler_name);
mem_dump(space->machine); mem_dump(space->machine);
return (UINT64 *)space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart)); return (UINT64 *)space_find_backing_memory(spacerw, addrstart, addrend);
} }
@ -1416,32 +1433,34 @@ void _memory_install_port(const address_space *space, offs_t addrstart, offs_t a
genf *rhandler = NULL; genf *rhandler = NULL;
genf *whandler = NULL; genf *whandler = NULL;
/* pick the appropriate read/write handlers */
switch (space->dbits) switch (space->dbits)
{ {
case 8: rhandler = (genf *)input_port_read8; whandler = (genf *)input_port_write8; break; case 8: rhandler = (genf *)input_port_read8; whandler = (genf *)input_port_write8; break;
case 16: rhandler = (genf *)input_port_read16; whandler = (genf *)input_port_write16; break; case 16: rhandler = (genf *)input_port_read16; whandler = (genf *)input_port_write16; break;
case 32: rhandler = (genf *)input_port_read32; whandler = (genf *)input_port_write32; break; case 32: rhandler = (genf *)input_port_read32; whandler = (genf *)input_port_write32; break;
case 64: rhandler = (genf *)input_port_read64; whandler = (genf *)input_port_write64; break; case 64: rhandler = (genf *)input_port_read64; whandler = (genf *)input_port_write64; break;
} }
/* assign the read handler */
if (rtag != NULL) if (rtag != NULL)
{ {
const input_port_config *port = input_port_by_tag(&space->machine->portlist, rtag); const input_port_config *port = input_port_by_tag(&space->machine->portlist, rtag);
if (port == NULL) if (port == NULL)
fatalerror("Non-existent port referenced: '%s'\n", rtag); fatalerror("Attempted to map non-existent port '%s' for read in space %s of device '%s'\n", rtag, space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
space_map_range(spacerw, ROW_READ, space->dbits, 0, addrstart, addrend, addrmask, addrmirror, rhandler, (void *)port, rtag); space_map_range(spacerw, ROW_READ, space->dbits, 0, addrstart, addrend, addrmask, addrmirror, rhandler, (void *)port, rtag);
} }
/* assign the write handler */
if (wtag != NULL) if (wtag != NULL)
{ {
const input_port_config *port = input_port_by_tag(&space->machine->portlist, wtag); const input_port_config *port = input_port_by_tag(&space->machine->portlist, wtag);
if (port == NULL) if (port == NULL)
fatalerror("Non-existent port referenced: '%s'\n", wtag); fatalerror("Attempted to map non-existent port '%s' for write in space %s of device '%s'\n", wtag, space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
space_map_range(spacerw, ROW_WRITE, space->dbits, 0, addrstart, addrend, addrmask, addrmirror, whandler, (void *)port, wtag); space_map_range(spacerw, ROW_WRITE, space->dbits, 0, addrstart, addrend, addrmask, addrmirror, whandler, (void *)port, wtag);
} }
/* update the memory dump */
mem_dump(space->machine); mem_dump(space->machine);
} }
@ -1455,22 +1474,71 @@ void _memory_install_bank(const address_space *space, offs_t addrstart, offs_t a
{ {
address_space *spacerw = (address_space *)space; address_space *spacerw = (address_space *)space;
/* map the read bank */
if (rtag != NULL) if (rtag != NULL)
{ {
void *handler = bank_find_or_allocate(space, rtag, addrstart, addrend, ROW_READ); void *handler = bank_find_or_allocate(space, rtag, addrstart, addrend, ROW_READ);
space_map_range(spacerw, ROW_READ, space->dbits, 0, addrstart, addrend, addrmask, addrmirror, handler, spacerw, rtag); space_map_range(spacerw, ROW_READ, space->dbits, 0, addrstart, addrend, addrmask, addrmirror, handler, spacerw, rtag);
} }
/* map the write bank */
if (wtag != NULL) if (wtag != NULL)
{ {
void *handler = bank_find_or_allocate(space, wtag, addrstart, addrend, ROW_WRITE); void *handler = bank_find_or_allocate(space, wtag, addrstart, addrend, ROW_WRITE);
space_map_range(spacerw, ROW_WRITE, space->dbits, 0, addrstart, addrend, addrmask, addrmirror, handler, spacerw, wtag); space_map_range(spacerw, ROW_WRITE, space->dbits, 0, addrstart, addrend, addrmask, addrmirror, handler, spacerw, wtag);
} }
/* update the memory dump */
mem_dump(space->machine); mem_dump(space->machine);
} }
/*-------------------------------------------------
_memory_install_ram - install a simple fixed
RAM region into the given address space
-------------------------------------------------*/
void _memory_install_ram(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, UINT8 install_read, UINT8 install_write)
{
memory_private *memdata = space->machine->memory_data;
address_space *spacerw = (address_space *)space;
FPTR bankindex;
void *handler;
/* map for read */
if (install_read)
{
handler = bank_find_or_allocate(space, NULL, addrstart, addrend, ROW_READ);
space_map_range(spacerw, ROW_READ, space->dbits, 0, addrstart, addrend, addrmask, addrmirror, handler, spacerw, "ram");
/* if we don't have a bank pointer yet, try to find one */
bankindex = (FPTR)handler;
if (memdata->bank_ptr[bankindex] == NULL)
memdata->bank_ptr[bankindex] = (UINT8 *)space_find_backing_memory(space, addrstart, addrend);
/* if we still don't have a pointer, and we're past the initialization phase, allocate a new block */
if (memdata->bank_ptr[bankindex] == NULL && memdata->initialized)
memdata->bank_ptr[bankindex] = block_allocate(space, memory_address_to_byte(space, addrstart), memory_address_to_byte_end(space, addrend), NULL);
}
/* map for write */
if (install_write)
{
handler = bank_find_or_allocate(space, NULL, addrstart, addrend, ROW_WRITE);
space_map_range(spacerw, ROW_WRITE, space->dbits, 0, addrstart, addrend, addrmask, addrmirror, handler, spacerw, "ram");
/* if we don't have a bank pointer yet, try to find one */
bankindex = (FPTR)handler;
if (memdata->bank_ptr[bankindex] == NULL)
memdata->bank_ptr[bankindex] = (UINT8 *)space_find_backing_memory(space, addrstart, addrend);
/* if we still don't have a pointer, and we're past the initialization phase, allocate a new block */
if (memdata->bank_ptr[bankindex] == NULL && memdata->initialized)
memdata->bank_ptr[bankindex] = block_allocate(space, memory_address_to_byte(space, addrstart), memory_address_to_byte_end(space, addrend), NULL);
}
}
/*------------------------------------------------- /*-------------------------------------------------
_memory_unmap - unmap a section of address _memory_unmap - unmap a section of address
space space
@ -1848,10 +1916,7 @@ static void memory_init_populate(running_machine *machine)
static void memory_init_map_entry(address_space *space, const address_map_entry *entry, read_or_write readorwrite) static void memory_init_map_entry(address_space *space, const address_map_entry *entry, read_or_write readorwrite)
{ {
const map_handler_data *handler = (readorwrite == ROW_READ) ? &entry->read : &entry->write; const map_handler_data *handler = (readorwrite == ROW_READ) ? &entry->read : &entry->write;
int bits = (handler->bits != 0) ? handler->bits : space->dbits; const device_config *device;
genf *funcptr = handler->handler.generic;
const char *name = handler->name;
void *object = space;
/* based on the handler type, alter the bits, name, funcptr, and object */ /* based on the handler type, alter the bits, name, funcptr, and object */
switch (handler->type) switch (handler->type)
@ -1859,62 +1924,107 @@ static void memory_init_map_entry(address_space *space, const address_map_entry
case AMH_NONE: case AMH_NONE:
return; return;
case AMH_ROM:
if (readorwrite == ROW_WRITE)
return;
/* fall through to the RAM case otherwise */
case AMH_RAM: case AMH_RAM:
bits = space->dbits; _memory_install_ram(space, entry->addrstart, entry->addrend, entry->addrmask, entry->addrmirror,
name = "RAM"; readorwrite == ROW_READ, readorwrite == ROW_WRITE);
funcptr = (genf *)STATIC_RAM;
break; break;
case AMH_ROM:
bits = space->dbits;
name = "ROM";
funcptr = (genf *)STATIC_ROM;
break;
case AMH_NOP: case AMH_NOP:
bits = space->dbits; _memory_unmap(space, entry->addrstart, entry->addrend, entry->addrmask, entry->addrmirror,
name = "nop"; readorwrite == ROW_READ, readorwrite == ROW_WRITE, TRUE);
funcptr = (genf *)STATIC_NOP;
break; break;
case AMH_UNMAP: case AMH_UNMAP:
bits = space->dbits; _memory_unmap(space, entry->addrstart, entry->addrend, entry->addrmask, entry->addrmirror,
name = "unmapped"; readorwrite == ROW_READ, readorwrite == ROW_WRITE, FALSE);
funcptr = (genf *)STATIC_NOP;
break; break;
case AMH_DEVICE_HANDLER:
object = (void *)device_list_find_by_tag(&space->machine->config->devicelist, handler->tag);
if (object == NULL)
fatalerror("Non-existent device '%s' referenced in memory map\n", handler->tag);
break;
case AMH_HANDLER: case AMH_HANDLER:
switch ((handler->bits != 0) ? handler->bits : space->dbits)
{
case 8:
_memory_install_handler8(space, entry->addrstart, entry->addrend, entry->addrmask, entry->addrmirror,
(readorwrite == ROW_READ) ? handler->handler.read.shandler8 : NULL, handler->name,
(readorwrite == ROW_WRITE) ? handler->handler.write.shandler8 : NULL, handler->name,
handler->mask);
break;
case 16:
_memory_install_handler16(space, entry->addrstart, entry->addrend, entry->addrmask, entry->addrmirror,
(readorwrite == ROW_READ) ? handler->handler.read.shandler16 : NULL, handler->name,
(readorwrite == ROW_WRITE) ? handler->handler.write.shandler16 : NULL, handler->name,
handler->mask);
break;
case 32:
_memory_install_handler32(space, entry->addrstart, entry->addrend, entry->addrmask, entry->addrmirror,
(readorwrite == ROW_READ) ? handler->handler.read.shandler32 : NULL, handler->name,
(readorwrite == ROW_WRITE) ? handler->handler.write.shandler32 : NULL, handler->name,
handler->mask);
break;
case 64:
_memory_install_handler64(space, entry->addrstart, entry->addrend, entry->addrmask, entry->addrmirror,
(readorwrite == ROW_READ) ? handler->handler.read.shandler64 : NULL, handler->name,
(readorwrite == ROW_WRITE) ? handler->handler.write.shandler64 : NULL, handler->name,
handler->mask);
break;
}
break; break;
case AMH_PORT: case AMH_DEVICE_HANDLER:
name = handler->tag; device = devtag_get_device(space->machine, handler->tag);
switch (bits) if (device == NULL)
fatalerror("Attempted to map a non-existent device '%s' in space %s of device '%s'\n", handler->tag, space->name, (space->cpu != NULL) ? space->cpu->tag : "??");
switch ((handler->bits != 0) ? handler->bits : space->dbits)
{ {
case 8: funcptr = (readorwrite == ROW_READ) ? (genf *)input_port_read8 : (genf *)input_port_write8; break; case 8:
case 16: funcptr = (readorwrite == ROW_READ) ? (genf *)input_port_read16 : (genf *)input_port_write16; break; _memory_install_device_handler8(space, device, entry->addrstart, entry->addrend, entry->addrmask, entry->addrmirror,
case 32: funcptr = (readorwrite == ROW_READ) ? (genf *)input_port_read32 : (genf *)input_port_write32; break; (readorwrite == ROW_READ) ? handler->handler.read.dhandler8 : NULL, handler->name,
case 64: funcptr = (readorwrite == ROW_READ) ? (genf *)input_port_read64 : (genf *)input_port_write64; break; (readorwrite == ROW_WRITE) ? handler->handler.write.dhandler8 : NULL, handler->name,
handler->mask);
break;
case 16:
_memory_install_device_handler16(space, device, entry->addrstart, entry->addrend, entry->addrmask, entry->addrmirror,
(readorwrite == ROW_READ) ? handler->handler.read.dhandler16 : NULL, handler->name,
(readorwrite == ROW_WRITE) ? handler->handler.write.dhandler16 : NULL, handler->name,
handler->mask);
break;
case 32:
_memory_install_device_handler32(space, device, entry->addrstart, entry->addrend, entry->addrmask, entry->addrmirror,
(readorwrite == ROW_READ) ? handler->handler.read.dhandler32 : NULL, handler->name,
(readorwrite == ROW_WRITE) ? handler->handler.write.dhandler32 : NULL, handler->name,
handler->mask);
break;
case 64:
_memory_install_device_handler64(space, device, entry->addrstart, entry->addrend, entry->addrmask, entry->addrmirror,
(readorwrite == ROW_READ) ? handler->handler.read.dhandler64 : NULL, handler->name,
(readorwrite == ROW_WRITE) ? handler->handler.write.dhandler64 : NULL, handler->name,
handler->mask);
break;
} }
object = (void *)input_port_by_tag(&space->machine->portlist, handler->tag); break;
if (object == NULL)
fatalerror("Non-existent port '%s' referenced in memory map\n", handler->tag); case AMH_PORT:
_memory_install_port(space, entry->addrstart, entry->addrend, entry->addrmask, entry->addrmirror,
(readorwrite == ROW_READ) ? handler->tag : NULL,
(readorwrite == ROW_WRITE) ? handler->tag : NULL);
break; break;
case AMH_BANK: case AMH_BANK:
bits = space->dbits; _memory_install_bank(space, entry->addrstart, entry->addrend, entry->addrmask, entry->addrmirror,
name = handler->tag; (readorwrite == ROW_READ) ? handler->tag : NULL,
funcptr = (genf *)bank_find_or_allocate(space, handler->tag, entry->addrstart, entry->addrend, readorwrite); (readorwrite == ROW_WRITE) ? handler->tag : NULL);
break; break;
} }
/* do the actual mapping */
space_map_range_private(space, readorwrite, bits, handler->mask, entry->addrstart, entry->addrend, entry->addrmask, entry->addrmirror, funcptr, object, name);
} }
@ -2369,42 +2479,6 @@ static void map_detokenize(memory_private *memdata, address_map *map, const game
MEMORY MAPPING HELPERS MEMORY MAPPING HELPERS
***************************************************************************/ ***************************************************************************/
/*-------------------------------------------------
space_map_range_private - wrapper for
space_map_range which is used at
initialization time and converts RAM/ROM
banks to dynamically assigned banks
-------------------------------------------------*/
static void space_map_range_private(address_space *space, read_or_write readorwrite, int handlerbits, int handlerunitmask, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, genf *handler, void *object, const char *handler_name)
{
/* translate ROM to RAM/UNMAP here */
if (HANDLER_IS_ROM(handler))
handler = (readorwrite == ROW_WRITE) ? (genf *)STATIC_UNMAP : (genf *)STATIC_RAM;
/* assign banks for RAM/ROM areas */
if (HANDLER_IS_RAM(handler))
{
memory_private *memdata = space->machine->memory_data;
offs_t bytestart = addrstart;
offs_t byteend = addrend;
offs_t bytemask = addrmask;
offs_t bytemirror = addrmirror;
/* adjust the incoming addresses (temporarily) */
adjust_addresses(space, &bytestart, &byteend, &bytemask, &bytemirror);
/* assign a bank to the adjusted addresses */
handler = bank_find_or_allocate(space, NULL, bytestart, byteend, readorwrite);
if (memdata->bank_ptr[HANDLER_TO_BANK(handler)] == NULL)
memdata->bank_ptr[HANDLER_TO_BANK(handler)] = (UINT8 *)space_find_backing_memory(space, bytestart);
}
/* then do a normal installation */
space_map_range(space, readorwrite, handlerbits, handlerunitmask, addrstart, addrend, addrmask, addrmirror, handler, object, handler_name);
}
/*------------------------------------------------- /*-------------------------------------------------
space_map_range - maps a range of addresses space_map_range - maps a range of addresses
to the specified handler within an address to the specified handler within an address
@ -2470,31 +2544,34 @@ static void space_map_range(address_space *space, read_or_write readorwrite, int
device and offset device and offset
-------------------------------------------------*/ -------------------------------------------------*/
static void *space_find_backing_memory(const address_space *space, offs_t byteaddress) static void *space_find_backing_memory(const address_space *space, offs_t addrstart, offs_t addrend)
{ {
offs_t bytestart = memory_address_to_byte(space, addrstart);
offs_t byteend = memory_address_to_byte_end(space, addrend);
memory_private *memdata = space->machine->memory_data; memory_private *memdata = space->machine->memory_data;
address_map_entry *entry; address_map_entry *entry;
memory_block *block; memory_block *block;
VPRINTF(("space_find_backing_memory('%s',%s,%08X) -> ", space->cpu->tag, space->name, byteaddress)); VPRINTF(("space_find_backing_memory('%s',%s,%08X-%08X) -> ", space->cpu->tag, space->name, bytestart, byteend));
/* look in the address map first */ /* look in the address map first */
for (entry = space->map->entrylist; entry != NULL; entry = entry->next) for (entry = space->map->entrylist; entry != NULL; entry = entry->next)
{ {
offs_t maskoffs = byteaddress & entry->bytemask; offs_t maskstart = bytestart & entry->bytemask;
if (maskoffs >= entry->bytestart && maskoffs <= entry->byteend) offs_t maskend = byteend & entry->bytemask;
if (maskstart >= entry->bytestart && maskend <= entry->byteend)
{ {
VPRINTF(("found in entry %08X-%08X [%p]\n", entry->addrstart, entry->addrend, (UINT8 *)entry->memory + (maskoffs - entry->bytestart))); VPRINTF(("found in entry %08X-%08X [%p]\n", entry->addrstart, entry->addrend, (UINT8 *)entry->memory + (maskstart - entry->bytestart)));
return (UINT8 *)entry->memory + (maskoffs - entry->bytestart); return (UINT8 *)entry->memory + (maskstart - entry->bytestart);
} }
} }
/* if not found there, look in the allocated blocks */ /* if not found there, look in the allocated blocks */
for (block = memdata->memory_block_list; block != NULL; block = block->next) for (block = memdata->memory_block_list; block != NULL; block = block->next)
if (block->space == space && block->bytestart <= byteaddress && block->byteend > byteaddress) if (block->space == space && block->bytestart <= bytestart && block->byteend >= byteend)
{ {
VPRINTF(("found in allocated memory block %08X-%08X [%p]\n", block->bytestart, block->byteend, block->data + (byteaddress - block->bytestart))); VPRINTF(("found in allocated memory block %08X-%08X [%p]\n", block->bytestart, block->byteend, block->data + (bytestart - block->bytestart)));
return block->data + byteaddress - block->bytestart; return block->data + bytestart - block->bytestart;
} }
VPRINTF(("did not find\n")); VPRINTF(("did not find\n"));
@ -2539,8 +2616,10 @@ static int space_needs_backing_store(const address_space *space, const address_m
read/write handler read/write handler
-------------------------------------------------*/ -------------------------------------------------*/
void *bank_find_or_allocate(const address_space *space, const char *tag, offs_t bytestart, offs_t byteend, read_or_write readorwrite) static void *bank_find_or_allocate(const address_space *space, const char *tag, offs_t addrstart, offs_t addrend, read_or_write readorwrite)
{ {
offs_t bytestart = memory_address_to_byte(space, addrstart);
offs_t byteend = memory_address_to_byte_end(space, addrend);
memory_private *memdata = space->machine->memory_data; memory_private *memdata = space->machine->memory_data;
bank_info *bank = NULL; bank_info *bank = NULL;
char temptag[10]; char temptag[10];
@ -3031,7 +3110,6 @@ static UINT8 subtable_alloc(address_table *tabledata)
if (!subtable_merge(tabledata)) if (!subtable_merge(tabledata))
fatalerror("Ran out of subtables!"); fatalerror("Ran out of subtables!");
} }
} }

89
src/emu/memory.h
View File

@ -468,27 +468,23 @@ union _addrmap64_token
/* wrappers for dynamic read handler installation */ /* wrappers for dynamic read handler installation */
#define memory_install_read_handler(space, start, end, mask, mirror, rhandler) \
_memory_install_handler(space, start, end, mask, mirror, rhandler, (FPTR)NULL, #rhandler, NULL)
#define memory_install_read8_handler(space, start, end, mask, mirror, rhandler) \ #define memory_install_read8_handler(space, start, end, mask, mirror, rhandler) \
_memory_install_handler8(space, start, end, mask, mirror, rhandler, NULL, #rhandler, NULL) _memory_install_handler8(space, start, end, mask, mirror, rhandler, #rhandler, NULL, NULL, 0)
#define memory_install_read16_handler(space, start, end, mask, mirror, rhandler) \ #define memory_install_read16_handler(space, start, end, mask, mirror, rhandler) \
_memory_install_handler16(space, start, end, mask, mirror, rhandler, NULL, #rhandler, NULL) _memory_install_handler16(space, start, end, mask, mirror, rhandler, #rhandler, NULL, NULL, 0)
#define memory_install_read32_handler(space, start, end, mask, mirror, rhandler) \ #define memory_install_read32_handler(space, start, end, mask, mirror, rhandler) \
_memory_install_handler32(space, start, end, mask, mirror, rhandler, NULL, #rhandler, NULL) _memory_install_handler32(space, start, end, mask, mirror, rhandler, #rhandler, NULL, NULL, 0)
#define memory_install_read64_handler(space, start, end, mask, mirror, rhandler) \ #define memory_install_read64_handler(space, start, end, mask, mirror, rhandler) \
_memory_install_handler64(space, start, end, mask, mirror, rhandler, NULL, #rhandler, NULL) _memory_install_handler64(space, start, end, mask, mirror, rhandler, #rhandler, NULL, NULL, 0)
#define memory_install_read_device_handler(space, device, start, end, mask, mirror, rhandler) \
_memory_install_device_handler(space, device, start, end, mask, mirror, rhandler, NULL, #rhandler, NULL)
#define memory_install_read8_device_handler(space, device, start, end, mask, mirror, rhandler) \ #define memory_install_read8_device_handler(space, device, start, end, mask, mirror, rhandler) \
_memory_install_device_handler8(space, device, start, end, mask, mirror, rhandler, NULL, #rhandler, NULL) _memory_install_device_handler8(space, device, start, end, mask, mirror, rhandler, #rhandler, NULL, NULL, 0)
#define memory_install_read16_device_handler(space, device, start, end, mask, mirror, rhandler) \ #define memory_install_read16_device_handler(space, device, start, end, mask, mirror, rhandler) \
_memory_install_device_handler16(space, device, start, end, mask, mirror, rhandler, NULL, #rhandler, NULL) _memory_install_device_handler16(space, device, start, end, mask, mirror, rhandler, #rhandler, NULL, NULL, 0)
#define memory_install_read32_device_handler(space, device, start, end, mask, mirror, rhandler) \ #define memory_install_read32_device_handler(space, device, start, end, mask, mirror, rhandler) \
_memory_install_device_handler32(space, device, start, end, mask, mirror, rhandler, NULL, #rhandler, NULL) _memory_install_device_handler32(space, device, start, end, mask, mirror, rhandler, #rhandler, NULL, NULL, 0)
#define memory_install_read64_device_handler(space, device, start, end, mask, mirror, rhandler) \ #define memory_install_read64_device_handler(space, device, start, end, mask, mirror, rhandler) \
_memory_install_device_handler64(space, device, start, end, mask, mirror, rhandler, NULL, #rhandler, NULL) _memory_install_device_handler64(space, device, start, end, mask, mirror, rhandler, #rhandler, NULL, NULL, 0)
#define memory_install_read_port(space, start, end, mask, mirror, rtag) \ #define memory_install_read_port(space, start, end, mask, mirror, rtag) \
_memory_install_port(space, start, end, mask, mirror, rtag, NULL) _memory_install_port(space, start, end, mask, mirror, rtag, NULL)
@ -500,27 +496,23 @@ union _addrmap64_token
_memory_unmap(space, start, end, mask, mirror, TRUE, FALSE, TRUE) _memory_unmap(space, start, end, mask, mirror, TRUE, FALSE, TRUE)
/* wrappers for dynamic write handler installation */ /* wrappers for dynamic write handler installation */
#define memory_install_write_handler(space, start, end, mask, mirror, whandler) \
_memory_install_handler(space, start, end, mask, mirror, (FPTR)NULL, whandler, NULL, #whandler)
#define memory_install_write8_handler(space, start, end, mask, mirror, whandler) \ #define memory_install_write8_handler(space, start, end, mask, mirror, whandler) \
_memory_install_handler8(space, start, end, mask, mirror, NULL, whandler, NULL, #whandler) _memory_install_handler8(space, start, end, mask, mirror, NULL, NULL, whandler, #whandler, 0)
#define memory_install_write16_handler(space, start, end, mask, mirror, whandler) \ #define memory_install_write16_handler(space, start, end, mask, mirror, whandler) \
_memory_install_handler16(space, start, end, mask, mirror, NULL, whandler, NULL, #whandler) _memory_install_handler16(space, start, end, mask, mirror, NULL, NULL, whandler, #whandler, 0)
#define memory_install_write32_handler(space, start, end, mask, mirror, whandler) \ #define memory_install_write32_handler(space, start, end, mask, mirror, whandler) \
_memory_install_handler32(space, start, end, mask, mirror, NULL, whandler, NULL, #whandler) _memory_install_handler32(space, start, end, mask, mirror, NULL, NULL, whandler, #whandler, 0)
#define memory_install_write64_handler(space, start, end, mask, mirror, whandler) \ #define memory_install_write64_handler(space, start, end, mask, mirror, whandler) \
_memory_install_handler64(space, start, end, mask, mirror, NULL, whandler, NULL, #whandler) _memory_install_handler64(space, start, end, mask, mirror, NULL, NULL, whandler, #whandler, 0)
#define memory_install_write_device_handler(space, device, start, end, mask, mirror, whandler) \
_memory_install_device_handler(space, device, start, end, mask, mirror, NULL, whandler, NULL, #whandler)
#define memory_install_write8_device_handler(space, device, start, end, mask, mirror, whandler) \ #define memory_install_write8_device_handler(space, device, start, end, mask, mirror, whandler) \
_memory_install_device_handler8(space, device, start, end, mask, mirror, NULL, whandler, NULL, #whandler) _memory_install_device_handler8(space, device, start, end, mask, mirror, NULL, NULL, whandler, #whandler, 0)
#define memory_install_write16_device_handler(space, device, start, end, mask, mirror, whandler) \ #define memory_install_write16_device_handler(space, device, start, end, mask, mirror, whandler) \
_memory_install_device_handler16(space, device, start, end, mask, mirror, NULL, whandler, NULL, #whandler) _memory_install_device_handler16(space, device, start, end, mask, mirror, NULL, NULL, whandler, #whandler, 0)
#define memory_install_write32_device_handler(space, device, start, end, mask, mirror, whandler) \ #define memory_install_write32_device_handler(space, device, start, end, mask, mirror, whandler) \
_memory_install_device_handler32(space, device, start, end, mask, mirror, NULL, whandler, NULL, #whandler) _memory_install_device_handler32(space, device, start, end, mask, mirror, NULL, NULL, whandler, #whandler, 0)
#define memory_install_write64_device_handler(space, device, start, end, mask, mirror, whandler) \ #define memory_install_write64_device_handler(space, device, start, end, mask, mirror, whandler) \
_memory_install_device_handler64(space, device, start, end, mask, mirror, NULL, whandler, NULL, #whandler) _memory_install_device_handler64(space, device, start, end, mask, mirror, NULL, NULL, whandler, #whandler, 0)
#define memory_install_write_port(space, start, end, mask, mirror, wtag) \ #define memory_install_write_port(space, start, end, mask, mirror, wtag) \
_memory_install_port(space, start, end, mask, mirror, NULL, wtag) _memory_install_port(space, start, end, mask, mirror, NULL, wtag)
@ -532,27 +524,23 @@ union _addrmap64_token
_memory_unmap(space, start, end, mask, mirror, FALSE, TRUE, TRUE) _memory_unmap(space, start, end, mask, mirror, FALSE, TRUE, TRUE)
/* wrappers for dynamic read/write handler installation */ /* wrappers for dynamic read/write handler installation */
#define memory_install_readwrite_handler(space, start, end, mask, mirror, rhandler, whandler) \
_memory_install_handler(space, start, end, mask, mirror, rhandler, whandler, #rhandler, #whandler)
#define memory_install_readwrite8_handler(space, start, end, mask, mirror, rhandler, whandler) \ #define memory_install_readwrite8_handler(space, start, end, mask, mirror, rhandler, whandler) \
_memory_install_handler8(space, start, end, mask, mirror, rhandler, whandler, #rhandler, #whandler) _memory_install_handler8(space, start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler, 0)
#define memory_install_readwrite16_handler(space, start, end, mask, mirror, rhandler, whandler) \ #define memory_install_readwrite16_handler(space, start, end, mask, mirror, rhandler, whandler) \
_memory_install_handler16(space, start, end, mask, mirror, rhandler, whandler, #rhandler, #whandler) _memory_install_handler16(space, start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler, 0)
#define memory_install_readwrite32_handler(space, start, end, mask, mirror, rhandler, whandler) \ #define memory_install_readwrite32_handler(space, start, end, mask, mirror, rhandler, whandler) \
_memory_install_handler32(space, start, end, mask, mirror, rhandler, whandler, #rhandler, #whandler) _memory_install_handler32(space, start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler, 0)
#define memory_install_readwrite64_handler(space, start, end, mask, mirror, rhandler, whandler) \ #define memory_install_readwrite64_handler(space, start, end, mask, mirror, rhandler, whandler) \
_memory_install_handler64(space, start, end, mask, mirror, rhandler, whandler, #rhandler, #whandler) _memory_install_handler64(space, start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler, 0)
#define memory_install_readwrite_device_handler(space, device, start, end, mask, mirror, rhandler, whandler) \
_memory_install_device_handler(space, device, start, end, mask, mirror, rhandler, whandler, #rhandler, #whandler)
#define memory_install_readwrite8_device_handler(space, device, start, end, mask, mirror, rhandler, whandler) \ #define memory_install_readwrite8_device_handler(space, device, start, end, mask, mirror, rhandler, whandler) \
_memory_install_device_handler8(space, device, start, end, mask, mirror, rhandler, whandler, #rhandler, #whandler) _memory_install_device_handler8(space, device, start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler, 0)
#define memory_install_readwrite16_device_handler(space, device, start, end, mask, mirror, rhandler, whandler) \ #define memory_install_readwrite16_device_handler(space, device, start, end, mask, mirror, rhandler, whandler) \
_memory_install_device_handler16(space, device, start, end, mask, mirror, rhandler, whandler, #rhandler, #whandler) _memory_install_device_handler16(space, device, start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler, 0)
#define memory_install_readwrite32_device_handler(space, device, start, end, mask, mirror, rhandler, whandler) \ #define memory_install_readwrite32_device_handler(space, device, start, end, mask, mirror, rhandler, whandler) \
_memory_install_device_handler32(space, device, start, end, mask, mirror, rhandler, whandler, #rhandler, #whandler) _memory_install_device_handler32(space, device, start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler, 0)
#define memory_install_readwrite64_device_handler(space, device, start, end, mask, mirror, rhandler, whandler) \ #define memory_install_readwrite64_device_handler(space, device, start, end, mask, mirror, rhandler, whandler) \
_memory_install_device_handler64(space, device, start, end, mask, mirror, rhandler, whandler, #rhandler, #whandler) _memory_install_device_handler64(space, device, start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler, 0)
#define memory_install_readwrite_port(space, start, end, mask, mirror, rtag, wtag) \ #define memory_install_readwrite_port(space, start, end, mask, mirror, rtag, wtag) \
_memory_install_port(space, start, end, mask, mirror, rtag, wtag) _memory_install_port(space, start, end, mask, mirror, rtag, wtag)
@ -998,35 +986,29 @@ void memory_set_bankptr(running_machine *machine, const char *tag, void *base) A
/* ----- dynamic address space mapping ----- */ /* ----- dynamic address space mapping ----- */
/* install a new memory handler into the given address space, returning a pointer to the memory backing it, if present */ /* install a new 8-bit memory handler into the given address space, returning a pointer to the memory backing it, if present */
void *_memory_install_handler(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, FPTR rhandler, FPTR whandler, const char *rhandler_name, const char *whandler_name) ATTR_NONNULL(1); UINT8 *_memory_install_handler8(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_space_func rhandler, const char *rhandler_name, write8_space_func whandler, const char *whandler_name, int handlerunitmask) ATTR_NONNULL(1);
/* same as above but explicitly for 8-bit handlers */
UINT8 *_memory_install_handler8(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_space_func rhandler, write8_space_func whandler, const char *rhandler_name, const char *whandler_name) ATTR_NONNULL(1);
/* same as above but explicitly for 16-bit handlers */ /* same as above but explicitly for 16-bit handlers */
UINT16 *_memory_install_handler16(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read16_space_func rhandler, write16_space_func whandler, const char *rhandler_name, const char *whandler_name) ATTR_NONNULL(1); UINT16 *_memory_install_handler16(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read16_space_func rhandler, const char *rhandler_name, write16_space_func whandler, const char *whandler_name, int handlerunitmask) ATTR_NONNULL(1);
/* same as above but explicitly for 32-bit handlers */ /* same as above but explicitly for 32-bit handlers */
UINT32 *_memory_install_handler32(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read32_space_func rhandler, write32_space_func whandler, const char *rhandler_name, const char *whandler_name) ATTR_NONNULL(1); UINT32 *_memory_install_handler32(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read32_space_func rhandler, const char *rhandler_name, write32_space_func whandler, const char *whandler_name, int handlerunitmask) ATTR_NONNULL(1);
/* same as above but explicitly for 64-bit handlers */ /* same as above but explicitly for 64-bit handlers */
UINT64 *_memory_install_handler64(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read64_space_func rhandler, write64_space_func whandler, const char *rhandler_name, const char *whandler_name) ATTR_NONNULL(1); UINT64 *_memory_install_handler64(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read64_space_func rhandler, const char *rhandler_name, write64_space_func whandler, const char *whandler_name, int handlerunitmask) ATTR_NONNULL(1);
/* install a new device memory handler into the given address space, returning a pointer to the memory backing it, if present */ /* install a new 8-bit device memory handler into the given address space, returning a pointer to the memory backing it, if present */
void *_memory_install_device_handler(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, FPTR rhandler, FPTR whandler, const char *rhandler_name, const char *whandler_name) ATTR_NONNULL(1, 2); UINT8 *_memory_install_device_handler8(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_device_func rhandler, const char *rhandler_name, write8_device_func whandler, const char *whandler_name, int handlerunitmask) ATTR_NONNULL(1, 2);
/* same as above but explicitly for 8-bit handlers */
UINT8 *_memory_install_device_handler8(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_device_func rhandler, write8_device_func whandler, const char *rhandler_name, const char *whandler_name) ATTR_NONNULL(1, 2);
/* same as above but explicitly for 16-bit handlers */ /* same as above but explicitly for 16-bit handlers */
UINT16 *_memory_install_device_handler16(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read16_device_func rhandler, write16_device_func whandler, const char *rhandler_name, const char *whandler_name) ATTR_NONNULL(1, 2); UINT16 *_memory_install_device_handler16(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read16_device_func rhandler, const char *rhandler_name, write16_device_func whandler, const char *whandler_name, int handlerunitmask) ATTR_NONNULL(1, 2);
/* same as above but explicitly for 32-bit handlers */ /* same as above but explicitly for 32-bit handlers */
UINT32 *_memory_install_device_handler32(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read32_device_func rhandler, write32_device_func whandler, const char *rhandler_name, const char *whandler_name) ATTR_NONNULL(1, 2); UINT32 *_memory_install_device_handler32(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read32_device_func rhandler, const char *rhandler_name, write32_device_func whandler, const char *whandler_name, int handlerunitmask) ATTR_NONNULL(1, 2);
/* same as above but explicitly for 64-bit handlers */ /* same as above but explicitly for 64-bit handlers */
UINT64 *_memory_install_device_handler64(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read64_device_func rhandler, write64_device_func whandler, const char *rhandler_name, const char *whandler_name) ATTR_NONNULL(1, 2); UINT64 *_memory_install_device_handler64(const address_space *space, const device_config *device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read64_device_func rhandler, const char *rhandler_name, write64_device_func whandler, const char *whandler_name, int handlerunitmask) ATTR_NONNULL(1, 2);
/* install a new port into the given address space */ /* install a new port into the given address space */
void _memory_install_port(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag) ATTR_NONNULL(1); void _memory_install_port(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag) ATTR_NONNULL(1);
@ -1034,6 +1016,9 @@ void _memory_install_port(const address_space *space, offs_t addrstart, offs_t a
/* install a new bank into the given address space */ /* install a new bank into the given address space */
void _memory_install_bank(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag) ATTR_NONNULL(1); void _memory_install_bank(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag) ATTR_NONNULL(1);
/* install a simple fixed RAM region into the given address space */
void _memory_install_ram(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, UINT8 install_read, UINT8 install_write) ATTR_NONNULL(1);
/* unmap a section of address space */ /* unmap a section of address space */
void _memory_unmap(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, UINT8 unmap_read, UINT8 unmap_write, UINT8 quiet) ATTR_NONNULL(1); void _memory_unmap(const address_space *space, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, UINT8 unmap_read, UINT8 unmap_write, UINT8 quiet) ATTR_NONNULL(1);

6
src/mame/drivers/vegas.c
View File

@ -1682,12 +1682,12 @@ static void remap_dynamic_addresses(running_machine *machine)
if (dynamic[addr].mread == NOP_HANDLER) if (dynamic[addr].mread == NOP_HANDLER)
memory_nop_read(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), dynamic[addr].start, dynamic[addr].end, 0, 0); memory_nop_read(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), dynamic[addr].start, dynamic[addr].end, 0, 0);
else if (dynamic[addr].mread != NULL) else if (dynamic[addr].mread != NULL)
_memory_install_handler32(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), dynamic[addr].start, dynamic[addr].end, 0, 0, dynamic[addr].mread, NULL, dynamic[addr].rdname, NULL); _memory_install_handler32(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), dynamic[addr].start, dynamic[addr].end, 0, 0, dynamic[addr].mread, dynamic[addr].rdname, NULL, NULL, 0);
if (dynamic[addr].mwrite != NULL) if (dynamic[addr].mwrite != NULL)
_memory_install_handler32(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), dynamic[addr].start, dynamic[addr].end, 0, 0, NULL, dynamic[addr].mwrite, NULL, dynamic[addr].wrname); _memory_install_handler32(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), dynamic[addr].start, dynamic[addr].end, 0, 0, NULL, NULL, dynamic[addr].mwrite, dynamic[addr].wrname, 0);
if (dynamic[addr].dread != NULL || dynamic[addr].dwrite != NULL) if (dynamic[addr].dread != NULL || dynamic[addr].dwrite != NULL)
_memory_install_device_handler32(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), dynamic[addr].device, dynamic[addr].start, dynamic[addr].end, 0, 0, dynamic[addr].dread, dynamic[addr].dwrite, dynamic[addr].rdname, dynamic[addr].wrname); _memory_install_device_handler32(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), dynamic[addr].device, dynamic[addr].start, dynamic[addr].end, 0, 0, dynamic[addr].dread, dynamic[addr].rdname, dynamic[addr].dwrite, dynamic[addr].wrname, 0);
} }
if (LOG_DYNAMIC) if (LOG_DYNAMIC)