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

Fixed review comments

Author: santhoshe447

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

@@ -734,7 +734,7 @@ def request_readMemory(self, memoryReference, offset, count):
         }
         return self.send_recv(command_dict)
 
-    def request_writeMemory(self, memoryReference, offset, data, allowPartial=True):
+    def request_writeMemory(self, memoryReference, data, offset=0, allowPartial=True):
         args_dict = {
             "memoryReference": memoryReference,
             "offset": offset,

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):
@@ -530,3 +531,11 @@ 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(data.to_bytes()).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

@@ -133,7 +133,7 @@ def test_writeMemory(self):
 
         # Write the Base64-encoded string "Mg==", which decodes to binary 0x32
         # which is decimal 50 and corresponds to the ASCII character '2'.
-        mem_response = self.dap_server.request_writeMemory(memref, 0, "Mg==")
+        mem_response = self.writeMemory(memref, 50, 0, True)
         self.assertEqual(mem_response["success"], True)
         self.assertEqual(mem_response["body"]["bytesWritten"], 1)
 
@@ -144,20 +144,28 @@ def test_writeMemory(self):
         self.assertEqual(mem_response["body"]["data"], "Mg==")
 
         # Memory write failed for 0x0.
-        mem_response = self.dap_server.request_writeMemory("0x0", 0, "Mg==")
+        mem_response = self.writeMemory("0x0", 50, 0, True)
         self.assertEqual(mem_response["success"], False)
 
         # Malformed memory reference.
-        mem_response = self.dap_server.request_writeMemory("12345", 0, "Mg==")
+        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.dap_server.request_writeMemory(memref, 0, "Mg==", False)
+        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",
+            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",
         )

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

@@ -113,23 +113,29 @@ void WriteMemoryRequestHandler::operator()(
       address + GetInteger<uint64_t>(arguments, "offset").value_or(0);
 
   llvm::StringRef data64 = GetString(arguments, "data").value_or("");
+  if (data64.empty()) {
+    response["success"] = false;
+    EmplaceSafeString(response, "message","Data cannot be empty value. Provide valid data");
+    dap.SendJSON(llvm::json::Value(std::move(response)));
+    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 decodeError = llvm::decodeBase64(data64, output);
+  auto decode_error = llvm::decodeBase64(data64, output);
 
-  if (decodeError) {
+  if (decode_error) {
     response["success"] = false;
-    EmplaceSafeString(response, "message",
-                      llvm::toString(std::move(decodeError)).c_str());
+    EmpleceSafeErrorMessage(dap, response, "message",
+                      llvm::toString(std::move(decode_error)).c_str());
     dap.SendJSON(llvm::json::Value(std::move(response)));
     return;
   }
 
   bool allowPartial = GetBoolean(arguments, "allowPartial").value_or(true);
-  lldb::SBError writeError;
+  lldb::SBError write_error;
   uint64_t bytes_written = 0;
 
   // Write the memory
@@ -155,12 +161,12 @@ void WriteMemoryRequestHandler::operator()(
 
     bytes_written =
         process.WriteMemory(address_offset, static_cast<void *>(output.data()),
-                            output.size(), writeError);
+                            output.size(), write_error);
   }
 
   if (bytes_written == 0) {
     response["success"] = false;
-    EmplaceSafeString(response, "message", writeError.GetCString());
+    EmplaceSafeString(response, "message", write_error.GetCString());
     dap.SendJSON(llvm::json::Value(std::move(response)));
     return;
   }