source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_arm64.cpp

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