static PDDebugState update(void* userData, PDAction action, PDReader* reader, PDWriter* writer) { //int event = 0; (void)reader; AngelScriptDebugger* debugger = (AngelScriptDebugger*)userData; /*processEvents(plugin, reader, writer); doAction(plugin, action); if (plugin->state == PDDebugState_running) updateLLDBEvent(plugin, writer);*/ //doAction(debugger, action, writer); uint32_t event; while ((event = PDRead_get_event(reader)) != 0) { switch (event) { case PDEventType_GetCallstack: log_out("GetCallstack!\n"); //debugger->engine //getCallstack(reader, writer); break; case PDEventType_GetLocals: log_out("GetLocals!\n"); //getLocals(reader, writer); break; } } return PDDebugState(debugger->runState); }
static void processEvents(LLDBPlugin* plugin, PDReader* reader, PDWriter* writer) { uint32_t event; while ((event = PDRead_get_event(reader))) { //printf("LLDBPlugin: %d Got event %s\n", event, eventTypes[event]); switch (event) { case PDEventType_GetExceptionLocation : setExceptionLocation(plugin, writer); break; case PDEventType_GetCallstack : setCallstack(plugin, writer); break; case PDEventType_SetExecutable : setExecutable(plugin, reader); break; case PDEventType_SelectThread : selectThread(plugin, reader, writer); break; case PDEventType_SelectFrame : selectFrame(plugin, reader, writer); break; case PDEventType_GetLocals : setLocals(plugin, writer); break; case PDEventType_GetThreads : setThreads(plugin, writer); break; case PDEventType_GetSourceFiles : setSourceFiles(plugin, writer); break; case PDEventType_SetBreakpoint : setBreakpoint(plugin, reader, writer); break; case PDEventType_Action : eventAction(plugin, reader); break; } } setTty(plugin, writer); }
static void test_lldb(void** state) { (void)state; // we only do the LLDB test on Mac for now #ifdef __APPLE__ PluginData* pluginData; Session* session; int count = 0; assert_true(PluginHandler_addPlugin(OBJECT_DIR, "lldb_plugin")); assert_non_null(pluginData = PluginHandler_getBackendPlugins(&count)[0]); session = Session_createLocal((PDBackendPlugin*)pluginData->plugin, OBJECT_DIR "/crashing_native"); assert_non_null(session); // I hate to do this but there is really no good way to deal with this otherwise (at least currently) Time_sleepMs(800); Session_update(session); Session_update(session); // Expect that we have a crash here and thus are in PDDebugState_stopException state assert_int_equal(session->state, PDDebugState_StopException); // Request locals location. PDWriter* writer = session->currentWriter; PDReader* reader = session->reader; PDWrite_event_begin(writer, PDEventType_GetCallstack); PDWrite_u8(writer, "dummy", 0); PDWrite_event_end(writer); Session_update(session); PDBinaryWriter_finalize(session->currentWriter); PDBinaryReader_initStream(reader, PDBinaryWriter_getData(session->currentWriter), PDBinaryWriter_getSize(session->currentWriter)); uint32_t event; bool foundCallstack = false; while ((event = PDRead_get_event(reader)) != 0) { switch (event) { case PDEventType_SetCallstack: { foundCallstack = true; break; } } } assert_true(foundCallstack); #endif }
static int update(void* user_data, PDUI* uiFuncs, PDReader* inEvents, PDWriter* writer) { uint32_t event; DissassemblyData* data = (DissassemblyData*)user_data; data->requestDisassembly = false; while ((event = PDRead_get_event(inEvents)) != 0) { switch (event) { case PDEventType_SetDisassembly: { setDisassemblyCode(data, inEvents); break; } case PDEventType_SetExceptionLocation: { uint64_t location = 0; PDRead_find_u64(inEvents, &location, "address", 0); if (location != data->location) { data->location = location; data->requestDisassembly = true; } PDRead_find_u8(inEvents, &data->locationSize, "address_size", 0); break; } case PDEventType_SetRegisters: { updateRegisters(data, inEvents); break; } } } renderUI(data, uiFuncs); if (data->requestDisassembly) { int pc = (int)(data->pc) & ~(BlockSize - 1); PDWrite_event_begin(writer, PDEventType_GetDisassembly); PDWrite_u64(writer, "address_start", (uint64_t)pc); PDWrite_u32(writer, "instruction_count", (uint32_t)BlockSize / 3); PDWrite_event_end(writer); } return 0; }
static int update(void* user_data, PDUI* uiFuncs, PDReader* inEvents, PDWriter* outEvents) { uint32_t event; RegistersData* data = (RegistersData*)user_data; (void)outEvents; // Loop over all the in events while ((event = PDRead_get_event(inEvents)) != 0) { switch (event) { case PDEventType_SetRegisters: updateRegisters(data, inEvents); break; } } showUI(data, uiFuncs); return 0; }
static int update(void* user_data, PDUI* uiFuncs, PDReader* inEvents, PDWriter* outEvents) { uint32_t event = 0; ThreadsData* data = (ThreadsData*)user_data; data->requestData = false; data->setSelectedThread = false; while ((event = PDRead_get_event(inEvents)) != 0) { switch (event) { case PDEventType_SetThreads: { showInUI((ThreadsData*)user_data, inEvents, uiFuncs); break; } case PDEventType_SetExceptionLocation: { data->requestData = true; break; } } } // Request threads data if (data->setSelectedThread) { PDWrite_event_begin(outEvents, PDEventType_SelectThread); printf("writing thread id %d\n", data->threadId); PDWrite_u32(outEvents, "thread_id", (uint32_t)data->threadId); PDWrite_event_end(outEvents); } if (data->requestData) { PDWrite_event_begin(outEvents, PDEventType_GetThreads); PDWrite_event_end(outEvents); } return 0; }
static void processEvents(DbgEngPlugin* plugin, PDReader* reader, PDWriter* writer) { printf("DbgEngPlugin: processEvents\n"); PDEventType event; while ((event = (PDEventType)PDRead_get_event(reader))) { printf("DbgEngPlugin: %d Got event %s\n", (int)event, eventTypes[event]); switch (event) { case PDEventType_getExceptionLocation: setExceptionLocation(plugin, writer); break; case PDEventType_getCallstack: setCallstack(plugin, writer); break; case PDEventType_setExecutable: setExecutable(plugin, reader); break; case PDEventType_getLocals: setLocals(plugin, writer); break; case PDEventType_setBreakpoint: setBreakpoint(plugin, reader, writer); break; case PDEventType_action: eventAction(plugin, reader); break; } } }
static void process_events(PluginData* data, PDReader* reader, PDWriter* writer) { uint32_t event; while ((event = PDRead_get_event(reader))) { switch (event) { //case PDEventType_getExceptionLocation : setExceptionLocation(plugin, writer); break; //case PDEventType_getCallstack : set_callstack(plugin, writer); break; case PDEventType_GetRegisters: { get_registers(data); break; } case PDEventType_GetCallstack: { if (should_send_command(data)) set_callstack(data, reader, writer); break; } case PDEventType_GetDisassembly: { if (should_send_command(data)) get_disassembly(data, reader, writer); break; } case PDEventType_GetMemory: { if (should_send_command(data)) get_memory(data, reader, writer); break; } case PDEventType_MenuEvent: { on_menu(data, reader); break; } case PDEventType_SetBreakpoint: { set_breakpoint(data, reader, writer); // if we add a breakpoint to VICE it will always stop but if we are already running when // adding the breakpoint we just force VICE to run again if (data->state == PDDebugState_Running) send_command(data, "ret\n"); break; } case PDEventType_DeleteBreakpoint: { del_breakpoint(data, reader, writer); break; } case PDEventType_SetExecutable: { //if (should_send_command(data)) set_executable(data, reader); break; } } } }
static int update(void* user_data, PDUI* uiFuncs, PDReader* inEvents, PDWriter* writer) { uint32_t event; (void)uiFuncs; SourceCodeData* data = (SourceCodeData*)user_data; PDUISCInterface* sourceFuncs = uiFuncs->sc_input_text("test", 800, 700, 0, 0); while ((event = PDRead_get_event(inEvents)) != 0) { switch (event) { case PDEventType_SetExceptionLocation: { setExceptionLocation(uiFuncs, sourceFuncs, data, inEvents); data->requestFiles = true; break; } case PDEventType_SetSourceCodeFile: { const char* filename; if (PDRead_find_string(inEvents, &filename, "filename", 0) == PDReadStatus_NotFound) break; setSourceCodeFile(uiFuncs, sourceFuncs, data, filename, 0); break; } case PDEventType_ToggleBreakpointCurrentLine: { toggleBreakpointCurrentLine(sourceFuncs, data, writer); break; } case PDEventType_SetSourceFiles: { // TODO: Store the files data->hasFiles = true; break; } } } updateKeyboard(data, sourceFuncs, uiFuncs); PDUI_sc_update(sourceFuncs); PDUI_sc_draw(sourceFuncs); //showInUI(data, uiFuncs); PDWrite_event_begin(writer, PDEventType_GetExceptionLocation); PDWrite_event_end(writer); if (!data->hasFiles && data->requestFiles) { PDWrite_event_begin(writer, PDEventType_GetSourceFiles); PDWrite_event_end(writer); } return 0; }
static int update(void* user_data, PDUI* uiFuncs, PDReader* reader, PDWriter* writer) { uint32_t event; CallstackData* data = (CallstackData*)user_data; data->request = false; data->setSelectedFrame = false; while ((event = PDRead_get_event(reader)) != 0) { switch (event) { case PDEventType_SetCallstack: { updateCallstack(data, reader); break; } case PDEventType_SelectFrame: { PDRead_find_u32(reader, &data->selectedFrame, "frame", 0); break; } case PDEventType_SetExceptionLocation: { const char* filename = 0; uint32_t line = 0; uint64_t location = 0; PDRead_find_u64(reader, &location, "address", 0); if (location != data->location) { data->location = location; data->request = true; } PDRead_find_string(reader, &filename, "filename", 0); PDRead_find_u32(reader, &line, "line", 0); if (!filename || line == 0) break; if (strcmp(data->filename, filename)) { strcpy(data->filename, filename); data->line = (int)line; data->request = true; } } } } showUI(uiFuncs, data); if (data->setSelectedFrame) { PDWrite_event_begin(writer, PDEventType_SelectFrame); PDWrite_u32(writer, "frame", (uint32_t)data->selectedFrame); PDWrite_event_end(writer); } if (data->request) { PDWrite_event_begin(writer, PDEventType_GetCallstack); PDWrite_event_end(writer); } return 0; }