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/Target/Thread.h"
11 #include "lldb/Utility/DataBufferHeap.h"
12 #include "lldb/Utility/RegisterValue.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::
RegisterContextPOSIXProcessMonitor_arm64(lldb_private::Thread & thread,uint32_t concrete_frame_idx,lldb_private::RegisterInfoInterface * register_info)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
GetMonitor()30 ProcessMonitor &RegisterContextPOSIXProcessMonitor_arm64::GetMonitor() {
31 lldb::ProcessSP base = CalculateProcess();
32 ProcessFreeBSD *process = static_cast<ProcessFreeBSD *>(base.get());
33 return process->GetMonitor();
34 }
35
ReadGPR()36 bool RegisterContextPOSIXProcessMonitor_arm64::ReadGPR() {
37 ProcessMonitor &monitor = GetMonitor();
38 return monitor.ReadGPR(m_thread.GetID(), &m_gpr_arm64, GetGPRSize());
39 }
40
ReadFPR()41 bool RegisterContextPOSIXProcessMonitor_arm64::ReadFPR() {
42 ProcessMonitor &monitor = GetMonitor();
43 return monitor.ReadFPR(m_thread.GetID(), &m_fpr, sizeof m_fpr);
44 }
45
WriteGPR()46 bool RegisterContextPOSIXProcessMonitor_arm64::WriteGPR() {
47 ProcessMonitor &monitor = GetMonitor();
48 return monitor.WriteGPR(m_thread.GetID(), &m_gpr_arm64, GetGPRSize());
49 }
50
WriteFPR()51 bool RegisterContextPOSIXProcessMonitor_arm64::WriteFPR() {
52 ProcessMonitor &monitor = GetMonitor();
53 return monitor.WriteFPR(m_thread.GetID(), &m_fpr, sizeof m_fpr);
54 }
55
ReadRegister(const unsigned reg,lldb_private::RegisterValue & value)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
WriteRegister(const unsigned reg,const lldb_private::RegisterValue & value)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::Status 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
ReadRegister(const lldb_private::RegisterInfo * reg_info,lldb_private::RegisterValue & value)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
WriteRegister(const lldb_private::RegisterInfo * reg_info,const lldb_private::RegisterValue & value)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
ReadAllRegisterValues(lldb::DataBufferSP & data_sp)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
WriteAllRegisterValues(const lldb::DataBufferSP & data_sp)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
SetHardwareWatchpoint(lldb::addr_t addr,size_t size,bool read,bool write)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
ClearHardwareWatchpoint(uint32_t hw_index)211 bool RegisterContextPOSIXProcessMonitor_arm64::ClearHardwareWatchpoint(
212 uint32_t hw_index) {
213 return false;
214 }
215
HardwareSingleStep(bool enable)216 bool RegisterContextPOSIXProcessMonitor_arm64::HardwareSingleStep(bool enable) {
217 return false;
218 }
219
UpdateAfterBreakpoint()220 bool RegisterContextPOSIXProcessMonitor_arm64::UpdateAfterBreakpoint() {
221 if (GetPC() == LLDB_INVALID_ADDRESS)
222 return false;
223
224 return true;
225 }
226
GetRegisterIndexFromOffset(unsigned offset)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
IsWatchpointHit(uint32_t hw_index)238 bool RegisterContextPOSIXProcessMonitor_arm64::IsWatchpointHit(
239 uint32_t hw_index) {
240 return false;
241 }
242
ClearWatchpointHits()243 bool RegisterContextPOSIXProcessMonitor_arm64::ClearWatchpointHits() {
244 return false;
245 }
246
GetWatchpointAddress(uint32_t hw_index)247 lldb::addr_t RegisterContextPOSIXProcessMonitor_arm64::GetWatchpointAddress(
248 uint32_t hw_index) {
249 return LLDB_INVALID_ADDRESS;
250 }
251
IsWatchpointVacant(uint32_t hw_index)252 bool RegisterContextPOSIXProcessMonitor_arm64::IsWatchpointVacant(
253 uint32_t hw_index) {
254 return false;
255 }
256
SetHardwareWatchpointWithIndex(lldb::addr_t addr,size_t size,bool read,bool write,uint32_t hw_index)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
NumSupportedHardwareWatchpoints()263 RegisterContextPOSIXProcessMonitor_arm64::NumSupportedHardwareWatchpoints() {
264 return 0;
265 }
266