Author: Adrian Vogelsgesang Date: 2024-09-16T22:56:20+02:00 New Revision: 3acb1eac5eb6ef4e60dd64b7845615e076cc6a3e
URL: https://github.com/llvm/llvm-project/commit/3acb1eac5eb6ef4e60dd64b7845615e076cc6a3e DIFF: https://github.com/llvm/llvm-project/commit/3acb1eac5eb6ef4e60dd64b7845615e076cc6a3e.diff LOG: [lldb-dap] Support inspecting memory (#104317) Add support for the `readMemory` request which allows VS-Code to inspect memory. Also, add `memoryReference` to variables and `evaluate` responses, such that the binary view can be opened from the variables view and from the "watch" pane. Added: lldb/test/API/tools/lldb-dap/memory/Makefile lldb/test/API/tools/lldb-dap/memory/TestDAP_memory.py lldb/test/API/tools/lldb-dap/memory/main.cpp Modified: lldb/packages/Python/lldbsuite/test/tools/lldb-dap/dap_server.py lldb/tools/lldb-dap/JSONUtils.cpp lldb/tools/lldb-dap/JSONUtils.h lldb/tools/lldb-dap/lldb-dap.cpp Removed: ################################################################################ diff --git a/lldb/packages/Python/lldbsuite/test/tools/lldb-dap/dap_server.py b/lldb/packages/Python/lldbsuite/test/tools/lldb-dap/dap_server.py index c6417760f17a2b..d6a386975c8fb9 100644 --- a/lldb/packages/Python/lldbsuite/test/tools/lldb-dap/dap_server.py +++ b/lldb/packages/Python/lldbsuite/test/tools/lldb-dap/dap_server.py @@ -691,6 +691,19 @@ def request_disassemble( for inst in instructions: self.disassembled_instructions[inst["address"]] = inst + def request_readMemory(self, memoryReference, offset, count): + args_dict = { + "memoryReference": memoryReference, + "offset": offset, + "count": count, + } + command_dict = { + "command": "readMemory", + "type": "request", + "arguments": args_dict, + } + return self.send_recv(command_dict) + def request_evaluate(self, expression, frameIndex=0, threadId=None, context=None): stackFrame = self.get_stackFrame(frameIndex=frameIndex, threadId=threadId) if stackFrame is None: diff --git a/lldb/test/API/tools/lldb-dap/memory/Makefile b/lldb/test/API/tools/lldb-dap/memory/Makefile new file mode 100644 index 00000000000000..99998b20bcb050 --- /dev/null +++ b/lldb/test/API/tools/lldb-dap/memory/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/lldb/test/API/tools/lldb-dap/memory/TestDAP_memory.py b/lldb/test/API/tools/lldb-dap/memory/TestDAP_memory.py new file mode 100644 index 00000000000000..8bee70e50dcad9 --- /dev/null +++ b/lldb/test/API/tools/lldb-dap/memory/TestDAP_memory.py @@ -0,0 +1,116 @@ +""" +Test lldb-dap memory support +""" + +from base64 import b64decode +import dap_server +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil +import lldbdap_testcase +import os + + +class TestDAP_memory(lldbdap_testcase.DAPTestCaseBase): + def test_memory_refs_variables(self): + """ + Tests memory references for evaluate + """ + program = self.getBuildArtifact("a.out") + self.build_and_launch(program) + source = "main.cpp" + self.source_path = os.path.join(os.getcwd(), source) + self.set_source_breakpoints( + source, + [line_number(source, "// Breakpoint")], + ) + self.continue_to_next_stop() + + locals = {l["name"]: l for l in self.dap_server.get_local_variables()} + + # Pointers should have memory-references + self.assertIn("memoryReference", locals["rawptr"].keys()) + # Non-pointers should also have memory-references + self.assertIn("memoryReference", locals["not_a_ptr"].keys()) + + def test_memory_refs_evaluate(self): + """ + Tests memory references for evaluate + """ + program = self.getBuildArtifact("a.out") + self.build_and_launch(program) + source = "main.cpp" + self.source_path = os.path.join(os.getcwd(), source) + self.set_source_breakpoints( + source, + [line_number(source, "// Breakpoint")], + ) + self.continue_to_next_stop() + + self.assertIn( + "memoryReference", + self.dap_server.request_evaluate("rawptr")["body"].keys(), + ) + + def test_memory_refs_set_variable(self): + """ + Tests memory references for `setVariable` + """ + program = self.getBuildArtifact("a.out") + self.build_and_launch(program) + source = "main.cpp" + self.source_path = os.path.join(os.getcwd(), source) + self.set_source_breakpoints( + source, + [line_number(source, "// Breakpoint")], + ) + self.continue_to_next_stop() + + ptr_value = self.get_local_as_int("rawptr") + self.assertIn( + "memoryReference", + self.dap_server.request_setVariable(1, "rawptr", ptr_value + 2)[ + "body" + ].keys(), + ) + + def test_readMemory(self): + """ + Tests the 'readMemory' request + """ + program = self.getBuildArtifact("a.out") + self.build_and_launch(program) + source = "main.cpp" + self.source_path = os.path.join(os.getcwd(), source) + self.set_source_breakpoints( + source, + [line_number(source, "// Breakpoint")], + ) + self.continue_to_next_stop() + + ptr_deref = self.dap_server.request_evaluate("*rawptr")["body"] + memref = ptr_deref["memoryReference"] + + # We can read the complete string + mem = self.dap_server.request_readMemory(memref, 0, 5)["body"] + self.assertEqual(mem["unreadableBytes"], 0) + self.assertEqual(b64decode(mem["data"]), b"dead\0") + + # Use an offset + mem = self.dap_server.request_readMemory(memref, 2, 3)["body"] + self.assertEqual(b64decode(mem["data"]), b"ad\0") + + # Use a negative offset + mem = self.dap_server.request_readMemory(memref, -1, 6)["body"] + self.assertEqual(b64decode(mem["data"])[1:], b"dead\0") + + # Reads of size 0 are successful + # VS-Code sends those in order to check if a `memoryReference` can actually be dereferenced. + mem = self.dap_server.request_readMemory(memref, 0, 0) + self.assertEqual(mem["success"], True) + self.assertEqual(mem["body"]["data"], "") + + # Reads at offset 0x0 fail + mem = self.dap_server.request_readMemory("0x0", 0, 6) + self.assertEqual(mem["success"], False) + self.assertEqual(mem["message"], "Memory region is not readable") diff --git a/lldb/test/API/tools/lldb-dap/memory/main.cpp b/lldb/test/API/tools/lldb-dap/memory/main.cpp new file mode 100644 index 00000000000000..14ac1ad95e330f --- /dev/null +++ b/lldb/test/API/tools/lldb-dap/memory/main.cpp @@ -0,0 +1,9 @@ +#include <iostream> +#include <memory> + +int main() { + int not_a_ptr = 666; + const char *rawptr = "dead"; + // Breakpoint + return 0; +} diff --git a/lldb/tools/lldb-dap/JSONUtils.cpp b/lldb/tools/lldb-dap/JSONUtils.cpp index f175079c6f1fb5..c068111c63ac49 100644 --- a/lldb/tools/lldb-dap/JSONUtils.cpp +++ b/lldb/tools/lldb-dap/JSONUtils.cpp @@ -112,6 +112,22 @@ bool ObjectContainsKey(const llvm::json::Object &obj, llvm::StringRef key) { return obj.find(key) != obj.end(); } +std::string EncodeMemoryReference(lldb::addr_t addr) { + return "0x" + llvm::utohexstr(addr); +} + +std::optional<lldb::addr_t> +DecodeMemoryReference(llvm::StringRef memoryReference) { + if (!memoryReference.starts_with("0x")) + return std::nullopt; + + lldb::addr_t addr; + if (memoryReference.consumeInteger(0, addr)) + return std::nullopt; + + return addr; +} + std::vector<std::string> GetStrings(const llvm::json::Object *obj, llvm::StringRef key) { std::vector<std::string> strs; @@ -690,8 +706,7 @@ std::optional<llvm::json::Value> CreateSource(lldb::SBFrame &frame) { // "instructionPointerReference": { // "type": "string", // "description": "A memory reference for the current instruction -// pointer -// in this frame." +// pointer in this frame." // }, // "moduleId": { // "type": ["integer", "string"], @@ -1239,8 +1254,16 @@ std::string VariableDescription::GetResult(llvm::StringRef context) { // can use this optional information to present the // children in a paged UI and fetch them in chunks." // } -// -// +// "memoryReference": { +// "type": "string", +// "description": "A memory reference associated with this variable. +// For pointer type variables, this is generally a +// reference to the memory address contained in the +// pointer. For executable data, this reference may later +// be used in a `disassemble` request. This attribute may +// be returned by a debug adapter if corresponding +// capability `supportsMemoryReferences` is true." +// }, // "$__lldb_extensions": { // "description": "Unofficial extensions to the protocol", // "properties": { @@ -1348,6 +1371,9 @@ llvm::json::Value CreateVariable(lldb::SBValue v, int64_t variablesReference, else object.try_emplace("variablesReference", (int64_t)0); + if (lldb::addr_t addr = v.GetLoadAddress(); addr != LLDB_INVALID_ADDRESS) + object.try_emplace("memoryReference", EncodeMemoryReference(addr)); + object.try_emplace("$__lldb_extensions", desc.GetVariableExtensionsJSON()); return llvm::json::Value(std::move(object)); } diff --git a/lldb/tools/lldb-dap/JSONUtils.h b/lldb/tools/lldb-dap/JSONUtils.h index f8fec22d7aa0ea..e44101f98103d6 100644 --- a/lldb/tools/lldb-dap/JSONUtils.h +++ b/lldb/tools/lldb-dap/JSONUtils.h @@ -131,6 +131,13 @@ int64_t GetSigned(const llvm::json::Object *obj, llvm::StringRef key, /// \b True if the key exists in the \a obj, \b False otherwise. bool ObjectContainsKey(const llvm::json::Object &obj, llvm::StringRef key); +/// Encodes a memory reference +std::string EncodeMemoryReference(lldb::addr_t addr); + +/// Decodes a memory reference +std::optional<lldb::addr_t> +DecodeMemoryReference(llvm::StringRef memoryReference); + /// Extract an array of strings for the specified key from an object. /// /// String values in the array will be extracted without any quotes diff --git a/lldb/tools/lldb-dap/lldb-dap.cpp b/lldb/tools/lldb-dap/lldb-dap.cpp index c2ebc9a96a9a29..7e17aeef1e53c6 100644 --- a/lldb/tools/lldb-dap/lldb-dap.cpp +++ b/lldb/tools/lldb-dap/lldb-dap.cpp @@ -9,6 +9,7 @@ #include "DAP.h" #include "Watchpoint.h" #include "lldb/API/SBMemoryRegionInfo.h" +#include "llvm/Support/Base64.h" #include <cassert> #include <climits> @@ -1541,6 +1542,16 @@ void request_completions(const llvm::json::Object &request) { // present the variables in a paged UI and fetch // them in chunks." // } +// "memoryReference": { +// "type": "string", +// "description": "A memory reference to a location appropriate +// for this result. For pointer type eval +// results, this is generally a reference to the +// memory address contained in the pointer. This +// attribute may be returned by a debug adapter +// if corresponding capability +// `supportsMemoryReferences` is true." +// }, // }, // "required": [ "result", "variablesReference" ] // } @@ -1606,6 +1617,9 @@ void request_evaluate(const llvm::json::Object &request) { } else { body.try_emplace("variablesReference", (int64_t)0); } + if (lldb::addr_t addr = value.GetLoadAddress(); + addr != LLDB_INVALID_ADDRESS) + body.try_emplace("memoryReference", EncodeMemoryReference(addr)); } } response.try_emplace("body", std::move(body)); @@ -1875,6 +1889,8 @@ void request_initialize(const llvm::json::Object &request) { // The debug adapter supports stepping granularities (argument `granularity`) // for the stepping requests. body.try_emplace("supportsSteppingGranularity", true); + // The debug adapter support for instruction breakpoint. + body.try_emplace("supportsInstructionBreakpoints", true); llvm::json::Array completion_characters; completion_characters.emplace_back("."); @@ -1916,8 +1932,8 @@ void request_initialize(const llvm::json::Object &request) { body.try_emplace("supportsLogPoints", true); // The debug adapter supports data watchpoints. body.try_emplace("supportsDataBreakpoints", true); - // The debug adapter support for instruction breakpoint. - body.try_emplace("supportsInstructionBreakpoints", true); + // The debug adapter supports the `readMemory` request. + body.try_emplace("supportsReadMemoryRequest", true); // Put in non-DAP specification lldb specific information. llvm::json::Object lldb_json; @@ -3775,8 +3791,11 @@ void request_setVariable(const llvm::json::Object &request) { if (variable.MightHaveChildren()) newVariablesReference = g_dap.variables.InsertExpandableVariable( variable, /*is_permanent=*/false); - body.try_emplace("variablesReference", newVariablesReference); + + if (lldb::addr_t addr = variable.GetLoadAddress(); + addr != LLDB_INVALID_ADDRESS) + body.try_emplace("memoryReference", EncodeMemoryReference(addr)); } else { EmplaceSafeString(body, "message", std::string(error.GetCString())); } @@ -4073,17 +4092,18 @@ void request_variables(const llvm::json::Object &request) { void request_disassemble(const llvm::json::Object &request) { llvm::json::Object response; FillResponse(request, response); - auto arguments = request.getObject("arguments"); + auto *arguments = request.getObject("arguments"); - auto memoryReference = GetString(arguments, "memoryReference"); - lldb::addr_t addr_ptr; - if (memoryReference.consumeInteger(0, addr_ptr)) { + llvm::StringRef memoryReference = GetString(arguments, "memoryReference"); + auto addr_opt = DecodeMemoryReference(memoryReference); + if (!addr_opt.has_value()) { response["success"] = false; response["message"] = "Malformed memory reference: " + memoryReference.str(); g_dap.SendJSON(llvm::json::Value(std::move(response))); return; } + lldb::addr_t addr_ptr = *addr_opt; addr_ptr += GetSigned(arguments, "instructionOffset", 0); lldb::SBAddress addr(addr_ptr, g_dap.target); @@ -4201,6 +4221,161 @@ void request_disassemble(const llvm::json::Object &request) { response.try_emplace("body", std::move(body)); g_dap.SendJSON(llvm::json::Value(std::move(response))); } + +// "ReadMemoryRequest": { +// "allOf": [ { "$ref": "#/definitions/Request" }, { +// "type": "object", +// "description": "Reads bytes from memory at the provided location. Clients +// should only call this request if the corresponding +// capability `supportsReadMemoryRequest` is true.", +// "properties": { +// "command": { +// "type": "string", +// "enum": [ "readMemory" ] +// }, +// "arguments": { +// "$ref": "#/definitions/ReadMemoryArguments" +// } +// }, +// "required": [ "command", "arguments" ] +// }] +// }, +// "ReadMemoryArguments": { +// "type": "object", +// "description": "Arguments for `readMemory` request.", +// "properties": { +// "memoryReference": { +// "type": "string", +// "description": "Memory reference to the base location from which data +// should be read." +// }, +// "offset": { +// "type": "integer", +// "description": "Offset (in bytes) to be applied to the reference +// location before reading data. Can be negative." +// }, +// "count": { +// "type": "integer", +// "description": "Number of bytes to read at the specified location and +// offset." +// } +// }, +// "required": [ "memoryReference", "count" ] +// }, +// "ReadMemoryResponse": { +// "allOf": [ { "$ref": "#/definitions/Response" }, { +// "type": "object", +// "description": "Response to `readMemory` request.", +// "properties": { +// "body": { +// "type": "object", +// "properties": { +// "address": { +// "type": "string", +// "description": "The address of the first byte of data returned. +// Treated as a hex value if prefixed with `0x`, or +// as a decimal value otherwise." +// }, +// "unreadableBytes": { +// "type": "integer", +// "description": "The number of unreadable bytes encountered after +// the last successfully read byte.\nThis can be +// used to determine the number of bytes that should +// be skipped before a subsequent +// `readMemory` request succeeds." +// }, +// "data": { +// "type": "string", +// "description": "The bytes read from memory, encoded using base64. +// If the decoded length of `data` is less than the +// requested `count` in the original `readMemory` +// request, and `unreadableBytes` is zero or +// omitted, then the client should assume it's +// reached the end of readable memory." +// } +// }, +// "required": [ "address" ] +// } +// } +// }] +// }, +void request_readMemory(const llvm::json::Object &request) { + llvm::json::Object response; + FillResponse(request, response); + auto *arguments = request.getObject("arguments"); + + lldb::SBProcess process = g_dap.target.GetProcess(); + if (!process.IsValid()) { + response["success"] = false; + response["message"] = "No process running"; + g_dap.SendJSON(llvm::json::Value(std::move(response))); + return; + } + + llvm::StringRef memoryReference = GetString(arguments, "memoryReference"); + auto addr_opt = DecodeMemoryReference(memoryReference); + if (!addr_opt.has_value()) { + response["success"] = false; + response["message"] = + "Malformed memory reference: " + memoryReference.str(); + g_dap.SendJSON(llvm::json::Value(std::move(response))); + return; + } + lldb::addr_t addr = *addr_opt; + + addr += GetSigned(arguments, "offset", 0); + const uint64_t requested_count = GetUnsigned(arguments, "count", 0); + lldb::SBMemoryRegionInfo region_info; + lldb::SBError memreg_error = process.GetMemoryRegionInfo(addr, region_info); + if (memreg_error.Fail()) { + response["success"] = false; + EmplaceSafeString(response, "message", + "Unable to find memory region: " + + std::string(memreg_error.GetCString())); + g_dap.SendJSON(llvm::json::Value(std::move(response))); + return; + } + if (!region_info.IsReadable()) { + response["success"] = false; + response.try_emplace("message", "Memory region is not readable"); + g_dap.SendJSON(llvm::json::Value(std::move(response))); + return; + } + const uint64_t available_count = + std::min(requested_count, region_info.GetRegionEnd() - addr); + const uint64_t unavailable_count = requested_count - available_count; + + std::vector<uint8_t> buf; + buf.resize(available_count); + if (available_count > 0) { + lldb::SBError memread_error; + uint64_t bytes_read = + process.ReadMemory(addr, buf.data(), available_count, memread_error); + if (memread_error.Fail()) { + response["success"] = false; + EmplaceSafeString(response, "message", + "Unable to read memory: " + + std::string(memread_error.GetCString())); + g_dap.SendJSON(llvm::json::Value(std::move(response))); + return; + } + if (bytes_read != available_count) { + response["success"] = false; + EmplaceSafeString(response, "message", "Unexpected, short read"); + g_dap.SendJSON(llvm::json::Value(std::move(response))); + return; + } + } + + llvm::json::Object body; + std::string formatted_addr = "0x" + llvm::utohexstr(addr); + body.try_emplace("address", formatted_addr); + body.try_emplace("data", llvm::encodeBase64(buf)); + body.try_emplace("unreadableBytes", unavailable_count); + response.try_emplace("body", std::move(body)); + g_dap.SendJSON(llvm::json::Value(std::move(response))); +} + // A request used in testing to get the details on all breakpoints that are // currently set in the target. This helps us to test "setBreakpoints" and // "setFunctionBreakpoints" requests to verify we have the correct set of @@ -4499,7 +4674,7 @@ void RegisterRequestCallbacks() { g_dap.RegisterRequestCallback("threads", request_threads); g_dap.RegisterRequestCallback("variables", request_variables); g_dap.RegisterRequestCallback("disassemble", request_disassemble); - // Instruction breakpoint request + g_dap.RegisterRequestCallback("readMemory", request_readMemory); g_dap.RegisterRequestCallback("setInstructionBreakpoints", request_setInstructionBreakpoints); // Custom requests _______________________________________________ lldb-commits mailing list lldb-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
