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

santhoshe447 · santhoshe447 · commit 2930a702f98a · 2025-07-04T01:38:09.000+05:30
Followed non-legacy approach to implement "writeMemory" request.
diff --git a/lldb/test/API/tools/lldb-dap/memory/TestDAP_memory.py b/lldb/test/API/tools/lldb-dap/memory/TestDAP_memory.py
@@ -184,15 +184,15 @@ def test_writeMemory(self):
         mem_response = self.writeMemory(memref, 50, 0, False)
         self.assertEqual(mem_response["success"], False)
         self.assertRegex(
-            mem_response["message"],
+            mem_response["body"]["error"]["format"],
             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"],
+            mem_response["body"]["error"]["format"],
             r"Data cannot be empty value. Provide valid data",
         )
 
@@ -204,6 +204,6 @@ def test_writeMemory(self):
         )
         self.assertEqual(mem_response["success"], False)
         self.assertRegex(
-            mem_response["message"],
+            mem_response["body"]["error"]["format"],
             r"Memory " + memref + " region is not writable",
-        )
+        )
diff --git a/lldb/tools/lldb-dap/DAP.cpp b/lldb/tools/lldb-dap/DAP.cpp
@@ -1563,10 +1563,4 @@ void DAP::RegisterRequests() {
   RegisterRequest<TestGetTargetBreakpointsRequestHandler>();
 }
 
-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
diff --git a/lldb/tools/lldb-dap/DAP.h b/lldb/tools/lldb-dap/DAP.h
@@ -418,14 +418,6 @@ struct DAP {
       const std::optional<std::vector<protocol::SourceBreakpoint>>
           &breakpoints);
 
-  /// 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::vector<protocol::Breakpoint> SetSourceBreakpoints(
       const protocol::Source &source,
diff --git a/lldb/tools/lldb-dap/Handler/RequestHandler.h b/lldb/tools/lldb-dap/Handler/RequestHandler.h
@@ -601,14 +601,17 @@ class TestGetTargetBreakpointsRequestHandler : public LegacyRequestHandler {
   void operator()(const llvm::json::Object &request) const override;
 };
 
-class WriteMemoryRequestHandler : public LegacyRequestHandler {
+class WriteMemoryRequestHandler final
+    : public RequestHandler<protocol::WriteMemoryArguments,
+                            llvm::Expected<protocol::WriteMemoryResponseBody>> {
 public:
-  using LegacyRequestHandler::LegacyRequestHandler;
+  using RequestHandler::RequestHandler;
   static llvm::StringLiteral GetCommand() { return "writeMemory"; }
   FeatureSet GetSupportedFeatures() const override {
     return {protocol::eAdapterFeatureWriteMemoryRequest};
   }
-  void operator()(const llvm::json::Object &request) const override;
+  llvm::Expected<protocol::WriteMemoryResponseBody>
+  Run(const protocol::WriteMemoryArguments &args) const override;
 };
 
 } // namespace lldb_dap
diff --git a/lldb/tools/lldb-dap/Handler/WriteMemoryRequestHandler.cpp b/lldb/tools/lldb-dap/Handler/WriteMemoryRequestHandler.cpp
@@ -15,119 +15,36 @@
 
 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;
+// Writes bytes to memory at the provided location.
+//
+// Clients should only call this request if the corresponding capability
+//  supportsWriteMemoryRequest is true.
+llvm::Expected<protocol::WriteMemoryResponseBody>
+WriteMemoryRequestHandler::Run(
+    const protocol::WriteMemoryArguments &args) const {
+  const lldb::addr_t address = args.memoryReference + args.offset.value_or(0);
+  ;
+
+  lldb::SBProcess process = dap.target.GetProcess();
+  if (!lldb::SBDebugger::StateIsStoppedState(process.GetState()))
+    return llvm::make_error<NotStoppedError>();
+
+  if (args.data.empty()) {
+    return llvm::make_error<DAPError>(
+        "Data cannot be empty value. Provide valid data");
   }
 
   // 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);
+  auto decode_error = llvm::decodeBase64(args.data, output);
 
   if (decode_error) {
-    dap.SendErrorResponse(response,
-                          llvm::toString(std::move(decode_error)).c_str());
-    return;
+    return llvm::make_error<DAPError>(
+        llvm::toString(std::move(decode_error)).c_str());
   }
 
-  bool allow_partial = GetBoolean(arguments, "allowPartial").value_or(true);
   lldb::SBError write_error;
   uint64_t bytes_written = 0;
 
@@ -137,7 +54,7 @@ void WriteMemoryRequestHandler::operator()(
     // 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) {
+    if (!args.allowPartial.value_or(false)) {
       // Start checking from the initial write address.
       lldb::addr_t start_address = address;
       // Compute the end of the write range.
@@ -153,10 +70,9 @@ void WriteMemoryRequestHandler::operator()(
         // 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;
+          return llvm::make_error<DAPError>(
+              "Memory 0x" + llvm::utohexstr(args.memoryReference) +
+              " region is not writable");
         }
         // If the current region covers the full requested range, stop futher
         // iterations.
@@ -174,15 +90,11 @@ void WriteMemoryRequestHandler::operator()(
   }
 
   if (bytes_written == 0) {
-    dap.SendErrorResponse(response, write_error.GetCString());
-    return;
+    return llvm::make_error<DAPError>(write_error.GetCString());
   }
-
-  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)));
+  protocol::WriteMemoryResponseBody response;
+  response.bytesWritten = bytes_written;
+  return response;
 }
 
 } // namespace lldb_dap
diff --git a/lldb/tools/lldb-dap/Protocol/ProtocolRequests.cpp b/lldb/tools/lldb-dap/Protocol/ProtocolRequests.cpp
@@ -517,4 +517,37 @@ json::Value toJSON(const ReadMemoryResponseBody &RMR) {
   return result;
 }
 
+bool fromJSON(const json::Value &Params, WriteMemoryArguments &WMA,
+              json::Path P) {
+  json::ObjectMapper O(Params, P);
+
+  const json::Object *wma_obj = Params.getAsObject();
+  constexpr llvm::StringRef ref_key = "memoryReference";
+  const std::optional<llvm::StringRef> memory_ref = wma_obj->getString(ref_key);
+  if (!memory_ref) {
+    P.field(ref_key).report("missing value");
+    return false;
+  }
+
+  const std::optional<lldb::addr_t> addr_opt =
+      DecodeMemoryReference(*memory_ref);
+  if (!addr_opt) {
+    P.field(ref_key).report("Malformed memory reference");
+    return false;
+  }
+
+  WMA.memoryReference = *addr_opt;
+
+  return O && O.mapOptional("allowPartial", WMA.allowPartial) &&
+         O.mapOptional("offset", WMA.offset) && O.map("data", WMA.data);
+}
+
+json::Value toJSON(const WriteMemoryResponseBody &WMR) {
+  json::Object result;
+
+  if (WMR.bytesWritten != 0)
+    result.insert({"bytesWritten", WMR.bytesWritten});
+  return result;
+}
+
 } // namespace lldb_dap::protocol
diff --git a/lldb/tools/lldb-dap/Protocol/ProtocolRequests.h b/lldb/tools/lldb-dap/Protocol/ProtocolRequests.h
@@ -875,6 +875,38 @@ struct ReadMemoryResponseBody {
 };
 llvm::json::Value toJSON(const ReadMemoryResponseBody &);
 
+/// Arguments for `writeMemory` request.
+struct WriteMemoryArguments {
+  /// Memory reference to the base location to which data should be written.
+  lldb::addr_t memoryReference;
+
+  /// Offset (in bytes) to be applied to the reference location before writing
+  /// data. Can be negative.
+  std::optional<int64_t> offset;
+
+  /// 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.
+  /// If false or missing, a debug adapter should attempt to verify the region
+  /// is writable before writing, and fail the response if it is not.
+  std::optional<bool> allowPartial;
+
+  /// Bytes to write, encoded using base64.
+  std::string data;
+};
+bool fromJSON(const llvm::json::Value &, WriteMemoryArguments &,
+              llvm::json::Path);
+
+/// Response to writeMemory request.
+struct WriteMemoryResponseBody {
+  /// Property that should be returned when `allowPartial` is true to indicate
+  /// the number of bytes starting from address that were successfully written.
+  uint64_t bytesWritten = 0;
+};
+llvm::json::Value toJSON(const WriteMemoryResponseBody &);
+
 } // namespace lldb_dap::protocol
 
 #endif
