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