source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_arm.cpp

   1 //===-- RegisterContextPOSIXProcessMonitor_arm.cpp -----------*- 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 "ProcessFreeBSD.h"
  15 #include "ProcessMonitor.h"
  16 #include "RegisterContextPOSIXProcessMonitor_arm.h"
  17 #include "RegisterContextPOSIX_arm.h"
  18
  19 using namespace lldb_private;
  20 using namespace lldb;
  21
  22 #define REG_CONTEXT_SIZE (GetGPRSize())
  23
  24 RegisterContextPOSIXProcessMonitor_arm::RegisterContextPOSIXProcessMonitor_arm(
  25     Thread &thread, uint32_t concrete_frame_idx,
  26     lldb_private::RegisterInfoInterface *register_info)
  27     : RegisterContextPOSIX_arm(thread, concrete_frame_idx, register_info) {}
  28
  29 ProcessMonitor &RegisterContextPOSIXProcessMonitor_arm::GetMonitor() {
  30   ProcessSP base = CalculateProcess();
  31   ProcessFreeBSD *process = static_cast<ProcessFreeBSD *>(base.get());
  32   return process->GetMonitor();
  33 }
  34
  35 bool RegisterContextPOSIXProcessMonitor_arm::ReadGPR() {
  36   ProcessMonitor &monitor = GetMonitor();
  37   return monitor.ReadGPR(m_thread.GetID(), &m_gpr_arm, GetGPRSize());
  38 }
  39
  40 bool RegisterContextPOSIXProcessMonitor_arm::ReadFPR() {
  41   ProcessMonitor &monitor = GetMonitor();
  42   return monitor.ReadFPR(m_thread.GetID(), &m_fpr, sizeof(m_fpr));
  43 }
  44
  45 bool RegisterContextPOSIXProcessMonitor_arm::WriteGPR() {
  46   ProcessMonitor &monitor = GetMonitor();
  47   return monitor.WriteGPR(m_thread.GetID(), &m_gpr_arm, GetGPRSize());
  48 }
  49
  50 bool RegisterContextPOSIXProcessMonitor_arm::WriteFPR() {
  51   ProcessMonitor &monitor = GetMonitor();
  52   return monitor.WriteFPR(m_thread.GetID(), &m_fpr, sizeof(m_fpr));
  53 }
  54
  55 bool RegisterContextPOSIXProcessMonitor_arm::ReadRegister(
  56     const unsigned reg, RegisterValue &value) {
  57   ProcessMonitor &monitor = GetMonitor();
  58   return monitor.ReadRegisterValue(m_thread.GetID(), GetRegisterOffset(reg),
  59                                    GetRegisterName(reg), GetRegisterSize(reg),
  60                                    value);
  61 }
  62
  63 bool RegisterContextPOSIXProcessMonitor_arm::WriteRegister(
  64     const unsigned reg, const RegisterValue &value) {
  65   unsigned reg_to_write = reg;
  66   RegisterValue value_to_write = value;
  67
  68   // Check if this is a subregister of a full register.
  69   const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
  70   if (reg_info->invalidate_regs &&
  71       (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM)) {
  72     RegisterValue full_value;
  73     uint32_t full_reg = reg_info->invalidate_regs[0];
  74     const RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg);
  75
  76     // Read the full register.
  77     if (ReadRegister(full_reg_info, full_value)) {
  78       Error error;
  79       ByteOrder byte_order = GetByteOrder();
  80       uint8_t dst[RegisterValue::kMaxRegisterByteSize];
  81
  82       // Get the bytes for the full register.
  83       const uint32_t dest_size = full_value.GetAsMemoryData(
  84           full_reg_info, dst, sizeof(dst), byte_order, error);
  85       if (error.Success() && dest_size) {
  86         uint8_t src[RegisterValue::kMaxRegisterByteSize];
  87
  88         // Get the bytes for the source data.
  89         const uint32_t src_size = value.GetAsMemoryData(
  90             reg_info, src, sizeof(src), byte_order, error);
  91         if (error.Success() && src_size && (src_size < dest_size)) {
  92           // Copy the src bytes to the destination.
  93           memcpy(dst + (reg_info->byte_offset & 0x1), src, src_size);
  94           // Set this full register as the value to write.
  95           value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order);
  96           value_to_write.SetType(full_reg_info);
  97           reg_to_write = full_reg;
  98         }
  99       }
 100     }
 101   }
 102
 103   ProcessMonitor &monitor = GetMonitor();
 104   return monitor.WriteRegisterValue(
 105       m_thread.GetID(), GetRegisterOffset(reg_to_write),
 106       GetRegisterName(reg_to_write), value_to_write);
 107 }
 108
 109 bool RegisterContextPOSIXProcessMonitor_arm::ReadRegister(
 110     const RegisterInfo *reg_info, RegisterValue &value) {
 111   if (!reg_info)
 112     return false;
 113
 114   const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 115
 116   if (IsFPR(reg)) {
 117     if (!ReadFPR())
 118       return false;
 119   } else {
 120     return ReadRegister(reg, value);
 121   }
 122
 123   // Get pointer to m_fpr variable and set the data from it.
 124   assert(reg_info->byte_offset < sizeof m_fpr);
 125   uint8_t *src = (uint8_t *)&m_fpr + reg_info->byte_offset;
 126   switch (reg_info->byte_size) {
 127   case 2:
 128     value.SetUInt16(*(uint16_t *)src);
 129     return true;
 130   case 4:
 131     value.SetUInt32(*(uint32_t *)src);
 132     return true;
 133   case 8:
 134     value.SetUInt64(*(uint64_t *)src);
 135     return true;
 136   default:
 137     assert(false && "Unhandled data size.");
 138     return false;
 139   }
 140 }
 141
 142 bool RegisterContextPOSIXProcessMonitor_arm::WriteRegister(
 143     const RegisterInfo *reg_info, const RegisterValue &value) {
 144   const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 145
 146   if (IsGPR(reg)) {
 147     return WriteRegister(reg, value);
 148   } else if (IsFPR(reg)) {
 149     return WriteFPR();
 150   }
 151
 152   return false;
 153 }
 154
 155 bool RegisterContextPOSIXProcessMonitor_arm::ReadAllRegisterValues(
 156     DataBufferSP &data_sp) {
 157   bool success = false;
 158   data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
 159   if (data_sp && ReadGPR() && ReadFPR()) {
 160     uint8_t *dst = data_sp->GetBytes();
 161     success = dst != 0;
 162
 163     if (success) {
 164       ::memcpy(dst, &m_gpr_arm, GetGPRSize());
 165       dst += GetGPRSize();
 166       ::memcpy(dst, &m_fpr, sizeof(m_fpr));
 167     }
 168   }
 169   return success;
 170 }
 171
 172 bool RegisterContextPOSIXProcessMonitor_arm::WriteAllRegisterValues(
 173     const DataBufferSP &data_sp) {
 174   bool success = false;
 175   if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE) {
 176     uint8_t *src = data_sp->GetBytes();
 177     if (src) {
 178       ::memcpy(&m_gpr_arm, src, GetGPRSize());
 179
 180       if (WriteGPR()) {
 181         src += GetGPRSize();
 182         ::memcpy(&m_fpr, src, sizeof(m_fpr));
 183
 184         success = WriteFPR();
 185       }
 186     }
 187   }
 188   return success;
 189 }
 190
 191 uint32_t RegisterContextPOSIXProcessMonitor_arm::SetHardwareWatchpoint(
 192     addr_t addr, size_t size, bool read, bool write) {
 193   const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
 194   uint32_t hw_index;
 195
 196   for (hw_index = 0; hw_index < num_hw_watchpoints; ++hw_index) {
 197     if (IsWatchpointVacant(hw_index))
 198       return SetHardwareWatchpointWithIndex(addr, size, read, write, hw_index);
 199   }
 200
 201   return LLDB_INVALID_INDEX32;
 202 }
 203
 204 bool RegisterContextPOSIXProcessMonitor_arm::ClearHardwareWatchpoint(
 205     uint32_t hw_index) {
 206   return false;
 207 }
 208
 209 bool RegisterContextPOSIXProcessMonitor_arm::HardwareSingleStep(bool enable) {
 210   return false;
 211 }
 212
 213 bool RegisterContextPOSIXProcessMonitor_arm::UpdateAfterBreakpoint() {
 214   lldb::addr_t pc;
 215
 216   if ((pc = GetPC()) == LLDB_INVALID_ADDRESS)
 217     return false;
 218
 219   return true;
 220 }
 221
 222 unsigned RegisterContextPOSIXProcessMonitor_arm::GetRegisterIndexFromOffset(
 223     unsigned offset) {
 224   unsigned reg;
 225   for (reg = 0; reg < k_num_registers_arm; reg++) {
 226     if (GetRegisterInfo()[reg].byte_offset == offset)
 227       break;
 228   }
 229   assert(reg < k_num_registers_arm && "Invalid register offset.");
 230   return reg;
 231 }
 232
 233 bool RegisterContextPOSIXProcessMonitor_arm::IsWatchpointHit(
 234     uint32_t hw_index) {
 235   return false;
 236 }
 237
 238 bool RegisterContextPOSIXProcessMonitor_arm::ClearWatchpointHits() {
 239   return false;
 240 }
 241
 242 addr_t RegisterContextPOSIXProcessMonitor_arm::GetWatchpointAddress(
 243     uint32_t hw_index) {
 244   return LLDB_INVALID_ADDRESS;
 245 }
 246
 247 bool RegisterContextPOSIXProcessMonitor_arm::IsWatchpointVacant(
 248     uint32_t hw_index) {
 249   return false;
 250 }
 251
 252 bool RegisterContextPOSIXProcessMonitor_arm::SetHardwareWatchpointWithIndex(
 253     addr_t addr, size_t size, bool read, bool write, uint32_t hw_index) {
 254   return false;
 255 }
 256
 257 uint32_t
 258 RegisterContextPOSIXProcessMonitor_arm::NumSupportedHardwareWatchpoints() {
 259   return 0;
 260 }