Use Process Plugin register indices when communicating with remote

[fjricci]

Summary

eRegisterKindProcessPlugin is used to store the register
indices used by the remote, and eRegisterKindLLDB is used
to store the internal lldb register indices. However, we're currently
using the lldb indices instead of the process plugin indices
when sending p/P packets. This will break if the remote uses
non-contiguous register indices.

[jasonmolenda]

This looks good to me. Do you think the ReadRegister decl in GDBRemoteCommunicationClient.h should have a comment noting that the reg_num is a number in the remote register numbering scheme (eRegisterKindProcessPlugin)? When lldb passes around register numbers internally, it is usually assuming the eRegisterKindLLDB register numbering convention.

(to be honest, I think we should have come up with a RegisterNumber class from the start - the presence of raw register numbers, with side knowledge about what register encoding should be used, makes it easy for mistakes to creep in.)

[clayborg]

Looks good. As to Jason's comment about a register number class: I wanted RegisterContext classes to be able to statically initialize an array or RegisterInfo structs without having to call C++ constructors. That is the main reason the register numbers are just an array.

[fjricci]

I can add a comment to the ReadRegister decl.

Alternatively, if you think it would be preferable, I could change the parameter name from reg_num to something more descriptive, like remote_reg_num or plugin_reg_num.

Or I could change ReadRegister to take a RegisterInfo instead of a register number, and that way it could select the appropriate ProcessPlugin regnum on its own, right when it generates the packet. This method actually might be most consistent with the rest of the changes in the patch.

[fjricci]

Committed with comment added to ReadRegister declaration to specify that the argument is an eRegisterKindProcessPlugin register number

source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp

GDBRemoteRegisterContext::PrivateSetRegisterValue (uint32_t reg, uint64_t new_reg_val)
     return false;
 }
 
 // Helper function for GDBRemoteRegisterContext::ReadRegisterBytes().
 bool
 GDBRemoteRegisterContext::GetPrimordialRegister(const RegisterInfo *reg_info,
                                                 GDBRemoteCommunicationClient &gdb_comm)
 {
-    const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
+    const uint32_t lldb_reg = reg_info->kinds[eRegisterKindLLDB];
+    const uint32_t remote_reg = reg_info->kinds[eRegisterKindProcessPlugin];
     StringExtractorGDBRemote response;
-    if (gdb_comm.ReadRegister(m_thread.GetProtocolID(), reg, response))
-        return PrivateSetRegisterValue (reg, response);
+    if (gdb_comm.ReadRegister(m_thread.GetProtocolID(), remote_reg, response))
+        return PrivateSetRegisterValue (lldb_reg, response);
     return false;
 }
 
 bool
 GDBRemoteRegisterContext::ReadRegisterBytes (const RegisterInfo *reg_info, DataExtractor &data)
 {
     ExecutionContext exe_ctx (CalculateThread());
 

 // Helper function for GDBRemoteRegisterContext::WriteRegisterBytes().
 bool
 GDBRemoteRegisterContext::SetPrimordialRegister(const RegisterInfo *reg_info,
                                                 GDBRemoteCommunicationClient &gdb_comm)
 {
     StreamString packet;
     StringExtractorGDBRemote response;
     const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
-    packet.Printf ("P%x=", reg);
+    packet.Printf ("P%x=", reg_info->kinds[eRegisterKindProcessPlugin]);
     packet.PutBytesAsRawHex8 (m_reg_data.PeekData(reg_info->byte_offset, reg_info->byte_size),
                               reg_info->byte_size,
                               endian::InlHostByteOrder(),
                               endian::InlHostByteOrder());
 
     if (gdb_comm.GetThreadSuffixSupported())
         packet.Printf (";thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
 
if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence mutex for write all registers."))
                             // if we are going to be doing registers individually.
                             bool write_reg = true;
                             const uint32_t reg_byte_size = reg_info->byte_size;
     
                             const char *restore_src = (const char *)restore_data.PeekData(register_offset, reg_byte_size);
                             if (restore_src)
                             {
                                 StreamString packet;
-                                packet.Printf ("P%x=", reg);
+                                packet.Printf ("P%x=", reg_info->kinds[eRegisterKindProcessPlugin]);
                                 packet.PutBytesAsRawHex8 (restore_src,
                                                           reg_byte_size,
                                                           endian::InlHostByteOrder(),
                                                           endian::InlHostByteOrder());
 
                                 if (thread_suffix_supported)
                                     packet.Printf (";thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
 
                                 SetRegisterIsValid(reg, false);
                                 if (gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(),
                                                                           packet.GetString().size(),
                                                                           response,
                                                                           false) == GDBRemoteCommunication::PacketResult::Success)
                                 {
                                     const char *current_src = (const char *)m_reg_data.PeekData(register_offset, reg_byte_size);
                                     if (current_src)
                                         write_reg = memcmp (current_src, restore_src, reg_byte_size) != 0;
                                 }
     
                                 if (write_reg)
                                 {
                                     StreamString packet;
-                                    packet.Printf ("P%x=", reg);
+                                    packet.Printf ("P%x=", reg_info->kinds[eRegisterKindProcessPlugin]);
                                     packet.PutBytesAsRawHex8 (restore_src,
                                                               reg_byte_size,
                                                               endian::InlHostByteOrder(),
                                                               endian::InlHostByteOrder());
     
                                     if (thread_suffix_supported)
                                         packet.Printf (";thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
     
if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence mutex for write all registers."))
                     // work around a bug in an older version of debugserver that would lead to
                     // register context corruption when writing fpsr/fpcr.
                     if (arm64_debugserver &&
                         (strcmp (reg_info->name, "fpsr") == 0 || strcmp (reg_info->name, "fpcr") == 0))
                     {
                         continue;
                     }
                     StreamString packet;
-                    packet.Printf ("P%x=", reg_info->kinds[eRegisterKindLLDB]);
+                    packet.Printf ("P%x=", reg_info->kinds[eRegisterKindProcessPlugin]);
                     packet.PutBytesAsRawHex8 (data_sp->GetBytes() + reg_info->byte_offset, reg_info->byte_size, endian::InlHostByteOrder(), endian::InlHostByteOrder());
                     if (thread_suffix_supported)
                         packet.Printf (";thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
 
                     SetRegisterIsValid(reg_info, false);
                     if (gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(),
                                                               packet.GetString().size(),
                                                               response,