[lldb-server] Implement the G packet

[labath]

Summary

The packet is not used by lldb, but some clients can still end up using
it. For example, the Go debugger gets confused when we support g but not
G.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h

protected:
   PacketResult Handle_vStdio(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_vStopped(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_vCtrlC(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_g(StringExtractorGDBRemote &packet);
 
+  PacketResult Handle_G(StringExtractorGDBRemote &packet);
+
   PacketResult Handle_qMemTags(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_QMemTags(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_T(StringExtractorGDBRemote &packet);
 
   void SetCurrentThreadID(lldb::tid_t tid);
 

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_jLLDBTraceGetState,
       &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceGetState);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_jLLDBTraceGetBinaryData,
       &GDBRemoteCommunicationServerLLGS::Handle_jLLDBTraceGetBinaryData);
 
   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_g,
                                 &GDBRemoteCommunicationServerLLGS::Handle_g);
+  RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_G,
+                                &GDBRemoteCommunicationServerLLGS::Handle_G);
 
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_qMemTags,
       &GDBRemoteCommunicationServerLLGS::Handle_qMemTags);
 
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_QMemTags,
       &GDBRemoteCommunicationServerLLGS::Handle_QMemTags);

 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo(
     StringExtractorGDBRemote &packet) {
   // FIXME for now we return the full thread list in the initial packet and
   // always do nothing here.
   return SendPacketNoLock("l");
 }
 
+static size_t GetGPacketSize(NativeRegisterContext &ctx) {
+  size_t result = 0;
+  for (uint32_t idx = 0; idx < ctx.GetUserRegisterCount(); ++idx) {
+    const RegisterInfo *info = ctx.GetRegisterInfoAtIndex(idx);
+    assert(info != nullptr);
+    if (info->value_regs != nullptr)
+      continue; // skip registers that are contained in other registers
+    result = std::max<size_t>(result, info->byte_size + info->byte_offset);
+  }
+  return result;
+}
+
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_g(StringExtractorGDBRemote &packet) {
   Log *log = GetLog(LLDBLog::Thread);
 
   // Move past packet name.
   packet.SetFilePos(strlen("g"));
 
   // Get the thread to use.
   NativeThreadProtocol *thread = GetThreadFromSuffix(packet);
   if (!thread) {
     LLDB_LOG(log, "failed, no thread available");
     return SendErrorResponse(0x15);
   }
 
   // Get the thread's register context.
   NativeRegisterContext &reg_ctx = thread->GetRegisterContext();
 
-  std::vector<uint8_t> regs_buffer;
+  std::vector<uint8_t> regs_buffer(GetGPacketSize(reg_ctx), 0);
   for (uint32_t reg_num = 0; reg_num < reg_ctx.GetUserRegisterCount();
        ++reg_num) {
     const RegisterInfo *reg_info = reg_ctx.GetRegisterInfoAtIndex(reg_num);
-
-    if (reg_info == nullptr) {
-      LLDB_LOG(log, "failed to get register info for register index {0}",
-               reg_num);
-      return SendErrorResponse(0x15);
-    }
+    assert(reg_info);
 
     if (reg_info->value_regs != nullptr)
       continue; // skip registers that are contained in other registers
 
     RegisterValue reg_value;
     Status error = reg_ctx.ReadRegister(reg_info, reg_value);
     if (error.Fail()) {
       LLDB_LOG(log, "failed to read register at index {0}", reg_num);
       return SendErrorResponse(0x15);
     }
 
-    if (reg_info->byte_offset + reg_info->byte_size >= regs_buffer.size())
-      // Resize the buffer to guarantee it can store the register offsetted
-      // data.
-      regs_buffer.resize(reg_info->byte_offset + reg_info->byte_size);
-
     // Copy the register offsetted data to the buffer.
     memcpy(regs_buffer.data() + reg_info->byte_offset, reg_value.GetBytes(),
            reg_info->byte_size);
   }
 
   // Write the response.
   StreamGDBRemote response;
   response.PutBytesAsRawHex8(regs_buffer.data(), regs_buffer.size());
 
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServerLLGS::Handle_G(StringExtractorGDBRemote &packet) {
+  // Move past packet name.
+  packet.SetFilePos(strlen("G"));
+
+  std::vector<uint8_t> regs_buffer(packet.GetBytesLeft() / 2, 0);
+  regs_buffer.resize(packet.GetHexBytesAvail(regs_buffer));
+
+  // Get the thread to use.
+  NativeThreadProtocol *thread = GetThreadFromSuffix(packet);
+  if (!thread)
+    return SendErrorResponse(Status("No thread available"));
+
+  NativeRegisterContext &reg_ctx = thread->GetRegisterContext();
+
+  if (regs_buffer.size() != GetGPacketSize(reg_ctx))
+    return SendErrorResponse(Status("Unexpected packet size"));
+
+  for (uint32_t reg_num = 0; reg_num < reg_ctx.GetUserRegisterCount();
+       ++reg_num) {
+    const RegisterInfo *reg_info = reg_ctx.GetRegisterInfoAtIndex(reg_num);
+    assert(reg_info);
+
+    if (reg_info->value_regs != nullptr)
+      continue; // skip registers that are contained in other registers
+
+    RegisterValue reg_value;
+    Status error;
+    reg_value.SetFromMemoryData(
+        *reg_info, regs_buffer.data() + reg_info->byte_offset,
+        reg_info->byte_size,
+        m_current_process->GetArchitecture().GetByteOrder(), error);
+    if (error.Fail())
+      return SendErrorResponse(error);
+    error = reg_ctx.WriteRegister(reg_info, reg_value);
+    if (error.Fail())
+      return SendErrorResponse(error);
+  }
+
+  return SendOKResponse();
+}
+
+GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_p(StringExtractorGDBRemote &packet) {
   Log *log = GetLog(LLDBLog::Thread);
 
   // Parse out the register number from the request.
   packet.SetFilePos(strlen("p"));
   const uint32_t reg_index =
       packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
   if (reg_index == std::numeric_limits<uint32_t>::max()) {

lldb/test/API/tools/lldb-server/register-reading/TestGdbRemoteGPacket.py

for entry in textwrap.wrap(reg_slice, 2 * bytes_per_entry):
         reg_value.append("0x" + entry)
 
     return reg_value
 
 
 class TestGdbRemoteGPacket(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     @skipIfOutOfTreeDebugserver
-    @skipUnlessDarwin # G packet not supported
     def test_g_packet(self):
         self.build()
         self.prep_debug_monitor_and_inferior()
         self.test_sequence.add_log_lines(
             ["read packet: $g#67",
              {"direction": "send", "regex": r"^\$(.+)#[0-9a-fA-F]{2}$",
               "capture": {1: "register_bank"}}],
             True)
def g_returns_correct_data(self, with_suffix):
             ['0x525456585a5c5e51', '0x535557595b5d5f50'], get_reg_value('xmm13'))
         self.assertEqual(
             ['0x626466686a6c6e61', '0x636567696b6d6f60'], get_reg_value('xmm14'))
         self.assertEqual(
             ['0x727476787a7c7e71', '0x737577797b7d7f70'], get_reg_value('xmm15'))
 
     @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48420")
     @expectedFailureNetBSD
-    @skipIfDarwin # g packet not supported
     def test_g_returns_correct_data_with_suffix(self):
         self.build()
         self.set_inferior_startup_launch()
         self.g_returns_correct_data(True)
 
     @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48420")
     @expectedFailureNetBSD
-    @skipIfDarwin # g packet not supported
     def test_g_returns_correct_data_no_suffix(self):
         self.build()
         self.set_inferior_startup_launch()
         self.g_returns_correct_data(False)