1 //===-- RegisterContextPOSIXProcessMonitor_arm64.cpp -----------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===---------------------------------------------------------------------===//
10 #include "lldb/Core/DataBufferHeap.h"
11 #include "lldb/Core/RegisterValue.h"
12 #include "lldb/Target/Thread.h"
14 #include "Plugins/Process/Utility/RegisterContextPOSIX_arm64.h"
15 #include "ProcessFreeBSD.h"
16 #include "ProcessMonitor.h"
17 #include "RegisterContextPOSIXProcessMonitor_arm64.h"
19 #define REG_CONTEXT_SIZE (GetGPRSize())
22 using namespace lldb_private;
24 RegisterContextPOSIXProcessMonitor_arm64::RegisterContextPOSIXProcessMonitor_arm64(lldb_private::Thread &thread,
25 uint32_t concrete_frame_idx,
26 lldb_private::RegisterInfoInterface *register_info)
27 : RegisterContextPOSIX_arm64(thread, concrete_frame_idx, register_info)
32 RegisterContextPOSIXProcessMonitor_arm64::GetMonitor()
34 lldb::ProcessSP base = CalculateProcess();
35 ProcessFreeBSD *process = static_cast<ProcessFreeBSD*>(base.get());
36 return process->GetMonitor();
40 RegisterContextPOSIXProcessMonitor_arm64::ReadGPR()
42 ProcessMonitor &monitor = GetMonitor();
43 return monitor.ReadGPR(m_thread.GetID(), &m_gpr_arm64, GetGPRSize());
47 RegisterContextPOSIXProcessMonitor_arm64::ReadFPR()
49 ProcessMonitor &monitor = GetMonitor();
50 return monitor.ReadFPR(m_thread.GetID(), &m_fpr, sizeof m_fpr);
54 RegisterContextPOSIXProcessMonitor_arm64::WriteGPR()
56 ProcessMonitor &monitor = GetMonitor();
57 return monitor.WriteGPR(m_thread.GetID(), &m_gpr_arm64, GetGPRSize());
61 RegisterContextPOSIXProcessMonitor_arm64::WriteFPR()
63 ProcessMonitor &monitor = GetMonitor();
64 return monitor.WriteFPR(m_thread.GetID(), &m_fpr, sizeof m_fpr);
68 RegisterContextPOSIXProcessMonitor_arm64::ReadRegister(const unsigned reg,
69 lldb_private::RegisterValue &value)
71 ProcessMonitor &monitor = GetMonitor();
72 return monitor.ReadRegisterValue(m_thread.GetID(),
73 GetRegisterOffset(reg),
80 RegisterContextPOSIXProcessMonitor_arm64::WriteRegister(const unsigned reg,
81 const lldb_private::RegisterValue &value)
83 unsigned reg_to_write = reg;
84 lldb_private::RegisterValue value_to_write = value;
86 // Check if this is a subregister of a full register.
87 const lldb_private::RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
88 if (reg_info->invalidate_regs && (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM))
90 lldb_private::RegisterValue full_value;
91 uint32_t full_reg = reg_info->invalidate_regs[0];
92 const lldb_private::RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg);
94 // Read the full register.
95 if (ReadRegister(full_reg_info, full_value))
97 lldb_private::Error error;
98 lldb::ByteOrder byte_order = GetByteOrder();
99 uint8_t dst[lldb_private::RegisterValue::kMaxRegisterByteSize];
101 // Get the bytes for the full register.
102 const uint32_t dest_size = full_value.GetAsMemoryData (full_reg_info,
107 if (error.Success() && dest_size)
109 uint8_t src[lldb_private::RegisterValue::kMaxRegisterByteSize];
111 // Get the bytes for the source data.
112 const uint32_t src_size = value.GetAsMemoryData (reg_info, src, sizeof(src), byte_order, error);
113 if (error.Success() && src_size && (src_size < dest_size))
115 // Copy the src bytes to the destination.
116 ::memcpy (dst + (reg_info->byte_offset & 0x1), src, src_size);
117 // Set this full register as the value to write.
118 value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order);
119 value_to_write.SetType(full_reg_info);
120 reg_to_write = full_reg;
126 ProcessMonitor &monitor = GetMonitor();
127 return monitor.WriteRegisterValue(m_thread.GetID(),
128 GetRegisterOffset(reg_to_write),
129 GetRegisterName(reg_to_write),
134 RegisterContextPOSIXProcessMonitor_arm64::ReadRegister(const lldb_private::RegisterInfo *reg_info, lldb_private::RegisterValue &value)
139 const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
148 uint32_t full_reg = reg;
149 bool is_subreg = reg_info->invalidate_regs && (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM);
153 // Read the full aligned 64-bit register.
154 full_reg = reg_info->invalidate_regs[0];
156 return ReadRegister(full_reg, value);
159 // Get pointer to m_fpr variable and set the data from it.
160 assert (reg_info->byte_offset < sizeof m_fpr);
161 uint8_t *src = (uint8_t *)&m_fpr + reg_info->byte_offset;
162 switch (reg_info->byte_size)
165 value.SetUInt16(*(uint16_t *)src);
168 value.SetUInt32(*(uint32_t *)src);
171 value.SetUInt64(*(uint64_t *)src);
174 assert(false && "Unhandled data size.");
180 RegisterContextPOSIXProcessMonitor_arm64::WriteRegister(const lldb_private::RegisterInfo *reg_info, const lldb_private::RegisterValue &value)
182 const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
185 return WriteRegister(reg, value);
191 RegisterContextPOSIXProcessMonitor_arm64::ReadAllRegisterValues(lldb::DataBufferSP &data_sp)
193 bool success = false;
194 data_sp.reset (new lldb_private::DataBufferHeap (REG_CONTEXT_SIZE, 0));
195 if (data_sp && ReadGPR () && ReadFPR ())
197 uint8_t *dst = data_sp->GetBytes();
202 ::memcpy (dst, &m_gpr_arm64, GetGPRSize());
204 ::memcpy (dst, &m_fpr, sizeof m_fpr);
211 RegisterContextPOSIXProcessMonitor_arm64::WriteAllRegisterValues(const lldb::DataBufferSP &data_sp)
213 bool success = false;
214 if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE)
216 uint8_t *src = data_sp->GetBytes();
219 ::memcpy (&m_gpr_arm64, src, GetGPRSize());
222 ::memcpy (&m_fpr, src, sizeof m_fpr);
223 success = WriteFPR();
231 RegisterContextPOSIXProcessMonitor_arm64::SetHardwareWatchpoint(lldb::addr_t addr, size_t size,
232 bool read, bool write)
234 const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
237 for (hw_index = 0; hw_index < num_hw_watchpoints; ++hw_index)
239 if (IsWatchpointVacant(hw_index))
240 return SetHardwareWatchpointWithIndex(addr, size,
245 return LLDB_INVALID_INDEX32;
249 RegisterContextPOSIXProcessMonitor_arm64::ClearHardwareWatchpoint(uint32_t hw_index)
255 RegisterContextPOSIXProcessMonitor_arm64::HardwareSingleStep(bool enable)
261 RegisterContextPOSIXProcessMonitor_arm64::UpdateAfterBreakpoint()
263 if (GetPC() == LLDB_INVALID_ADDRESS)
270 RegisterContextPOSIXProcessMonitor_arm64::GetRegisterIndexFromOffset(unsigned offset)
273 for (reg = 0; reg < k_num_registers_arm64; reg++)
275 if (GetRegisterInfo()[reg].byte_offset == offset)
278 assert(reg < k_num_registers_arm64 && "Invalid register offset.");
283 RegisterContextPOSIXProcessMonitor_arm64::IsWatchpointHit(uint32_t hw_index)
289 RegisterContextPOSIXProcessMonitor_arm64::ClearWatchpointHits()
295 RegisterContextPOSIXProcessMonitor_arm64::GetWatchpointAddress(uint32_t hw_index)
297 return LLDB_INVALID_ADDRESS;
301 RegisterContextPOSIXProcessMonitor_arm64::IsWatchpointVacant(uint32_t hw_index)
307 RegisterContextPOSIXProcessMonitor_arm64::SetHardwareWatchpointWithIndex(lldb::addr_t addr, size_t size,
308 bool read, bool write,
315 RegisterContextPOSIXProcessMonitor_arm64::NumSupportedHardwareWatchpoints()