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