diff options
| author | 2010-06-08 06:09:57 +0000 | |
|---|---|---|
| committer | 2010-06-08 06:09:57 +0000 | |
| commit | 100564d41225bfd2fa163c0174557ed979285b4e (patch) | |
| tree | 0be83fbde1ddb95633293c9faee60d0f2bc6ace1 /src/emu/debug/debugcpu.c | |
| parent | 962dca9f57d61cdea65ee32c6362bf3d0d1e2dae (diff) | |
WARNING: There are likely to be regressions in both functionality and
performance as a result of this change. Do not panic; report issues to the
list in the short term and I will look into them. There are probably also
some details I forgot to mention. Please ask questions if anything is not
clear.
NOTE: This is a major internal change to the way devices are handled in
MAME. There is a small impact on drivers, but the bulk of the changes are
to the devices themselves. Full documentation on the new device handling
is in progress at http://mamedev.org/devwiki/index.php/MAME_Device_Basics
Defined two new casting helpers: [Aaron Giles]
downcast<type>(value) should be used for safe and efficient downcasting
from a base class to a derived class. It wraps static_cast<> by adding
an assert that a matching dynamic_cast<> returns the same result in
debug builds.
crosscast<type>(value) should be used for safe casting from one type to
another in multiple inheritance scenarios. It compiles to a
dynamic_cast<> plus an assert on the result. Since it does not optimize
down to static_cast<>, you should prefer downcast<> over crosscast<>
when you can.
Redefined running_device to be a proper C++ class (now called device_t).
Same for device_config (still called device_config). All devices and
device_configs must now be derived from these base classes. This means
each device type now has a pair of its own unique classes that describe
the device. Drivers are encouraged to use the specific device types
instead of the generic running_device or device_t classes. Drivers that
have a state class defined in their header file are encouraged to use
initializers off the constructor to locate devices. [Aaron Giles]
Removed the following fields from the device and device configuration
classes as they never were necessary or provided any use: device class,
device family, source file, version, credits. [Aaron Giles]
Added templatized variant of machine->device() which performs a downcast
as part of the device fetch. Thus machine->device<timer_device>("timer")
will locate a device named "timer", downcast it to a timer_device, and
assert if the downcast fails. [Aaron Giles]
Removed most publically accessible members of running_device/device_t in
favor of inline accessor functions. The only remaining public member is
machine. Thus all references to device->type are now device->type(), etc.
[Aaron Giles]
Created a number of device interface classes which are designed to be mix-
ins for the device classes, providing specific extended functionality and
information. There are standard interface classes for sound, execution,
state, nvram, memory, and disassembly. Devices can opt into 0 or more of
these classes. [Aaron Giles]
Converted the classic CPU device to a standard device that uses the
execution, state, memory, and disassembly interfaces. Used this new class
(cpu_device) to implement the existing CPU device interface. In the future
it will be possible to convert each CPU core to its own device type, but
for now they are still all CPU devices with a cpu_type() that specifies
exactly which kind of CPU. [Aaron Giles]
Created a new header devlegcy.h which wraps the old device interface using
some special template classes. To use these with an existing device,
simply remove from the device header the DEVICE_GET_INFO() declaration and
the #define mapping the ALL_CAPS name to the DEVICE_GET_INFO. In their
place #include "devlegcy.h" and use the DECLARE_LEGACY_DEVICE() macro.
In addition, there is a DECLARE_LEGACY_SOUND_DEVICE() macro for wrapping
existing sound devices into new-style devices, and a
DECLARE_LEGACY_NVRAM_DEVICE() for wrapping NVRAM devices. Also moved the
token and inline_config members to the legacy device class, as these are
not used in modern devices. [Aaron Giles]
Converted the standard base devices (VIDEO_SCREEN, SPEAKER, and TIMER)
from legacy devices to the new C++ style. Also renamed VIDEO_SCREEN to
simply SCREEN. The various global functions that were previously used to
access information or modify the state of these devices are now replaced
by methods on the device classes. Specifically:
video_screen_configure() == screen->configure()
video_screen_set_visarea() == screen->set_visible_area()
video_screen_update_partial() == screen->update_partial()
video_screen_update_now() == screen->update_now()
video_screen_get_vpos() == screen->vpos()
video_screen_get_hpos() == screen->hpos()
video_screen_get_vblank() == screen->vblank()
video_screen_get_hblank() == screen->hblank()
video_screen_get_width() == screen->width()
video_screen_get_height() == screen->height()
video_screen_get_visible_area() == screen->visible_area()
video_screen_get_time_until_pos() == screen->time_until_pos()
video_screen_get_time_until_vblank_start() ==
screen->time_until_vblank_start()
video_screen_get_time_until_vblank_end() ==
screen->time_until_vblank_end()
video_screen_get_time_until_update() == screen->time_until_update()
video_screen_get_scan_period() == screen->scan_period()
video_screen_get_frame_period() == screen->frame_period()
video_screen_get_frame_number() == screen->frame_number()
timer_device_adjust_oneshot() == timer->adjust()
timer_device_adjust_periodic() == timer->adjust()
timer_device_reset() == timer->reset()
timer_device_enable() == timer->enable()
timer_device_enabled() == timer->enabled()
timer_device_get_param() == timer->param()
timer_device_set_param() == timer->set_param()
timer_device_get_ptr() == timer->get_ptr()
timer_device_set_ptr() == timer->set_ptr()
timer_device_timeelapsed() == timer->time_elapsed()
timer_device_timeleft() == timer->time_left()
timer_device_starttime() == timer->start_time()
timer_device_firetime() == timer->fire_time()
Updated all drivers that use the above functions to fetch the specific
device type (timer_device or screen_device) and call the appropriate
method. [Aaron Giles]
Changed machine->primary_screen and the 'screen' parameter to VIDEO_UPDATE
to specifically pass in a screen_device object. [Aaron Giles]
Defined a new custom interface for the Z80 daisy chain. This interface
behaves like the standard interfaces, and can be added to any device that
implements the Z80 daisy chain behavior. Converted all existing Z80 daisy
chain devices to new-style devices that inherit this interface.
[Aaron Giles]
Changed the way CPU state tables are built up. Previously, these were data
structures defined by a CPU core which described all the registers and how
to output them. This functionality is now part of the state interface and
is implemented via the device_state_entry class. Updated all CPU cores
which were using the old data structure to use the new form. The syntax is
currently awkward, but will be cleaner for CPUs that are native new
devices. [Aaron Giles]
Converted the okim6295 and eeprom devices to the new model. These were
necessary because they both require multiple interfaces to operate and it
didn't make sense to create legacy device templates for these single cases.
(okim6295 needs the sound interface and the memory interface, while eeprom
requires both the nvram and memory interfaces). [Aaron Giles]
Changed parameters in a few callback functions from pointers to references
in situations where they are guaranteed to never be NULL. [Aaron Giles]
Removed MDRV_CPU_FLAGS() which was only used for disabling a CPU. Changed
it to MDRV_DEVICE_DISABLE() instead. Updated drivers. [Aaron Giles]
Reorganized the token parsing for machine configurations. The core parsing
code knows how to create/replace/remove devices, but all device token
parsing is now handled in the device_config class, which in turn will make
use of any interface classes or device-specific token handling for custom
token processing. [Aaron Giles]
Moved many validity checks out of validity.c and into the device interface
classes. For example, address space validation is now part of the memory
interface class. [Aaron Giles]
Consolidated address space parameters (bus width, endianness, etc.) into
a single address_space_config class. Updated all code that queried for
address space parameters to use the new mechanism. [Aaron Giles]
Diffstat (limited to 'src/emu/debug/debugcpu.c')
| -rw-r--r-- | src/emu/debug/debugcpu.c | 686 |
1 files changed, 314 insertions, 372 deletions
diff --git a/src/emu/debug/debugcpu.c b/src/emu/debug/debugcpu.c index aa57387dc1b..0622cd55bfc 100644 --- a/src/emu/debug/debugcpu.c +++ b/src/emu/debug/debugcpu.c @@ -51,9 +51,9 @@ enum /* in mame.h: typedef struct _debugcpu_private debugcpu_private; */ struct _debugcpu_private { - running_device *livecpu; - running_device *visiblecpu; - running_device *breakcpu; + device_t *livecpu; + device_t *visiblecpu; + device_t *breakcpu; FILE * source_file; /* script source file */ @@ -84,18 +84,18 @@ struct _debugcpu_private /* internal helpers */ static void debug_cpu_exit(running_machine *machine); -static void on_vblank(running_device *device, void *param, int vblank_state); +static void on_vblank(screen_device &device, void *param, bool vblank_state); static void reset_transient_flags(running_machine *machine); -static void compute_debug_flags(running_device *device); -static void perform_trace(cpu_debug_data *info); -static void prepare_for_step_overout(cpu_debug_data *info); +static void compute_debug_flags(device_t *device); +static void perform_trace(cpu_debug_data *cpudebug); +static void prepare_for_step_overout(cpu_debug_data *cpudebug); static void process_source_file(running_machine *machine); -static void breakpoint_update_flags(cpu_debug_data *info); -static void breakpoint_check(running_machine *machine, cpu_debug_data *info, offs_t pc); +static void breakpoint_update_flags(cpu_debug_data *cpudebug); +static void breakpoint_check(running_machine *machine, cpu_debug_data *cpudebug, offs_t pc); static void watchpoint_update_flags(const address_space *space); static void watchpoint_check(const address_space *space, int type, offs_t address, UINT64 value_to_write, UINT64 mem_mask); static void check_hotspots(const address_space *space, offs_t address); -static UINT32 dasm_wrapped(running_device *device, char *buffer, offs_t pc); +static UINT32 dasm_wrapped(device_t *device, char *buffer, offs_t pc); /* expression handlers */ static UINT64 expression_read_memory(void *param, const char *name, int space, UINT32 address, int size); @@ -148,9 +148,8 @@ const express_callbacks debug_expression_callbacks = void debug_cpu_init(running_machine *machine) { - running_device *first_screen = video_screen_first(machine); + screen_device *first_screen = screen_first(*machine); debugcpu_private *global; - running_device *cpu; int regnum; /* allocate and reset globals */ @@ -178,70 +177,42 @@ void debug_cpu_init(running_machine *machine) symtable_add_register(global->symtable, symname, &global->tempvar[regnum], get_tempvar, set_tempvar); } - /* loop over CPUs and build up their info */ - for (cpu = machine->firstcpu; cpu != NULL; cpu = cpu_next(cpu)) + /* loop over CPUs and build up their cpudebug */ + for (cpu_device *device = downcast<cpu_device *>(machine->firstcpu); device != NULL; device = downcast<cpu_device *>(cpu_next(device))) { - cpu_class_header *classheader = cpu_get_class_header(cpu); - cpu_debug_data *info; - /* allocate some information */ - info = auto_alloc_clear(machine, cpu_debug_data); - classheader->debug = info; + cpu_debug_data *cpudebug = auto_alloc_clear(machine, cpu_debug_data); + device->m_debug = cpudebug; /* reset the PC data */ - info->flags = DEBUG_FLAG_OBSERVING | DEBUG_FLAG_HISTORY; - info->device = cpu; - info->opwidth = cpu_get_min_opcode_bytes(info->device); - - /* fetch the memory accessors */ - info->read = (cpu_read_func)info->device->get_config_fct(CPUINFO_FCT_READ); - info->write = (cpu_write_func)info->device->get_config_fct(CPUINFO_FCT_WRITE); - info->readop = (cpu_readop_func)info->device->get_config_fct(CPUINFO_FCT_READOP); - info->translate = (cpu_translate_func)info->device->get_config_fct(CPUINFO_FCT_TRANSLATE); - info->disassemble = (cpu_disassemble_func)info->device->get_config_fct(CPUINFO_FCT_DISASSEMBLE); + cpudebug->flags = DEBUG_FLAG_OBSERVING | DEBUG_FLAG_HISTORY; + cpudebug->cpudevice = device; + cpudebug->opwidth = device->min_opcode_bytes(); /* allocate a symbol table */ - info->symtable = symtable_alloc(global->symtable, (void *)cpu); + cpudebug->symtable = symtable_alloc(global->symtable, (void *)device); /* add a global symbol for the current instruction pointer */ - symtable_add_register(info->symtable, "cycles", NULL, get_cycles, NULL); - if (cpu->space(AS_PROGRAM) != NULL) - symtable_add_register(info->symtable, "logunmap", (void *)cpu->space(AS_PROGRAM), get_logunmap, set_logunmap); - if (cpu->space(AS_DATA) != NULL) - symtable_add_register(info->symtable, "logunmapd", (void *)cpu->space(AS_DATA), get_logunmap, set_logunmap); - if (cpu->space(AS_IO) != NULL) - symtable_add_register(info->symtable, "logunmapi", (void *)cpu->space(AS_IO), get_logunmap, set_logunmap); + symtable_add_register(cpudebug->symtable, "cycles", NULL, get_cycles, NULL); + if (device->space(AS_PROGRAM) != NULL) + symtable_add_register(cpudebug->symtable, "logunmap", (void *)device->space(AS_PROGRAM), get_logunmap, set_logunmap); + if (device->space(AS_DATA) != NULL) + symtable_add_register(cpudebug->symtable, "logunmapd", (void *)device->space(AS_DATA), get_logunmap, set_logunmap); + if (device->space(AS_IO) != NULL) + symtable_add_register(cpudebug->symtable, "logunmapi", (void *)device->space(AS_IO), get_logunmap, set_logunmap); /* add all registers into it */ - for (regnum = 0; regnum < MAX_REGS; regnum++) + device_state_interface *stateintf; + if (device->interface(stateintf)) { - const char *str = cpu_get_reg_string(info->device, regnum); - const char *colon; - char symname[256]; - int charnum; - - /* skip if we don't get a valid string, or one without a colon */ - if (str == NULL) - continue; - if (str[0] == '~') - str++; - colon = strchr(str, ':'); - if (colon == NULL) - continue; - - /* strip all spaces from the name and convert to lowercase */ - for (charnum = 0; charnum < sizeof(symname) - 1 && str < colon; str++) - if (!isspace((UINT8)*str)) - symname[charnum++] = tolower((UINT8)*str); - symname[charnum] = 0; - - /* add the symbol to the table */ - symtable_add_register(info->symtable, symname, (void *)(FPTR)regnum, get_cpu_reg, set_cpu_reg); + astring tempstr; + for (const device_state_entry *entry = stateintf->state_first(); entry != NULL; entry = entry->next()) + symtable_add_register(cpudebug->symtable, tempstr.cpy(entry->symbol()).tolower(), (void *)(FPTR)entry->index(), get_cpu_reg, set_cpu_reg); } /* if no curpc, add one */ - if (symtable_find(info->symtable, "curpc") == NULL) - symtable_add_register(info->symtable, "curpc", NULL, get_current_pc, 0); + if (symtable_find(cpudebug->symtable, "curpc") == NULL) + symtable_add_register(cpudebug->symtable, "curpc", NULL, get_current_pc, 0); } /* first CPU is visible by default */ @@ -249,7 +220,7 @@ void debug_cpu_init(running_machine *machine) /* add callback for breaking on VBLANK */ if (machine->primary_screen != NULL) - video_screen_register_vblank_callback(machine->primary_screen, on_vblank, NULL); + machine->primary_screen->register_vblank_callback(on_vblank, NULL); add_exit_callback(machine, debug_cpu_exit); } @@ -263,16 +234,16 @@ void debug_cpu_init(running_machine *machine) void debug_cpu_flush_traces(running_machine *machine) { - running_device *cpu; + device_t *cpu; for (cpu = machine->firstcpu; cpu != NULL; cpu = cpu_next(cpu)) { - cpu_debug_data *info = cpu_get_debug_data(cpu); + cpu_debug_data *cpudebug = cpu_get_debug_data(cpu); /* this can be called on exit even when no debugging is enabled, so - make sure the info is valid before proceeding */ - if (info != NULL && info->trace.file != NULL) - fflush(info->trace.file); + make sure the cpudebug is valid before proceeding */ + if (cpudebug != NULL && cpudebug->trace.file != NULL) + fflush(cpudebug->trace.file); } } @@ -287,7 +258,7 @@ void debug_cpu_flush_traces(running_machine *machine) device (the one that commands should apply to) -------------------------------------------------*/ -running_device *debug_cpu_get_visible_cpu(running_machine *machine) +device_t *debug_cpu_get_visible_cpu(running_machine *machine) { return machine->debugcpu_data->visiblecpu; } @@ -348,7 +319,7 @@ symbol_table *debug_cpu_get_visible_symtable(running_machine *machine) CPU's symbol table -------------------------------------------------*/ -symbol_table *debug_cpu_get_symtable(running_device *device) +symbol_table *debug_cpu_get_symtable(device_t *device) { return cpu_get_debug_data(device)->symtable; } @@ -367,11 +338,10 @@ symbol_table *debug_cpu_get_symtable(running_device *device) int debug_cpu_translate(const address_space *space, int intention, offs_t *address) { - if (space->cpu != NULL && space->cpu->type == CPU) + if (space->cpu != NULL && space->cpu->type() == CPU) { - cpu_debug_data *info = cpu_get_debug_data(space->cpu); - if (info->translate != NULL) - return (*info->translate)(space->cpu, space->spacenum, intention, address); + cpu_debug_data *cpudebug = cpu_get_debug_data(space->cpu); + return cpudebug->cpudevice->translate(space->spacenum, intention, *address); } return TRUE; } @@ -382,52 +352,27 @@ int debug_cpu_translate(const address_space *space, int intention, offs_t *addre a given PC on a given CPU -------------------------------------------------*/ -offs_t debug_cpu_disassemble(running_device *device, char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram) +offs_t debug_cpu_disassemble(device_t *device, char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram) { - cpu_debug_data *info = cpu_get_debug_data(device); + cpu_debug_data *cpudebug = cpu_get_debug_data(device); offs_t result = 0; /* check for disassembler override */ - if (info->dasm_override != NULL) - result = (*info->dasm_override)(device, buffer, pc, oprom, opram, 0); + if (cpudebug->dasm_override != NULL) + result = (*cpudebug->dasm_override)(device, buffer, pc, oprom, opram, 0); /* if we have a disassembler, run it */ - if (result == 0 && info->disassemble != NULL) - result = (*info->disassemble)(device, buffer, pc, oprom, opram, 0); - - /* if we still have nothing, output vanilla bytes */ if (result == 0) - { - result = cpu_get_min_opcode_bytes(device); - switch (result) - { - case 1: - default: - sprintf(buffer, "$%02X", *(UINT8 *)oprom); - break; - - case 2: - sprintf(buffer, "$%04X", *(UINT16 *)oprom); - break; - - case 4: - sprintf(buffer, "$%08X", *(UINT32 *)oprom); - break; - - case 8: - sprintf(buffer, "$%08X%08X", (UINT32)(*(UINT64 *)oprom >> 32), (UINT32)(*(UINT64 *)oprom >> 0)); - break; - } - } + result = cpudebug->cpudevice->disassemble(buffer, pc, oprom, opram, 0); /* make sure we get good results */ assert((result & DASMFLAG_LENGTHMASK) != 0); #ifdef MAME_DEBUG { - const address_space *space = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM); + const address_space *space = device_memory(device)->space(AS_PROGRAM); int bytes = memory_address_to_byte(space, result & DASMFLAG_LENGTHMASK); - assert(bytes >= cpu_get_min_opcode_bytes(device)); - assert(bytes <= cpu_get_max_opcode_bytes(device)); + assert(bytes >= cpudebug->cpudevice->min_opcode_bytes()); + assert(bytes <= cpudebug->cpudevice->max_opcode_bytes()); (void) bytes; /* appease compiler */ } #endif @@ -441,11 +386,11 @@ offs_t debug_cpu_disassemble(running_device *device, char *buffer, offs_t pc, co handler for disassembly -------------------------------------------------*/ -void debug_cpu_set_dasm_override(running_device *device, cpu_disassemble_func dasm_override) +void debug_cpu_set_dasm_override(device_t *device, cpu_disassemble_func dasm_override) { - cpu_debug_data *info = cpu_get_debug_data(device); - if (info != NULL) - info->dasm_override = dasm_override; + cpu_debug_data *cpudebug = cpu_get_debug_data(device); + if (cpudebug != NULL) + cpudebug->dasm_override = dasm_override; } @@ -460,10 +405,10 @@ void debug_cpu_set_dasm_override(running_device *device, cpu_disassemble_func da execution for the given CPU -------------------------------------------------*/ -void debug_cpu_start_hook(running_device *device, attotime endtime) +void debug_cpu_start_hook(device_t *device, attotime endtime) { debugcpu_private *global = device->machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(device); + cpu_debug_data *cpudebug = cpu_get_debug_data(device); assert((device->machine->debug_flags & DEBUG_FLAG_ENABLED) != 0); @@ -472,7 +417,7 @@ void debug_cpu_start_hook(running_device *device, attotime endtime) global->livecpu = device; /* update the target execution end time */ - info->endexectime = endtime; + cpudebug->endexectime = endtime; /* if we're running, do some periodic updating */ if (global->execution_state != EXECUTION_STATE_STOPPED) @@ -498,7 +443,7 @@ void debug_cpu_start_hook(running_device *device, attotime endtime) global->vblank_occurred = FALSE; /* if we were waiting for a VBLANK, signal it now */ - if ((info->flags & DEBUG_FLAG_STOP_VBLANK) != 0) + if ((cpudebug->flags & DEBUG_FLAG_STOP_VBLANK) != 0) { global->execution_state = EXECUTION_STATE_STOPPED; debug_console_printf(device->machine, "Stopped at VBLANK\n"); @@ -521,15 +466,15 @@ void debug_cpu_start_hook(running_device *device, attotime endtime) for the given CPU -------------------------------------------------*/ -void debug_cpu_stop_hook(running_device *device) +void debug_cpu_stop_hook(device_t *device) { debugcpu_private *global = device->machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(device); + cpu_debug_data *cpudebug = cpu_get_debug_data(device); assert(global->livecpu == device); /* if we're stopping on a context switch, handle it now */ - if (info->flags & DEBUG_FLAG_STOP_CONTEXT) + if (cpudebug->flags & DEBUG_FLAG_STOP_CONTEXT) { global->execution_state = EXECUTION_STATE_STOPPED; reset_transient_flags(device->machine); @@ -545,13 +490,13 @@ void debug_cpu_stop_hook(running_device *device) interrupt is acknowledged -------------------------------------------------*/ -void debug_cpu_interrupt_hook(running_device *device, int irqline) +void debug_cpu_interrupt_hook(device_t *device, int irqline) { debugcpu_private *global = device->machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(device); + cpu_debug_data *cpudebug = cpu_get_debug_data(device); /* see if this matches a pending interrupt request */ - if (info != NULL && (info->flags & DEBUG_FLAG_STOP_INTERRUPT) != 0 && (info->stopirq == -1 || info->stopirq == irqline)) + if (cpudebug != NULL && (cpudebug->flags & DEBUG_FLAG_STOP_INTERRUPT) != 0 && (cpudebug->stopirq == -1 || cpudebug->stopirq == irqline)) { global->execution_state = EXECUTION_STATE_STOPPED; debug_console_printf(device->machine, "Stopped on interrupt (CPU '%s', IRQ %d)\n", device->tag(), irqline); @@ -565,13 +510,13 @@ void debug_cpu_interrupt_hook(running_device *device, int irqline) exception is generated -------------------------------------------------*/ -void debug_cpu_exception_hook(running_device *device, int exception) +void debug_cpu_exception_hook(device_t *device, int exception) { debugcpu_private *global = device->machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(device); + cpu_debug_data *cpudebug = cpu_get_debug_data(device); /* see if this matches a pending interrupt request */ - if ((info->flags & DEBUG_FLAG_STOP_EXCEPTION) != 0 && (info->stopexception == -1 || info->stopexception == exception)) + if ((cpudebug->flags & DEBUG_FLAG_STOP_EXCEPTION) != 0 && (cpudebug->stopexception == -1 || cpudebug->stopexception == exception)) { global->execution_state = EXECUTION_STATE_STOPPED; debug_console_printf(device->machine, "Stopped on exception (CPU '%s', exception %d)\n", device->tag(), exception); @@ -585,41 +530,41 @@ void debug_cpu_exception_hook(running_device *device, int exception) CPU cores before executing each instruction -------------------------------------------------*/ -void debug_cpu_instruction_hook(running_device *device, offs_t curpc) +void debug_cpu_instruction_hook(device_t *device, offs_t curpc) { debugcpu_private *global = device->machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(device); + cpu_debug_data *cpudebug = cpu_get_debug_data(device); /* note that we are in the debugger code */ global->within_instruction_hook = TRUE; /* update the history */ - info->pc_history[info->pc_history_index++ % DEBUG_HISTORY_SIZE] = curpc; + cpudebug->pc_history[cpudebug->pc_history_index++ % DEBUG_HISTORY_SIZE] = curpc; /* are we tracing? */ - if (info->flags & DEBUG_FLAG_TRACING_ANY) - perform_trace(info); + if (cpudebug->flags & DEBUG_FLAG_TRACING_ANY) + perform_trace(cpudebug); /* per-instruction hook? */ - if (global->execution_state != EXECUTION_STATE_STOPPED && (info->flags & DEBUG_FLAG_HOOKED) != 0 && (*info->instrhook)(device, curpc)) + if (global->execution_state != EXECUTION_STATE_STOPPED && (cpudebug->flags & DEBUG_FLAG_HOOKED) != 0 && (*cpudebug->instrhook)(device, curpc)) global->execution_state = EXECUTION_STATE_STOPPED; /* handle single stepping */ - if (global->execution_state != EXECUTION_STATE_STOPPED && (info->flags & DEBUG_FLAG_STEPPING_ANY) != 0) + if (global->execution_state != EXECUTION_STATE_STOPPED && (cpudebug->flags & DEBUG_FLAG_STEPPING_ANY) != 0) { /* is this an actual step? */ - if (info->stepaddr == ~0 || curpc == info->stepaddr) + if (cpudebug->stepaddr == ~0 || curpc == cpudebug->stepaddr) { /* decrement the count and reset the breakpoint */ - info->stepsleft--; - info->stepaddr = ~0; + cpudebug->stepsleft--; + cpudebug->stepaddr = ~0; /* if we hit 0, stop */ - if (info->stepsleft == 0) + if (cpudebug->stepsleft == 0) global->execution_state = EXECUTION_STATE_STOPPED; /* update every 100 steps until we are within 200 of the end */ - else if ((info->flags & DEBUG_FLAG_STEPPING_OUT) == 0 && (info->stepsleft < 200 || info->stepsleft % 100 == 0)) + else if ((cpudebug->flags & DEBUG_FLAG_STEPPING_OUT) == 0 && (cpudebug->stepsleft < 200 || cpudebug->stepsleft % 100 == 0)) { debug_view_update_all(device->machine); debug_view_flush_updates(device->machine); @@ -629,25 +574,25 @@ void debug_cpu_instruction_hook(running_device *device, offs_t curpc) } /* handle breakpoints */ - if (global->execution_state != EXECUTION_STATE_STOPPED && (info->flags & (DEBUG_FLAG_STOP_TIME | DEBUG_FLAG_STOP_PC | DEBUG_FLAG_LIVE_BP)) != 0) + if (global->execution_state != EXECUTION_STATE_STOPPED && (cpudebug->flags & (DEBUG_FLAG_STOP_TIME | DEBUG_FLAG_STOP_PC | DEBUG_FLAG_LIVE_BP)) != 0) { /* see if we hit a target time */ - if ((info->flags & DEBUG_FLAG_STOP_TIME) != 0 && attotime_compare(timer_get_time(device->machine), info->stoptime) >= 0) + if ((cpudebug->flags & DEBUG_FLAG_STOP_TIME) != 0 && attotime_compare(timer_get_time(device->machine), cpudebug->stoptime) >= 0) { debug_console_printf(device->machine, "Stopped at time interval %.1g\n", attotime_to_double(timer_get_time(device->machine))); global->execution_state = EXECUTION_STATE_STOPPED; } /* check the temp running breakpoint and break if we hit it */ - else if ((info->flags & DEBUG_FLAG_STOP_PC) != 0 && info->stopaddr == curpc) + else if ((cpudebug->flags & DEBUG_FLAG_STOP_PC) != 0 && cpudebug->stopaddr == curpc) { - debug_console_printf(device->machine, "Stopped at temporary breakpoint %X on CPU '%s'\n", info->stopaddr, device->tag()); + debug_console_printf(device->machine, "Stopped at temporary breakpoint %X on CPU '%s'\n", cpudebug->stopaddr, device->tag()); global->execution_state = EXECUTION_STATE_STOPPED; } /* check for execution breakpoints */ - else if ((info->flags & DEBUG_FLAG_LIVE_BP) != 0) - breakpoint_check(device->machine, info, curpc); + else if ((cpudebug->flags & DEBUG_FLAG_LIVE_BP) != 0) + breakpoint_check(device->machine, cpudebug, curpc); } /* if we are supposed to halt, do it now */ @@ -702,8 +647,8 @@ void debug_cpu_instruction_hook(running_device *device, offs_t curpc) } /* handle step out/over on the instruction we are about to execute */ - if ((info->flags & (DEBUG_FLAG_STEPPING_OVER | DEBUG_FLAG_STEPPING_OUT)) != 0 && info->stepaddr == ~0) - prepare_for_step_overout(info); + if ((cpudebug->flags & (DEBUG_FLAG_STEPPING_OVER | DEBUG_FLAG_STEPPING_OUT)) != 0 && cpudebug->stepaddr == ~0) + prepare_for_step_overout(cpudebug); /* no longer in debugger code */ global->within_instruction_hook = FALSE; @@ -718,13 +663,13 @@ void debug_cpu_instruction_hook(running_device *device, offs_t curpc) void debug_cpu_memory_read_hook(const address_space *space, offs_t address, UINT64 mem_mask) { - cpu_debug_data *info = cpu_get_debug_data(space->cpu); + cpu_debug_data *cpudebug = cpu_get_debug_data(space->cpu); /* check watchpoints */ watchpoint_check(space, WATCHPOINT_READ, address, 0, mem_mask); /* check hotspots */ - if (info->hotspots != NULL) + if (cpudebug->hotspots != NULL) check_hotspots(space, address); } @@ -751,14 +696,14 @@ void debug_cpu_memory_write_hook(const address_space *space, offs_t address, UIN the debugger on the next instruction -------------------------------------------------*/ -void debug_cpu_halt_on_next_instruction(running_device *device, const char *fmt, ...) +void debug_cpu_halt_on_next_instruction(device_t *device, const char *fmt, ...) { debugcpu_private *global = device->machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(device); + cpu_debug_data *cpudebug = cpu_get_debug_data(device); va_list arg; /* if something is pending on this CPU already, ignore this request */ - if (info != NULL && device == global->breakcpu) + if (cpudebug != NULL && device == global->breakcpu) return; /* output the message to the console */ @@ -783,15 +728,15 @@ void debug_cpu_halt_on_next_instruction(running_device *device, const char *fmt, CPU -------------------------------------------------*/ -void debug_cpu_ignore_cpu(running_device *device, int ignore) +void debug_cpu_ignore_cpu(device_t *device, int ignore) { debugcpu_private *global = device->machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(device); + cpu_debug_data *cpudebug = cpu_get_debug_data(device); if (ignore) - info->flags &= ~DEBUG_FLAG_OBSERVING; + cpudebug->flags &= ~DEBUG_FLAG_OBSERVING; else - info->flags |= DEBUG_FLAG_OBSERVING; + cpudebug->flags |= DEBUG_FLAG_OBSERVING; if (device == global->livecpu && ignore) debug_cpu_next_cpu(device->machine); @@ -806,13 +751,13 @@ void debug_cpu_ignore_cpu(running_device *device, int ignore) void debug_cpu_single_step(running_machine *machine, int numsteps) { debugcpu_private *global = machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(global->visiblecpu); + cpu_debug_data *cpudebug = cpu_get_debug_data(global->visiblecpu); - assert(info != NULL); + assert(cpudebug != NULL); - info->stepsleft = numsteps; - info->stepaddr = ~0; - info->flags |= DEBUG_FLAG_STEPPING; + cpudebug->stepsleft = numsteps; + cpudebug->stepaddr = ~0; + cpudebug->flags |= DEBUG_FLAG_STEPPING; global->execution_state = EXECUTION_STATE_RUNNING; } @@ -826,13 +771,13 @@ void debug_cpu_single_step(running_machine *machine, int numsteps) void debug_cpu_single_step_over(running_machine *machine, int numsteps) { debugcpu_private *global = machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(global->visiblecpu); + cpu_debug_data *cpudebug = cpu_get_debug_data(global->visiblecpu); - assert(info != NULL); + assert(cpudebug != NULL); - info->stepsleft = numsteps; - info->stepaddr = ~0; - info->flags |= DEBUG_FLAG_STEPPING_OVER; + cpudebug->stepsleft = numsteps; + cpudebug->stepaddr = ~0; + cpudebug->flags |= DEBUG_FLAG_STEPPING_OVER; global->execution_state = EXECUTION_STATE_RUNNING; } @@ -845,13 +790,13 @@ void debug_cpu_single_step_over(running_machine *machine, int numsteps) void debug_cpu_single_step_out(running_machine *machine) { debugcpu_private *global = machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(global->visiblecpu); + cpu_debug_data *cpudebug = cpu_get_debug_data(global->visiblecpu); - assert(info != NULL); + assert(cpudebug != NULL); - info->stepsleft = 100; - info->stepaddr = ~0; - info->flags |= DEBUG_FLAG_STEPPING_OUT; + cpudebug->stepsleft = 100; + cpudebug->stepaddr = ~0; + cpudebug->flags |= DEBUG_FLAG_STEPPING_OUT; global->execution_state = EXECUTION_STATE_RUNNING; } @@ -864,12 +809,12 @@ void debug_cpu_single_step_out(running_machine *machine) void debug_cpu_go(running_machine *machine, offs_t targetpc) { debugcpu_private *global = machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(global->visiblecpu); + cpu_debug_data *cpudebug = cpu_get_debug_data(global->visiblecpu); - assert(info != NULL); + assert(cpudebug != NULL); - info->stopaddr = targetpc; - info->flags |= DEBUG_FLAG_STOP_PC; + cpudebug->stopaddr = targetpc; + cpudebug->flags |= DEBUG_FLAG_STOP_PC; global->execution_state = EXECUTION_STATE_RUNNING; } @@ -882,12 +827,12 @@ void debug_cpu_go(running_machine *machine, offs_t targetpc) void debug_cpu_go_vblank(running_machine *machine) { debugcpu_private *global = machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(global->visiblecpu); + cpu_debug_data *cpudebug = cpu_get_debug_data(global->visiblecpu); - assert(info != NULL); + assert(cpudebug != NULL); global->vblank_occurred = FALSE; - info->flags |= DEBUG_FLAG_STOP_VBLANK; + cpudebug->flags |= DEBUG_FLAG_STOP_VBLANK; global->execution_state = EXECUTION_STATE_RUNNING; } @@ -900,12 +845,12 @@ void debug_cpu_go_vblank(running_machine *machine) void debug_cpu_go_interrupt(running_machine *machine, int irqline) { debugcpu_private *global = machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(global->visiblecpu); + cpu_debug_data *cpudebug = cpu_get_debug_data(global->visiblecpu); - assert(info != NULL); + assert(cpudebug != NULL); - info->stopirq = irqline; - info->flags |= DEBUG_FLAG_STOP_INTERRUPT; + cpudebug->stopirq = irqline; + cpudebug->flags |= DEBUG_FLAG_STOP_INTERRUPT; global->execution_state = EXECUTION_STATE_RUNNING; } @@ -918,12 +863,12 @@ void debug_cpu_go_interrupt(running_machine *machine, int irqline) void debug_cpu_go_exception(running_machine *machine, int exception) { debugcpu_private *global = machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(global->visiblecpu); + cpu_debug_data *cpudebug = cpu_get_debug_data(global->visiblecpu); - assert(info != NULL); + assert(cpudebug != NULL); - info->stopexception = exception; - info->flags |= DEBUG_FLAG_STOP_EXCEPTION; + cpudebug->stopexception = exception; + cpudebug->flags |= DEBUG_FLAG_STOP_EXCEPTION; global->execution_state = EXECUTION_STATE_RUNNING; } @@ -936,12 +881,12 @@ void debug_cpu_go_exception(running_machine *machine, int exception) void debug_cpu_go_milliseconds(running_machine *machine, UINT64 milliseconds) { debugcpu_private *global = machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(global->visiblecpu); + cpu_debug_data *cpudebug = cpu_get_debug_data(global->visiblecpu); - assert(info != NULL); + assert(cpudebug != NULL); - info->stoptime = attotime_add(timer_get_time(machine), ATTOTIME_IN_MSEC(milliseconds)); - info->flags |= DEBUG_FLAG_STOP_TIME; + cpudebug->stoptime = attotime_add(timer_get_time(machine), ATTOTIME_IN_MSEC(milliseconds)); + cpudebug->flags |= DEBUG_FLAG_STOP_TIME; global->execution_state = EXECUTION_STATE_RUNNING; } @@ -954,11 +899,11 @@ void debug_cpu_go_milliseconds(running_machine *machine, UINT64 milliseconds) void debug_cpu_next_cpu(running_machine *machine) { debugcpu_private *global = machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(global->visiblecpu); + cpu_debug_data *cpudebug = cpu_get_debug_data(global->visiblecpu); - assert(info != NULL); + assert(cpudebug != NULL); - info->flags |= DEBUG_FLAG_STOP_CONTEXT; + cpudebug->flags |= DEBUG_FLAG_STOP_CONTEXT; global->execution_state = EXECUTION_STATE_RUNNING; } @@ -973,10 +918,10 @@ void debug_cpu_next_cpu(running_machine *machine) breakpoint, returning its index -------------------------------------------------*/ -int debug_cpu_breakpoint_set(running_device *device, offs_t address, parsed_expression *condition, const char *action) +int debug_cpu_breakpoint_set(device_t *device, offs_t address, parsed_expression *condition, const char *action) { debugcpu_private *global = device->machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(device); + cpu_debug_data *cpudebug = cpu_get_debug_data(device); debug_cpu_breakpoint *bp; assert_always(device != NULL, "debug_cpu_breakpoint_set() called with invalid cpu!"); @@ -995,11 +940,11 @@ int debug_cpu_breakpoint_set(running_device *device, offs_t address, parsed_expr } /* hook us in */ - bp->next = info->bplist; - info->bplist = bp; + bp->next = cpudebug->bplist; + cpudebug->bplist = bp; /* ensure the live breakpoint flag is set */ - breakpoint_update_flags(info); + breakpoint_update_flags(cpudebug); return bp->index; } @@ -1012,18 +957,18 @@ int debug_cpu_breakpoint_set(running_device *device, offs_t address, parsed_expr int debug_cpu_breakpoint_clear(running_machine *machine, int bpnum) { debug_cpu_breakpoint *bp, *pbp; - running_device *cpu; + device_t *cpu; /* loop over CPUs and find the requested breakpoint */ for (cpu = machine->firstcpu; cpu != NULL; cpu = cpu_next(cpu)) { - cpu_debug_data *info = cpu_get_debug_data(cpu); - for (pbp = NULL, bp = info->bplist; bp != NULL; pbp = bp, bp = bp->next) + cpu_debug_data *cpudebug = cpu_get_debug_data(cpu); + for (pbp = NULL, bp = cpudebug->bplist; bp != NULL; pbp = bp, bp = bp->next) if (bp->index == bpnum) { /* unlink us from the list */ if (pbp == NULL) - info->bplist = bp->next; + cpudebug->bplist = bp->next; else pbp->next = bp->next; @@ -1035,7 +980,7 @@ int debug_cpu_breakpoint_clear(running_machine *machine, int bpnum) auto_free(machine, bp); /* update the flags */ - breakpoint_update_flags(info); + breakpoint_update_flags(cpudebug); return TRUE; } } @@ -1053,17 +998,17 @@ int debug_cpu_breakpoint_clear(running_machine *machine, int bpnum) int debug_cpu_breakpoint_enable(running_machine *machine, int bpnum, int enable) { debug_cpu_breakpoint *bp; - running_device *cpu; + device_t *cpu; /* loop over CPUs and find the requested breakpoint */ for (cpu = machine->firstcpu; cpu != NULL; cpu = cpu_next(cpu)) { - cpu_debug_data *info = cpu_get_debug_data(cpu); - for (bp = info->bplist; bp != NULL; bp = bp->next) + cpu_debug_data *cpudebug = cpu_get_debug_data(cpu); + for (bp = cpudebug->bplist; bp != NULL; bp = bp->next) if (bp->index == bpnum) { bp->enabled = (enable != 0); - breakpoint_update_flags(info); + breakpoint_update_flags(cpudebug); return TRUE; } } @@ -1085,7 +1030,7 @@ int debug_cpu_breakpoint_enable(running_machine *machine, int bpnum, int enable) int debug_cpu_watchpoint_set(const address_space *space, int type, offs_t address, offs_t length, parsed_expression *condition, const char *action) { debugcpu_private *global = space->machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(space->cpu); + cpu_debug_data *cpudebug = cpu_get_debug_data(space->cpu); debug_cpu_watchpoint *wp = auto_alloc(space->machine, debug_cpu_watchpoint); /* fill in the structure */ @@ -1103,8 +1048,8 @@ int debug_cpu_watchpoint_set(const address_space *space, int type, offs_t addres } /* hook us in */ - wp->next = info->wplist[space->spacenum]; - info->wplist[space->spacenum] = wp; + wp->next = cpudebug->wplist[space->spacenum]; + cpudebug->wplist[space->spacenum] = wp; watchpoint_update_flags(space); @@ -1120,21 +1065,21 @@ int debug_cpu_watchpoint_set(const address_space *space, int type, offs_t addres int debug_cpu_watchpoint_clear(running_machine *machine, int wpnum) { debug_cpu_watchpoint *wp, *pwp; - running_device *cpu; + device_t *cpu; int spacenum; /* loop over CPUs and find the requested watchpoint */ for (cpu = machine->firstcpu; cpu != NULL; cpu = cpu_next(cpu)) { - cpu_debug_data *info = cpu_get_debug_data(cpu); + cpu_debug_data *cpudebug = cpu_get_debug_data(cpu); for (spacenum = 0; spacenum < ADDRESS_SPACES; spacenum++) - for (pwp = NULL, wp = info->wplist[spacenum]; wp != NULL; pwp = wp, wp = wp->next) + for (pwp = NULL, wp = cpudebug->wplist[spacenum]; wp != NULL; pwp = wp, wp = wp->next) if (wp->index == wpnum) { /* unlink us from the list */ if (pwp == NULL) - info->wplist[spacenum] = wp->next; + cpudebug->wplist[spacenum] = wp->next; else pwp->next = wp->next; @@ -1163,16 +1108,16 @@ int debug_cpu_watchpoint_clear(running_machine *machine, int wpnum) int debug_cpu_watchpoint_enable(running_machine *machine, int wpnum, int enable) { debug_cpu_watchpoint *wp; - running_device *cpu; + device_t *cpu; int spacenum; /* loop over CPUs and address spaces and find the requested watchpoint */ for (cpu = machine->firstcpu; cpu != NULL; cpu = cpu_next(cpu)) { - cpu_debug_data *info = cpu_get_debug_data(cpu); + cpu_debug_data *cpudebug = cpu_get_debug_data(cpu); for (spacenum = 0; spacenum < ADDRESS_SPACES; spacenum++) - for (wp = info->wplist[spacenum]; wp != NULL; wp = wp->next) + for (wp = cpudebug->wplist[spacenum]; wp != NULL; wp = wp->next) if (wp->index == wpnum) { wp->enabled = (enable != 0); @@ -1225,34 +1170,34 @@ void debug_cpu_source_script(running_machine *machine, const char *file) CPU -------------------------------------------------*/ -void debug_cpu_trace(running_device *device, FILE *file, int trace_over, const char *action) +void debug_cpu_trace(device_t *device, FILE *file, int trace_over, const char *action) { - cpu_debug_data *info = cpu_get_debug_data(device); + cpu_debug_data *cpudebug = cpu_get_debug_data(device); /* close existing files and delete expressions */ - if (info->trace.file != NULL) - fclose(info->trace.file); - info->trace.file = NULL; + if (cpudebug->trace.file != NULL) + fclose(cpudebug->trace.file); + cpudebug->trace.file = NULL; - if (info->trace.action != NULL) - auto_free(device->machine, info->trace.action); - info->trace.action = NULL; + if (cpudebug->trace.action != NULL) + auto_free(device->machine, cpudebug->trace.action); + cpudebug->trace.action = NULL; /* open any new files */ - info->trace.file = file; - info->trace.action = NULL; - info->trace.trace_over_target = ~0; + cpudebug->trace.file = file; + cpudebug->trace.action = NULL; + cpudebug->trace.trace_over_target = ~0; if (action != NULL) { - info->trace.action = auto_alloc_array(device->machine, char, strlen(action) + 1); - strcpy(info->trace.action, action); + cpudebug->trace.action = auto_alloc_array(device->machine, char, strlen(action) + 1); + strcpy(cpudebug->trace.action, action); } /* update flags */ - if (info->trace.file != NULL) - info->flags |= trace_over ? DEBUG_FLAG_TRACING_OVER : DEBUG_FLAG_TRACING; + if (cpudebug->trace.file != NULL) + cpudebug->flags |= trace_over ? DEBUG_FLAG_TRACING_OVER : DEBUG_FLAG_TRACING; else - info->flags &= ~DEBUG_FLAG_TRACING_ANY; + cpudebug->flags &= ~DEBUG_FLAG_TRACING_ANY; } @@ -1261,16 +1206,16 @@ void debug_cpu_trace(running_device *device, FILE *file, int trace_over, const c given CPU's tracefile, if tracing -------------------------------------------------*/ -void debug_cpu_trace_printf(running_device *device, const char *fmt, ...) +void debug_cpu_trace_printf(device_t *device, const char *fmt, ...) { va_list va; - cpu_debug_data *info = cpu_get_debug_data(device); + cpu_debug_data *cpudebug = cpu_get_debug_data(device); - if (info->trace.file) + if (cpudebug->trace.file) { va_start(va, fmt); - vfprintf(info->trace.file, fmt, va); + vfprintf(cpudebug->trace.file, fmt, va); va_end(va); } } @@ -1281,16 +1226,16 @@ void debug_cpu_trace_printf(running_device *device, const char *fmt, ...) be called on each instruction for a given CPU -------------------------------------------------*/ -void debug_cpu_set_instruction_hook(running_device *device, debug_instruction_hook_func hook) +void debug_cpu_set_instruction_hook(device_t *device, debug_instruction_hook_func hook) { - cpu_debug_data *info = cpu_get_debug_data(device); + cpu_debug_data *cpudebug = cpu_get_debug_data(device); /* set the hook and also the CPU's flag for fast knowledge of the hook */ - info->instrhook = hook; + cpudebug->instrhook = hook; if (hook != NULL) - info->flags |= DEBUG_FLAG_HOOKED; + cpudebug->flags |= DEBUG_FLAG_HOOKED; else - info->flags &= ~DEBUG_FLAG_HOOKED; + cpudebug->flags &= ~DEBUG_FLAG_HOOKED; } @@ -1299,25 +1244,25 @@ void debug_cpu_set_instruction_hook(running_device *device, debug_instruction_ho tracking of hotspots -------------------------------------------------*/ -int debug_cpu_hotspot_track(running_device *device, int numspots, int threshhold) +int debug_cpu_hotspot_track(device_t *device, int numspots, int threshhold) { - cpu_debug_data *info = cpu_get_debug_data(device); + cpu_debug_data *cpudebug = cpu_get_debug_data(device); - /* if we already have tracking info, kill it */ - if (info->hotspots) - auto_free(device->machine, info->hotspots); - info->hotspots = NULL; + /* if we already have tracking cpudebug, kill it */ + if (cpudebug->hotspots) + auto_free(device->machine, cpudebug->hotspots); + cpudebug->hotspots = NULL; /* only start tracking if we have a non-zero count */ if (numspots > 0) { /* allocate memory for hotspots */ - info->hotspots = auto_alloc_array(device->machine, debug_hotspot_entry, numspots); - memset(info->hotspots, 0xff, sizeof(*info->hotspots) * numspots); + cpudebug->hotspots = auto_alloc_array(device->machine, debug_hotspot_entry, numspots); + memset(cpudebug->hotspots, 0xff, sizeof(*cpudebug->hotspots) * numspots); - /* fill in the info */ - info->hotspot_count = numspots; - info->hotspot_threshhold = threshhold; + /* fill in the cpudebug */ + cpudebug->hotspot_count = numspots; + cpudebug->hotspot_threshhold = threshhold; } watchpoint_update_flags(cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM)); @@ -1337,7 +1282,7 @@ int debug_cpu_hotspot_track(running_device *device, int numspots, int threshhold UINT8 debug_read_byte(const address_space *space, offs_t address, int apply_translation) { - cpu_debug_data *info = (space->cpu->type == CPU) ? cpu_get_debug_data(space->cpu) : NULL; + cpu_debug_data *cpudebug = (space->cpu->type() == CPU) ? cpu_get_debug_data(space->cpu) : NULL; debugcpu_private *global = space->machine->debugcpu_data; UINT64 custom; UINT8 result; @@ -1353,7 +1298,7 @@ UINT8 debug_read_byte(const address_space *space, offs_t address, int apply_tran result = 0xff; /* if there is a custom read handler, and it returns TRUE, use that value */ - else if (info != NULL && info->read != NULL && (*info->read)(space->cpu, space->spacenum, address, 1, &custom)) + else if (cpudebug != NULL && cpudebug->cpudevice->read(space->spacenum, address, 1, custom)) result = custom; /* otherwise, call the byte reading function for the translated address */ @@ -1395,7 +1340,7 @@ UINT16 debug_read_word(const address_space *space, offs_t address, int apply_tra /* otherwise, this proceeds like the byte case */ else { - cpu_debug_data *info = (space->cpu->type == CPU) ? cpu_get_debug_data(space->cpu) : NULL; + cpu_debug_data *cpudebug = (space->cpu->type() == CPU) ? cpu_get_debug_data(space->cpu) : NULL; UINT64 custom; /* all accesses from this point on are for the debugger */ @@ -1406,7 +1351,7 @@ UINT16 debug_read_word(const address_space *space, offs_t address, int apply_tra result = 0xffff; /* if there is a custom read handler, and it returns TRUE, use that value */ - else if (info != NULL && info->read != NULL && (*info->read)(space->cpu, space->spacenum, address, 2, &custom)) + else if (cpudebug != NULL && cpudebug->cpudevice->read(space->spacenum, address, 2, custom)) result = custom; /* otherwise, call the byte reading function for the translated address */ @@ -1450,7 +1395,7 @@ UINT32 debug_read_dword(const address_space *space, offs_t address, int apply_tr /* otherwise, this proceeds like the byte case */ else { - cpu_debug_data *info = (space->cpu->type == CPU) ? cpu_get_debug_data(space->cpu) : NULL; + cpu_debug_data *cpudebug = (space->cpu->type() == CPU) ? cpu_get_debug_data(space->cpu) : NULL; UINT64 custom; /* all accesses from this point on are for the debugger */ @@ -1461,7 +1406,7 @@ UINT32 debug_read_dword(const address_space *space, offs_t address, int apply_tr result = 0xffffffff; /* if there is a custom read handler, and it returns TRUE, use that value */ - else if (info != NULL && info->read != NULL && (*info->read)(space->cpu, space->spacenum, address, 4, &custom)) + else if (cpudebug != NULL && cpudebug->cpudevice->read(space->spacenum, address, 4, custom)) result = custom; /* otherwise, call the byte reading function for the translated address */ @@ -1505,7 +1450,7 @@ UINT64 debug_read_qword(const address_space *space, offs_t address, int apply_tr /* otherwise, this proceeds like the byte case */ else { - cpu_debug_data *info = (space->cpu->type == CPU) ? cpu_get_debug_data(space->cpu) : NULL; + cpu_debug_data *cpudebug = (space->cpu->type() == CPU) ? cpu_get_debug_data(space->cpu) : NULL; UINT64 custom; /* all accesses from this point on are for the debugger */ @@ -1516,7 +1461,7 @@ UINT64 debug_read_qword(const address_space *space, offs_t address, int apply_tr result = ~(UINT64)0; /* if there is a custom read handler, and it returns TRUE, use that value */ - else if (info != NULL && info->read != NULL && (*info->read)(space->cpu, space->spacenum, address, 8, &custom)) + else if (cpudebug != NULL && cpudebug->cpudevice->read(space->spacenum, address, 8, custom)) result = custom; /* otherwise, call the byte reading function for the translated address */ @@ -1557,7 +1502,7 @@ UINT64 debug_read_memory(const address_space *space, offs_t address, int size, i void debug_write_byte(const address_space *space, offs_t address, UINT8 data, int apply_translation) { - cpu_debug_data *info = (space->cpu->type == CPU) ? cpu_get_debug_data(space->cpu) : NULL; + cpu_debug_data *cpudebug = (space->cpu->type() == CPU) ? cpu_get_debug_data(space->cpu) : NULL; debugcpu_private *global = space->machine->debugcpu_data; /* mask against the logical byte mask */ @@ -1571,7 +1516,7 @@ void debug_write_byte(const address_space *space, offs_t address, UINT8 data, in ; /* if there is a custom write handler, and it returns TRUE, use that */ - else if (info != NULL && info->write != NULL && (*info->write)(space->cpu, space->spacenum, address, 1, data)) + else if (cpudebug != NULL && cpudebug->cpudevice->write(space->spacenum, address, 1, data)) ; /* otherwise, call the byte reading function for the translated address */ @@ -1614,7 +1559,7 @@ void debug_write_word(const address_space *space, offs_t address, UINT16 data, i /* otherwise, this proceeds like the byte case */ else { - cpu_debug_data *info = (space->cpu->type == CPU) ? cpu_get_debug_data(space->cpu) : NULL; + cpu_debug_data *cpudebug = (space->cpu->type() == CPU) ? cpu_get_debug_data(space->cpu) : NULL; /* all accesses from this point on are for the debugger */ memory_set_debugger_access(space, global->debugger_access = TRUE); @@ -1624,7 +1569,7 @@ void debug_write_word(const address_space *space, offs_t address, UINT16 data, i ; /* if there is a custom write handler, and it returns TRUE, use that */ - else if (info != NULL && info->write != NULL && (*info->write)(space->cpu, space->spacenum, address, 2, data)) + else if (cpudebug != NULL && cpudebug->cpudevice->write(space->spacenum, address, 2, data)) ; /* otherwise, call the byte reading function for the translated address */ @@ -1668,7 +1613,7 @@ void debug_write_dword(const address_space *space, offs_t address, UINT32 data, /* otherwise, this proceeds like the byte case */ else { - cpu_debug_data *info = (space->cpu->type == CPU) ? cpu_get_debug_data(space->cpu) : NULL; + cpu_debug_data *cpudebug = (space->cpu->type() == CPU) ? cpu_get_debug_data(space->cpu) : NULL; /* all accesses from this point on are for the debugger */ memory_set_debugger_access(space, global->debugger_access = TRUE); @@ -1678,7 +1623,7 @@ void debug_write_dword(const address_space *space, offs_t address, UINT32 data, ; /* if there is a custom write handler, and it returns TRUE, use that */ - else if (info != NULL && info->write != NULL && (*info->write)(space->cpu, space->spacenum, address, 4, data)) + else if (cpudebug != NULL && cpudebug->cpudevice->write(space->spacenum, address, 4, data)) ; /* otherwise, call the byte reading function for the translated address */ @@ -1722,7 +1667,7 @@ void debug_write_qword(const address_space *space, offs_t address, UINT64 data, /* otherwise, this proceeds like the byte case */ else { - cpu_debug_data *info = (space->cpu->type == CPU) ? cpu_get_debug_data(space->cpu) : NULL; + cpu_debug_data *cpudebug = (space->cpu->type() == CPU) ? cpu_get_debug_data(space->cpu) : NULL; /* all accesses from this point on are for the debugger */ memory_set_debugger_access(space, global->debugger_access = TRUE); @@ -1732,7 +1677,7 @@ void debug_write_qword(const address_space *space, offs_t address, UINT64 data, ; /* if there is a custom write handler, and it returns TRUE, use that */ - else if (info != NULL && info->write != NULL && (*info->write)(space->cpu, space->spacenum, address, 8, data)) + else if (cpudebug != NULL && cpudebug->cpudevice->write(space->spacenum, address, 8, data)) ; /* otherwise, call the byte reading function for the translated address */ @@ -1772,21 +1717,17 @@ UINT64 debug_read_opcode(const address_space *space, offs_t address, int size, i { UINT64 result = ~(UINT64)0 & (~(UINT64)0 >> (64 - 8*size)), result2; debugcpu_private *global = space->machine->debugcpu_data; - cpu_debug_data *info = cpu_get_debug_data(space->cpu); + cpu_debug_data *cpudebug = cpu_get_debug_data(space->cpu); /* keep in logical range */ address &= space->logbytemask; - /* shortcut if we have a custom routine */ - if (info->readop != NULL) + /* return early if we got the result directly */ + memory_set_debugger_access(space, global->debugger_access = TRUE); + if (cpudebug->cpudevice->readop(address, size, result2)) { - /* return early if we got the result directly */ - memory_set_debugger_access(space, global->debugger_access = TRUE); - if ((*info->readop)(space->cpu, address, size, &result2)) - { - memory_set_debugger_access(space, global->debugger_access = FALSE); - return result2; - } + memory_set_debugger_access(space, global->debugger_access = FALSE); + return result2; } /* if we're bigger than the address bus, break into smaller pieces */ @@ -1929,34 +1870,34 @@ UINT64 debug_read_opcode(const address_space *space, offs_t address, int size, i static void debug_cpu_exit(running_machine *machine) { debugcpu_private *global = machine->debugcpu_data; - running_device *cpu; + device_t *cpu; int spacenum; /* loop over all watchpoints and breakpoints to free their memory */ for (cpu = machine->firstcpu; cpu != NULL; cpu = cpu_next(cpu)) { - cpu_debug_data *info = cpu_get_debug_data(cpu); + cpu_debug_data *cpudebug = cpu_get_debug_data(cpu); /* close any tracefiles */ - if (info->trace.file != NULL) - fclose(info->trace.file); - if (info->trace.action != NULL) - auto_free(machine, info->trace.action); + if (cpudebug->trace.file != NULL) + fclose(cpudebug->trace.file); + if (cpudebug->trace.action != NULL) + auto_free(machine, cpudebug->trace.action); /* free the symbol table */ - if (info->symtable != NULL) - symtable_free(info->symtable); + if (cpudebug->symtable != NULL) + symtable_free(cpudebug->symtable); /* free all breakpoints */ - while (info->bplist != NULL) - debug_cpu_breakpoint_clear(machine, info->bplist->index); + while (cpudebug->bplist != NULL) + debug_cpu_breakpoint_clear(machine, cpudebug->bplist->index); /* loop over all address spaces */ - for (spacenum = 0; spacenum < ARRAY_LENGTH(info->wplist); spacenum++) + for (spacenum = 0; spacenum < ARRAY_LENGTH(cpudebug->wplist); spacenum++) { /* free all watchpoints */ - while (info->wplist[spacenum] != NULL) - debug_cpu_watchpoint_clear(machine, info->wplist[spacenum]->index); + while (cpudebug->wplist[spacenum] != NULL) + debug_cpu_watchpoint_clear(machine, cpudebug->wplist[spacenum]->index); } } @@ -1970,11 +1911,11 @@ static void debug_cpu_exit(running_machine *machine) on_vblank - called when a VBLANK hits -------------------------------------------------*/ -static void on_vblank(running_device *device, void *param, int vblank_state) +static void on_vblank(screen_device &device, void *param, bool vblank_state) { /* just set a global flag to be consumed later */ if (vblank_state) - device->machine->debugcpu_data->vblank_occurred = TRUE; + device.machine->debugcpu_data->vblank_occurred = TRUE; } @@ -1985,7 +1926,7 @@ static void on_vblank(running_device *device, void *param, int vblank_state) static void reset_transient_flags(running_machine *machine) { - running_device *cpu; + device_t *cpu; /* loop over CPUs and reset the transient flags */ for (cpu = machine->firstcpu; cpu != NULL; cpu = cpu_next(cpu)) @@ -1998,9 +1939,9 @@ static void reset_transient_flags(running_machine *machine) debug flags for optimal efficiency -------------------------------------------------*/ -static void compute_debug_flags(running_device *device) +static void compute_debug_flags(device_t *device) { - cpu_debug_data *info = cpu_get_debug_data(device); + cpu_debug_data *cpudebug = cpu_get_debug_data(device); running_machine *machine = device->machine; debugcpu_private *global = machine->debugcpu_data; @@ -2009,18 +1950,18 @@ static void compute_debug_flags(running_device *device) machine->debug_flags |= DEBUG_FLAG_ENABLED; /* if we are ignoring this CPU, or if events are pending, we're done */ - if ((info->flags & DEBUG_FLAG_OBSERVING) == 0 || mame_is_scheduled_event_pending(machine) || mame_is_save_or_load_pending(machine)) + if ((cpudebug->flags & DEBUG_FLAG_OBSERVING) == 0 || mame_is_scheduled_event_pending(machine) || mame_is_save_or_load_pending(machine)) return; /* many of our states require us to be called on each instruction */ if (global->execution_state == EXECUTION_STATE_STOPPED) machine->debug_flags |= DEBUG_FLAG_CALL_HOOK; - if ((info->flags & (DEBUG_FLAG_HISTORY | DEBUG_FLAG_TRACING_ANY | DEBUG_FLAG_HOOKED | + if ((cpudebug->flags & (DEBUG_FLAG_HISTORY | DEBUG_FLAG_TRACING_ANY | DEBUG_FLAG_HOOKED | DEBUG_FLAG_STEPPING_ANY | DEBUG_FLAG_STOP_PC | DEBUG_FLAG_LIVE_BP)) != 0) machine->debug_flags |= DEBUG_FLAG_CALL_HOOK; /* if we are stopping at a particular time and that time is within the current timeslice, we need to be called */ - if ((info->flags & DEBUG_FLAG_STOP_TIME) && attotime_compare(info->endexectime, info->stoptime) <= 0) + if ((cpudebug->flags & DEBUG_FLAG_STOP_TIME) && attotime_compare(cpudebug->endexectime, cpudebug->stoptime) <= 0) machine->debug_flags |= DEBUG_FLAG_CALL_HOOK; } @@ -2030,70 +1971,70 @@ static void compute_debug_flags(running_device *device) data for a given instruction -------------------------------------------------*/ -static void perform_trace(cpu_debug_data *info) +static void perform_trace(cpu_debug_data *cpudebug) { - offs_t pc = cpu_get_pc(info->device); + offs_t pc = cpu_get_pc(cpudebug->cpudevice); int offset, count, i; char buffer[100]; offs_t dasmresult; /* are we in trace over mode and in a subroutine? */ - if ((info->flags & DEBUG_FLAG_TRACING_OVER) != 0 && info->trace.trace_over_target != ~0) + if ((cpudebug->flags & DEBUG_FLAG_TRACING_OVER) != 0 && cpudebug->trace.trace_over_target != ~0) { - if (info->trace.trace_over_target != pc) + if (cpudebug->trace.trace_over_target != pc) return; - info->trace.trace_over_target = ~0; + cpudebug->trace.trace_over_target = ~0; } /* check for a loop condition */ for (i = count = 0; i < TRACE_LOOPS; i++) - if (info->trace.history[i] == pc) + if (cpudebug->trace.history[i] == pc) count++; /* if no more than 1 hit, process normally */ if (count <= 1) { - const address_space *space = cpu_get_address_space(info->device, ADDRESS_SPACE_PROGRAM); + const address_space *space = cpu_get_address_space(cpudebug->cpudevice, ADDRESS_SPACE_PROGRAM); /* if we just finished looping, indicate as much */ - if (info->trace.loops != 0) - fprintf(info->trace.file, "\n (loops for %d instructions)\n\n", info->trace.loops); - info->trace.loops = 0; + if (cpudebug->trace.loops != 0) + fprintf(cpudebug->trace.file, "\n (loops for %d instructions)\n\n", cpudebug->trace.loops); + cpudebug->trace.loops = 0; /* execute any trace actions first */ - if (info->trace.action != NULL) - debug_console_execute_command(info->device->machine, info->trace.action, 0); + if (cpudebug->trace.action != NULL) + debug_console_execute_command(cpudebug->cpudevice->machine, cpudebug->trace.action, 0); /* print the address */ offset = sprintf(buffer, "%0*X: ", space->logaddrchars, pc); /* print the disassembly */ - dasmresult = dasm_wrapped(info->device, &buffer[offset], pc); + dasmresult = dasm_wrapped(cpudebug->cpudevice, &buffer[offset], pc); /* output the result */ - fprintf(info->trace.file, "%s\n", buffer); + fprintf(cpudebug->trace.file, "%s\n", buffer); /* do we need to step the trace over this instruction? */ - if ((info->flags & DEBUG_FLAG_TRACING_OVER) != 0 && (dasmresult & DASMFLAG_SUPPORTED) != 0 && (dasmresult & DASMFLAG_STEP_OVER) != 0) + if ((cpudebug->flags & DEBUG_FLAG_TRACING_OVER) != 0 && (dasmresult & DASMFLAG_SUPPORTED) != 0 && (dasmresult & DASMFLAG_STEP_OVER) != 0) { int extraskip = (dasmresult & DASMFLAG_OVERINSTMASK) >> DASMFLAG_OVERINSTSHIFT; offs_t trace_over_target = pc + (dasmresult & DASMFLAG_LENGTHMASK); /* if we need to skip additional instructions, advance as requested */ while (extraskip-- > 0) - trace_over_target += dasm_wrapped(info->device, buffer, trace_over_target) & DASMFLAG_LENGTHMASK; + trace_over_target += dasm_wrapped(cpudebug->cpudevice, buffer, trace_over_target) & DASMFLAG_LENGTHMASK; - info->trace.trace_over_target = trace_over_target; + cpudebug->trace.trace_over_target = trace_over_target; } /* log this PC */ - info->trace.nextdex = (info->trace.nextdex + 1) % TRACE_LOOPS; - info->trace.history[info->trace.nextdex] = pc; + cpudebug->trace.nextdex = (cpudebug->trace.nextdex + 1) % TRACE_LOOPS; + cpudebug->trace.history[cpudebug->trace.nextdex] = pc; } /* else just count the loop */ else - info->trace.loops++; + cpudebug->trace.loops++; } @@ -2102,14 +2043,14 @@ static void perform_trace(cpu_debug_data *info) stepping over an instruction -------------------------------------------------*/ -static void prepare_for_step_overout(cpu_debug_data *info) +static void prepare_for_step_overout(cpu_debug_data *cpudebug) { - offs_t pc = cpu_get_pc(info->device); + offs_t pc = cpu_get_pc(cpudebug->cpudevice); char dasmbuffer[100]; offs_t dasmresult; /* disassemble the current instruction and get the flags */ - dasmresult = dasm_wrapped(info->device, dasmbuffer, pc); + dasmresult = dasm_wrapped(cpudebug->cpudevice, dasmbuffer, pc); /* if flags are supported and it's a call-style opcode, set a temp breakpoint after that instruction */ if ((dasmresult & DASMFLAG_SUPPORTED) != 0 && (dasmresult & DASMFLAG_STEP_OVER) != 0) @@ -2119,17 +2060,17 @@ static void prepare_for_step_overout(cpu_debug_data *info) /* if we need to skip additional instructions, advance as requested */ while (extraskip-- > 0) - pc += dasm_wrapped(info->device, dasmbuffer, pc) & DASMFLAG_LENGTHMASK; - info->stepaddr = pc; + pc += dasm_wrapped(cpudebug->cpudevice, dasmbuffer, pc) & DASMFLAG_LENGTHMASK; + cpudebug->stepaddr = pc; } /* if we're stepping out and this isn't a step out instruction, reset the steps until stop to a high number */ - if ((info->flags & DEBUG_FLAG_STEPPING_OUT) != 0) + if ((cpudebug->flags & DEBUG_FLAG_STEPPING_OUT) != 0) { if ((dasmresult & DASMFLAG_SUPPORTED) != 0 && (dasmresult & DASMFLAG_STEP_OUT) == 0) - info->stepsleft = 100; + cpudebug->stepsleft = 100; else - info->stepsleft = 1; + cpudebug->stepsleft = 1; } } @@ -2184,17 +2125,17 @@ static void process_source_file(running_machine *machine) breakpoint flags -------------------------------------------------*/ -static void breakpoint_update_flags(cpu_debug_data *info) +static void breakpoint_update_flags(cpu_debug_data *cpudebug) { - debugcpu_private *global = info->device->machine->debugcpu_data; + debugcpu_private *global = cpudebug->cpudevice->machine->debugcpu_data; debug_cpu_breakpoint *bp; /* see if there are any enabled breakpoints */ - info->flags &= ~DEBUG_FLAG_LIVE_BP; - for (bp = info->bplist; bp != NULL; bp = bp->next) + cpudebug->flags &= ~DEBUG_FLAG_LIVE_BP; + for (bp = cpudebug->bplist; bp != NULL; bp = bp->next) if (bp->enabled) { - info->flags |= DEBUG_FLAG_LIVE_BP; + cpudebug->flags |= DEBUG_FLAG_LIVE_BP; break; } @@ -2209,14 +2150,14 @@ static void breakpoint_update_flags(cpu_debug_data *info) a given CPU -------------------------------------------------*/ -static void breakpoint_check(running_machine *machine, cpu_debug_data *info, offs_t pc) +static void breakpoint_check(running_machine *machine, cpu_debug_data *cpudebug, offs_t pc) { debugcpu_private *global = machine->debugcpu_data; debug_cpu_breakpoint *bp; UINT64 result; /* see if we match */ - for (bp = info->bplist; bp != NULL; bp = bp->next) + for (bp = cpudebug->bplist; bp != NULL; bp = bp->next) if (bp->enabled && bp->address == pc) /* if we do, evaluate the condition */ @@ -2244,17 +2185,17 @@ static void breakpoint_check(running_machine *machine, cpu_debug_data *info, off static void watchpoint_update_flags(const address_space *space) { - const cpu_debug_data *info = cpu_get_debug_data(space->cpu); + const cpu_debug_data *cpudebug = cpu_get_debug_data(space->cpu); debug_cpu_watchpoint *wp; int enablewrite = FALSE; int enableread = FALSE; /* if hotspots are enabled, turn on all reads */ - if (info->hotspots != NULL) + if (cpudebug->hotspots != NULL) enableread = TRUE; /* see if there are any enabled breakpoints */ - for (wp = info->wplist[space->spacenum]; wp != NULL; wp = wp->next) + for (wp = cpudebug->wplist[space->spacenum]; wp != NULL; wp = wp->next) if (wp->enabled) { if (wp->type & WATCHPOINT_READ) @@ -2276,7 +2217,7 @@ static void watchpoint_update_flags(const address_space *space) static void watchpoint_check(const address_space *space, int type, offs_t address, UINT64 value_to_write, UINT64 mem_mask) { - const cpu_debug_data *info = cpu_get_debug_data(space->cpu); + const cpu_debug_data *cpudebug = cpu_get_debug_data(space->cpu); debugcpu_private *global = space->machine->debugcpu_data; debug_cpu_watchpoint *wp; offs_t size = 0; @@ -2319,7 +2260,7 @@ static void watchpoint_check(const address_space *space, int type, offs_t addres global->wpdata = value_to_write; /* see if we match */ - for (wp = info->wplist[space->spacenum]; wp != NULL; wp = wp->next) + for (wp = cpudebug->wplist[space->spacenum]; wp != NULL; wp = wp->next) if (wp->enabled && (wp->type & type) != 0 && address + size > wp->address && address < wp->address + wp->length) /* if we do, evaluate the condition */ @@ -2368,40 +2309,40 @@ static void watchpoint_check(const address_space *space, int type, offs_t addres static void check_hotspots(const address_space *space, offs_t address) { - cpu_debug_data *info = cpu_get_debug_data(space->cpu); + cpu_debug_data *cpudebug = cpu_get_debug_data(space->cpu); offs_t pc = cpu_get_pc(space->cpu); int hotindex; /* see if we have a match in our list */ - for (hotindex = 0; hotindex < info->hotspot_count; hotindex++) - if (info->hotspots[hotindex].access == address && info->hotspots[hotindex].pc == pc && info->hotspots[hotindex].space == space) + for (hotindex = 0; hotindex < cpudebug->hotspot_count; hotindex++) + if (cpudebug->hotspots[hotindex].access == address && cpudebug->hotspots[hotindex].pc == pc && cpudebug->hotspots[hotindex].space == space) break; /* if we didn't find any, make a new entry */ - if (hotindex == info->hotspot_count) + if (hotindex == cpudebug->hotspot_count) { /* if the bottom of the list is over the threshhold, print it */ - debug_hotspot_entry *spot = &info->hotspots[info->hotspot_count - 1]; - if (spot->count > info->hotspot_threshhold) + debug_hotspot_entry *spot = &cpudebug->hotspots[cpudebug->hotspot_count - 1]; + if (spot->count > cpudebug->hotspot_threshhold) debug_console_printf(space->machine, "Hotspot @ %s %08X (PC=%08X) hit %d times (fell off bottom)\n", space->name, spot->access, spot->pc, spot->count); /* move everything else down and insert this one at the top */ - memmove(&info->hotspots[1], &info->hotspots[0], sizeof(info->hotspots[0]) * (info->hotspot_count - 1)); - info->hotspots[0].access = address; - info->hotspots[0].pc = pc; - info->hotspots[0].space = space; - info->hotspots[0].count = 1; + memmove(&cpudebug->hotspots[1], &cpudebug->hotspots[0], sizeof(cpudebug->hotspots[0]) * (cpudebug->hotspot_count - 1)); + cpudebug->hotspots[0].access = address; + cpudebug->hotspots[0].pc = pc; + cpudebug->hotspots[0].space = space; + cpudebug->hotspots[0].count = 1; } /* if we did find one, increase the count and move it to the top */ else { - info->hotspots[hotindex].count++; + cpudebug->hotspots[hotindex].count++; if (hotindex != 0) { - debug_hotspot_entry temp = info->hotspots[hotindex]; - memmove(&info->hotspots[1], &info->hotspots[0], sizeof(info->hotspots[0]) * hotindex); - info->hotspots[0] = temp; + debug_hotspot_entry temp = cpudebug->hotspots[hotindex]; + memmove(&cpudebug->hotspots[1], &cpudebug->hotspots[0], sizeof(cpudebug->hotspots[0]) * hotindex); + cpudebug->hotspots[0] = temp; } } } @@ -2413,10 +2354,11 @@ static void check_hotspots(const address_space *space, offs_t address) buffer and then disassembling them -------------------------------------------------*/ -static UINT32 dasm_wrapped(running_device *device, char *buffer, offs_t pc) +static UINT32 dasm_wrapped(device_t *device, char *buffer, offs_t pc) { - const address_space *space = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM); - int maxbytes = cpu_get_max_opcode_bytes(device); + const address_space *space = device_memory(device)->space(AS_PROGRAM); + cpu_device *cpudevice = downcast<cpu_device *>(device); + int maxbytes = cpudevice->max_opcode_bytes(); UINT8 opbuf[64], argbuf[64]; offs_t pcbyte; int numbytes; @@ -2443,11 +2385,11 @@ static UINT32 dasm_wrapped(running_device *device, char *buffer, offs_t pc) based on a case insensitive tag search -------------------------------------------------*/ -static running_device *expression_get_device(running_machine *machine, const char *tag) +static device_t *expression_get_device(running_machine *machine, const char *tag) { - running_device *device; + device_t *device; - for (device = machine->devicelist.first(); device != NULL; device = device->next) + for (device = machine->devicelist.first(); device != NULL; device = device->next()) if (mame_stricmp(device->tag(), tag) == 0) return device; @@ -2465,7 +2407,7 @@ static UINT64 expression_read_memory(void *param, const char *name, int spacenum { running_machine *machine = (running_machine *)param; UINT64 result = ~(UINT64)0 >> (64 - 8*size); - running_device *device = NULL; + device_t *device = NULL; const address_space *space; switch (spacenum) @@ -2635,7 +2577,7 @@ static UINT64 expression_read_memory_region(running_machine *machine, const char static void expression_write_memory(void *param, const char *name, int spacenum, UINT32 address, int size, UINT64 data) { running_machine *machine = (running_machine *)param; - running_device *device = NULL; + device_t *device = NULL; const address_space *space; switch (spacenum) @@ -2817,7 +2759,7 @@ static void expression_write_memory_region(running_machine *machine, const char static EXPRERR expression_validate(void *param, const char *name, int space) { running_machine *machine = (running_machine *)param; - running_device *device = NULL; + device_t *device = NULL; switch (space) { @@ -2947,8 +2889,8 @@ static void set_tempvar(void *globalref, void *ref, UINT64 value) static UINT64 get_beamx(void *globalref, void *ref) { - running_device *screen = (running_device *)ref; - return (screen != NULL) ? video_screen_get_hpos(screen) : 0; + screen_device *screen = reinterpret_cast<screen_device *>(ref); + return (screen != NULL) ? screen->hpos() : 0; } @@ -2958,8 +2900,8 @@ static UINT64 get_beamx(void *globalref, void *ref) static UINT64 get_beamy(void *globalref, void *ref) { - running_device *screen = (running_device *)ref; - return (screen != NULL) ? video_screen_get_vpos(screen) : 0; + screen_device *screen = reinterpret_cast<screen_device *>(ref); + return (screen != NULL) ? screen->vpos() : 0; } @@ -2969,8 +2911,8 @@ static UINT64 get_beamy(void *globalref, void *ref) static UINT64 get_frame(void *globalref, void *ref) { - running_device *screen = (running_device *)ref; - return (screen != NULL) ? video_screen_get_frame_number(screen) : 0; + screen_device *screen = reinterpret_cast<screen_device *>(ref); + return (screen != NULL) ? screen->frame_number() : 0; } @@ -2981,7 +2923,7 @@ static UINT64 get_frame(void *globalref, void *ref) static UINT64 get_current_pc(void *globalref, void *ref) { - running_device *device = (running_device *)globalref; + cpu_device *device = (cpu_device *)globalref; return cpu_get_pc(device); } @@ -2993,8 +2935,8 @@ static UINT64 get_current_pc(void *globalref, void *ref) static UINT64 get_cycles(void *globalref, void *ref) { - running_device *device = (running_device *)globalref; - return *cpu_get_icount_ptr(device); + cpu_device *device = (cpu_device *)globalref; + return device->cycles_remaining(); } @@ -3030,7 +2972,7 @@ static void set_logunmap(void *globalref, void *ref, UINT64 value) static UINT64 get_cpu_reg(void *globalref, void *ref) { - running_device *device = (running_device *)globalref; + cpu_device *device = (cpu_device *)globalref; return cpu_get_reg(device, (FPTR)ref); } @@ -3042,6 +2984,6 @@ static UINT64 get_cpu_reg(void *globalref, void *ref) static void set_cpu_reg(void *globalref, void *ref, UINT64 value) { - running_device *device = (running_device *)globalref; + cpu_device *device = (cpu_device *)globalref; cpu_set_reg(device, (FPTR)ref, value); } |
