static void showInUI(LocalsData* data, PDReader* reader, PDUI* uiFuncs)
{
PDReaderIterator it;
(void)data;
if (PDRead_findArray(reader, &it, "locals", 0) == PDReadStatus_notFound)
return;
uiFuncs->text("");
uiFuncs->columns(3, "callstack", true);
uiFuncs->text("Name"); uiFuncs->nextColumn();
uiFuncs->text("Value"); uiFuncs->nextColumn();
uiFuncs->text("Type"); uiFuncs->nextColumn();
while (PDRead_getNextEntry(reader, &it))
{
const char* name = "";
const char* value = "";
const char* type = "";
PDRead_findString(reader, &name, "name", it);
PDRead_findString(reader, &value, "value", it);
PDRead_findString(reader, &type, "type", it);
uiFuncs->text(name); uiFuncs->nextColumn();
uiFuncs->text(value); uiFuncs->nextColumn();
uiFuncs->text(type); uiFuncs->nextColumn();
}
}
static void updateRegisters(CPUState* cpuState, PDReader* reader)
{
PDReaderIterator it;
if (PDRead_findArray(reader, &it, "registers", 0) == PDReadStatus_notFound)
return;
while (PDRead_getNextEntry(reader, &it))
{
const char* name = "";
uint16_t regValue;
PDRead_findString(reader, &name, "name", it);
PDRead_findU16(reader, ®Value, "register", it);
if (!strcmp(name, "pc"))
cpuState->pc = (uint16_t)regValue;
else if (!strcmp(name, "sp"))
cpuState->sp = (uint8_t)regValue;
else if (!strcmp(name, "a"))
cpuState->a = (uint8_t)regValue;
else if (!strcmp(name, "x"))
cpuState->x = (uint8_t)regValue;
else if (!strcmp(name, "y"))
cpuState->y = (uint8_t)regValue;
}
}
void toggleBreakpointAddress(BreakpointsData* data, PDReader* reader)
{
const char* address;
if (PDRead_findString(reader, &address, "address", 0) == PDReadStatus_notFound)
return;
for (auto i = data->breakpoints.begin(); i != data->breakpoints.end(); ++i)
{
if (!strcmp((*i)->location.address, address))
{
destroyBreakpoint(*i);
data->breakpoints.erase(i);
return;
}
}
Breakpoint* breakpoint = createBreakpoint(data);
breakpoint->location.address = (char*)malloc(data->maxPath);
strcpy(breakpoint->location.address, address);
updateCondition(breakpoint, reader);
data->breakpoints.push_back(breakpoint);
}
static void setBreakpoint(LLDBPlugin* plugin, PDReader* reader, PDWriter* writer)
{
const char* filename;
uint32_t line;
PDRead_findString(reader, &filename, "filename", 0);
PDRead_findU32(reader, &line, "line", 0);
// TODO: Handle failure here
lldb::SBBreakpoint breakpoint = plugin->target.BreakpointCreateByLocation(filename, line);
if (!breakpoint.IsValid())
{
printf("adding breakpoints to breakpoint list %s:%d\n", filename, line);
// Unable to set breakpoint as the target doesn't seem to be valid. This is the usual case
// if we haven't actually started an executable yet. So we save them here for later and
// then set them before launching the executable
Breakpoint bp = { strdup(filename), (int)line };
plugin->breakpoints.push_back(bp);
return;
}
printf("Set breakpoint at %s:%d\n", filename, line);
}
void test_c64_vice_get_disassembly(void**)
{
static Assembly assembly[] =
{
{ 0x080e, "A9 22 LDA #$22" },
{ 0x0810, "A2 32 LDX #$32" },
{ 0x0812, "C8 INY" },
{ 0x0813, "EE 20 D0 INC $D020" },
{ 0x0816, "EE 21 D0 INC $D021" },
{ 0x0819, "4C 0E 08 JMP $080E" },
{ 0, 0 },
};
PDWriter* writer = s_session->currentWriter;
PDWrite_eventBegin(writer, PDEventType_getDisassembly);
PDWrite_u64(writer, "address_start", 0x80e);
PDWrite_u32(writer, "instruction_count", (uint32_t)4);
PDWrite_eventEnd(writer);
PDBinaryWriter_finalize(writer);
Session_update(s_session);
PDReader* reader = s_session->reader;
PDBinaryReader_initStream(reader, PDBinaryWriter_getData(s_session->currentWriter), PDBinaryWriter_getSize(s_session->currentWriter));
uint32_t event;
while ((event = PDRead_getEvent(reader)) != 0)
{
if (event != PDEventType_setDisassembly)
continue;
PDReaderIterator it;
assert_false(PDRead_findArray(reader, &it, "disassembly", 0) == PDReadStatus_notFound);
int i = 0;
while (PDRead_getNextEntry(reader, &it))
{
uint64_t address;
const char* text;
PDRead_findU64(reader, &address, "address", it);
PDRead_findString(reader, &text, "line", it);
assert_non_null(assembly[i].text);
assert_int_equal((int)assembly[i].address, (int)address);
assert_string_equal(assembly[i].text, text);
i++;
}
return;
}
}
static void updateCondition(Breakpoint* bp, PDReader* reader)
{
const char* condition;
bp->condition = 0;
PDRead_findString(reader, &condition, "condition", 0);
if (condition)
bp->condition = strdup(condition);
}
static void setDisassemblyCode(DissassemblyData* data, PDReader* inEvents)
{
const char* stringBuffer;
PDRead_findString(inEvents, &stringBuffer, "string_buffer", 0);
//printf("Got disassembly\n");
//printf("disassembly %s\n", stringBuffer);
free(data->code);
if (!stringBuffer)
return;
data->code = strdup(stringBuffer);
splitIntoLines(data, data->code, strlen(stringBuffer));
}
static void setDisassemblyCode(DissassemblyData* data, PDReader* reader)
{
PDReaderIterator it;
if (PDRead_findArray(reader, &it, "disassembly", 0) == PDReadStatus_notFound)
return;
while (PDRead_getNextEntry(reader, &it))
{
uint64_t address;
const char* text;
PDRead_findU64(reader, &address, "address", it);
PDRead_findString(reader, &text, "line", it);
insertLine(data, address, text);
}
}
static void updateRegisters(DissassemblyData* data, PDReader* reader)
{
PDReaderIterator it;
if (PDRead_findArray(reader, &it, "registers", 0) == PDReadStatus_notFound)
return;
while (PDRead_getNextEntry(reader, &it))
{
const char* name = "";
PDRead_findString(reader, &name, "name", it);
if (!strcmp(name, "pc"))
{
PDRead_findU64(reader, &data->pc, "register", it);
}
}
}
static void setBreakpoint(PluginData* data, PDReader* reader, PDWriter* writer)
{
uint64_t address = 0;
int32_t id = -1;
const char* condition = 0;
(void)writer;
PDRead_findS32(reader, &id, "id", 0);
PDRead_findU64(reader, &address, "address", 0);
PDRead_findString(reader, &condition, "condition", 0);
if (id != -1)
delBreakpointById(data, id);
if (condition)
sendCommand(data, "break $%04x if %s\n", (uint16_t)address, condition);
else
sendCommand(data, "break $%04x\n", (uint16_t)address);
}
void toogleBreakpointFileLine(BreakpointsData* data, PDReader* reader)
{
const char* filename = 0;
uint32_t line;
char fileLine[8192];
PDRead_findString(reader, &filename, "filename", 0);
PDRead_findU32(reader, &line, "line", 0);
if (!filename)
return;
for (auto i = data->breakpoints.begin(); i != data->breakpoints.end(); ++i)
{
if ((*i)->location.line == (int)line && !strcmp((*i)->location.filename, filename))
{
destroyBreakpoint(*i);
data->breakpoints.erase(i);
return;
}
}
Breakpoint* breakpoint = createBreakpoint(data);
sprintf(fileLine, "%s:%d\n", filename, line);
breakpoint->location.filename = (char*)malloc(data->maxPath);
breakpoint->location.line = (int)line;
strcpy(breakpoint->location.filename, fileLine);
updateCondition(breakpoint, reader);
data->breakpoints.push_back(breakpoint);
}
static void setExecutable(LLDBPlugin* plugin, PDReader* reader)
{
const char* filename = 0;
PDRead_findString(reader, &filename, "filename", 0);
if (!filename)
{
printf("Unable to find filename which is required when starting a LLDB debug session\n");
return;
}
printf("found filename \"%s\"\n", filename);
plugin->target = plugin->debugger.CreateTarget(filename);
if (!plugin->target.IsValid())
{
printf("Unable to create valid target (%s)\n", filename);
}
for (Breakpoint& bp : plugin->breakpoints)
{
lldb::SBBreakpoint breakpoint = plugin->target.BreakpointCreateByLocation(bp.filename, (uint32_t)bp.line);
if (!breakpoint.IsValid())
{
// TODO: Send message back that this breakpoint could't be set
printf("Unable to set breakpoint %s:%d\n", bp.filename, bp.line);
}
}
printf("Valid target %s\n", filename);
onRun(plugin);
}
