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

Resolved review comments and added additional case in writeMemory test.

Author: santhoshe447

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

@@ -536,10 +536,14 @@ 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()
+        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
         )

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

@@ -131,8 +131,8 @@ def test_writeMemory(self):
         ptr_deref = self.dap_server.request_evaluate("not_a_ptr")["body"]
         memref = ptr_deref["memoryReference"]
 
-        # Write the Base64-encoded string "Mg==", which decodes to binary 0x32
-        # which is decimal 50 and corresponds to the ASCII character '2'.
+        # 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)
@@ -143,6 +143,19 @@ def test_writeMemory(self):
         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)

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

@@ -105,10 +105,8 @@ void WriteMemoryRequestHandler::operator()(
                                         memoryReference.str());
     return;
   }
-
-  lldb::addr_t address = *addr_opt;
-  lldb::addr_t address_offset =
-      address + GetInteger<uint64_t>(arguments, "offset").value_or(0);
+  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()) {
@@ -133,27 +131,32 @@ void WriteMemoryRequestHandler::operator()(
   lldb::SBError write_error;
   uint64_t bytes_written = 0;
 
-  // Write the memory
+  // 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 (allowPartial == false) {
-
+    if (!allowPartial) {
+      // Compute the end of the write range.
+      lldb::addr_t end_address = address + output.size();
+      // 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(address_offset, region_info);
-      if (!error.Success() || !region_info.IsWritable()) {
-        dap.SendErrorResponse(response, "Memory 0x" +
-                                            llvm::utohexstr(address_offset) +
+      lldb::SBError error = process.GetMemoryRegionInfo(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() ||
+          end_address > region_info.GetRegionEnd()) {
+        dap.SendErrorResponse(response, "Memory 0x" + llvm::utohexstr(address) +
                                             " region is not writable");
         return;
       }
     }
 
     bytes_written =
-        process.WriteMemory(address_offset, static_cast<void *>(output.data()),
+        process.WriteMemory(address, static_cast<void *>(output.data()),
                             output.size(), write_error);
   }