contrib/llvm/tools/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_powerpc.cpp

   1 //===-- RegisterContextPOSIXProcessMonitor_powerpc.h ------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===---------------------------------------------------------------------===//
   9
  10 #include "lldb/Core/DataBufferHeap.h"
  11 #include "lldb/Core/RegisterValue.h"
  12 #include "lldb/Target/Thread.h"
  13
  14 #include "RegisterContextPOSIX_powerpc.h"
  15 #include "ProcessFreeBSD.h"
  16 #include "RegisterContextPOSIXProcessMonitor_powerpc.h"
  17 #include "ProcessMonitor.h"
  18
  19 using namespace lldb_private;
  20 using namespace lldb;
  21
  22 #define REG_CONTEXT_SIZE (GetGPRSize())
  23
  24 RegisterContextPOSIXProcessMonitor_powerpc::RegisterContextPOSIXProcessMonitor_powerpc(Thread &thread,
  25                                                                                      uint32_t concrete_frame_idx,
  26                                                                                      lldb_private::RegisterInfoInterface *register_info)
  27     : RegisterContextPOSIX_powerpc(thread, concrete_frame_idx, register_info)
  28 {
  29 }
  30
  31 ProcessMonitor &
  32 RegisterContextPOSIXProcessMonitor_powerpc::GetMonitor()
  33 {
  34     ProcessSP base = CalculateProcess();
  35     ProcessFreeBSD *process = static_cast<ProcessFreeBSD*>(base.get());
  36     return process->GetMonitor();
  37 }
  38
  39 bool
  40 RegisterContextPOSIXProcessMonitor_powerpc::ReadGPR()
  41 {
  42     ProcessMonitor &monitor = GetMonitor();
  43     return monitor.ReadGPR(m_thread.GetID(), &m_gpr_powerpc, GetGPRSize());
  44 }
  45
  46 bool
  47 RegisterContextPOSIXProcessMonitor_powerpc::ReadFPR()
  48 {
  49     ProcessMonitor &monitor = GetMonitor();
  50     return monitor.ReadFPR(m_thread.GetID(), &m_fpr_powerpc, sizeof(m_fpr_powerpc));
  51 }
  52
  53 bool
  54 RegisterContextPOSIXProcessMonitor_powerpc::ReadVMX()
  55 {
  56     // XXX: Need a way to read/write process VMX registers with ptrace.
  57     return false;
  58 }
  59
  60 bool
  61 RegisterContextPOSIXProcessMonitor_powerpc::WriteGPR()
  62 {
  63     ProcessMonitor &monitor = GetMonitor();
  64     return monitor.WriteGPR(m_thread.GetID(), &m_gpr_powerpc, GetGPRSize());
  65 }
  66
  67 bool
  68 RegisterContextPOSIXProcessMonitor_powerpc::WriteFPR()
  69 {
  70     ProcessMonitor &monitor = GetMonitor();
  71     return monitor.WriteFPR(m_thread.GetID(), &m_fpr_powerpc, sizeof(m_fpr_powerpc));
  72 }
  73
  74 bool
  75 RegisterContextPOSIXProcessMonitor_powerpc::WriteVMX()
  76 {
  77     // XXX: Need a way to read/write process VMX registers with ptrace.
  78     return false;
  79 }
  80
  81 bool
  82 RegisterContextPOSIXProcessMonitor_powerpc::ReadRegister(const unsigned reg,
  83                                                         RegisterValue &value)
  84 {
  85     ProcessMonitor &monitor = GetMonitor();
  86     return monitor.ReadRegisterValue(m_thread.GetID(),
  87                                      GetRegisterOffset(reg),
  88                                      GetRegisterName(reg),
  89                                      GetRegisterSize(reg),
  90                                      value);
  91 }
  92
  93 bool
  94 RegisterContextPOSIXProcessMonitor_powerpc::WriteRegister(const unsigned reg,
  95                                                          const RegisterValue &value)
  96 {
  97     unsigned reg_to_write = reg;
  98     RegisterValue value_to_write = value;
  99
 100     // Check if this is a subregister of a full register.
 101     const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
 102     if (reg_info->invalidate_regs && (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM))
 103     {
 104         RegisterValue full_value;
 105         uint32_t full_reg = reg_info->invalidate_regs[0];
 106         const RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg);
 107
 108         // Read the full register.
 109         if (ReadRegister(full_reg_info, full_value))
 110         {
 111             Error error;
 112             ByteOrder byte_order = GetByteOrder();
 113             uint8_t dst[RegisterValue::kMaxRegisterByteSize];
 114
 115             // Get the bytes for the full register.
 116             const uint32_t dest_size = full_value.GetAsMemoryData (full_reg_info,
 117                                                                    dst,
 118                                                                    sizeof(dst),
 119                                                                    byte_order,
 120                                                                    error);
 121             if (error.Success() && dest_size)
 122             {
 123                 uint8_t src[RegisterValue::kMaxRegisterByteSize];
 124
 125                 // Get the bytes for the source data.
 126                 const uint32_t src_size = value.GetAsMemoryData (reg_info, src, sizeof(src), byte_order, error);
 127                 if (error.Success() && src_size && (src_size < dest_size))
 128                 {
 129                     // Copy the src bytes to the destination.
 130                     memcpy (dst + (reg_info->byte_offset & 0x1), src, src_size);
 131                     // Set this full register as the value to write.
 132                     value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order);
 133                     value_to_write.SetType(full_reg_info);
 134                     reg_to_write = full_reg;
 135                 }
 136             }
 137         }
 138     }
 139
 140     ProcessMonitor &monitor = GetMonitor();
 141     // Account for the fact that 32-bit targets on powerpc64 really use 64-bit
 142     // registers in ptrace, but expose here 32-bit registers with a higher
 143     // offset.
 144     uint64_t offset = GetRegisterOffset(reg_to_write);
 145     offset &= ~(sizeof(uintptr_t) - 1);
 146     return monitor.WriteRegisterValue(m_thread.GetID(),
 147                                       offset,
 148                                       GetRegisterName(reg_to_write),
 149                                       value_to_write);
 150 }
 151
 152 bool
 153 RegisterContextPOSIXProcessMonitor_powerpc::ReadRegister(const RegisterInfo *reg_info, RegisterValue &value)
 154 {
 155     if (!reg_info)
 156         return false;
 157
 158     const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 159
 160     if (IsFPR(reg))
 161     {
 162         if (!ReadFPR())
 163             return false;
 164         uint8_t *src = (uint8_t *)&m_fpr_powerpc + reg_info->byte_offset;
 165         value.SetUInt64(*(uint64_t*)src);
 166     }
 167     else if (IsGPR(reg))
 168     {
 169         bool success = ReadRegister(reg, value);
 170
 171         if (success)
 172         {
 173             // If our return byte size was greater than the return value reg size, then
 174             // use the type specified by reg_info rather than the uint64_t default
 175             if (value.GetByteSize() > reg_info->byte_size)
 176                 value.SetType(reg_info);
 177         }
 178         return success;
 179     }
 180
 181     return false;
 182 }
 183
 184 bool
 185 RegisterContextPOSIXProcessMonitor_powerpc::WriteRegister(const RegisterInfo *reg_info, const RegisterValue &value)
 186 {
 187     const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 188
 189     if (IsGPR(reg))
 190     {
 191         return WriteRegister(reg, value);
 192     }
 193     else if (IsFPR(reg))
 194     {
 195         assert (reg_info->byte_offset < sizeof(m_fpr_powerpc));
 196         uint8_t *dst = (uint8_t *)&m_fpr_powerpc + reg_info->byte_offset;
 197         *(uint64_t *)dst = value.GetAsUInt64();
 198         return WriteFPR();
 199     }
 200
 201     return false;
 202 }
 203
 204 bool
 205 RegisterContextPOSIXProcessMonitor_powerpc::ReadAllRegisterValues(DataBufferSP &data_sp)
 206 {
 207     bool success = false;
 208     data_sp.reset (new DataBufferHeap (REG_CONTEXT_SIZE, 0));
 209     if (data_sp && ReadGPR () && ReadFPR ())
 210     {
 211         uint8_t *dst = data_sp->GetBytes();
 212         success = dst != 0;
 213
 214         if (success)
 215         {
 216             ::memcpy (dst, &m_gpr_powerpc, GetGPRSize());
 217             dst += GetGPRSize();
 218         }
 219     }
 220     return success;
 221 }
 222
 223 bool
 224 RegisterContextPOSIXProcessMonitor_powerpc::WriteAllRegisterValues(const DataBufferSP &data_sp)
 225 {
 226     bool success = false;
 227     if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE)
 228     {
 229         uint8_t *src = data_sp->GetBytes();
 230         if (src)
 231         {
 232             ::memcpy (&m_gpr_powerpc, src, GetGPRSize());
 233
 234             if (WriteGPR())
 235             {
 236                 src += GetGPRSize();
 237                 ::memcpy (&m_fpr_powerpc, src, sizeof(m_fpr_powerpc));
 238
 239                 success = WriteFPR();
 240             }
 241         }
 242     }
 243     return success;
 244 }
 245
 246 uint32_t
 247 RegisterContextPOSIXProcessMonitor_powerpc::SetHardwareWatchpoint(addr_t addr, size_t size,
 248                                               bool read, bool write)
 249 {
 250     const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
 251     uint32_t hw_index;
 252
 253     for (hw_index = 0; hw_index < num_hw_watchpoints; ++hw_index)
 254     {
 255         if (IsWatchpointVacant(hw_index))
 256             return SetHardwareWatchpointWithIndex(addr, size,
 257                                                   read, write,
 258                                                   hw_index);
 259     }
 260
 261     return LLDB_INVALID_INDEX32;
 262 }
 263
 264 bool
 265 RegisterContextPOSIXProcessMonitor_powerpc::ClearHardwareWatchpoint(uint32_t hw_index)
 266 {
 267     return false;
 268 }
 269
 270 bool
 271 RegisterContextPOSIXProcessMonitor_powerpc::HardwareSingleStep(bool enable)
 272 {
 273     return false;
 274 }
 275
 276 bool
 277 RegisterContextPOSIXProcessMonitor_powerpc::UpdateAfterBreakpoint()
 278 {
 279     lldb::addr_t pc;
 280
 281     if ((pc = GetPC()) == LLDB_INVALID_ADDRESS)
 282         return false;
 283
 284     return true;
 285 }
 286
 287 unsigned
 288 RegisterContextPOSIXProcessMonitor_powerpc::GetRegisterIndexFromOffset(unsigned offset)
 289 {
 290     unsigned reg;
 291     for (reg = 0; reg < k_num_registers_powerpc; reg++)
 292     {
 293         if (GetRegisterInfo()[reg].byte_offset == offset)
 294             break;
 295     }
 296     assert(reg < k_num_registers_powerpc && "Invalid register offset.");
 297     return reg;
 298 }
 299
 300 bool
 301 RegisterContextPOSIXProcessMonitor_powerpc::IsWatchpointHit(uint32_t hw_index)
 302 {
 303     return false;
 304 }
 305
 306 bool
 307 RegisterContextPOSIXProcessMonitor_powerpc::ClearWatchpointHits()
 308 {
 309     return false;
 310 }
 311
 312 addr_t
 313 RegisterContextPOSIXProcessMonitor_powerpc::GetWatchpointAddress(uint32_t hw_index)
 314 {
 315     return LLDB_INVALID_ADDRESS;
 316 }
 317
 318 bool
 319 RegisterContextPOSIXProcessMonitor_powerpc::IsWatchpointVacant(uint32_t hw_index)
 320 {
 321     return false;
 322 }
 323
 324 bool
 325 RegisterContextPOSIXProcessMonitor_powerpc::SetHardwareWatchpointWithIndex(addr_t addr, size_t size,
 326                                                        bool read, bool write,
 327                                                        uint32_t hw_index)
 328 {
 329     return false;
 330 }
 331
 332 uint32_t
 333 RegisterContextPOSIXProcessMonitor_powerpc::NumSupportedHardwareWatchpoints()
 334 {
 335     return 0;
 336 }
 337