[lldb][lldb-dap] Added support for "WriteMemory" request.

lldb/packages/Python/lldbsuite/test/tools/lldb-dap/dap_server.py

@@ -753,6 +753,20 @@ def request_readMemory(self, memoryReference, offset, count):
         }
         return self.send_recv(command_dict)
 
+    def request_writeMemory(self, memoryReference, data, offset=0, allowPartial=True):
+        args_dict = {
+            "memoryReference": memoryReference,
+            "offset": offset,
+            "allowPartial": allowPartial,
+            "data": data,
+        }
+        command_dict = {
+            "command": "writeMemory",
+            "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:

lldb/packages/Python/lldbsuite/test/tools/lldb-dap/lldbdap_testcase.py

@@ -6,6 +6,7 @@
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbplatformutil
 import lldbgdbserverutils
+import base64
 
 
 class DAPTestCaseBase(TestBase):
@@ -556,3 +557,20 @@ def getBuiltinDebugServerTool(self):
                 self.dap_server.request_disconnect(terminateDebuggee=True)
                 self.assertIsNotNone(server_tool, "debugserver not found.")
         return server_tool
+
+    def writeMemory(self, memoryReference, data=None, offset=None, allowPartial=None):
+        # This function accepts data in decimal and hexadecimal format,
+        # converts it to a Base64 string, and send it to the DAP,
+        # which expects Base64 encoded data.
+        encodedData = (
+            ""
+            if data is None
+            else base64.b64encode(
+                # (bit_length + 7 (rounding up to nearest byte) ) //8 = converts to bytes.
+                data.to_bytes((data.bit_length() + 7) // 8, "little")
+            ).decode()
+        )
+        response = self.dap_server.request_writeMemory(
+            memoryReference, encodedData, offset=offset, allowPartial=allowPartial
+        )
+        return response

lldb/test/API/tools/lldb-dap/memory/TestDAP_memory.py

@@ -113,3 +113,85 @@ def test_readMemory(self):
         # Reads at offset 0x0 fail
         mem = self.dap_server.request_readMemory("0x0", 0, 6)
         self.assertEqual(mem["success"], False)
+
+    def test_writeMemory(self):
+        """
+        Tests the 'writeMemory' 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()
+
+        # Get the 'not_a_ptr' writable variable reference address.
+        ptr_deref = self.dap_server.request_evaluate("not_a_ptr")["body"]
+        memref = ptr_deref["memoryReference"]
+
+        # Write the decimal value 50 (0x32 in hexadecimal) to memory.
+        # This corresponds to the ASCII character '2' and encodes to Base64 as "Mg==".
+        mem_response = self.writeMemory(memref, 50, 0, True)
+        self.assertEqual(mem_response["success"], True)
+        self.assertEqual(mem_response["body"]["bytesWritten"], 1)
+
+        # Read back the modified memory and verify that the written data matches
+        # the expected result.
+        mem_response = self.dap_server.request_readMemory(memref, 0, 1)
+        self.assertEqual(mem_response["success"], True)
+        self.assertEqual(mem_response["body"]["data"], "Mg==")
+
+        # Write the decimal value 100 (0x64 in hexadecimal) to memory.
+        # This corresponds to the ASCII character 'd' and encodes to Base64 as "ZA==".
+        # allowPartial=False
+        mem_response = self.writeMemory(memref, 100, 0, False)
+        self.assertEqual(mem_response["success"], True)
+        self.assertEqual(mem_response["body"]["bytesWritten"], 1)
+
+        # Read back the modified memory and verify that the written data matches
+        # the expected result.
+        mem_response = self.dap_server.request_readMemory(memref, 0, 1)
+        self.assertEqual(mem_response["success"], True)
+        self.assertEqual(mem_response["body"]["data"], "ZA==")
+
+        # Memory write failed for 0x0.
+        mem_response = self.writeMemory("0x0", 50, 0, True)
+        self.assertEqual(mem_response["success"], False)
+
+        # Malformed memory reference.
+        mem_response = self.writeMemory("12345", 50, 0, True)
+        self.assertEqual(mem_response["success"], False)
+
+        ptr_deref = self.dap_server.request_evaluate("nonWritable")["body"]
+        memref = ptr_deref["memoryReference"]
+
+        # Writing to non-writable region should return an appropriate error.
+        mem_response = self.writeMemory(memref, 50, 0, False)
+        self.assertEqual(mem_response["success"], False)
+        self.assertRegex(
+            mem_response["message"],
+            r"Memory " + memref + " region is not writable",
+        )
+
+        # Trying to write empty value; data=""
+        mem_response = self.writeMemory(memref)
+        self.assertEqual(mem_response["success"], False)
+        self.assertRegex(
+            mem_response["message"],
+            r"Data cannot be empty value. Provide valid data",
+        )
+
+        # Verify that large memory writes fail if the range spans non-writable
+        # or non -contiguous regions.
+        data = bytes([0xFF] * 8192)
+        mem_response = self.writeMemory(
+            memref, int.from_bytes(data, byteorder="little"), 0, False
+        )
+        self.assertEqual(mem_response["success"], False)
+        self.assertRegex(
+            mem_response["message"],
+            r"Memory " + memref + " region is not writable",
+        )

lldb/test/API/tools/lldb-dap/memory/main.cpp

@@ -1,6 +1,8 @@
 int main() {
   int not_a_ptr = 666;
   const char *rawptr = "dead";
+  // Immutable variable, .rodata region.
+  static const int nonWritable = 100;
   // Breakpoint
   return 0;
 }

lldb/tools/lldb-dap/CMakeLists.txt

@@ -71,7 +71,8 @@ add_lldb_tool(lldb-dap
   Handler/TestGetTargetBreakpointsRequestHandler.cpp
   Handler/ThreadsRequestHandler.cpp
   Handler/VariablesRequestHandler.cpp
-
+  Handler/WriteMemoryRequestHandler.cpp
+
   Protocol/ProtocolBase.cpp
   Protocol/ProtocolTypes.cpp
   Protocol/ProtocolRequests.cpp

lldb/tools/lldb-dap/DAP.cpp

@@ -1367,4 +1367,11 @@ protocol::Capabilities DAP::GetCapabilities() {
   return capabilities;
 }
 
+void DAP::SendErrorResponse(llvm::json::Object &response,
+                            llvm::StringRef message) {
+  response["success"] = false;
+  EmplaceSafeString(response, "message", message);
+  SendJSON(llvm::json::Value(std::move(response)));
+}
+
 } // namespace lldb_dap

lldb/tools/lldb-dap/DAP.h

@@ -416,6 +416,14 @@ struct DAP {
 
   lldb::SBMutex GetAPIMutex() const { return target.GetAPIMutex(); }
 
+  /// Sends an error response in DAP with success=false and an error message.
+  ///
+  /// \param[out] response
+  ///   The response object to update.
+  /// \param[in] message
+  ///   The error message.
+  void SendErrorResponse(llvm::json::Object &response, llvm::StringRef message);
+
 private:
   std::mutex m_queue_mutex;
   std::deque<protocol::Message> m_queue;

lldb/tools/lldb-dap/Handler/RequestHandler.h

@@ -529,6 +529,16 @@ class TestGetTargetBreakpointsRequestHandler : public LegacyRequestHandler {
   void operator()(const llvm::json::Object &request) const override;
 };
 
+class WriteMemoryRequestHandler : public LegacyRequestHandler {
+public:
+  using LegacyRequestHandler::LegacyRequestHandler;
+  static llvm::StringLiteral GetCommand() { return "writeMemory"; }
+  FeatureSet GetSupportedFeatures() const override {
+    return {protocol::eAdapterFeatureWriteMemoryRequest};
+  }
+  void operator()(const llvm::json::Object &request) const override;
+};
+
 } // namespace lldb_dap
 
 #endif

lldb/tools/lldb-dap/Handler/WriteMemoryRequestHandler.cpp

@@ -0,0 +1,188 @@
+//===-- WriteMemoryRequestHandler.cpp -------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "DAP.h"
+#include "JSONUtils.h"
+#include "RequestHandler.h"
+#include "lldb/API/SBMemoryRegionInfo.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/Base64.h"
+
+namespace lldb_dap {
+
+// "WriteMemoryRequest": {
+//       "allOf": [ { "$ref": "#/definitions/Request" }, {
+//         "type": "object",
+//         "description": "Writes bytes to memory at the provided location.\n
+//         Clients should only call this request if the corresponding
+//         capability `supportsWriteMemoryRequest` is true.",
+//         "properties": {
+//           "command": {
+//             "type": "string",
+//             "enum": [ "writeMemory" ]
+//           },
+//           "arguments": {
+//             "$ref": "#/definitions/WriteMemoryArguments"
+//           }
+//         },
+//         "required": [ "command", "arguments" ]
+//       }]
+//     },
+//     "WriteMemoryArguments": {
+//       "type": "object",
+//       "description": "Arguments for `writeMemory` request.",
+//       "properties": {
+//         "memoryReference": {
+//           "type": "string",
+//           "description": "Memory reference to the base location to which
+//           data should be written."
+//         },
+//         "offset": {
+//           "type": "integer",
+//           "description": "Offset (in bytes) to be applied to the reference
+//           location before writing data. Can be negative."
+//         },
+//         "allowPartial": {
+//           "type": "boolean",
+//           "description": "Property to control partial writes. If true, the
+//           debug adapter should attempt to write memory even if the entire
+//           memory region is not writable. In such a case the debug adapter
+//           should stop after hitting the first byte of memory that cannot be
+//           written and return the number of bytes written in the response
+//           via the `offset` and `bytesWritten` properties.\nIf false or
+//           missing, a debug adapter should attempt to verify the region is
+//           writable before writing, and fail the response if it is not."
+//         },
+//         "data": {
+//           "type": "string",
+//           "description": "Bytes to write, encoded using base64."
+//         }
+//       },
+//       "required": [ "memoryReference", "data" ]
+//     },
+//     "WriteMemoryResponse": {
+//       "allOf": [ { "$ref": "#/definitions/Response" }, {
+//         "type": "object",
+//         "description": "Response to `writeMemory` request.",
+//         "properties": {
+//           "body": {
+//             "type": "object",
+//             "properties": {
+//               "offset": {
+//                 "type": "integer",
+//                 "description": "Property that should be returned when
+//                 `allowPartial` is true to indicate the offset of the first
+//                 byte of data successfully written. Can be negative."
+//               },
+//               "bytesWritten": {
+//                 "type": "integer",
+//                 "description": "Property that should be returned when
+//                 `allowPartial` is true to indicate the number of bytes
+//                 starting from address that were successfully written."
+//               }
+//             }
+//           }
+//         }
+//       }]
+//     },
+void WriteMemoryRequestHandler::operator()(
+    const llvm::json::Object &request) const {
+  llvm::json::Object response;
+  FillResponse(request, response);
+
+  auto arguments = request.getObject("arguments");
+  llvm::StringRef memory_reference =
+      GetString(arguments, "memoryReference").value_or("");
+
+  auto addr_opt = DecodeMemoryReference(memory_reference);
+  if (!addr_opt.has_value()) {
+    dap.SendErrorResponse(response, "Malformed memory reference: " +
+                                        memory_reference.str());
+    return;
+  }
+  lldb::addr_t address =
+      *addr_opt + GetInteger<uint64_t>(arguments, "offset").value_or(0);
+
+  llvm::StringRef data64 = GetString(arguments, "data").value_or("");
+  if (data64.empty()) {
+    dap.SendErrorResponse(response,
+                          "Data cannot be empty value. Provide valid data");
+    return;
+  }
+
+  // The VSCode IDE or other DAP clients send memory data as a Base64 string.
+  // This function decodes it into raw binary before writing it to the target
+  // process memory.
+  std::vector<char> output;
+  auto decode_error = llvm::decodeBase64(data64, output);
+
+  if (decode_error) {
+    dap.SendErrorResponse(response,
+                          llvm::toString(std::move(decode_error)).c_str());
+    return;
+  }
+
+  bool allow_partial = GetBoolean(arguments, "allowPartial").value_or(true);
+  lldb::SBError write_error;
+  uint64_t bytes_written = 0;
+
+  // Write the memory.
+  if (!output.empty()) {
+    lldb::SBProcess process = dap.target.GetProcess();
+    // If 'allowPartial' is false or missing, a debug adapter should attempt to
+    // verify the region is writable before writing, and fail the response if it
+    // is not.
+    if (!allow_partial) {
+      // Start checking from the initial write address.
+      lldb::addr_t start_address = address;
+      // Compute the end of the write range.
+      lldb::addr_t end_address = start_address + output.size() - 1;
+
+      while (start_address <= end_address) {
+        // Get memory region info for the given address.
+        // This provides the region's base, end, and permissions
+        // (read/write/executable).
+        lldb::SBMemoryRegionInfo region_info;
+        lldb::SBError error =
+            process.GetMemoryRegionInfo(start_address, region_info);
+        // Fail if the region info retrieval fails, is not writable, or the
+        // range exceeds the region.
+        if (!error.Success() || !region_info.IsWritable()) {
+          dap.SendErrorResponse(response, "Memory 0x" +
+                                              llvm::utohexstr(address) +
+                                              " region is not writable");
+          return;
+        }
+        // If the current region covers the full requested range, stop futher
+        // iterations.
+        if (end_address <= region_info.GetRegionEnd()) {
+          break;
+        }
+        // Move to the start of the next memory region.
+        start_address = region_info.GetRegionEnd() + 1;
+      }
+    }
+
+    bytes_written =
+        process.WriteMemory(address, static_cast<void *>(output.data()),
+                            output.size(), write_error);
+  }
+
+  if (bytes_written == 0) {
+    dap.SendErrorResponse(response, write_error.GetCString());
+    return;
+  }
+
+  llvm::json::Object body;
+  body.try_emplace("bytesWritten", std::move(bytes_written));
+
+  response.try_emplace("body", std::move(body));
+  dap.SendJSON(llvm::json::Value(std::move(response)));
+}
+
+} // namespace lldb_dap

lldb/tools/lldb-dap/lldb-dap.cpp

@@ -148,6 +148,7 @@ static void RegisterRequestCallbacks(DAP &dap) {
   dap.RegisterRequest<StepOutRequestHandler>();
   dap.RegisterRequest<ThreadsRequestHandler>();
   dap.RegisterRequest<VariablesRequestHandler>();
+  dap.RegisterRequest<WriteMemoryRequestHandler>();
 
   // Custom requests
   dap.RegisterRequest<CompileUnitsRequestHandler>();