Add PowerPC FPR access to the process monitor

[jhibbits]

Summary

This adds reading and writing to the POSIX PowerPC ProcessMonitor.

[emaste]

Would you mind reuploading with context (e.g. -U999999 if generating a diff and uploading through the web interface)?

[jhibbits]

Diff with full context.

[emaste]

source/Plugins/Process/POSIX/RegisterContextPOSIXProcessMonitor_powerpc.cpp

149 ↗

(On Diff #19108)

double-check spaces vs tabs here

174–175 ↗

(On Diff #19108)

Minor style point, I think it's better to have braces on all branches if any do.

lldb/trunk/source/Plugins/Process/POSIX/RegisterContextPOSIXProcessMonitor_powerpc.cpp

RegisterContextPOSIXProcessMonitor_powerpc::GetMonitor()
     ProcessSP base = CalculateProcess();
     ProcessPOSIX *process = static_cast<ProcessPOSIX*>(base.get());
     return process->GetMonitor();
 }
 
 bool
 RegisterContextPOSIXProcessMonitor_powerpc::ReadGPR()
 {
-     ProcessMonitor &monitor = GetMonitor();
-     return monitor.ReadGPR(m_thread.GetID(), &m_gpr_powerpc, GetGPRSize());
 }
 
 bool
 RegisterContextPOSIXProcessMonitor_powerpc::ReadFPR()
 {
-    // XXX not yet implemented
-    return false;
+    ProcessMonitor &monitor = GetMonitor();
+    return monitor.ReadFPR(m_thread.GetID(), &m_fpr_powerpc, sizeof(m_fpr_powerpc));
 }
 
 bool
 RegisterContextPOSIXProcessMonitor_powerpc::WriteGPR()
 {
     ProcessMonitor &monitor = GetMonitor();
     return monitor.WriteGPR(m_thread.GetID(), &m_gpr_powerpc, GetGPRSize());
 }
 
 bool
 RegisterContextPOSIXProcessMonitor_powerpc::WriteFPR()
 {
-    // XXX not yet implemented
-    return false;
+    ProcessMonitor &monitor = GetMonitor();
+    return monitor.WriteFPR(m_thread.GetID(), &m_fpr_powerpc, sizeof(m_fpr_powerpc));
 }
 
 bool
 RegisterContextPOSIXProcessMonitor_powerpc::ReadRegister(const unsigned reg,
                                                         RegisterValue &value)
 {
     ProcessMonitor &monitor = GetMonitor();
     return monitor.ReadRegisterValue(m_thread.GetID(),
if (!reg_info)
         return false;
 
     const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 
     if (IsFPR(reg))
     {
         if (!ReadFPR())
             return false;
+        uint8_t *src = (uint8_t *)&m_fpr_powerpc + reg_info->byte_offset;
+        value.SetUInt64(*(uint64_t*)src);
     }
-    else
+    else if (IsGPR(reg))
     {
-        uint32_t full_reg = reg;
-        bool is_subreg = reg_info->invalidate_regs && (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM);
-
-        if (is_subreg)
-        {
-            // Read the full aligned 64-bit register.
-            full_reg = reg_info->invalidate_regs[0];
-        }
-
-        bool success = ReadRegister(full_reg, value);
+        bool success = ReadRegister(reg, value);
 
         if (success)
         {
-            // If our read was not aligned (for ah,bh,ch,dh), shift our returned value one byte to the right.
-            if (is_subreg && (reg_info->byte_offset & 0x1))
-                value.SetUInt64(value.GetAsUInt64() >> 8);
-
             // If our return byte size was greater than the return value reg size, then
             // use the type specified by reg_info rather than the uint64_t default
             if (value.GetByteSize() > reg_info->byte_size)
                 value.SetType(reg_info);
         }
         return success;
     }
 
     return false;
 }
 
 bool
 RegisterContextPOSIXProcessMonitor_powerpc::WriteRegister(const RegisterInfo *reg_info, const RegisterValue &value)
 {
     const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 
     if (IsGPR(reg))
+    {
         return WriteRegister(reg, value);
+    }
+    else if (IsFPR(reg))
+    {
+        assert (reg_info->byte_offset < sizeof(m_fpr_powerpc));
+        uint8_t *dst = (uint8_t *)&m_fpr_powerpc + reg_info->byte_offset;
+        *(uint64_t *)dst = value.GetAsUInt64();
+        return WriteFPR();
+    }
 
     return false;
 }
 
 bool
 RegisterContextPOSIXProcessMonitor_powerpc::ReadAllRegisterValues(DataBufferSP &data_sp)
 {
     bool success = false;
if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE)
         uint8_t *src = data_sp->GetBytes();
         if (src)
         {
             ::memcpy (&m_gpr_powerpc, src, GetGPRSize());
 
             if (WriteGPR())
             {
                 src += GetGPRSize();
+                ::memcpy (&m_fpr_powerpc, src, sizeof(m_fpr_powerpc));
+
+                success = WriteFPR();
             }
         }
     }
     return success;
 }
 
 uint32_t
 RegisterContextPOSIXProcessMonitor_powerpc::SetHardwareWatchpoint(addr_t addr, size_t size,

lldb/trunk/source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.h

public:
     const char *
     GetRegisterName(unsigned reg);
 
     uint32_t
     ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num);
 
 protected:
     uint64_t m_gpr_powerpc[k_num_gpr_registers_powerpc];         // general purpose registers.
+    uint64_t m_fpr_powerpc[k_num_fpr_registers_powerpc];         // floating point registers.
     std::unique_ptr<lldb_private::RegisterInfoInterface> m_register_info_ap; // Register Info Interface (FreeBSD or Linux)
 
     // Determines if an extended register set is supported on the processor running the inferior process.
     virtual bool
     IsRegisterSetAvailable(size_t set_index);
 
     virtual const lldb_private::RegisterInfo *
     GetRegisterInfo();