max/gb-emu
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cpu,gbdb: implement better breakpoints

Browse Source 
Previously, gbdb had to check several signals, including the current
PC, to determine when do_run() should stop. This code was hotpath and
unecessarily slow.

Instead, leverage a n undefined instruction (0xd3) as a breakpoint instruction.
When the CPU emulation encounters this instruction, it will call a callback
which is implemented by gbdb. This can set a simple flag which is less expensive to
query.

Finally, both the signal handler and the breakpoint callback set specific
"paused" flags and a generic "pause" flag. Now, do_run() can simply check
the generic "paused" flag, then use the specific flags to determine the
stop reason.

This change increased performance by ~10% on Raspberry Pi.
This commit is contained in:
Max Regan
2018-07-01 23:53:30 +00:00
parent 9d40f5026a
commit 1bb3d8512a
3 changed files with 94 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
src/apps/gbdb.c
View File

@@ -25,8 +25,9 @@
typedef void (gbdb_cmd)(char *arg_string);
static bool cpu_at_breakpoint(void);
static void breakpoint_addr_hit(uint16_t id);
static void breakpoint_cb(struct lr35902_state *lr);
static void reset_breakpoints(void);
static uint8_t ram[MAX_RAM_LEN];
static const char prompt[] = "gbdb >";
@@ -40,12 +41,16 @@ static const char usage[] =
"peek: view the next instruction to run\n"
"exit: quit the program\n";
static struct lr35902_ops cpu_ops;
static struct lr35902_state cpu;
static struct gb_video video;
static unsigned char bootrom[0x100] = {0};
static int bootrom_mapped = 1;
static int paused_breakpoint = 0;
static volatile sig_atomic_t paused_signal = 0;
static volatile sig_atomic_t paused = 0;
static struct {
@@ -151,7 +156,11 @@ static void mem_dump(char *filename)
static void init(void)
{
lr35902_init(&cpu, mem_read, mem_write);
cpu_ops.mem_read = mem_read;
cpu_ops.mem_write = mem_write;
cpu_ops.undef_d3 = breakpoint_cb;
lr35902_init(&cpu, &cpu_ops);
gb_video_init(&video);
memset(&ram, 0, MAX_RAM_LEN);
bootrom_mapped = 1;
@@ -184,6 +193,17 @@ static void echo(char *arg_list)
}
}
static void breakpoint_cb(struct lr35902_state *lr)
{
int i;
paused_breakpoint = 1;
paused = 1;
breakpoint_addr_hit(cpu.pc);
}
static void step(char *arg_list)
{
uint64_t steps, end_steps;
@@ -199,22 +219,27 @@ static void step(char *arg_list)
paused = 0;
signal(SIGINT, break_execution_handler);
end_steps = cpu.metrics.retired_instrs + steps;
do {
cycle();
} while (end_steps > cpu.metrics.retired_instrs &&
!cpu_at_breakpoint() &&
!paused);
cycle();
reset_breakpoints();
while(end_steps > cpu.metrics.retired_instrs &&
!paused) {
cycle();
}
if (end_steps <= cpu.metrics.retired_instrs) {
gb_log("CPU stopped after %" PRId64 " instructions\n", steps);
} else if (cpu_at_breakpoint()) {
} else if (paused_breakpoint) {
breakpoint_addr_hit(cpu.pc);
gb_log("Breakpoint hit\n");
} else if (cpu.halted) {
gb_log("CPU halted\n");
} else {
} else if (paused_signal){
gb_log("Interrupted\n");
}
paused = 0;
paused_signal = 0;
paused_breakpoint = 0;
}
static void regs(char *arg_list)
@@ -447,18 +472,24 @@ static void quit(char *arg_list)
static void do_run(void) {
paused = 0;
signal(SIGINT, break_execution_handler);
while(!cpu.halted && !cpu_at_breakpoint() && !paused) {
cycle();
reset_breakpoints();
while(!paused) {
cycle();
}
if (cpu.halted) {
gb_log("CPU halted after %ld cycles\n", cpu.metrics.cycles);
} else if (paused) {
if (paused_signal) {
gb_log("Interrupted.\n");
} else {
} else if (paused_breakpoint) {
breakpoint_addr_hit(cpu.pc);
gb_log("Breakpoint hit\n");
}
paused = 0;
paused_breakpoint = 0;
paused_signal = 0;
}
static void run(char *arg_list)
@@ -470,6 +501,8 @@ static struct breakpoint {
uint16_t addr;
int id;
bool temp;
uint8_t op;
uint8_t *ptr;
} breakpoints[MAX_BREAKPTS];
static int num_breakpoints = 0;
@@ -487,11 +520,29 @@ static struct breakpoint *get_breakpoint(int id)
return NULL;
}
static void reset_breakpoints(void)
{
int i;
for (i = 0; i < num_breakpoints; i++) {
struct breakpoint *bkpt = &breakpoints[i];
*bkpt->ptr = 0xd3;
}
}
static int do_set_breakpoint(uint16_t addr, bool temp)
{
static int id = 0;
if (num_breakpoints < ARRAY_SIZE(breakpoints)) {
breakpoints[num_breakpoints].addr = addr;
breakpoints[num_breakpoints].op = mem_read(NULL, addr);
if (bootrom_mapped && addr < 0x100) {
breakpoints[num_breakpoints].ptr = &bootrom[addr];
} else {
breakpoints[num_breakpoints].ptr = &ram[addr];
}
*breakpoints[num_breakpoints].ptr = 0xd3;
breakpoints[num_breakpoints].id = id++;
breakpoints[num_breakpoints].temp = temp;
num_breakpoints++;
@@ -543,6 +594,8 @@ static int do_delete_breakpoint(int id)
return -1;
}
*bkpt->ptr = bkpt->op;
index = bkpt - breakpoints;
memmove(&breakpoints[index], &breakpoints[index + 1],
num_breakpoints - index - 1);
@@ -659,11 +712,6 @@ static bool breakpoint_is_at_addr(uint16_t addr) {
return false;
}
static bool cpu_at_breakpoint(void)
{
return breakpoint_is_at_addr(cpu.pc);
}
static void process_cmd(const char *cmd_str, struct tri *commands)
{
char cmd_buffer[INPUT_MAX_LEN]; /* Buffer for command parsing */