From 75d18b3a334c459f480d722167850b2c60ab2431 Mon Sep 17 00:00:00 2001 From: Aaron Giles Date: Sat, 28 Jun 2008 07:21:54 +0000 Subject: [PATCH] Changed how watchpoints work so that supporting them adds 0 overhead unless some are actually live. Changed a few call sites from using memory_set_context() to cpuintrf_push_context(). --- src/emu/debug/debugcpu.c | 127 ++-- src/emu/debug/debugcpu.h | 8 +- src/emu/memory.c | 1155 +++++++++++++++++++----------------- src/emu/memory.h | 5 +- src/mame/machine/pitnrun.c | 8 +- src/mame/machine/taitosj.c | 8 +- 6 files changed, 698 insertions(+), 613 deletions(-) diff --git a/src/emu/debug/debugcpu.c b/src/emu/debug/debugcpu.c index 5a8c9c1ea1c..56d947a054e 100644 --- a/src/emu/debug/debugcpu.c +++ b/src/emu/debug/debugcpu.c @@ -59,7 +59,6 @@ struct _debugger_private UINT8 memory_modified; int execution_state; - int memory_hook_cpunum; UINT32 bpindex; UINT32 wpindex; @@ -355,6 +354,10 @@ static void compute_debug_flags(running_machine *machine, const debug_cpu_info * /* add in the watchpoint flags */ machine->debug_flags |= (info->flags & DEBUG_FLAG_WATCHPOINT) >> (24 - 4); + + /* if any of the watchpoint flags are set and we're live, tell the memory system */ + if (global.livecpu != NULL && ((info->flags & DEBUG_FLAG_WATCHPOINT) != 0)) + memory_set_context(-1); } @@ -598,6 +601,42 @@ void debug_cpu_instruction_hook(running_machine *machine, offs_t curpc) } +/*------------------------------------------------- + debug_cpu_memory_read_hook - the memory system + calls this hook when watchpoints are enabled + and a memory read happens +-------------------------------------------------*/ + +void debug_cpu_memory_read_hook(running_machine *machine, int cpunum, int spacenum, offs_t address, UINT64 mem_mask) +{ + debug_cpu_info *info = &global.cpuinfo[cpunum]; + + /* check watchpoints */ + if ((info->flags & (DEBUG_FLAG_LIVE_WPR_PROGRAM << spacenum)) != 0) + watchpoint_check(cpunum, spacenum, WATCHPOINT_READ, address, 0, mem_mask); + + /* check hotspots */ + if (info->hotspots != NULL) + check_hotspots(cpunum, spacenum, address); +} + + +/*------------------------------------------------- + debug_cpu_memory_write_hook - the memory + system calls this hook when watchpoints are + enabled and a memory write happens +-------------------------------------------------*/ + +void debug_cpu_memory_write_hook(running_machine *machine, int cpunum, int spacenum, offs_t address, UINT64 data, UINT64 mem_mask) +{ + debug_cpu_info *info = &global.cpuinfo[cpunum]; + + /* check watchpoints */ + if ((info->flags & (DEBUG_FLAG_LIVE_WPW_PROGRAM << spacenum)) != 0) + watchpoint_check(cpunum, spacenum, WATCHPOINT_WRITE, address, data, mem_mask); +} + + /*************************************************************************** EXECUTION CONTROL @@ -1045,61 +1084,6 @@ static void process_source_file(void) } -/*------------------------------------------------- - standard_debug_hook_read - standard read hook --------------------------------------------------*/ - -static void standard_debug_hook_read(int spacenum, offs_t address, UINT64 mem_mask) -{ - debug_cpu_info *info = &global.cpuinfo[global.memory_hook_cpunum]; - - /* check watchpoints */ - if ((info->flags & (DEBUG_FLAG_LIVE_WPR_PROGRAM << spacenum)) != 0) - watchpoint_check(global.memory_hook_cpunum, spacenum, WATCHPOINT_READ, address, 0, mem_mask); - - /* check hotspots */ - if (info->hotspots != NULL) - check_hotspots(global.memory_hook_cpunum, spacenum, address); -} - - -/*------------------------------------------------- - standard_debug_hook_write - standard write hook --------------------------------------------------*/ - -static void standard_debug_hook_write(int spacenum, offs_t address, UINT64 data, UINT64 mem_mask) -{ - debug_cpu_info *info = &global.cpuinfo[global.memory_hook_cpunum]; - - /* check watchpoints */ - if ((info->flags & (DEBUG_FLAG_LIVE_WPW_PROGRAM << spacenum)) != 0) - watchpoint_check(global.memory_hook_cpunum, spacenum, WATCHPOINT_WRITE, address, data, mem_mask); -} - - -/*------------------------------------------------- - debug_cpu_get_memory_hooks - get memory hooks - for the specified CPU --------------------------------------------------*/ - -void debug_cpu_get_memory_hooks(int cpunum, debug_hook_read_func *read, debug_hook_write_func *write) -{ - debug_cpu_info *info = &global.cpuinfo[cpunum]; - - global.memory_hook_cpunum = cpunum; - - if ((info->flags & DEBUG_FLAG_READ_WATCHPOINT) != 0 || info->hotspots != NULL) - *read = standard_debug_hook_read; - else - *read = NULL; - - if ((info->flags & DEBUG_FLAG_WRITE_WATCHPOINT) != 0) - *write = standard_debug_hook_write; - else - *write = NULL; -} - - /*------------------------------------------------- debug_cpu_set_instruction_hook - set a hook to be called on each instruction for a given CPU @@ -1140,6 +1124,10 @@ static void breakpoint_update_flags(debug_cpu_info *info) info->flags |= DEBUG_FLAG_LIVE_BP; break; } + + /* push the flags out globally */ + if (global.livecpu != NULL) + compute_debug_flags(Machine, global.livecpu); } @@ -1291,6 +1279,13 @@ static void watchpoint_update_flags(debug_cpu_info *info, int spacenum) UINT32 writeflag = DEBUG_FLAG_LIVE_WPW_PROGRAM << spacenum; UINT32 readflag = DEBUG_FLAG_LIVE_WPR_PROGRAM << spacenum; debug_cpu_watchpoint *wp; + + /* if hotspots are enabled, turn on all reads */ + if (info->hotspots != NULL) + { + info->flags |= DEBUG_FLAG_READ_WATCHPOINT; + readflag = 0; + } /* see if there are any enabled breakpoints */ info->flags &= ~(readflag | writeflag); @@ -1310,6 +1305,10 @@ static void watchpoint_update_flags(debug_cpu_info *info, int spacenum) if ((readflag | writeflag) == 0) break; } + + /* push the flags out globally */ + if (global.livecpu != NULL) + compute_debug_flags(Machine, global.livecpu); } @@ -1395,6 +1394,7 @@ static void watchpoint_check(int cpunum, int spacenum, int type, offs_t address, else sprintf(buffer, "Stopped at watchpoint %X reading %s from %08X (PC=%X)", wp->index, sizes[size], BYTE2ADDR(address, &global.cpuinfo[cpunum], spacenum), activecpu_get_pc()); debug_console_printf("%s\n", buffer); + compute_debug_flags(Machine, info); } break; } @@ -1432,10 +1432,6 @@ int debug_cpu_watchpoint_set(int cpunum, int spacenum, int type, offs_t address, watchpoint_update_flags(info, spacenum); - /* force debug_cpu_get_memory_hooks() to be called */ - cpuintrf_push_context(-1); - cpuintrf_pop_context(); - return wp->index; } @@ -1472,11 +1468,6 @@ int debug_cpu_watchpoint_clear(int wpnum) free(wp); watchpoint_update_flags(info, spacenum); - - /* force debug_cpu_get_memory_hooks() to be called */ - cpuintrf_push_context(-1); - cpuintrf_pop_context(); - return 1; } } @@ -1510,7 +1501,6 @@ int debug_cpu_watchpoint_enable(int wpnum, int enable) return 1; } } - return 0; } @@ -1546,10 +1536,7 @@ int debug_cpu_hotspot_track(int cpunum, int numspots, int threshhold) info->hotspot_threshhold = threshhold; } - /* force debug_cpu_get_memory_hooks() to be called */ - cpuintrf_push_context(-1); - cpuintrf_pop_context(); - + watchpoint_update_flags(info, ADDRESS_SPACE_PROGRAM); return 1; } diff --git a/src/emu/debug/debugcpu.h b/src/emu/debug/debugcpu.h index ae898cb0098..16ab211a1e6 100644 --- a/src/emu/debug/debugcpu.h +++ b/src/emu/debug/debugcpu.h @@ -228,12 +228,18 @@ void debug_cpu_stop_hook(running_machine *machine, int cpunum); /* the CPU execution system calls this hook when an interrupt is acknowledged */ void debug_cpu_interrupt_hook(running_machine *machine, int cpunum, int irqline); -/* the CPU execution system calls this hook when an exception is generated */ +/* called by the CPU cores when an exception is generated */ void debug_cpu_exception_hook(running_machine *machine, int cpunum, int exception); /* called by the CPU cores before executing each instruction */ void debug_cpu_instruction_hook(running_machine *machine, offs_t curpc); +/* the memory system calls this hook when watchpoints are enabled and a memory read happens */ +void debug_cpu_memory_read_hook(running_machine *machine, int cpunum, int spacenum, offs_t address, UINT64 mem_mask); + +/* the memory system calls this hook when watchpoints are enabled and a memory write happens */ +void debug_cpu_memory_write_hook(running_machine *machine, int cpunum, int spacenum, offs_t address, UINT64 data, UINT64 mem_mask); + /* ----- core debugger functions ----- */ diff --git a/src/emu/memory.c b/src/emu/memory.c index e30a2d3a3e5..994f9e11670 100644 --- a/src/emu/memory.c +++ b/src/emu/memory.c @@ -193,9 +193,6 @@ typedef enum _read_or_write read_or_write; #define SUBTABLE_PTR(tabledata, entry) (&(tabledata)->table[(1 << LEVEL1_BITS) + (((entry) - SUBTABLE_BASE) << LEVEL2_BITS)]) -#define DEBUG_HOOK_READ(spacenum,address,mem_mask) if (debug_hook_read) (*debug_hook_read)(spacenum,address,mem_mask) -#define DEBUG_HOOK_WRITE(spacenum,address,data,mem_mask) if (debug_hook_write) (*debug_hook_write)(spacenum,address,data,mem_mask) - /*************************************************************************** @@ -319,8 +316,7 @@ static UINT8 log_unmap[ADDRESS_SPACES]; /* log unmapped memory accesses */ static cpu_data cpudata[MAX_CPU]; /* data gathered for each CPU */ static bank_info bankdata[STATIC_COUNT]; /* data gathered for each bank */ -static debug_hook_read_func debug_hook_read; /* pointer to debugger callback for memory reads */ -static debug_hook_write_func debug_hook_write; /* pointer to debugger callback for memory writes */ +static UINT8 * wptable; /* watchpoint-fill table */ #define ACCESSOR_GROUP(type, width) \ { \ @@ -378,7 +374,7 @@ const char *const address_space_names[ADDRESS_SPACES] = { "program", "data", "I/ static void address_map_detokenize(address_map *map, const addrmap_token *tokens); -static void memory_init_cpudata(const machine_config *config); +static void memory_init_cpudata(running_machine *machine); static void memory_init_preflight(const machine_config *config); static void memory_init_populate(running_machine *machine); static void space_map_range_private(addrspace_data *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); @@ -447,6 +443,263 @@ INLINE void adjust_addresses(addrspace_data *space, offs_t *start, offs_t *end, } +/*------------------------------------------------- + read_byte_generic - read a byte from an + arbitrary address space +-------------------------------------------------*/ + +INLINE UINT8 read_byte_generic(UINT8 spacenum, offs_t address) +{ + const address_space *space = &active_address_space[spacenum]; + const handler_data *handler; + offs_t offset; + UINT32 entry; + UINT8 result; + + profiler_mark(PROFILER_MEMREAD); + + address &= space->bytemask; + entry = space->readlookup[LEVEL1_INDEX(address)]; + if (entry >= SUBTABLE_BASE) + entry = space->readlookup[LEVEL2_INDEX(entry, address)]; + handler = &space->readhandlers[entry]; + + offset = (address - handler->bytestart) & handler->bytemask; + if (entry < STATIC_RAM) + result = bank_ptr[entry][offset]; + else + result = (*handler->handler.read.mhandler8)(handler->object, offset); + + profiler_mark(PROFILER_END); + return result; +} + + +/*------------------------------------------------- + write_byte_generic - write a byte to an + arbitrary address space +-------------------------------------------------*/ + +INLINE void write_byte_generic(UINT8 spacenum, offs_t address, UINT8 data) +{ + const address_space *space = &active_address_space[spacenum]; + const handler_data *handler; + offs_t offset; + UINT32 entry; + + profiler_mark(PROFILER_MEMWRITE); + + address &= space->bytemask; + entry = space->writelookup[LEVEL1_INDEX(address)]; + if (entry >= SUBTABLE_BASE) + entry = space->writelookup[LEVEL2_INDEX(entry, address)]; + handler = &space->writehandlers[entry]; + + offset = (address - handler->bytestart) & handler->bytemask; + if (entry < STATIC_RAM) + bank_ptr[entry][offset] = data; + else + (*handler->handler.write.mhandler8)(handler->object, offset, data); + + profiler_mark(PROFILER_END); +} + + +/*------------------------------------------------- + read_word_generic - read a word from an + arbitrary address space +-------------------------------------------------*/ + +INLINE UINT16 read_word_generic(UINT8 spacenum, offs_t address, UINT16 mem_mask) +{ + const address_space *space = &active_address_space[spacenum]; + const handler_data *handler; + offs_t offset; + UINT32 entry; + UINT16 result; + + profiler_mark(PROFILER_MEMREAD); + + address &= space->bytemask; + entry = space->readlookup[LEVEL1_INDEX(address)]; + if (entry >= SUBTABLE_BASE) + entry = space->readlookup[LEVEL2_INDEX(entry, address)]; + handler = &space->readhandlers[entry]; + + offset = (address - handler->bytestart) & handler->bytemask; + if (entry < STATIC_RAM) + result = *(UINT16 *)&bank_ptr[entry][offset & ~1]; + else + result = (*handler->handler.read.mhandler16)(handler->object, offset >> 1, mem_mask); + + profiler_mark(PROFILER_END); + return result; +} + + +/*------------------------------------------------- + write_word_generic - write a word to an + arbitrary address space +-------------------------------------------------*/ + +INLINE void write_word_generic(UINT8 spacenum, offs_t address, UINT16 data, UINT16 mem_mask) +{ + const address_space *space = &active_address_space[spacenum]; + const handler_data *handler; + offs_t offset; + UINT32 entry; + + profiler_mark(PROFILER_MEMWRITE); + + address &= space->bytemask; + entry = space->writelookup[LEVEL1_INDEX(address)]; + if (entry >= SUBTABLE_BASE) + entry = space->writelookup[LEVEL2_INDEX(entry, address)]; + handler = &space->writehandlers[entry]; + + offset = (address - handler->bytestart) & handler->bytemask; + if (entry < STATIC_RAM) + { + UINT16 *dest = (UINT16 *)&bank_ptr[entry][offset & ~1]; + *dest = (*dest & ~mem_mask) | (data & mem_mask); + } + else + (*handler->handler.write.mhandler16)(handler->object, offset >> 1, data, mem_mask); + + profiler_mark(PROFILER_END); +} + + +/*------------------------------------------------- + read_dword_generic - read a dword from an + arbitrary address space +-------------------------------------------------*/ + +INLINE UINT32 read_dword_generic(UINT8 spacenum, offs_t address, UINT32 mem_mask) +{ + const address_space *space = &active_address_space[spacenum]; + const handler_data *handler; + offs_t offset; + UINT32 entry; + UINT32 result; + + profiler_mark(PROFILER_MEMREAD); + + address &= space->bytemask; + entry = space->readlookup[LEVEL1_INDEX(address)]; + if (entry >= SUBTABLE_BASE) + entry = space->readlookup[LEVEL2_INDEX(entry, address)]; + handler = &space->readhandlers[entry]; + + offset = (address - handler->bytestart) & handler->bytemask; + if (entry < STATIC_RAM) + result = *(UINT32 *)&bank_ptr[entry][offset & ~3]; + else + result = (*handler->handler.read.mhandler32)(handler->object, offset >> 2, mem_mask); + + profiler_mark(PROFILER_END); + return result; +} + + +/*------------------------------------------------- + write_dword_generic - write a dword to an + arbitrary address space +-------------------------------------------------*/ + +INLINE void write_dword_generic(UINT8 spacenum, offs_t address, UINT32 data, UINT32 mem_mask) +{ + const address_space *space = &active_address_space[spacenum]; + const handler_data *handler; + offs_t offset; + UINT32 entry; + + profiler_mark(PROFILER_MEMWRITE); + + address &= space->bytemask; + entry = space->writelookup[LEVEL1_INDEX(address)]; + if (entry >= SUBTABLE_BASE) + entry = space->writelookup[LEVEL2_INDEX(entry, address)]; + handler = &space->writehandlers[entry]; + + offset = (address - handler->bytestart) & handler->bytemask; + if (entry < STATIC_RAM) + { + UINT32 *dest = (UINT32 *)&bank_ptr[entry][offset & ~3]; + *dest = (*dest & ~mem_mask) | (data & mem_mask); + } + else + (*handler->handler.write.mhandler32)(handler->object, offset >> 2, data, mem_mask); + + profiler_mark(PROFILER_END); +} + + +/*------------------------------------------------- + read_qword_generic - read a qword from an + arbitrary address space +-------------------------------------------------*/ + +INLINE UINT64 read_qword_generic(UINT8 spacenum, offs_t address, UINT64 mem_mask) +{ + const address_space *space = &active_address_space[spacenum]; + const handler_data *handler; + offs_t offset; + UINT32 entry; + UINT64 result; + + profiler_mark(PROFILER_MEMREAD); + + address &= space->bytemask; + entry = space->readlookup[LEVEL1_INDEX(address)]; + if (entry >= SUBTABLE_BASE) + entry = space->readlookup[LEVEL2_INDEX(entry, address)]; + handler = &space->readhandlers[entry]; + + offset = (address - handler->bytestart) & handler->bytemask; + if (entry < STATIC_RAM) + result = *(UINT64 *)&bank_ptr[entry][offset & ~7]; + else + result = (*handler->handler.read.mhandler64)(handler->object, offset >> 3, mem_mask); + + profiler_mark(PROFILER_END); + return result; +} + + +/*------------------------------------------------- + write_qword_generic - write a qword to an + arbitrary address space +-------------------------------------------------*/ + +INLINE void write_qword_generic(UINT8 spacenum, offs_t address, UINT64 data, UINT64 mem_mask) +{ + const address_space *space = &active_address_space[spacenum]; + const handler_data *handler; + offs_t offset; + UINT32 entry; + + profiler_mark(PROFILER_MEMWRITE); + + address &= space->bytemask; + entry = space->writelookup[LEVEL1_INDEX(address)]; + if (entry >= SUBTABLE_BASE) + entry = space->writelookup[LEVEL2_INDEX(entry, address)]; + handler = &space->writehandlers[entry]; + + offset = (address - handler->bytestart) & handler->bytemask; + if (entry < STATIC_RAM) + { + UINT64 *dest = (UINT64 *)&bank_ptr[entry][offset & ~7]; + *dest = (*dest & ~mem_mask) | (data & mem_mask); + } + else + (*handler->handler.write.mhandler64)(handler->object, offset >> 3, data, mem_mask); + + profiler_mark(PROFILER_END); +} + + /*************************************************************************** CORE SYSTEM OPERATIONS @@ -473,7 +726,7 @@ void memory_init(running_machine *machine) memset(bankd_ptr, 0, sizeof(bankd_ptr)); /* build up the cpudata array with info about all CPUs and address spaces */ - memory_init_cpudata(machine->config); + memory_init_cpudata(machine); /* preflight the memory handlers and check banks */ memory_init_preflight(machine->config); @@ -520,6 +773,10 @@ static void memory_exit(running_machine *machine) if (space->write.table != NULL) free(space->write.table); } + + /* free the global watchpoint table */ + if (wptable != NULL) + free(wptable); } @@ -529,53 +786,49 @@ static void memory_exit(running_machine *machine) void memory_set_context(int activecpu) { + addrspace_data *space; + /* remember dynamic RAM/ROM */ - if (cur_context != -1) - { + if (activecpu == -1) + activecpu = cur_context; + else if (cur_context != -1) cpudata[cur_context].opbase = opbase; - } cur_context = activecpu; opbase = cpudata[activecpu].opbase; + opbase_handler = cpudata[activecpu].opbase_handler; /* program address space */ - active_address_space[ADDRESS_SPACE_PROGRAM].bytemask = cpudata[activecpu].space[ADDRESS_SPACE_PROGRAM].bytemask; - active_address_space[ADDRESS_SPACE_PROGRAM].readlookup = cpudata[activecpu].space[ADDRESS_SPACE_PROGRAM].read.table; - active_address_space[ADDRESS_SPACE_PROGRAM].writelookup = cpudata[activecpu].space[ADDRESS_SPACE_PROGRAM].write.table; - active_address_space[ADDRESS_SPACE_PROGRAM].readhandlers = cpudata[activecpu].space[ADDRESS_SPACE_PROGRAM].read.handlers; - active_address_space[ADDRESS_SPACE_PROGRAM].writehandlers = cpudata[activecpu].space[ADDRESS_SPACE_PROGRAM].write.handlers; - active_address_space[ADDRESS_SPACE_PROGRAM].accessors = cpudata[activecpu].space[ADDRESS_SPACE_PROGRAM].accessors; + space = &cpudata[activecpu].space[ADDRESS_SPACE_PROGRAM]; + active_address_space[ADDRESS_SPACE_PROGRAM].bytemask = space->bytemask; + active_address_space[ADDRESS_SPACE_PROGRAM].readlookup = ((Machine->debug_flags & DEBUG_FLAG_WPR_PROGRAM) != 0) ? wptable : space->read.table; + active_address_space[ADDRESS_SPACE_PROGRAM].writelookup = ((Machine->debug_flags & DEBUG_FLAG_WPW_PROGRAM) != 0) ? wptable : space->write.table; + active_address_space[ADDRESS_SPACE_PROGRAM].readhandlers = space->read.handlers; + active_address_space[ADDRESS_SPACE_PROGRAM].writehandlers = space->write.handlers; + active_address_space[ADDRESS_SPACE_PROGRAM].accessors = space->accessors; /* data address space */ if (cpudata[activecpu].spacemask & (1 << ADDRESS_SPACE_DATA)) { - active_address_space[ADDRESS_SPACE_DATA].bytemask = cpudata[activecpu].space[ADDRESS_SPACE_DATA].bytemask; - active_address_space[ADDRESS_SPACE_DATA].readlookup = cpudata[activecpu].space[ADDRESS_SPACE_DATA].read.table; - active_address_space[ADDRESS_SPACE_DATA].writelookup = cpudata[activecpu].space[ADDRESS_SPACE_DATA].write.table; - active_address_space[ADDRESS_SPACE_DATA].readhandlers = cpudata[activecpu].space[ADDRESS_SPACE_DATA].read.handlers; - active_address_space[ADDRESS_SPACE_DATA].writehandlers = cpudata[activecpu].space[ADDRESS_SPACE_DATA].write.handlers; - active_address_space[ADDRESS_SPACE_DATA].accessors = cpudata[activecpu].space[ADDRESS_SPACE_DATA].accessors; + space = &cpudata[activecpu].space[ADDRESS_SPACE_DATA]; + active_address_space[ADDRESS_SPACE_DATA].bytemask = space->bytemask; + active_address_space[ADDRESS_SPACE_DATA].readlookup = ((Machine->debug_flags & DEBUG_FLAG_WPR_DATA) != 0) ? wptable : space->read.table; + active_address_space[ADDRESS_SPACE_DATA].writelookup = ((Machine->debug_flags & DEBUG_FLAG_WPW_DATA) != 0) ? wptable : space->write.table; + active_address_space[ADDRESS_SPACE_DATA].readhandlers = space->read.handlers; + active_address_space[ADDRESS_SPACE_DATA].writehandlers = space->write.handlers; + active_address_space[ADDRESS_SPACE_DATA].accessors = space->accessors; } /* I/O address space */ if (cpudata[activecpu].spacemask & (1 << ADDRESS_SPACE_IO)) { - active_address_space[ADDRESS_SPACE_IO].bytemask = cpudata[activecpu].space[ADDRESS_SPACE_IO].bytemask; - active_address_space[ADDRESS_SPACE_IO].readlookup = cpudata[activecpu].space[ADDRESS_SPACE_IO].read.table; - active_address_space[ADDRESS_SPACE_IO].writelookup = cpudata[activecpu].space[ADDRESS_SPACE_IO].write.table; - active_address_space[ADDRESS_SPACE_IO].readhandlers = cpudata[activecpu].space[ADDRESS_SPACE_IO].read.handlers; - active_address_space[ADDRESS_SPACE_IO].writehandlers = cpudata[activecpu].space[ADDRESS_SPACE_IO].write.handlers; - active_address_space[ADDRESS_SPACE_IO].accessors = cpudata[activecpu].space[ADDRESS_SPACE_IO].accessors; - } - - opbase_handler = cpudata[activecpu].opbase_handler; - - if (activecpu != -1 && (Machine->debug_flags & DEBUG_FLAG_ENABLED) != 0) - debug_cpu_get_memory_hooks(activecpu, &debug_hook_read, &debug_hook_write); - else - { - debug_hook_read = NULL; - debug_hook_write = NULL; + space = &cpudata[activecpu].space[ADDRESS_SPACE_IO]; + active_address_space[ADDRESS_SPACE_IO].bytemask = space->bytemask; + active_address_space[ADDRESS_SPACE_IO].readlookup = ((Machine->debug_flags & DEBUG_FLAG_WPR_DATA) != 0) ? wptable : space->read.table; + active_address_space[ADDRESS_SPACE_IO].writelookup = ((Machine->debug_flags & DEBUG_FLAG_WPW_DATA) != 0) ? wptable : space->write.table; + active_address_space[ADDRESS_SPACE_IO].readhandlers = space->read.handlers; + active_address_space[ADDRESS_SPACE_IO].writehandlers = space->write.handlers; + active_address_space[ADDRESS_SPACE_IO].accessors = space->accessors; } } @@ -1343,13 +1596,18 @@ UINT64 *_memory_install_device_handler64(const device_config *device, int cpunum structure for each CPU -------------------------------------------------*/ -static void memory_init_cpudata(const machine_config *config) +static void memory_init_cpudata(running_machine *machine) { + const machine_config *config = machine->config; int cpunum, spacenum; /* zap the cpudata structure */ memset(&cpudata, 0, sizeof(cpudata)); + /* create a global watchpoint-filled table */ + wptable = malloc_or_die(1 << LEVEL1_BITS); + memset(wptable, STATIC_WATCHPOINT, 1 << LEVEL1_BITS); + /* loop over CPUs */ for (cpunum = 0; cpunum < ARRAY_LENGTH(cpudata); cpunum++) { @@ -1392,9 +1650,11 @@ static void memory_init_cpudata(const machine_config *config) space->write.handlers[entrynum].handler.generic = get_static_handler(space->dbits, 1, spacenum, entrynum); } - /* make sure we fix up the mask for the unmap handler */ + /* make sure we fix up the mask for the unmap and watchpoint handlers */ space->read.handlers[STATIC_UNMAP].bytemask = ~0; space->write.handlers[STATIC_UNMAP].bytemask = ~0; + space->read.handlers[STATIC_WATCHPOINT].bytemask = ~0; + space->write.handlers[STATIC_WATCHPOINT].bytemask = ~0; /* allocate memory */ space->read.table = malloc_or_die(1 << LEVEL1_BITS); @@ -2711,6 +2971,113 @@ static WRITE32_HANDLER( mwh32_nop ) { } static WRITE64_HANDLER( mwh64_nop ) { } +/*------------------------------------------------- + watchpoint memory handlers +-------------------------------------------------*/ + +INLINE UINT8 watchpoint_read8(int spacenum, offs_t address) +{ + UINT8 result; + debug_cpu_memory_read_hook(Machine, cur_context, spacenum, address, 0xff); + active_address_space[spacenum].readlookup = cpudata[cur_context].space[spacenum].read.table; + result = read_byte_generic(spacenum, address); + active_address_space[spacenum].readlookup = wptable; + return result; +} + +INLINE UINT16 watchpoint_read16(int spacenum, offs_t address, UINT16 mem_mask) +{ + UINT16 result; + debug_cpu_memory_read_hook(Machine, cur_context, spacenum, address, mem_mask); + active_address_space[spacenum].readlookup = cpudata[cur_context].space[spacenum].read.table; + result = read_word_generic(spacenum, address, mem_mask); + active_address_space[spacenum].readlookup = wptable; + return result; +} + +INLINE UINT32 watchpoint_read32(int spacenum, offs_t address, UINT32 mem_mask) +{ + UINT32 result; + debug_cpu_memory_read_hook(Machine, cur_context, spacenum, address, mem_mask); + active_address_space[spacenum].readlookup = cpudata[cur_context].space[spacenum].read.table; + result = read_dword_generic(spacenum, address, mem_mask); + active_address_space[spacenum].readlookup = wptable; + return result; +} + +INLINE UINT64 watchpoint_read64(int spacenum, offs_t address, UINT64 mem_mask) +{ + UINT64 result; + debug_cpu_memory_read_hook(Machine, cur_context, spacenum, address, mem_mask); + active_address_space[spacenum].readlookup = cpudata[cur_context].space[spacenum].read.table; + result = read_qword_generic(spacenum, address, mem_mask); + active_address_space[spacenum].readlookup = wptable; + return result; +} + +INLINE void watchpoint_write8(int spacenum, offs_t address, UINT8 data) +{ + debug_cpu_memory_write_hook(Machine, cur_context, spacenum, address, data, 0xff); + active_address_space[spacenum].writelookup = cpudata[cur_context].space[spacenum].write.table; + write_byte_generic(spacenum, address, data); + active_address_space[spacenum].writelookup = wptable; +} + +INLINE void watchpoint_write16(int spacenum, offs_t address, UINT16 data, UINT16 mem_mask) +{ + debug_cpu_memory_write_hook(Machine, cur_context, spacenum, address, data, mem_mask); + active_address_space[spacenum].writelookup = cpudata[cur_context].space[spacenum].write.table; + write_word_generic(spacenum, address, data, mem_mask); + active_address_space[spacenum].writelookup = wptable; +} + +INLINE void watchpoint_write32(int spacenum, offs_t address, UINT32 data, UINT32 mem_mask) +{ + debug_cpu_memory_write_hook(Machine, cur_context, spacenum, address, data, mem_mask); + active_address_space[spacenum].writelookup = cpudata[cur_context].space[spacenum].write.table; + write_dword_generic(spacenum, address, data, mem_mask); + active_address_space[spacenum].writelookup = wptable; +} + +INLINE void watchpoint_write64(int spacenum, offs_t address, UINT64 data, UINT64 mem_mask) +{ + debug_cpu_memory_write_hook(Machine, cur_context, spacenum, address, data, mem_mask); + active_address_space[spacenum].writelookup = cpudata[cur_context].space[spacenum].write.table; + write_qword_generic(spacenum, address, data, mem_mask); + active_address_space[spacenum].writelookup = wptable; +} + +static READ8_HANDLER( mrh8_watchpoint_program ) { return watchpoint_read8 (ADDRESS_SPACE_PROGRAM, offset); } +static READ16_HANDLER( mrh16_watchpoint_program ) { return watchpoint_read16(ADDRESS_SPACE_PROGRAM, offset, mem_mask); } +static READ32_HANDLER( mrh32_watchpoint_program ) { return watchpoint_read32(ADDRESS_SPACE_PROGRAM, offset, mem_mask); } +static READ64_HANDLER( mrh64_watchpoint_program ) { return watchpoint_read64(ADDRESS_SPACE_PROGRAM, offset, mem_mask); } + +static WRITE8_HANDLER( mwh8_watchpoint_program ) { watchpoint_write8 (ADDRESS_SPACE_PROGRAM, offset, data); } +static WRITE16_HANDLER( mwh16_watchpoint_program ) { watchpoint_write16(ADDRESS_SPACE_PROGRAM, offset, data, mem_mask); } +static WRITE32_HANDLER( mwh32_watchpoint_program ) { watchpoint_write32(ADDRESS_SPACE_PROGRAM, offset, data, mem_mask); } +static WRITE64_HANDLER( mwh64_watchpoint_program ) { watchpoint_write64(ADDRESS_SPACE_PROGRAM, offset, data, mem_mask); } + +static READ8_HANDLER( mrh8_watchpoint_data ) { return watchpoint_read8 (ADDRESS_SPACE_DATA, offset); } +static READ16_HANDLER( mrh16_watchpoint_data ) { return watchpoint_read16(ADDRESS_SPACE_DATA, offset, mem_mask); } +static READ32_HANDLER( mrh32_watchpoint_data ) { return watchpoint_read32(ADDRESS_SPACE_DATA, offset, mem_mask); } +static READ64_HANDLER( mrh64_watchpoint_data ) { return watchpoint_read64(ADDRESS_SPACE_DATA, offset, mem_mask); } + +static WRITE8_HANDLER( mwh8_watchpoint_data ) { watchpoint_write8 (ADDRESS_SPACE_DATA, offset, data); } +static WRITE16_HANDLER( mwh16_watchpoint_data ) { watchpoint_write16(ADDRESS_SPACE_DATA, offset, data, mem_mask); } +static WRITE32_HANDLER( mwh32_watchpoint_data ) { watchpoint_write32(ADDRESS_SPACE_DATA, offset, data, mem_mask); } +static WRITE64_HANDLER( mwh64_watchpoint_data ) { watchpoint_write64(ADDRESS_SPACE_DATA, offset, data, mem_mask); } + +static READ8_HANDLER( mrh8_watchpoint_io ) { return watchpoint_read8 (ADDRESS_SPACE_IO, offset); } +static READ16_HANDLER( mrh16_watchpoint_io ) { return watchpoint_read16(ADDRESS_SPACE_IO, offset, mem_mask); } +static READ32_HANDLER( mrh32_watchpoint_io ) { return watchpoint_read32(ADDRESS_SPACE_IO, offset, mem_mask); } +static READ64_HANDLER( mrh64_watchpoint_io ) { return watchpoint_read64(ADDRESS_SPACE_IO, offset, mem_mask); } + +static WRITE8_HANDLER( mwh8_watchpoint_io ) { watchpoint_write8 (ADDRESS_SPACE_IO, offset, data); } +static WRITE16_HANDLER( mwh16_watchpoint_io ) { watchpoint_write16(ADDRESS_SPACE_IO, offset, data, mem_mask); } +static WRITE32_HANDLER( mwh32_watchpoint_io ) { watchpoint_write32(ADDRESS_SPACE_IO, offset, data, mem_mask); } +static WRITE64_HANDLER( mwh64_watchpoint_io ) { watchpoint_write64(ADDRESS_SPACE_IO, offset, data, mem_mask); } + + /*------------------------------------------------- get_static_handler - returns points to static memory handlers @@ -2727,33 +3094,45 @@ static genf *get_static_handler(int handlerbits, int readorwrite, int spacenum, genf * write; } static_handler_list[] = { - { 8, STATIC_UNMAP, ADDRESS_SPACE_PROGRAM, (genf *)mrh8_unmap_program, (genf *)mwh8_unmap_program }, - { 8, STATIC_UNMAP, ADDRESS_SPACE_DATA, (genf *)mrh8_unmap_data, (genf *)mwh8_unmap_data }, - { 8, STATIC_UNMAP, ADDRESS_SPACE_IO, (genf *)mrh8_unmap_io, (genf *)mwh8_unmap_io }, - { 8, STATIC_NOP, ADDRESS_SPACE_PROGRAM, (genf *)mrh8_nop_program, (genf *)mwh8_nop }, - { 8, STATIC_NOP, ADDRESS_SPACE_DATA, (genf *)mrh8_nop_data, (genf *)mwh8_nop }, - { 8, STATIC_NOP, ADDRESS_SPACE_IO, (genf *)mrh8_nop_io, (genf *)mwh8_nop }, + { 8, STATIC_UNMAP, ADDRESS_SPACE_PROGRAM, (genf *)mrh8_unmap_program, (genf *)mwh8_unmap_program }, + { 8, STATIC_UNMAP, ADDRESS_SPACE_DATA, (genf *)mrh8_unmap_data, (genf *)mwh8_unmap_data }, + { 8, STATIC_UNMAP, ADDRESS_SPACE_IO, (genf *)mrh8_unmap_io, (genf *)mwh8_unmap_io }, + { 8, STATIC_NOP, ADDRESS_SPACE_PROGRAM, (genf *)mrh8_nop_program, (genf *)mwh8_nop }, + { 8, STATIC_NOP, ADDRESS_SPACE_DATA, (genf *)mrh8_nop_data, (genf *)mwh8_nop }, + { 8, STATIC_NOP, ADDRESS_SPACE_IO, (genf *)mrh8_nop_io, (genf *)mwh8_nop }, + { 8, STATIC_WATCHPOINT, ADDRESS_SPACE_PROGRAM, (genf *)mrh8_watchpoint_program, (genf *)mwh8_watchpoint_program }, + { 8, STATIC_WATCHPOINT, ADDRESS_SPACE_DATA, (genf *)mrh8_watchpoint_data, (genf *)mwh8_watchpoint_data }, + { 8, STATIC_WATCHPOINT, ADDRESS_SPACE_IO, (genf *)mrh8_watchpoint_io, (genf *)mwh8_watchpoint_io }, - { 16, STATIC_UNMAP, ADDRESS_SPACE_PROGRAM, (genf *)mrh16_unmap_program,(genf *)mwh16_unmap_program }, - { 16, STATIC_UNMAP, ADDRESS_SPACE_DATA, (genf *)mrh16_unmap_data, (genf *)mwh16_unmap_data }, - { 16, STATIC_UNMAP, ADDRESS_SPACE_IO, (genf *)mrh16_unmap_io, (genf *)mwh16_unmap_io }, - { 16, STATIC_NOP, ADDRESS_SPACE_PROGRAM, (genf *)mrh16_nop_program, (genf *)mwh16_nop }, - { 16, STATIC_NOP, ADDRESS_SPACE_DATA, (genf *)mrh16_nop_data, (genf *)mwh16_nop }, - { 16, STATIC_NOP, ADDRESS_SPACE_IO, (genf *)mrh16_nop_io, (genf *)mwh16_nop }, + { 16, STATIC_UNMAP, ADDRESS_SPACE_PROGRAM, (genf *)mrh16_unmap_program, (genf *)mwh16_unmap_program }, + { 16, STATIC_UNMAP, ADDRESS_SPACE_DATA, (genf *)mrh16_unmap_data, (genf *)mwh16_unmap_data }, + { 16, STATIC_UNMAP, ADDRESS_SPACE_IO, (genf *)mrh16_unmap_io, (genf *)mwh16_unmap_io }, + { 16, STATIC_NOP, ADDRESS_SPACE_PROGRAM, (genf *)mrh16_nop_program, (genf *)mwh16_nop }, + { 16, STATIC_NOP, ADDRESS_SPACE_DATA, (genf *)mrh16_nop_data, (genf *)mwh16_nop }, + { 16, STATIC_NOP, ADDRESS_SPACE_IO, (genf *)mrh16_nop_io, (genf *)mwh16_nop }, + { 16, STATIC_WATCHPOINT, ADDRESS_SPACE_PROGRAM, (genf *)mrh16_watchpoint_program, (genf *)mwh16_watchpoint_program }, + { 16, STATIC_WATCHPOINT, ADDRESS_SPACE_DATA, (genf *)mrh16_watchpoint_data, (genf *)mwh16_watchpoint_data }, + { 16, STATIC_WATCHPOINT, ADDRESS_SPACE_IO, (genf *)mrh16_watchpoint_io, (genf *)mwh16_watchpoint_io }, - { 32, STATIC_UNMAP, ADDRESS_SPACE_PROGRAM, (genf *)mrh32_unmap_program,(genf *)mwh32_unmap_program }, - { 32, STATIC_UNMAP, ADDRESS_SPACE_DATA, (genf *)mrh32_unmap_data, (genf *)mwh32_unmap_data }, - { 32, STATIC_UNMAP, ADDRESS_SPACE_IO, (genf *)mrh32_unmap_io, (genf *)mwh32_unmap_io }, - { 32, STATIC_NOP, ADDRESS_SPACE_PROGRAM, (genf *)mrh32_nop_program, (genf *)mwh32_nop }, - { 32, STATIC_NOP, ADDRESS_SPACE_DATA, (genf *)mrh32_nop_data, (genf *)mwh32_nop }, - { 32, STATIC_NOP, ADDRESS_SPACE_IO, (genf *)mrh32_nop_io, (genf *)mwh32_nop }, + { 32, STATIC_UNMAP, ADDRESS_SPACE_PROGRAM, (genf *)mrh32_unmap_program, (genf *)mwh32_unmap_program }, + { 32, STATIC_UNMAP, ADDRESS_SPACE_DATA, (genf *)mrh32_unmap_data, (genf *)mwh32_unmap_data }, + { 32, STATIC_UNMAP, ADDRESS_SPACE_IO, (genf *)mrh32_unmap_io, (genf *)mwh32_unmap_io }, + { 32, STATIC_NOP, ADDRESS_SPACE_PROGRAM, (genf *)mrh32_nop_program, (genf *)mwh32_nop }, + { 32, STATIC_NOP, ADDRESS_SPACE_DATA, (genf *)mrh32_nop_data, (genf *)mwh32_nop }, + { 32, STATIC_NOP, ADDRESS_SPACE_IO, (genf *)mrh32_nop_io, (genf *)mwh32_nop }, + { 32, STATIC_WATCHPOINT, ADDRESS_SPACE_PROGRAM, (genf *)mrh32_watchpoint_program, (genf *)mwh32_watchpoint_program }, + { 32, STATIC_WATCHPOINT, ADDRESS_SPACE_DATA, (genf *)mrh32_watchpoint_data, (genf *)mwh32_watchpoint_data }, + { 32, STATIC_WATCHPOINT, ADDRESS_SPACE_IO, (genf *)mrh32_watchpoint_io, (genf *)mwh32_watchpoint_io }, - { 64, STATIC_UNMAP, ADDRESS_SPACE_PROGRAM, (genf *)mrh64_unmap_program,(genf *)mwh64_unmap_program }, - { 64, STATIC_UNMAP, ADDRESS_SPACE_DATA, (genf *)mrh64_unmap_data, (genf *)mwh64_unmap_data }, - { 64, STATIC_UNMAP, ADDRESS_SPACE_IO, (genf *)mrh64_unmap_io, (genf *)mwh64_unmap_io }, - { 64, STATIC_NOP, ADDRESS_SPACE_PROGRAM, (genf *)mrh64_nop_program, (genf *)mwh64_nop }, - { 64, STATIC_NOP, ADDRESS_SPACE_DATA, (genf *)mrh64_nop_data, (genf *)mwh64_nop }, - { 64, STATIC_NOP, ADDRESS_SPACE_IO, (genf *)mrh64_nop_io, (genf *)mwh64_nop }, + { 64, STATIC_UNMAP, ADDRESS_SPACE_PROGRAM, (genf *)mrh64_unmap_program, (genf *)mwh64_unmap_program }, + { 64, STATIC_UNMAP, ADDRESS_SPACE_DATA, (genf *)mrh64_unmap_data, (genf *)mwh64_unmap_data }, + { 64, STATIC_UNMAP, ADDRESS_SPACE_IO, (genf *)mrh64_unmap_io, (genf *)mwh64_unmap_io }, + { 64, STATIC_NOP, ADDRESS_SPACE_PROGRAM, (genf *)mrh64_nop_program, (genf *)mwh64_nop }, + { 64, STATIC_NOP, ADDRESS_SPACE_DATA, (genf *)mrh64_nop_data, (genf *)mwh64_nop }, + { 64, STATIC_NOP, ADDRESS_SPACE_IO, (genf *)mrh64_nop_io, (genf *)mwh64_nop }, + { 64, STATIC_WATCHPOINT, ADDRESS_SPACE_PROGRAM, (genf *)mrh64_watchpoint_program, (genf *)mwh64_watchpoint_program }, + { 64, STATIC_WATCHPOINT, ADDRESS_SPACE_DATA, (genf *)mrh64_watchpoint_data, (genf *)mwh64_watchpoint_data }, + { 64, STATIC_WATCHPOINT, ADDRESS_SPACE_IO, (genf *)mrh64_watchpoint_io, (genf *)mwh64_watchpoint_io } }; int tablenum; @@ -3330,70 +3709,10 @@ static memory_handler get_stub_handler(read_or_write readorwrite, int spacedbits -/*************************************************************************** - MEMORY HANDLER LOOKUP HELPERS -***************************************************************************/ - -/*------------------------------------------------- - Program memory handlers --------------------------------------------------*/ - -INLINE UINT32 lookup_read_entry(const address_space *space, offs_t address) -{ - UINT32 entry = space->readlookup[LEVEL1_INDEX(address)]; - if (entry >= SUBTABLE_BASE) - entry = space->readlookup[LEVEL2_INDEX(entry, address)]; - return entry; -} - - -INLINE UINT32 lookup_write_entry(const address_space *space, offs_t address) -{ - UINT32 entry = space->writelookup[LEVEL1_INDEX(address)]; - if (entry >= SUBTABLE_BASE) - entry = space->writelookup[LEVEL2_INDEX(entry, address)]; - return entry; -} - - - /*************************************************************************** 8-BIT READ HANDLERS ***************************************************************************/ -/*------------------------------------------------- - read_byte_generic - read a byte from an - arbitrary address space --------------------------------------------------*/ - -INLINE UINT8 read_byte_generic(UINT8 spacenum, offs_t address) -{ - const address_space *space = &active_address_space[spacenum]; - const handler_data *handler; - offs_t offset; - UINT32 entry; - UINT8 result; - - profiler_mark(PROFILER_MEMREAD); - - address &= space->bytemask; - entry = lookup_read_entry(space, address); - handler = &space->readhandlers[entry]; - - DEBUG_HOOK_READ(spacenum, address, 0xff); - - offset = (address - handler->bytestart) & handler->bytemask; - if (entry < STATIC_RAM) - result = bank_ptr[entry][offset]; - else - result = (*handler->handler.read.mhandler8)(handler->object, offset); - - profiler_mark(PROFILER_END); - - return result; -} - - /*------------------------------------------------- ADDRESS_SPACE_PROGRAM -------------------------------------------------*/ @@ -3696,36 +4015,6 @@ UINT64 io_read_qword_masked_8be(offs_t address, UINT64 mask) 8-BIT WRITE HANDLERS ***************************************************************************/ -/*------------------------------------------------- - stub_write_byte_generic - write a byte to an - arbitrary address space --------------------------------------------------*/ - -INLINE void write_byte_generic(UINT8 spacenum, offs_t address, UINT8 data) -{ - const address_space *space = &active_address_space[spacenum]; - const handler_data *handler; - offs_t offset; - UINT32 entry; - - profiler_mark(PROFILER_MEMWRITE); - - address &= space->bytemask; - entry = lookup_write_entry(space, address); - handler = &space->writehandlers[entry]; - - DEBUG_HOOK_WRITE(spacenum, address, data, 0xff); - - offset = (address - handler->bytestart) & handler->bytemask; - if (entry < STATIC_RAM) - bank_ptr[entry][offset] = data; - else - (*handler->handler.write.mhandler8)(handler->object, offset, data); - - profiler_mark(PROFILER_END); -} - - /*------------------------------------------------- ADDRESS_SPACE_PROGRAM -------------------------------------------------*/ @@ -3992,39 +4281,6 @@ void io_write_qword_masked_8be(offs_t address, UINT64 data, UINT64 mask) 16-BIT READ HANDLERS ***************************************************************************/ -/*------------------------------------------------- - read_word_masked_generic - read a word from - an arbitrary address space --------------------------------------------------*/ - -INLINE UINT16 read_word_masked_generic(UINT8 spacenum, offs_t address, UINT16 mem_mask) -{ - const address_space *space = &active_address_space[spacenum]; - const handler_data *handler; - offs_t offset; - UINT32 entry; - UINT16 result; - - profiler_mark(PROFILER_MEMREAD); - - address &= space->bytemask; - entry = lookup_read_entry(space, address); - handler = &space->readhandlers[entry]; - - DEBUG_HOOK_READ(spacenum, address & ~1, mem_mask); - - offset = (address - handler->bytestart) & handler->bytemask; - if (entry < STATIC_RAM) - result = *(UINT16 *)&bank_ptr[entry][offset & ~1]; - else - result = (*handler->handler.read.mhandler16)(handler->object, offset >> 1, mem_mask); - - profiler_mark(PROFILER_END); - - return result; -} - - /*------------------------------------------------- ADDRESS_SPACE_PROGRAM -------------------------------------------------*/ @@ -4032,33 +4288,33 @@ INLINE UINT16 read_word_masked_generic(UINT8 spacenum, offs_t address, UINT16 me UINT8 program_read_byte_16le(offs_t address) { UINT32 shift = (address & 1) * 8; - return read_word_masked_generic(ADDRESS_SPACE_PROGRAM, address, 0xff << shift) >> shift; + return read_word_generic(ADDRESS_SPACE_PROGRAM, address, 0xff << shift) >> shift; } UINT8 program_read_byte_16be(offs_t address) { UINT32 shift = (~address & 1) * 8; - return read_word_masked_generic(ADDRESS_SPACE_PROGRAM, address, 0xff << shift) >> shift; + return read_word_generic(ADDRESS_SPACE_PROGRAM, address, 0xff << shift) >> shift; } UINT16 program_read_word_16le(offs_t address) { - return read_word_masked_generic(ADDRESS_SPACE_PROGRAM, address, 0xffff); + return read_word_generic(ADDRESS_SPACE_PROGRAM, address, 0xffff); } UINT16 program_read_word_masked_16le(offs_t address, UINT16 mask) { - return read_word_masked_generic(ADDRESS_SPACE_PROGRAM, address, mask); + return read_word_generic(ADDRESS_SPACE_PROGRAM, address, mask); } UINT16 program_read_word_16be(offs_t address) { - return read_word_masked_generic(ADDRESS_SPACE_PROGRAM, address, 0xffff); + return read_word_generic(ADDRESS_SPACE_PROGRAM, address, 0xffff); } UINT16 program_read_word_masked_16be(offs_t address, UINT16 mask) { - return read_word_masked_generic(ADDRESS_SPACE_PROGRAM, address, mask); + return read_word_generic(ADDRESS_SPACE_PROGRAM, address, mask); } UINT32 program_read_dword_16le(offs_t address) @@ -4125,33 +4381,33 @@ UINT64 program_read_qword_masked_16be(offs_t address, UINT64 mask) UINT8 data_read_byte_16le(offs_t address) { UINT32 shift = (address & 1) * 8; - return read_word_masked_generic(ADDRESS_SPACE_DATA, address, 0xff << shift) >> shift; + return read_word_generic(ADDRESS_SPACE_DATA, address, 0xff << shift) >> shift; } UINT8 data_read_byte_16be(offs_t address) { UINT32 shift = (~address & 1) * 8; - return read_word_masked_generic(ADDRESS_SPACE_DATA, address, 0xff << shift) >> shift; + return read_word_generic(ADDRESS_SPACE_DATA, address, 0xff << shift) >> shift; } UINT16 data_read_word_16le(offs_t address) { - return read_word_masked_generic(ADDRESS_SPACE_DATA, address, 0xffff); + return read_word_generic(ADDRESS_SPACE_DATA, address, 0xffff); } UINT16 data_read_word_masked_16le(offs_t address, UINT16 mask) { - return read_word_masked_generic(ADDRESS_SPACE_DATA, address, mask); + return read_word_generic(ADDRESS_SPACE_DATA, address, mask); } UINT16 data_read_word_16be(offs_t address) { - return read_word_masked_generic(ADDRESS_SPACE_DATA, address, 0xffff); + return read_word_generic(ADDRESS_SPACE_DATA, address, 0xffff); } UINT16 data_read_word_masked_16be(offs_t address, UINT16 mask) { - return read_word_masked_generic(ADDRESS_SPACE_DATA, address, mask); + return read_word_generic(ADDRESS_SPACE_DATA, address, mask); } UINT32 data_read_dword_16le(offs_t address) @@ -4218,33 +4474,33 @@ UINT64 data_read_qword_masked_16be(offs_t address, UINT64 mask) UINT8 io_read_byte_16le(offs_t address) { UINT32 shift = (address & 1) * 8; - return read_word_masked_generic(ADDRESS_SPACE_IO, address, 0xff << shift) >> shift; + return read_word_generic(ADDRESS_SPACE_IO, address, 0xff << shift) >> shift; } UINT8 io_read_byte_16be(offs_t address) { UINT32 shift = (~address & 1) * 8; - return read_word_masked_generic(ADDRESS_SPACE_IO, address, 0xff << shift) >> shift; + return read_word_generic(ADDRESS_SPACE_IO, address, 0xff << shift) >> shift; } UINT16 io_read_word_16le(offs_t address) { - return read_word_masked_generic(ADDRESS_SPACE_IO, address, 0xffff); + return read_word_generic(ADDRESS_SPACE_IO, address, 0xffff); } UINT16 io_read_word_masked_16le(offs_t address, UINT16 mask) { - return read_word_masked_generic(ADDRESS_SPACE_IO, address, mask); + return read_word_generic(ADDRESS_SPACE_IO, address, mask); } UINT16 io_read_word_16be(offs_t address) { - return read_word_masked_generic(ADDRESS_SPACE_IO, address, 0xffff); + return read_word_generic(ADDRESS_SPACE_IO, address, 0xffff); } UINT16 io_read_word_masked_16be(offs_t address, UINT16 mask) { - return read_word_masked_generic(ADDRESS_SPACE_IO, address, mask); + return read_word_generic(ADDRESS_SPACE_IO, address, mask); } UINT32 io_read_dword_16le(offs_t address) @@ -4309,39 +4565,6 @@ UINT64 io_read_qword_masked_16be(offs_t address, UINT64 mask) 16-BIT WRITE HANDLERS ***************************************************************************/ -/*------------------------------------------------- - write_word_masked_generic - write a masked - word to an arbitrary address space --------------------------------------------------*/ - -INLINE void write_word_masked_generic(UINT8 spacenum, offs_t address, UINT16 data, UINT16 mem_mask) -{ - const address_space *space = &active_address_space[spacenum]; - const handler_data *handler; - offs_t offset; - UINT32 entry; - - profiler_mark(PROFILER_MEMWRITE); - - address &= space->bytemask; - entry = lookup_write_entry(space, address); - handler = &space->writehandlers[entry]; - - DEBUG_HOOK_WRITE(spacenum, address & ~1, data, mem_mask); - - offset = (address - handler->bytestart) & handler->bytemask; - if (entry < STATIC_RAM) - { - UINT16 *dest = (UINT16 *)&bank_ptr[entry][offset & ~1]; - *dest = (*dest & ~mem_mask) | (data & mem_mask); - } - else - (*handler->handler.write.mhandler16)(handler->object, offset >> 1, data, mem_mask); - - profiler_mark(PROFILER_END); -} - - /*------------------------------------------------- ADDRESS_SPACE_PROGRAM -------------------------------------------------*/ @@ -4349,33 +4572,33 @@ INLINE void write_word_masked_generic(UINT8 spacenum, offs_t address, UINT16 dat void program_write_byte_16le(offs_t address, UINT8 data) { UINT32 shift = (address & 1) * 8; - write_word_masked_generic(ADDRESS_SPACE_PROGRAM, address, data << shift, 0xff << shift); + write_word_generic(ADDRESS_SPACE_PROGRAM, address, data << shift, 0xff << shift); } void program_write_byte_16be(offs_t address, UINT8 data) { UINT32 shift = (~address & 1) * 8; - write_word_masked_generic(ADDRESS_SPACE_PROGRAM, address, data << shift, 0xff << shift); + write_word_generic(ADDRESS_SPACE_PROGRAM, address, data << shift, 0xff << shift); } void program_write_word_16le(offs_t address, UINT16 data) { - write_word_masked_generic(ADDRESS_SPACE_PROGRAM, address, data, 0xffff); + write_word_generic(ADDRESS_SPACE_PROGRAM, address, data, 0xffff); } void program_write_word_masked_16le(offs_t address, UINT16 data, UINT16 mask) { - write_word_masked_generic(ADDRESS_SPACE_PROGRAM, address, data, mask); + write_word_generic(ADDRESS_SPACE_PROGRAM, address, data, mask); } void program_write_word_16be(offs_t address, UINT16 data) { - write_word_masked_generic(ADDRESS_SPACE_PROGRAM, address, data, 0xffff); + write_word_generic(ADDRESS_SPACE_PROGRAM, address, data, 0xffff); } void program_write_word_masked_16be(offs_t address, UINT16 data, UINT16 mask) { - write_word_masked_generic(ADDRESS_SPACE_PROGRAM, address, data, mask); + write_word_generic(ADDRESS_SPACE_PROGRAM, address, data, mask); } void program_write_dword_16le(offs_t address, UINT32 data) @@ -4434,33 +4657,33 @@ void program_write_qword_masked_16be(offs_t address, UINT64 data, UINT64 mask) void data_write_byte_16le(offs_t address, UINT8 data) { UINT32 shift = (address & 1) * 8; - write_word_masked_generic(ADDRESS_SPACE_DATA, address, data << shift, 0xff << shift); + write_word_generic(ADDRESS_SPACE_DATA, address, data << shift, 0xff << shift); } void data_write_byte_16be(offs_t address, UINT8 data) { UINT32 shift = (~address & 1) * 8; - write_word_masked_generic(ADDRESS_SPACE_DATA, address, data << shift, 0xff << shift); + write_word_generic(ADDRESS_SPACE_DATA, address, data << shift, 0xff << shift); } void data_write_word_16le(offs_t address, UINT16 data) { - write_word_masked_generic(ADDRESS_SPACE_DATA, address, data, 0xffff); + write_word_generic(ADDRESS_SPACE_DATA, address, data, 0xffff); } void data_write_word_masked_16le(offs_t address, UINT16 data, UINT16 mask) { - write_word_masked_generic(ADDRESS_SPACE_DATA, address, data, mask); + write_word_generic(ADDRESS_SPACE_DATA, address, data, mask); } void data_write_word_16be(offs_t address, UINT16 data) { - write_word_masked_generic(ADDRESS_SPACE_DATA, address, data, 0xffff); + write_word_generic(ADDRESS_SPACE_DATA, address, data, 0xffff); } void data_write_word_masked_16be(offs_t address, UINT16 data, UINT16 mask) { - write_word_masked_generic(ADDRESS_SPACE_DATA, address, data, mask); + write_word_generic(ADDRESS_SPACE_DATA, address, data, mask); } void data_write_dword_16le(offs_t address, UINT32 data) @@ -4519,33 +4742,33 @@ void data_write_qword_masked_16be(offs_t address, UINT64 data, UINT64 mask) void io_write_byte_16le(offs_t address, UINT8 data) { UINT32 shift = (address & 1) * 8; - write_word_masked_generic(ADDRESS_SPACE_IO, address, data << shift, 0xff << shift); + write_word_generic(ADDRESS_SPACE_IO, address, data << shift, 0xff << shift); } void io_write_byte_16be(offs_t address, UINT8 data) { UINT32 shift = (~address & 1) * 8; - write_word_masked_generic(ADDRESS_SPACE_IO, address, data << shift, 0xff << shift); + write_word_generic(ADDRESS_SPACE_IO, address, data << shift, 0xff << shift); } void io_write_word_16le(offs_t address, UINT16 data) { - write_word_masked_generic(ADDRESS_SPACE_IO, address, data, 0xffff); + write_word_generic(ADDRESS_SPACE_IO, address, data, 0xffff); } void io_write_word_masked_16le(offs_t address, UINT16 data, UINT16 mask) { - write_word_masked_generic(ADDRESS_SPACE_IO, address, data, mask); + write_word_generic(ADDRESS_SPACE_IO, address, data, mask); } void io_write_word_16be(offs_t address, UINT16 data) { - write_word_masked_generic(ADDRESS_SPACE_IO, address, data, 0xffff); + write_word_generic(ADDRESS_SPACE_IO, address, data, 0xffff); } void io_write_word_masked_16be(offs_t address, UINT16 data, UINT16 mask) { - write_word_masked_generic(ADDRESS_SPACE_IO, address, data, mask); + write_word_generic(ADDRESS_SPACE_IO, address, data, mask); } void io_write_dword_16le(offs_t address, UINT32 data) @@ -4602,39 +4825,6 @@ void io_write_qword_masked_16be(offs_t address, UINT64 data, UINT64 mask) 32-BIT READ HANDLERS ***************************************************************************/ -/*------------------------------------------------- - read_dword_masked_generic - read a dword from - an arbitrary address space --------------------------------------------------*/ - -INLINE UINT32 read_dword_masked_generic(UINT8 spacenum, offs_t address, UINT32 mem_mask) -{ - const address_space *space = &active_address_space[spacenum]; - const handler_data *handler; - offs_t offset; - UINT32 entry; - UINT32 result; - - profiler_mark(PROFILER_MEMREAD); - - address &= space->bytemask; - entry = lookup_read_entry(space, address); - handler = &space->readhandlers[entry]; - - DEBUG_HOOK_READ(spacenum, address & ~3, mem_mask); - - offset = (address - handler->bytestart) & handler->bytemask; - if (entry < STATIC_RAM) - result = *(UINT32 *)&bank_ptr[entry][offset & ~3]; - else - result = (*handler->handler.read.mhandler32)(handler->object, offset >> 2, mem_mask); - - profiler_mark(PROFILER_END); - - return result; -} - - /*------------------------------------------------- ADDRESS_SPACE_PROGRAM -------------------------------------------------*/ @@ -4642,57 +4832,57 @@ INLINE UINT32 read_dword_masked_generic(UINT8 spacenum, offs_t address, UINT32 m UINT8 program_read_byte_32le(offs_t address) { UINT32 shift = (address & 3) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, 0xff << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_PROGRAM, address, 0xff << shift) >> shift; } UINT8 program_read_byte_32be(offs_t address) { UINT32 shift = (~address & 3) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, 0xff << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_PROGRAM, address, 0xff << shift) >> shift; } UINT16 program_read_word_32le(offs_t address) { UINT32 shift = (address & 2) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, 0xffff << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_PROGRAM, address, 0xffff << shift) >> shift; } UINT16 program_read_word_masked_32le(offs_t address, UINT16 mask) { UINT32 shift = (address & 2) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, mask << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_PROGRAM, address, mask << shift) >> shift; } UINT16 program_read_word_32be(offs_t address) { UINT32 shift = (~address & 2) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, 0xffff << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_PROGRAM, address, 0xffff << shift) >> shift; } UINT16 program_read_word_masked_32be(offs_t address, UINT16 mask) { UINT32 shift = (~address & 2) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, mask << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_PROGRAM, address, mask << shift) >> shift; } UINT32 program_read_dword_32le(offs_t address) { - return read_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, 0xffffffff); + return read_dword_generic(ADDRESS_SPACE_PROGRAM, address, 0xffffffff); } UINT32 program_read_dword_masked_32le(offs_t address, UINT32 mask) { - return read_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, mask); + return read_dword_generic(ADDRESS_SPACE_PROGRAM, address, mask); } UINT32 program_read_dword_32be(offs_t address) { - return read_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, 0xffffffff); + return read_dword_generic(ADDRESS_SPACE_PROGRAM, address, 0xffffffff); } UINT32 program_read_dword_masked_32be(offs_t address, UINT32 mask) { - return read_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, mask); + return read_dword_generic(ADDRESS_SPACE_PROGRAM, address, mask); } UINT64 program_read_qword_32le(offs_t address) @@ -4731,57 +4921,57 @@ UINT64 program_read_qword_masked_32be(offs_t address, UINT64 mask) UINT8 data_read_byte_32le(offs_t address) { UINT32 shift = (address & 3) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_DATA, address, 0xff << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_DATA, address, 0xff << shift) >> shift; } UINT8 data_read_byte_32be(offs_t address) { UINT32 shift = (~address & 3) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_DATA, address, 0xff << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_DATA, address, 0xff << shift) >> shift; } UINT16 data_read_word_32le(offs_t address) { UINT32 shift = (address & 2) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_DATA, address, 0xffff << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_DATA, address, 0xffff << shift) >> shift; } UINT16 data_read_word_masked_32le(offs_t address, UINT16 mask) { UINT32 shift = (address & 2) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_DATA, address, mask << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_DATA, address, mask << shift) >> shift; } UINT16 data_read_word_32be(offs_t address) { UINT32 shift = (~address & 2) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_DATA, address, 0xffff << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_DATA, address, 0xffff << shift) >> shift; } UINT16 data_read_word_masked_32be(offs_t address, UINT16 mask) { UINT32 shift = (~address & 2) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_DATA, address, mask << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_DATA, address, mask << shift) >> shift; } UINT32 data_read_dword_32le(offs_t address) { - return read_dword_masked_generic(ADDRESS_SPACE_DATA, address, 0xffffffff); + return read_dword_generic(ADDRESS_SPACE_DATA, address, 0xffffffff); } UINT32 data_read_dword_masked_32le(offs_t address, UINT32 mask) { - return read_dword_masked_generic(ADDRESS_SPACE_DATA, address, mask); + return read_dword_generic(ADDRESS_SPACE_DATA, address, mask); } UINT32 data_read_dword_32be(offs_t address) { - return read_dword_masked_generic(ADDRESS_SPACE_DATA, address, 0xffffffff); + return read_dword_generic(ADDRESS_SPACE_DATA, address, 0xffffffff); } UINT32 data_read_dword_masked_32be(offs_t address, UINT32 mask) { - return read_dword_masked_generic(ADDRESS_SPACE_DATA, address, mask); + return read_dword_generic(ADDRESS_SPACE_DATA, address, mask); } UINT64 data_read_qword_32le(offs_t address) @@ -4820,57 +5010,57 @@ UINT64 data_read_qword_masked_32be(offs_t address, UINT64 mask) UINT8 io_read_byte_32le(offs_t address) { UINT32 shift = (address & 3) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_IO, address, 0xff << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_IO, address, 0xff << shift) >> shift; } UINT8 io_read_byte_32be(offs_t address) { UINT32 shift = (~address & 3) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_IO, address, 0xff << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_IO, address, 0xff << shift) >> shift; } UINT16 io_read_word_32le(offs_t address) { UINT32 shift = (address & 2) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_IO, address, 0xffff << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_IO, address, 0xffff << shift) >> shift; } UINT16 io_read_word_masked_32le(offs_t address, UINT16 mask) { UINT32 shift = (address & 2) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_IO, address, mask << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_IO, address, mask << shift) >> shift; } UINT16 io_read_word_32be(offs_t address) { UINT32 shift = (~address & 2) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_IO, address, 0xffff << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_IO, address, 0xffff << shift) >> shift; } UINT16 io_read_word_masked_32be(offs_t address, UINT16 mask) { UINT32 shift = (~address & 2) * 8; - return read_dword_masked_generic(ADDRESS_SPACE_IO, address, mask << shift) >> shift; + return read_dword_generic(ADDRESS_SPACE_IO, address, mask << shift) >> shift; } UINT32 io_read_dword_32le(offs_t address) { - return read_dword_masked_generic(ADDRESS_SPACE_IO, address, 0xffffffff); + return read_dword_generic(ADDRESS_SPACE_IO, address, 0xffffffff); } UINT32 io_read_dword_masked_32le(offs_t address, UINT32 mask) { - return read_dword_masked_generic(ADDRESS_SPACE_IO, address, mask); + return read_dword_generic(ADDRESS_SPACE_IO, address, mask); } UINT32 io_read_dword_32be(offs_t address) { - return read_dword_masked_generic(ADDRESS_SPACE_IO, address, 0xffffffff); + return read_dword_generic(ADDRESS_SPACE_IO, address, 0xffffffff); } UINT32 io_read_dword_masked_32be(offs_t address, UINT32 mask) { - return read_dword_masked_generic(ADDRESS_SPACE_IO, address, mask); + return read_dword_generic(ADDRESS_SPACE_IO, address, mask); } UINT64 io_read_qword_32le(offs_t address) @@ -4907,39 +5097,6 @@ UINT64 io_read_qword_masked_32be(offs_t address, UINT64 mask) 32-BIT WRITE HANDLERS ***************************************************************************/ -/*------------------------------------------------- - write_dword_masked_generic - write a masked - dword to an arbitrary address space --------------------------------------------------*/ - -INLINE void write_dword_masked_generic(UINT8 spacenum, offs_t address, UINT32 data, UINT32 mem_mask) -{ - const address_space *space = &active_address_space[spacenum]; - const handler_data *handler; - offs_t offset; - UINT32 entry; - - profiler_mark(PROFILER_MEMWRITE); - - address &= space->bytemask; - entry = lookup_write_entry(space, address); - handler = &space->writehandlers[entry]; - - DEBUG_HOOK_WRITE(spacenum, address & ~3, data, mem_mask); - - offset = (address - handler->bytestart) & handler->bytemask; - if (entry < STATIC_RAM) - { - UINT32 *dest = (UINT32 *)&bank_ptr[entry][offset & ~3]; - *dest = (*dest & ~mem_mask) | (data & mem_mask); - } - else - (*handler->handler.write.mhandler32)(handler->object, offset >> 2, data, mem_mask); - - profiler_mark(PROFILER_END); -} - - /*------------------------------------------------- ADDRESS_SPACE_PROGRAM -------------------------------------------------*/ @@ -4947,57 +5104,57 @@ INLINE void write_dword_masked_generic(UINT8 spacenum, offs_t address, UINT32 da void program_write_byte_32le(offs_t address, UINT8 data) { UINT32 shift = (address & 3) * 8; - write_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, data << shift, 0xff << shift); + write_dword_generic(ADDRESS_SPACE_PROGRAM, address, data << shift, 0xff << shift); } void program_write_byte_32be(offs_t address, UINT8 data) { UINT32 shift = (~address & 3) * 8; - write_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, data << shift, 0xff << shift); + write_dword_generic(ADDRESS_SPACE_PROGRAM, address, data << shift, 0xff << shift); } void program_write_word_32le(offs_t address, UINT16 data) { UINT32 shift = (address & 2) * 8; - write_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, data << shift, 0xffff << shift); + write_dword_generic(ADDRESS_SPACE_PROGRAM, address, data << shift, 0xffff << shift); } void program_write_word_masked_32le(offs_t address, UINT16 data, UINT16 mask) { UINT32 shift = (address & 2) * 8; - write_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, data << shift, mask << shift); + write_dword_generic(ADDRESS_SPACE_PROGRAM, address, data << shift, mask << shift); } void program_write_word_32be(offs_t address, UINT16 data) { UINT32 shift = (~address & 2) * 8; - write_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, data << shift, 0xffff << shift); + write_dword_generic(ADDRESS_SPACE_PROGRAM, address, data << shift, 0xffff << shift); } void program_write_word_masked_32be(offs_t address, UINT16 data, UINT16 mask) { UINT32 shift = (~address & 2) * 8; - write_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, data << shift, mask << shift); + write_dword_generic(ADDRESS_SPACE_PROGRAM, address, data << shift, mask << shift); } void program_write_dword_32le(offs_t address, UINT32 data) { - write_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, data, 0xffffffff); + write_dword_generic(ADDRESS_SPACE_PROGRAM, address, data, 0xffffffff); } void program_write_dword_masked_32le(offs_t address, UINT32 data, UINT32 mask) { - write_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, data, mask); + write_dword_generic(ADDRESS_SPACE_PROGRAM, address, data, mask); } void program_write_dword_32be(offs_t address, UINT32 data) { - write_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, data, 0xffffffff); + write_dword_generic(ADDRESS_SPACE_PROGRAM, address, data, 0xffffffff); } void program_write_dword_masked_32be(offs_t address, UINT32 data, UINT32 mask) { - write_dword_masked_generic(ADDRESS_SPACE_PROGRAM, address, data, mask); + write_dword_generic(ADDRESS_SPACE_PROGRAM, address, data, mask); } void program_write_qword_32le(offs_t address, UINT64 data) @@ -5032,57 +5189,57 @@ void program_write_qword_masked_32be(offs_t address, UINT64 data, UINT64 mask) void data_write_byte_32le(offs_t address, UINT8 data) { UINT32 shift = (address & 3) * 8; - write_dword_masked_generic(ADDRESS_SPACE_DATA, address, data << shift, 0xff << shift); + write_dword_generic(ADDRESS_SPACE_DATA, address, data << shift, 0xff << shift); } void data_write_byte_32be(offs_t address, UINT8 data) { UINT32 shift = (~address & 3) * 8; - write_dword_masked_generic(ADDRESS_SPACE_DATA, address, data << shift, 0xff << shift); + write_dword_generic(ADDRESS_SPACE_DATA, address, data << shift, 0xff << shift); } void data_write_word_32le(offs_t address, UINT16 data) { UINT32 shift = (address & 2) * 8; - write_dword_masked_generic(ADDRESS_SPACE_DATA, address, data << shift, 0xffff << shift); + write_dword_generic(ADDRESS_SPACE_DATA, address, data << shift, 0xffff << shift); } void data_write_word_masked_32le(offs_t address, UINT16 data, UINT16 mask) { UINT32 shift = (address & 2) * 8; - write_dword_masked_generic(ADDRESS_SPACE_DATA, address, data << shift, mask << shift); + write_dword_generic(ADDRESS_SPACE_DATA, address, data << shift, mask << shift); } void data_write_word_32be(offs_t address, UINT16 data) { UINT32 shift = (~address & 2) * 8; - write_dword_masked_generic(ADDRESS_SPACE_DATA, address, data << shift, 0xffff << shift); + write_dword_generic(ADDRESS_SPACE_DATA, address, data << shift, 0xffff << shift); } void data_write_word_masked_32be(offs_t address, UINT16 data, UINT16 mask) { UINT32 shift = (~address & 2) * 8; - write_dword_masked_generic(ADDRESS_SPACE_DATA, address, data << shift, mask << shift); + write_dword_generic(ADDRESS_SPACE_DATA, address, data << shift, mask << shift); } void data_write_dword_32le(offs_t address, UINT32 data) { - write_dword_masked_generic(ADDRESS_SPACE_DATA, address, data, 0xffffffff); + write_dword_generic(ADDRESS_SPACE_DATA, address, data, 0xffffffff); } void data_write_dword_masked_32le(offs_t address, UINT32 data, UINT32 mask) { - write_dword_masked_generic(ADDRESS_SPACE_DATA, address, data, mask); + write_dword_generic(ADDRESS_SPACE_DATA, address, data, mask); } void data_write_dword_32be(offs_t address, UINT32 data) { - write_dword_masked_generic(ADDRESS_SPACE_DATA, address, data, 0xffffffff); + write_dword_generic(ADDRESS_SPACE_DATA, address, data, 0xffffffff); } void data_write_dword_masked_32be(offs_t address, UINT32 data, UINT32 mask) { - write_dword_masked_generic(ADDRESS_SPACE_DATA, address, data, mask); + write_dword_generic(ADDRESS_SPACE_DATA, address, data, mask); } void data_write_qword_32le(offs_t address, UINT64 data) @@ -5117,57 +5274,57 @@ void data_write_qword_masked_32be(offs_t address, UINT64 data, UINT64 mask) void io_write_byte_32le(offs_t address, UINT8 data) { UINT32 shift = (address & 3) * 8; - write_dword_masked_generic(ADDRESS_SPACE_IO, address, data << shift, 0xff << shift); + write_dword_generic(ADDRESS_SPACE_IO, address, data << shift, 0xff << shift); } void io_write_byte_32be(offs_t address, UINT8 data) { UINT32 shift = (~address & 3) * 8; - write_dword_masked_generic(ADDRESS_SPACE_IO, address, data << shift, 0xff << shift); + write_dword_generic(ADDRESS_SPACE_IO, address, data << shift, 0xff << shift); } void io_write_word_32le(offs_t address, UINT16 data) { UINT32 shift = (address & 2) * 8; - write_dword_masked_generic(ADDRESS_SPACE_IO, address, data << shift, 0xffff << shift); + write_dword_generic(ADDRESS_SPACE_IO, address, data << shift, 0xffff << shift); } void io_write_word_masked_32le(offs_t address, UINT16 data, UINT16 mask) { UINT32 shift = (address & 2) * 8; - write_dword_masked_generic(ADDRESS_SPACE_IO, address, data << shift, mask << shift); + write_dword_generic(ADDRESS_SPACE_IO, address, data << shift, mask << shift); } void io_write_word_32be(offs_t address, UINT16 data) { UINT32 shift = (~address & 2) * 8; - write_dword_masked_generic(ADDRESS_SPACE_IO, address, data << shift, 0xffff << shift); + write_dword_generic(ADDRESS_SPACE_IO, address, data << shift, 0xffff << shift); } void io_write_word_masked_32be(offs_t address, UINT16 data, UINT16 mask) { UINT32 shift = (~address & 2) * 8; - write_dword_masked_generic(ADDRESS_SPACE_IO, address, data << shift, mask << shift); + write_dword_generic(ADDRESS_SPACE_IO, address, data << shift, mask << shift); } void io_write_dword_32le(offs_t address, UINT32 data) { - write_dword_masked_generic(ADDRESS_SPACE_IO, address, data, 0xffffffff); + write_dword_generic(ADDRESS_SPACE_IO, address, data, 0xffffffff); } void io_write_dword_masked_32le(offs_t address, UINT32 data, UINT32 mask) { - write_dword_masked_generic(ADDRESS_SPACE_IO, address, data, mask); + write_dword_generic(ADDRESS_SPACE_IO, address, data, mask); } void io_write_dword_32be(offs_t address, UINT32 data) { - write_dword_masked_generic(ADDRESS_SPACE_IO, address, data, 0xffffffff); + write_dword_generic(ADDRESS_SPACE_IO, address, data, 0xffffffff); } void io_write_dword_masked_32be(offs_t address, UINT32 data, UINT32 mask) { - write_dword_masked_generic(ADDRESS_SPACE_IO, address, data, mask); + write_dword_generic(ADDRESS_SPACE_IO, address, data, mask); } void io_write_qword_32le(offs_t address, UINT64 data) @@ -5200,39 +5357,6 @@ void io_write_qword_masked_32be(offs_t address, UINT64 data, UINT64 mask) 64-BIT READ HANDLERS ***************************************************************************/ -/*------------------------------------------------- - read_qword_masked_generic - read a qword from - an arbitrary address space --------------------------------------------------*/ - -INLINE UINT64 read_qword_masked_generic(UINT8 spacenum, offs_t address, UINT64 mem_mask) -{ - const address_space *space = &active_address_space[spacenum]; - const handler_data *handler; - offs_t offset; - UINT32 entry; - UINT64 result; - - profiler_mark(PROFILER_MEMREAD); - - address &= space->bytemask; - entry = lookup_read_entry(space, address); - handler = &space->readhandlers[entry]; - - DEBUG_HOOK_READ(spacenum, address & ~7, mem_mask); - - offset = (address - handler->bytestart) & handler->bytemask; - if (entry < STATIC_RAM) - result = *(UINT64 *)&bank_ptr[entry][offset & ~7]; - else - result = (*handler->handler.read.mhandler64)(handler->object, offset >> 3, mem_mask); - - profiler_mark(PROFILER_END); - - return result; -} - - /*------------------------------------------------- ADDRESS_SPACE_PROGRAM -------------------------------------------------*/ @@ -5240,81 +5364,81 @@ INLINE UINT64 read_qword_masked_generic(UINT8 spacenum, offs_t address, UINT64 m UINT8 program_read_byte_64le(offs_t address) { UINT32 shift = (address & 7) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)0xff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)0xff << shift) >> shift; } UINT8 program_read_byte_64be(offs_t address) { UINT32 shift = (~address & 7) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)0xff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)0xff << shift) >> shift; } UINT16 program_read_word_64le(offs_t address) { UINT32 shift = (address & 6) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)0xffff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)0xffff << shift) >> shift; } UINT16 program_read_word_masked_64le(offs_t address, UINT16 mask) { UINT32 shift = (address & 6) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)mask << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)mask << shift) >> shift; } UINT16 program_read_word_64be(offs_t address) { UINT32 shift = (~address & 6) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)0xffff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)0xffff << shift) >> shift; } UINT16 program_read_word_masked_64be(offs_t address, UINT16 mask) { UINT32 shift = (~address & 6) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)mask << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)mask << shift) >> shift; } UINT32 program_read_dword_64le(offs_t address) { UINT32 shift = (address & 4) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)0xffffffff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)0xffffffff << shift) >> shift; } UINT32 program_read_dword_masked_64le(offs_t address, UINT32 mask) { UINT32 shift = (address & 4) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)mask << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)mask << shift) >> shift; } UINT32 program_read_dword_64be(offs_t address) { UINT32 shift = (~address & 4) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)0xffffffff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)0xffffffff << shift) >> shift; } UINT32 program_read_dword_masked_64be(offs_t address, UINT32 mask) { UINT32 shift = (~address & 4) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)mask << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)mask << shift) >> shift; } UINT64 program_read_qword_64le(offs_t address) { - return read_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, U64(0xffffffffffffffff)); + return read_qword_generic(ADDRESS_SPACE_PROGRAM, address, U64(0xffffffffffffffff)); } UINT64 program_read_qword_masked_64le(offs_t address, UINT64 mask) { - return read_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, mask); + return read_qword_generic(ADDRESS_SPACE_PROGRAM, address, mask); } UINT64 program_read_qword_64be(offs_t address) { - return read_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, U64(0xffffffffffffffff)); + return read_qword_generic(ADDRESS_SPACE_PROGRAM, address, U64(0xffffffffffffffff)); } UINT64 program_read_qword_masked_64be(offs_t address, UINT64 mask) { - return read_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, mask); + return read_qword_generic(ADDRESS_SPACE_PROGRAM, address, mask); } @@ -5325,81 +5449,81 @@ UINT64 program_read_qword_masked_64be(offs_t address, UINT64 mask) UINT8 data_read_byte_64le(offs_t address) { UINT32 shift = (address & 7) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)0xff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)0xff << shift) >> shift; } UINT8 data_read_byte_64be(offs_t address) { UINT32 shift = (~address & 7) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)0xff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)0xff << shift) >> shift; } UINT16 data_read_word_64le(offs_t address) { UINT32 shift = (address & 6) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)0xffff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)0xffff << shift) >> shift; } UINT16 data_read_word_masked_64le(offs_t address, UINT16 mask) { UINT32 shift = (address & 6) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)mask << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)mask << shift) >> shift; } UINT16 data_read_word_64be(offs_t address) { UINT32 shift = (~address & 6) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)0xffff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)0xffff << shift) >> shift; } UINT16 data_read_word_masked_64be(offs_t address, UINT16 mask) { UINT32 shift = (~address & 6) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)mask << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)mask << shift) >> shift; } UINT32 data_read_dword_64le(offs_t address) { UINT32 shift = (address & 4) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)0xffffffff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)0xffffffff << shift) >> shift; } UINT32 data_read_dword_masked_64le(offs_t address, UINT32 mask) { UINT32 shift = (address & 4) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)mask << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)mask << shift) >> shift; } UINT32 data_read_dword_64be(offs_t address) { UINT32 shift = (~address & 4) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)0xffffffff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)0xffffffff << shift) >> shift; } UINT32 data_read_dword_masked_64be(offs_t address, UINT32 mask) { UINT32 shift = (~address & 4) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)mask << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)mask << shift) >> shift; } UINT64 data_read_qword_64le(offs_t address) { - return read_qword_masked_generic(ADDRESS_SPACE_DATA, address, U64(0xffffffffffffffff)); + return read_qword_generic(ADDRESS_SPACE_DATA, address, U64(0xffffffffffffffff)); } UINT64 data_read_qword_masked_64le(offs_t address, UINT64 mask) { - return read_qword_masked_generic(ADDRESS_SPACE_DATA, address, mask); + return read_qword_generic(ADDRESS_SPACE_DATA, address, mask); } UINT64 data_read_qword_64be(offs_t address) { - return read_qword_masked_generic(ADDRESS_SPACE_DATA, address, U64(0xffffffffffffffff)); + return read_qword_generic(ADDRESS_SPACE_DATA, address, U64(0xffffffffffffffff)); } UINT64 data_read_qword_masked_64be(offs_t address, UINT64 mask) { - return read_qword_masked_generic(ADDRESS_SPACE_DATA, address, mask); + return read_qword_generic(ADDRESS_SPACE_DATA, address, mask); } @@ -5410,81 +5534,81 @@ UINT64 data_read_qword_masked_64be(offs_t address, UINT64 mask) UINT8 io_read_byte_64le(offs_t address) { UINT32 shift = (address & 7) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)0xff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)0xff << shift) >> shift; } UINT8 io_read_byte_64be(offs_t address) { UINT32 shift = (~address & 7) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)0xff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)0xff << shift) >> shift; } UINT16 io_read_word_64le(offs_t address) { UINT32 shift = (address & 6) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)0xffff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)0xffff << shift) >> shift; } UINT16 io_read_word_masked_64le(offs_t address, UINT16 mask) { UINT32 shift = (address & 6) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)mask << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)mask << shift) >> shift; } UINT16 io_read_word_64be(offs_t address) { UINT32 shift = (~address & 6) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)0xffff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)0xffff << shift) >> shift; } UINT16 io_read_word_masked_64be(offs_t address, UINT16 mask) { UINT32 shift = (~address & 6) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)mask << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)mask << shift) >> shift; } UINT32 io_read_dword_64le(offs_t address) { UINT32 shift = (address & 4) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)0xffffffff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)0xffffffff << shift) >> shift; } UINT32 io_read_dword_masked_64le(offs_t address, UINT32 mask) { UINT32 shift = (address & 4) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)mask << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)mask << shift) >> shift; } UINT32 io_read_dword_64be(offs_t address) { UINT32 shift = (~address & 4) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)0xffffffff << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)0xffffffff << shift) >> shift; } UINT32 io_read_dword_masked_64be(offs_t address, UINT32 mask) { UINT32 shift = (~address & 4) * 8; - return read_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)mask << shift) >> shift; + return read_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)mask << shift) >> shift; } UINT64 io_read_qword_64le(offs_t address) { - return read_qword_masked_generic(ADDRESS_SPACE_IO, address, U64(0xffffffffffffffff)); + return read_qword_generic(ADDRESS_SPACE_IO, address, U64(0xffffffffffffffff)); } UINT64 io_read_qword_masked_64le(offs_t address, UINT64 mask) { - return read_qword_masked_generic(ADDRESS_SPACE_IO, address, mask); + return read_qword_generic(ADDRESS_SPACE_IO, address, mask); } UINT64 io_read_qword_64be(offs_t address) { - return read_qword_masked_generic(ADDRESS_SPACE_IO, address, U64(0xffffffffffffffff)); + return read_qword_generic(ADDRESS_SPACE_IO, address, U64(0xffffffffffffffff)); } UINT64 io_read_qword_masked_64be(offs_t address, UINT64 mask) { - return read_qword_masked_generic(ADDRESS_SPACE_IO, address, mask); + return read_qword_generic(ADDRESS_SPACE_IO, address, mask); } @@ -5493,39 +5617,6 @@ UINT64 io_read_qword_masked_64be(offs_t address, UINT64 mask) 64-BIT WRITE HANDLERS ***************************************************************************/ -/*------------------------------------------------- - write_qword_masked_generic - write a masked - dword to an arbitrary address space --------------------------------------------------*/ - -INLINE void write_qword_masked_generic(UINT8 spacenum, offs_t address, UINT64 data, UINT64 mem_mask) -{ - const address_space *space = &active_address_space[spacenum]; - const handler_data *handler; - offs_t offset; - UINT32 entry; - - profiler_mark(PROFILER_MEMWRITE); - - address &= space->bytemask; - entry = lookup_write_entry(space, address); - handler = &space->writehandlers[entry]; - - DEBUG_HOOK_WRITE(spacenum, address & ~7, data, mem_mask); - - offset = (address - handler->bytestart) & handler->bytemask; - if (entry < STATIC_RAM) - { - UINT64 *dest = (UINT64 *)&bank_ptr[entry][offset & ~7]; - *dest = (*dest & ~mem_mask) | (data & mem_mask); - } - else - (*handler->handler.write.mhandler64)(handler->object, offset >> 3, data, mem_mask); - - profiler_mark(PROFILER_END); -} - - /*------------------------------------------------- ADDRESS_SPACE_PROGRAM -------------------------------------------------*/ @@ -5533,81 +5624,81 @@ INLINE void write_qword_masked_generic(UINT8 spacenum, offs_t address, UINT64 da void program_write_byte_64le(offs_t address, UINT8 data) { UINT32 shift = (address & 7) * 8; - write_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)0xff << shift); + write_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)0xff << shift); } void program_write_byte_64be(offs_t address, UINT8 data) { UINT32 shift = (~address & 7) * 8; - write_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)0xff << shift); + write_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)0xff << shift); } void program_write_word_64le(offs_t address, UINT16 data) { UINT32 shift = (address & 6) * 8; - write_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)0xffff << shift); + write_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)0xffff << shift); } void program_write_word_masked_64le(offs_t address, UINT16 data, UINT16 mask) { UINT32 shift = (address & 6) * 8; - write_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)mask << shift); + write_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)mask << shift); } void program_write_word_64be(offs_t address, UINT16 data) { UINT32 shift = (~address & 6) * 8; - write_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)0xffff << shift); + write_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)0xffff << shift); } void program_write_word_masked_64be(offs_t address, UINT16 data, UINT16 mask) { UINT32 shift = (~address & 6) * 8; - write_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)mask << shift); + write_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)mask << shift); } void program_write_dword_64le(offs_t address, UINT32 data) { UINT32 shift = (address & 4) * 8; - write_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)0xffffffff << shift); + write_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)0xffffffff << shift); } void program_write_dword_masked_64le(offs_t address, UINT32 data, UINT32 mask) { UINT32 shift = (address & 4) * 8; - write_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)mask << shift); + write_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)mask << shift); } void program_write_dword_64be(offs_t address, UINT32 data) { UINT32 shift = (~address & 4) * 8; - write_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)0xffffffff << shift); + write_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)0xffffffff << shift); } void program_write_dword_masked_64be(offs_t address, UINT32 data, UINT32 mask) { UINT32 shift = (~address & 4) * 8; - write_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)mask << shift); + write_qword_generic(ADDRESS_SPACE_PROGRAM, address, (UINT64)data << shift, (UINT64)mask << shift); } void program_write_qword_64le(offs_t address, UINT64 data) { - write_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, data, U64(0xffffffffffffffff)); + write_qword_generic(ADDRESS_SPACE_PROGRAM, address, data, U64(0xffffffffffffffff)); } void program_write_qword_masked_64le(offs_t address, UINT64 data, UINT64 mask) { - write_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, data, mask); + write_qword_generic(ADDRESS_SPACE_PROGRAM, address, data, mask); } void program_write_qword_64be(offs_t address, UINT64 data) { - write_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, data, U64(0xffffffffffffffff)); + write_qword_generic(ADDRESS_SPACE_PROGRAM, address, data, U64(0xffffffffffffffff)); } void program_write_qword_masked_64be(offs_t address, UINT64 data, UINT64 mask) { - write_qword_masked_generic(ADDRESS_SPACE_PROGRAM, address, data, mask); + write_qword_generic(ADDRESS_SPACE_PROGRAM, address, data, mask); } @@ -5618,81 +5709,81 @@ void program_write_qword_masked_64be(offs_t address, UINT64 data, UINT64 mask) void data_write_byte_64le(offs_t address, UINT8 data) { UINT32 shift = (address & 7) * 8; - write_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)0xff << shift); + write_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)0xff << shift); } void data_write_byte_64be(offs_t address, UINT8 data) { UINT32 shift = (~address & 7) * 8; - write_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)0xff << shift); + write_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)0xff << shift); } void data_write_word_64le(offs_t address, UINT16 data) { UINT32 shift = (address & 6) * 8; - write_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)0xffff << shift); + write_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)0xffff << shift); } void data_write_word_masked_64le(offs_t address, UINT16 data, UINT16 mask) { UINT32 shift = (address & 6) * 8; - write_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)mask << shift); + write_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)mask << shift); } void data_write_word_64be(offs_t address, UINT16 data) { UINT32 shift = (~address & 6) * 8; - write_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)0xffff << shift); + write_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)0xffff << shift); } void data_write_word_masked_64be(offs_t address, UINT16 data, UINT16 mask) { UINT32 shift = (~address & 6) * 8; - write_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)mask << shift); + write_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)mask << shift); } void data_write_dword_64le(offs_t address, UINT32 data) { UINT32 shift = (address & 4) * 8; - write_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)0xffffffff << shift); + write_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)0xffffffff << shift); } void data_write_dword_masked_64le(offs_t address, UINT32 data, UINT32 mask) { UINT32 shift = (address & 4) * 8; - write_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)mask << shift); + write_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)mask << shift); } void data_write_dword_64be(offs_t address, UINT32 data) { UINT32 shift = (~address & 4) * 8; - write_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)0xffffffff << shift); + write_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)0xffffffff << shift); } void data_write_dword_masked_64be(offs_t address, UINT32 data, UINT32 mask) { UINT32 shift = (~address & 4) * 8; - write_qword_masked_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)mask << shift); + write_qword_generic(ADDRESS_SPACE_DATA, address, (UINT64)data << shift, (UINT64)mask << shift); } void data_write_qword_64le(offs_t address, UINT64 data) { - write_qword_masked_generic(ADDRESS_SPACE_DATA, address, data, U64(0xffffffffffffffff)); + write_qword_generic(ADDRESS_SPACE_DATA, address, data, U64(0xffffffffffffffff)); } void data_write_qword_masked_64le(offs_t address, UINT64 data, UINT64 mask) { - write_qword_masked_generic(ADDRESS_SPACE_DATA, address, data, mask); + write_qword_generic(ADDRESS_SPACE_DATA, address, data, mask); } void data_write_qword_64be(offs_t address, UINT64 data) { - write_qword_masked_generic(ADDRESS_SPACE_DATA, address, data, U64(0xffffffffffffffff)); + write_qword_generic(ADDRESS_SPACE_DATA, address, data, U64(0xffffffffffffffff)); } void data_write_qword_masked_64be(offs_t address, UINT64 data, UINT64 mask) { - write_qword_masked_generic(ADDRESS_SPACE_DATA, address, data, mask); + write_qword_generic(ADDRESS_SPACE_DATA, address, data, mask); } @@ -5703,79 +5794,79 @@ void data_write_qword_masked_64be(offs_t address, UINT64 data, UINT64 mask) void io_write_byte_64le(offs_t address, UINT8 data) { UINT32 shift = (address & 7) * 8; - write_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)0xff << shift); + write_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)0xff << shift); } void io_write_byte_64be(offs_t address, UINT8 data) { UINT32 shift = (~address & 7) * 8; - write_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)0xff << shift); + write_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)0xff << shift); } void io_write_word_64le(offs_t address, UINT16 data) { UINT32 shift = (address & 6) * 8; - write_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)0xffff << shift); + write_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)0xffff << shift); } void io_write_word_masked_64le(offs_t address, UINT16 data, UINT16 mask) { UINT32 shift = (address & 6) * 8; - write_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)mask << shift); + write_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)mask << shift); } void io_write_word_64be(offs_t address, UINT16 data) { UINT32 shift = (~address & 6) * 8; - write_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)0xffff << shift); + write_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)0xffff << shift); } void io_write_word_masked_64be(offs_t address, UINT16 data, UINT16 mask) { UINT32 shift = (~address & 6) * 8; - write_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)mask << shift); + write_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)mask << shift); } void io_write_dword_64le(offs_t address, UINT32 data) { UINT32 shift = (address & 4) * 8; - write_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)0xffffffff << shift); + write_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)0xffffffff << shift); } void io_write_dword_masked_64le(offs_t address, UINT32 data, UINT32 mask) { UINT32 shift = (address & 4) * 8; - write_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)mask << shift); + write_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)mask << shift); } void io_write_dword_64be(offs_t address, UINT32 data) { UINT32 shift = (~address & 4) * 8; - write_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)0xffffffff << shift); + write_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)0xffffffff << shift); } void io_write_dword_masked_64be(offs_t address, UINT32 data, UINT32 mask) { UINT32 shift = (~address & 4) * 8; - write_qword_masked_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)mask << shift); + write_qword_generic(ADDRESS_SPACE_IO, address, (UINT64)data << shift, (UINT64)mask << shift); } void io_write_qword_64le(offs_t address, UINT64 data) { - write_qword_masked_generic(ADDRESS_SPACE_IO, address, data, U64(0xffffffffffffffff)); + write_qword_generic(ADDRESS_SPACE_IO, address, data, U64(0xffffffffffffffff)); } void io_write_qword_masked_64le(offs_t address, UINT64 data, UINT64 mask) { - write_qword_masked_generic(ADDRESS_SPACE_IO, address, data, mask); + write_qword_generic(ADDRESS_SPACE_IO, address, data, mask); } void io_write_qword_64be(offs_t address, UINT64 data) { - write_qword_masked_generic(ADDRESS_SPACE_IO, address, data, U64(0xffffffffffffffff)); + write_qword_generic(ADDRESS_SPACE_IO, address, data, U64(0xffffffffffffffff)); } void io_write_qword_masked_64be(offs_t address, UINT64 data, UINT64 mask) { - write_qword_masked_generic(ADDRESS_SPACE_IO, address, data, mask); + write_qword_generic(ADDRESS_SPACE_IO, address, data, mask); } diff --git a/src/emu/memory.h b/src/emu/memory.h index 9c44edf815e..048ff280ac5 100644 --- a/src/emu/memory.h +++ b/src/emu/memory.h @@ -39,12 +39,13 @@ enum STATIC_INVALID = 0, /* invalid - should never be used */ STATIC_BANK1 = 1, /* first memory bank */ /* entries 1-32 are for fixed banks 1-32 specified by the driver */ - /* entries 33-67 are for dynamically allocated internal banks */ - STATIC_BANKMAX = 67, /* last memory bank */ + /* entries 33-66 are for dynamically allocated internal banks */ + STATIC_BANKMAX = 66, /* last memory bank */ STATIC_RAM, /* RAM - reads/writes map to dynamic banks */ STATIC_ROM, /* ROM - reads = RAM; writes = UNMAP */ STATIC_NOP, /* NOP - reads = unmapped value; writes = no-op */ STATIC_UNMAP, /* unmapped - same as NOP except we log errors */ + STATIC_WATCHPOINT, /* watchpoint - used internally */ STATIC_COUNT /* total number of static handlers */ }; diff --git a/src/mame/machine/pitnrun.c b/src/mame/machine/pitnrun.c index e9d5421f6a4..f4d21e8f758 100644 --- a/src/mame/machine/pitnrun.c +++ b/src/mame/machine/pitnrun.c @@ -120,15 +120,15 @@ WRITE8_HANDLER( pitnrun_68705_portB_w ) } if (~data & 0x10) { - memory_set_context(0); + cpuintrf_push_context(0); program_write_byte(address, portA_out); - memory_set_context(2); + cpuintrf_pop_context(); } if (~data & 0x20) { - memory_set_context(0); + cpuintrf_push_context(0); portA_in = program_read_byte(address); - memory_set_context(2); + cpuintrf_pop_context(); } if (~data & 0x40) { diff --git a/src/mame/machine/taitosj.c b/src/mame/machine/taitosj.c index 638df9d500b..758fe9116f3 100644 --- a/src/mame/machine/taitosj.c +++ b/src/mame/machine/taitosj.c @@ -221,18 +221,18 @@ WRITE8_HANDLER( taitosj_68705_portB_w ) { LOG(("%04x: 68705 write %02x to address %04x\n",activecpu_get_pc(),portA_out,address)); - memory_set_context(0); + cpuintrf_push_context(0); program_write_byte(address, portA_out); - memory_set_context(2); + cpuintrf_pop_context(); /* increase low 8 bits of latched address for burst writes */ address = (address & 0xff00) | ((address + 1) & 0xff); } if (~data & 0x20) { - memory_set_context(0); + cpuintrf_push_context(0); portA_in = program_read_byte(address); - memory_set_context(2); + cpuintrf_pop_context(); LOG(("%04x: 68705 read %02x from address %04x\n",activecpu_get_pc(),portA_in,address)); } if (~data & 0x40)