mirror of
https://github.com/hrydgard/ppsspp.git
synced 2025-04-02 11:01:50 -04:00
474 lines
16 KiB
C++
474 lines
16 KiB
C++
// Copyright (c) 2018- PPSSPP Project.
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, version 2.0 or later versions.
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License 2.0 for more details.
|
|
|
|
// A copy of the GPL 2.0 should have been included with the program.
|
|
// If not, see http://www.gnu.org/licenses/
|
|
|
|
// Official git repository and contact information can be found at
|
|
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
|
|
|
|
#include "Common/StringUtils.h"
|
|
#include "Core/Debugger/Breakpoints.h"
|
|
#include "Core/Debugger/DisassemblyManager.h"
|
|
#include "Core/Debugger/SymbolMap.h"
|
|
#include "Core/Debugger/WebSocket/BreakpointSubscriber.h"
|
|
#include "Core/Debugger/WebSocket/WebSocketUtils.h"
|
|
#include "Core/MIPS/MIPSDebugInterface.h"
|
|
|
|
DebuggerSubscriber *WebSocketBreakpointInit(DebuggerEventHandlerMap &map) {
|
|
// No need to bind or alloc state, these are all global.
|
|
map["cpu.breakpoint.add"] = &WebSocketCPUBreakpointAdd;
|
|
map["cpu.breakpoint.update"] = &WebSocketCPUBreakpointUpdate;
|
|
map["cpu.breakpoint.remove"] = &WebSocketCPUBreakpointRemove;
|
|
map["cpu.breakpoint.list"] = &WebSocketCPUBreakpointList;
|
|
|
|
map["memory.breakpoint.add"] = &WebSocketMemoryBreakpointAdd;
|
|
map["memory.breakpoint.update"] = &WebSocketMemoryBreakpointUpdate;
|
|
map["memory.breakpoint.remove"] = &WebSocketMemoryBreakpointRemove;
|
|
map["memory.breakpoint.list"] = &WebSocketMemoryBreakpointList;
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
struct WebSocketCPUBreakpointParams {
|
|
uint32_t address = 0;
|
|
bool hasEnabled = false;
|
|
bool hasLog = false;
|
|
bool hasCondition = false;
|
|
bool hasLogFormat = false;
|
|
|
|
bool enabled;
|
|
bool log;
|
|
std::string condition;
|
|
PostfixExpression compiledCondition;
|
|
std::string logFormat;
|
|
|
|
bool Parse(DebuggerRequest &req) {
|
|
if (!currentDebugMIPS->isAlive()) {
|
|
req.Fail("CPU not started");
|
|
return false;
|
|
}
|
|
|
|
if (!req.ParamU32("address", &address))
|
|
return false;
|
|
|
|
hasEnabled = req.HasParam("enabled");
|
|
if (hasEnabled) {
|
|
if (!req.ParamBool("enabled", &enabled))
|
|
return false;
|
|
}
|
|
hasLog = req.HasParam("log");
|
|
if (hasLog) {
|
|
if (!req.ParamBool("log", &log))
|
|
return false;
|
|
}
|
|
hasCondition = req.HasParam("condition");
|
|
if (hasCondition) {
|
|
if (!req.ParamString("condition", &condition))
|
|
return false;
|
|
if (!currentDebugMIPS->initExpression(condition.c_str(), compiledCondition)) {
|
|
req.Fail(StringFromFormat("Could not parse expression syntax: %s", getExpressionError()));
|
|
return false;
|
|
}
|
|
}
|
|
hasLogFormat = req.HasParam("logFormat");
|
|
if (hasLogFormat) {
|
|
if (!req.ParamString("logFormat", &logFormat))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void Apply() {
|
|
if (hasCondition && !condition.empty()) {
|
|
BreakPointCond cond;
|
|
cond.debug = currentDebugMIPS;
|
|
cond.expressionString = condition;
|
|
cond.expression = compiledCondition;
|
|
CBreakPoints::ChangeBreakPointAddCond(address, cond);
|
|
} else if (hasCondition && condition.empty()) {
|
|
CBreakPoints::ChangeBreakPointRemoveCond(address);
|
|
}
|
|
|
|
if (hasLogFormat) {
|
|
CBreakPoints::ChangeBreakPointLogFormat(address, logFormat);
|
|
}
|
|
|
|
// TODO: Fix this interface.
|
|
if (hasLog && !hasEnabled) {
|
|
CBreakPoints::IsAddressBreakPoint(address, &enabled);
|
|
hasEnabled = true;
|
|
}
|
|
if (hasLog && hasEnabled) {
|
|
BreakAction result = BREAK_ACTION_IGNORE;
|
|
if (log)
|
|
result |= BREAK_ACTION_LOG;
|
|
if (enabled)
|
|
result |= BREAK_ACTION_PAUSE;
|
|
CBreakPoints::ChangeBreakPoint(address, result);
|
|
} else if (hasEnabled) {
|
|
CBreakPoints::ChangeBreakPoint(address, enabled);
|
|
}
|
|
}
|
|
};
|
|
|
|
// Add a new CPU instruction breakpoint (cpu.breakpoint.add)
|
|
//
|
|
// Parameters:
|
|
// - address: unsigned integer address of instruction to break at.
|
|
// - enabled: optional boolean, whether to actually enter stepping when this breakpoint trips.
|
|
// - log: optional boolean, whether to log when this breakpoint trips.
|
|
// - condition: optional string expression to evaluate - breakpoint does not trip if false.
|
|
// - logFormat: optional string to log when breakpoint trips, may include {expression} parts.
|
|
//
|
|
// Response (same event name) with no extra data.
|
|
//
|
|
// Note: will replace any breakpoint at the same address.
|
|
void WebSocketCPUBreakpointAdd(DebuggerRequest &req) {
|
|
WebSocketCPUBreakpointParams params;
|
|
if (!params.Parse(req))
|
|
return;
|
|
|
|
CBreakPoints::AddBreakPoint(params.address);
|
|
params.Apply();
|
|
req.Respond();
|
|
}
|
|
|
|
// Update a CPU instruction breakpoint (cpu.breakpoint.update)
|
|
//
|
|
// Parameters:
|
|
// - address: unsigned integer address of instruction to break at.
|
|
// - enabled: optional boolean, whether to actually enter stepping when this breakpoint trips.
|
|
// - log: optional boolean, whether to log when this breakpoint trips.
|
|
// - condition: optional string expression to evaluate - breakpoint does not trip if false.
|
|
// - logFormat: optional string to log when breakpoint trips, may include {expression} parts.
|
|
//
|
|
// Response (same event name) with no extra data.
|
|
void WebSocketCPUBreakpointUpdate(DebuggerRequest &req) {
|
|
WebSocketCPUBreakpointParams params;
|
|
if (!params.Parse(req))
|
|
return;
|
|
bool enabled;
|
|
if (!CBreakPoints::IsAddressBreakPoint(params.address, &enabled))
|
|
return req.Fail("Breakpoint not found");
|
|
|
|
params.Apply();
|
|
req.Respond();
|
|
}
|
|
|
|
// Remove a CPU instruction breakpoint (cpu.breakpoint.remove)
|
|
//
|
|
// Parameters:
|
|
// - address: unsigned integer address of instruction to break at.
|
|
//
|
|
// Response (same event name) with no extra data.
|
|
void WebSocketCPUBreakpointRemove(DebuggerRequest &req) {
|
|
if (!currentDebugMIPS->isAlive()) {
|
|
return req.Fail("CPU not started");
|
|
}
|
|
|
|
uint32_t address;
|
|
if (!req.ParamU32("address", &address))
|
|
return;
|
|
|
|
CBreakPoints::RemoveBreakPoint(address);
|
|
req.Respond();
|
|
}
|
|
|
|
// List all CPU instruction breakpoints (cpu.breakpoint.list)
|
|
//
|
|
// No parameters.
|
|
//
|
|
// Response (same event name):
|
|
// - breakpoints: array of objects, each with properties:
|
|
// - address: unsigned integer address of instruction to break at.
|
|
// - enabled: boolean, whether to actually enter stepping when this breakpoint trips.
|
|
// - log: optional boolean, whether to log when this breakpoint trips.
|
|
// - condition: null, or string expression to evaluate - breakpoint does not trip if false.
|
|
// - logFormat: null, or string to log when breakpoint trips, may include {expression} parts.
|
|
// - symbol: null, or string label or symbol at breakpoint address.
|
|
// - code: string disassembly of breakpoint address.
|
|
void WebSocketCPUBreakpointList(DebuggerRequest &req) {
|
|
if (!currentDebugMIPS->isAlive()) {
|
|
return req.Fail("CPU not started");
|
|
}
|
|
|
|
JsonWriter &json = req.Respond();
|
|
json.pushArray("breakpoints");
|
|
auto bps = CBreakPoints::GetBreakpoints();
|
|
for (const auto &bp : bps) {
|
|
if (bp.temporary)
|
|
continue;
|
|
|
|
json.pushDict();
|
|
json.writeUint("address", bp.addr);
|
|
json.writeBool("enabled", bp.IsEnabled());
|
|
json.writeBool("log", (bp.result & BREAK_ACTION_LOG) != 0);
|
|
if (bp.hasCond)
|
|
json.writeString("condition", bp.cond.expressionString);
|
|
else
|
|
json.writeNull("condition");
|
|
if (!bp.logFormat.empty())
|
|
json.writeString("logFormat", bp.logFormat);
|
|
else
|
|
json.writeNull("logFormat");
|
|
std::string symbol = g_symbolMap->GetLabelString(bp.addr);
|
|
if (symbol.empty())
|
|
json.writeNull("symbol");
|
|
else
|
|
json.writeString("symbol", symbol);
|
|
|
|
DisassemblyManager manager;
|
|
DisassemblyLineInfo line;
|
|
manager.getLine(manager.getStartAddress(bp.addr), true, line);
|
|
json.writeString("code", line.name + " " + line.params);
|
|
|
|
json.pop();
|
|
}
|
|
json.pop();
|
|
}
|
|
|
|
struct WebSocketMemoryBreakpointParams {
|
|
uint32_t address = 0;
|
|
uint32_t end = 0;
|
|
bool hasEnabled = false;
|
|
bool hasLog = false;
|
|
bool hasCond = false;
|
|
bool hasCondition = false;
|
|
bool hasLogFormat = false;
|
|
|
|
bool enabled = true;
|
|
bool log = true;
|
|
MemCheckCondition cond = MEMCHECK_READWRITE;
|
|
std::string condition;
|
|
PostfixExpression compiledCondition;
|
|
std::string logFormat;
|
|
|
|
bool Parse(DebuggerRequest &req) {
|
|
if (!currentDebugMIPS->isAlive()) {
|
|
req.Fail("CPU not started");
|
|
return false;
|
|
}
|
|
|
|
if (!req.ParamU32("address", &address))
|
|
return false;
|
|
uint32_t size;
|
|
if (!req.ParamU32("size", &size))
|
|
return false;
|
|
if (address + size < address) {
|
|
req.Fail("Size is too large");
|
|
return false;
|
|
}
|
|
end = size == 0 ? 0 : address + size;
|
|
|
|
hasEnabled = req.HasParam("enabled");
|
|
if (hasEnabled) {
|
|
if (!req.ParamBool("enabled", &enabled))
|
|
return false;
|
|
}
|
|
hasLog = req.HasParam("log");
|
|
if (hasLog) {
|
|
if (!req.ParamBool("log", &log))
|
|
return false;
|
|
}
|
|
hasCond = req.HasParam("read") || req.HasParam("write") || req.HasParam("change");
|
|
if (hasCond) {
|
|
bool read = false, write = false, change = false;
|
|
if (!req.ParamBool("read", &read, DebuggerParamType::OPTIONAL) || !req.ParamBool("write", &write, DebuggerParamType::OPTIONAL) || !req.ParamBool("change", &change, DebuggerParamType::OPTIONAL))
|
|
return false;
|
|
int bits = (read ? MEMCHECK_READ : 0) | (write ? MEMCHECK_WRITE : 0) | (change ? MEMCHECK_WRITE_ONCHANGE : 0);
|
|
cond = MemCheckCondition(bits);
|
|
}
|
|
hasCondition = req.HasParam("condition");
|
|
if (hasCondition) {
|
|
if (!req.ParamString("condition", &condition))
|
|
return false;
|
|
if (!currentDebugMIPS->initExpression(condition.c_str(), compiledCondition)) {
|
|
req.Fail(StringFromFormat("Could not parse expression syntax: %s", getExpressionError()));
|
|
return false;
|
|
}
|
|
}
|
|
hasLogFormat = req.HasParam("logFormat");
|
|
if (hasLogFormat) {
|
|
if (!req.ParamString("logFormat", &logFormat))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
BreakAction Result(bool adding) {
|
|
int bits = MEMCHECK_READWRITE;
|
|
if (adding || (hasLog && hasEnabled)) {
|
|
bits = (enabled ? BREAK_ACTION_PAUSE : 0) | (log ? BREAK_ACTION_LOG : 0);
|
|
} else {
|
|
MemCheck prev;
|
|
if (CBreakPoints::GetMemCheck(address, end, &prev))
|
|
bits = prev.result;
|
|
|
|
if (hasEnabled)
|
|
bits = (bits & ~BREAK_ACTION_PAUSE) | (enabled ? BREAK_ACTION_PAUSE : 0);
|
|
if (hasLog)
|
|
bits = (bits & ~BREAK_ACTION_LOG) | (log ? BREAK_ACTION_LOG : 0);
|
|
}
|
|
|
|
return BreakAction(bits);
|
|
}
|
|
|
|
void Apply() {
|
|
if (hasCondition && !condition.empty()) {
|
|
BreakPointCond cond;
|
|
cond.debug = currentDebugMIPS;
|
|
cond.expressionString = condition;
|
|
cond.expression = compiledCondition;
|
|
CBreakPoints::ChangeMemCheckAddCond(address, end, cond);
|
|
} else if (hasCondition && condition.empty()) {
|
|
CBreakPoints::ChangeMemCheckRemoveCond(address, end);
|
|
}
|
|
if (hasLogFormat) {
|
|
CBreakPoints::ChangeMemCheckLogFormat(address, end, logFormat);
|
|
}
|
|
}
|
|
};
|
|
|
|
// Add a new memory breakpoint (memory.breakpoint.add)
|
|
//
|
|
// Parameters:
|
|
// - address: unsigned integer address for the start of the memory range.
|
|
// - size: unsigned integer specifying size of memory range.
|
|
// - enabled: optional boolean, whether to actually enter stepping when this breakpoint trips.
|
|
// - log: optional boolean, whether to log when this breakpoint trips.
|
|
// - read: optional boolean, whether to trip on any read to this address.
|
|
// - write: optional boolean, whether to trip on any write to this address.
|
|
// - change: optional boolean, whether to trip on a write to this address which modifies data
|
|
// (or any write that may modify data.)
|
|
// - condition: optional string expression to evaluate - breakpoint does not trip if false.
|
|
// - logFormat: optional string to log when breakpoint trips, may include {expression} parts.
|
|
//
|
|
// Response (same event name) with no extra data.
|
|
//
|
|
// Note: will replace any breakpoint that has the same start address and size.
|
|
void WebSocketMemoryBreakpointAdd(DebuggerRequest &req) {
|
|
WebSocketMemoryBreakpointParams params;
|
|
if (!params.Parse(req))
|
|
return;
|
|
|
|
CBreakPoints::AddMemCheck(params.address, params.end, params.cond, params.Result(true));
|
|
params.Apply();
|
|
req.Respond();
|
|
}
|
|
|
|
// Update a memory breakpoint (memory.breakpoint.update)
|
|
//
|
|
// Parameters:
|
|
// - address: unsigned integer address for the start of the memory range.
|
|
// - size: unsigned integer specifying size of memory range.
|
|
// - enabled: optional boolean, whether to actually enter stepping when this breakpoint trips.
|
|
// - log: optional boolean, whether to log when this breakpoint trips.
|
|
// - read: optional boolean, whether to trip on any read to this address.
|
|
// - write: optional boolean, whether to trip on any write to this address.
|
|
// - change: optional boolean, whether to trip on a write to this address which modifies data
|
|
// (or any write that may modify data.)
|
|
// - condition: optional string expression to evaluate - breakpoint does not trip if false.
|
|
// - logFormat: optional string to log when breakpoint trips, may include {expression} parts.
|
|
//
|
|
// Response (same event name) with no extra data.
|
|
void WebSocketMemoryBreakpointUpdate(DebuggerRequest &req) {
|
|
WebSocketMemoryBreakpointParams params;
|
|
if (!params.Parse(req))
|
|
return;
|
|
|
|
MemCheck mc;
|
|
if (!CBreakPoints::GetMemCheck(params.address, params.end, &mc))
|
|
return req.Fail("Breakpoint not found");
|
|
|
|
CBreakPoints::ChangeMemCheck(params.address, params.end, params.cond, params.Result(true));
|
|
params.Apply();
|
|
req.Respond();
|
|
}
|
|
|
|
// Remove a memory breakpoint (memory.breakpoint.remove)
|
|
//
|
|
// Parameters:
|
|
// - address: unsigned integer address for the start of the memory range.
|
|
// - size: unsigned integer specifying size of memory range.
|
|
//
|
|
// Response (same event name) with no extra data.
|
|
void WebSocketMemoryBreakpointRemove(DebuggerRequest &req) {
|
|
if (!currentDebugMIPS->isAlive()) {
|
|
return req.Fail("CPU not started");
|
|
}
|
|
|
|
uint32_t address;
|
|
if (!req.ParamU32("address", &address))
|
|
return;
|
|
uint32_t size;
|
|
if (!req.ParamU32("size", &size))
|
|
return;
|
|
|
|
CBreakPoints::RemoveMemCheck(address, size == 0 ? 0 : address + size);
|
|
req.Respond();
|
|
}
|
|
|
|
// List all memory breakpoints (memory.breakpoint.list)
|
|
//
|
|
// No parameters.
|
|
//
|
|
// Response (same event name):
|
|
// - breakpoints: array of objects, each with properties:
|
|
// - address: unsigned integer address for the start of the memory range.
|
|
// - size: unsigned integer specifying size of memory range.
|
|
// - enabled: boolean, whether to actually enter stepping when this breakpoint trips.
|
|
// - log: optional boolean, whether to log when this breakpoint trips.
|
|
// - read: optional boolean, whether to trip on any read to this address.
|
|
// - write: optional boolean, whether to trip on any write to this address.
|
|
// - change: optional boolean, whether to trip on a write to this address which modifies data
|
|
// (or any write that may modify data.)
|
|
// - condition: null, or string expression to evaluate - breakpoint does not trip if false.
|
|
// - logFormat: null, or string to log when breakpoint trips, may include {expression} parts.
|
|
// - symbol: null, or string label or symbol at breakpoint address.
|
|
void WebSocketMemoryBreakpointList(DebuggerRequest &req) {
|
|
if (!currentDebugMIPS->isAlive()) {
|
|
return req.Fail("CPU not started");
|
|
}
|
|
|
|
JsonWriter &json = req.Respond();
|
|
json.pushArray("breakpoints");
|
|
auto mcs = CBreakPoints::GetMemChecks();
|
|
for (const auto &mc : mcs) {
|
|
json.pushDict();
|
|
json.writeUint("address", mc.start);
|
|
json.writeUint("size", mc.end == 0 ? 0 : mc.end - mc.start);
|
|
json.writeBool("enabled", mc.IsEnabled());
|
|
json.writeBool("log", (mc.result & BREAK_ACTION_LOG) != 0);
|
|
json.writeBool("read", (mc.cond & MEMCHECK_READ) != 0);
|
|
json.writeBool("write", (mc.cond & MEMCHECK_WRITE) != 0);
|
|
json.writeBool("change", (mc.cond & MEMCHECK_WRITE_ONCHANGE) != 0);
|
|
json.writeUint("hits", mc.numHits);
|
|
if (mc.hasCondition)
|
|
json.writeString("condition", mc.condition.expressionString);
|
|
else
|
|
json.writeNull("condition");
|
|
if (!mc.logFormat.empty())
|
|
json.writeString("logFormat", mc.logFormat);
|
|
else
|
|
json.writeNull("logFormat");
|
|
std::string symbol = g_symbolMap->GetLabelString(mc.start);
|
|
if (symbol.empty())
|
|
json.writeNull("symbol");
|
|
else
|
|
json.writeString("symbol", symbol);
|
|
|
|
json.pop();
|
|
}
|
|
json.pop();
|
|
}
|