lldb fix ARM64 register access - llgs side

[pawelo]

Summary

This solves problem described in D5232, for llgs this time.

[tfiala]

LGTM. (I'm ignoring the nit on sizeof optional parens bit we talked about
before).

Patch up here:

svn commit
Sending source/Plugins/Process/Linux/NativeProcessLinux.cpp
Transmitting file data .
Committed revision 217788.

Thanks!

-Todd

source/Plugins/Process/Linux/NativeProcessLinux.cpp

 // C Includes
 #include <errno.h>
 #include <poll.h>
 #include <string.h>
 #include <stdint.h>
 #include <unistd.h>
 #include <linux/unistd.h>
 #include <sys/personality.h>
+#include <sys/procfs.h>
 #include <sys/ptrace.h>
 #include <sys/uio.h>
 #include <sys/socket.h>
 #include <sys/syscall.h>
 #include <sys/types.h>
 #include <sys/user.h>
 #include <sys/wait.h>
 
private:
         const char *m_reg_name;
         RegisterValue &m_value;
         bool &m_result;
     };
 
     void
     ReadRegOperation::Execute(NativeProcessLinux *monitor)
     {
+#if defined (__arm64__) || defined (__aarch64__)
+        if (m_offset > sizeof(struct user_pt_regs))
+        {
+            uintptr_t offset = m_offset - sizeof(struct user_pt_regs);
+            if (offset > sizeof(struct user_fpsimd_state))
+            {
+                m_result = false;
+            }
+            else
+            {
+                elf_fpregset_t regs;
+                int regset = NT_FPREGSET;
+                struct iovec ioVec;
+
+                ioVec.iov_base = &regs;
+                ioVec.iov_len = sizeof regs;
+                if (PTRACE(PTRACE_GETREGSET, m_tid, &regset, &ioVec, sizeof regs) < 0)
+                    m_result = false;
+                else
+                {
+                    lldb_private::ArchSpec arch;
+                    if (monitor->GetArchitecture(arch))
+                    {
+                        m_result = true;
+                        m_value.SetBytes((void *)(((unsigned char *)(&regs)) + offset), 16, arch.GetByteOrder());
+                    }
+                    else
+                        m_result = false;
+                }
+            }
+        }
+        else
+        {
+            elf_gregset_t regs;
+            int regset = NT_PRSTATUS;
+            struct iovec ioVec;
+
+            ioVec.iov_base = &regs;
+            ioVec.iov_len = sizeof regs;
+            if (PTRACE(PTRACE_GETREGSET, m_tid, &regset, &ioVec, sizeof regs) < 0)
+                m_result = false;
+            else
+            {
+                lldb_private::ArchSpec arch;
+                if (monitor->GetArchitecture(arch))
+                {
+                    m_result = true;
+                    m_value.SetBytes((void *)(((unsigned char *)(regs)) + m_offset), 8, arch.GetByteOrder());
+                } else
+                    m_result = false;
+            }
+        }
+#else
         Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_REGISTERS));
 
         // Set errno to zero so that we can detect a failed peek.
         errno = 0;
         lldb::addr_t data = PTRACE(PTRACE_PEEKUSER, m_tid, (void*)m_offset, NULL, 0);
         if (errno)
             m_result = false;
         else
         {
             m_value = data;
             m_result = true;
         }
         if (log)
             log->Printf ("NativeProcessLinux::%s() reg %s: 0x%" PRIx64, __FUNCTION__,
                     m_reg_name, data);
+#endif
     }
 
     //------------------------------------------------------------------------------
     /// @class WriteRegOperation
     /// @brief Implements NativeProcessLinux::WriteRegisterValue.
     class WriteRegOperation : public Operation
     {
     public:
private:
         const char *m_reg_name;
         const RegisterValue &m_value;
         bool &m_result;
     };
 
     void
     WriteRegOperation::Execute(NativeProcessLinux *monitor)
     {
+#if defined (__arm64__) || defined (__aarch64__)
+        if (m_offset > sizeof(struct user_pt_regs))
+        {
+            uintptr_t offset = m_offset - sizeof(struct user_pt_regs);
+            if (offset > sizeof(struct user_fpsimd_state))
+            {
+                m_result = false;
+            }
+            else
+            {
+                elf_fpregset_t regs;
+                int regset = NT_FPREGSET;
+                struct iovec ioVec;
+
+                ioVec.iov_base = &regs;
+                ioVec.iov_len = sizeof regs;
+                if (PTRACE(PTRACE_GETREGSET, m_tid, &regset, &ioVec, sizeof regs) < 0)
+                    m_result = false;
+                else
+                {
+                    ::memcpy((void *)(((unsigned char *)(&regs)) + offset), m_value.GetBytes(), 16);
+                    if (PTRACE(PTRACE_SETREGSET, m_tid, &regset, &ioVec, sizeof regs) < 0)
+                        m_result = false;
+                    else
+                        m_result = true;
+                }
+            }
+        }
+        else
+        {
+            elf_gregset_t regs;
+            int regset = NT_PRSTATUS;
+            struct iovec ioVec;
+
+            ioVec.iov_base = &regs;
+            ioVec.iov_len = sizeof regs;
+            if (PTRACE(PTRACE_GETREGSET, m_tid, &regset, &ioVec, sizeof regs) < 0)
+                m_result = false;
+            else
+            {
+                ::memcpy((void *)(((unsigned char *)(&regs)) + m_offset), m_value.GetBytes(), 8);
+                if (PTRACE(PTRACE_SETREGSET, m_tid, &regset, &ioVec, sizeof regs) < 0)
+                    m_result = false;
+                else
+                    m_result = true;
+            }
+        }
+#else
         void* buf;
         Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_REGISTERS));
 
         buf = (void*) m_value.GetAsUInt64();
 
         if (log)
             log->Printf ("NativeProcessLinux::%s() reg %s: %p", __FUNCTION__, m_reg_name, buf);
         if (PTRACE(PTRACE_POKEUSER, m_tid, (void*)m_offset, buf, 0))
             m_result = false;
         else
             m_result = true;
+#endif
     }
 
     //------------------------------------------------------------------------------
     /// @class ReadGPROperation
     /// @brief Implements NativeProcessLinux::ReadGPR.
     class ReadGPROperation : public Operation
     {
     public: