[lldb] [gdb-remote client] Avoid zero padding PID/TID in H packet

[mgorny]

Summary

Change SetCurrentThread*() logic not to include the zero padding
in PID/TID that was a side effect of 02ef0f5ab483. This should fix
problems caused by sending 64-bit integers to 32-bit servers. Reported
by Ted Woodward.

[ted]

LGTM. Thanks Michał!

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

 llvm::Optional<PidTid>
 GDBRemoteCommunicationClient::SendSetCurrentThreadPacket(uint64_t tid,
                                                          uint64_t pid,
                                                          char op) {
   lldb_private::StreamString packet;
   packet.PutChar('H');
   packet.PutChar(op);
 
-  if (pid != LLDB_INVALID_PROCESS_ID) {
-    packet.PutChar('p');
-    packet.PutHex64(pid);
-    packet.PutChar('.');
-  }
+  if (pid != LLDB_INVALID_PROCESS_ID)
+    packet.Printf("p%" PRIx64 ".", pid);
 
   if (tid == UINT64_MAX)
     packet.PutCString("-1");
   else
-    packet.PutHex64(tid);
+    packet.Printf("%" PRIx64, tid);
 
   StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse(packet.GetString(), response) 
       == PacketResult::Success) {
     if (response.IsOKResponse())
       return {{pid, tid}};
 
     /*

lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

 TEST_F(GDBRemoteCommunicationClientTest, WriteRegisterNoSuffix) {
   const lldb::tid_t tid = 0x47;
   const uint32_t reg_num = 4;
   std::future<bool> write_result = std::async(std::launch::async, [&] {
     return client.WriteRegister(tid, reg_num, one_register);
   });
 
   Handle_QThreadSuffixSupported(server, false);
-  HandlePacket(server, "Hg0000000000000047", "OK");
+  HandlePacket(server, "Hg47", "OK");
   HandlePacket(server, "P4=" + one_register_hex, "OK");
   ASSERT_TRUE(write_result.get());
 
   write_result = std::async(std::launch::async, [&] {
     return client.WriteAllRegisters(tid, all_registers);
   });
 
   HandlePacket(server, "G" + all_registers_hex, "OK");

 
 TEST_F(GDBRemoteCommunicationClientTest, SaveRestoreRegistersNoSuffix) {
   const lldb::tid_t tid = 0x47;
   uint32_t save_id;
   std::future<bool> async_result = std::async(std::launch::async, [&] {
     return client.SaveRegisterState(tid, save_id);
   });
   Handle_QThreadSuffixSupported(server, false);
-  HandlePacket(server, "Hg0000000000000047", "OK");
+  HandlePacket(server, "Hg47", "OK");
   HandlePacket(server, "QSaveRegisterState", "1");
   ASSERT_TRUE(async_result.get());
   EXPECT_EQ(1u, save_id);
 
   async_result = std::async(std::launch::async, [&] {
     return client.RestoreRegisterState(tid, save_id);
   });
   HandlePacket(server, "QRestoreRegisterState:1", "OK");