1 //===-- NativeRegisterContext.cpp -------------------------*- C++ -*-===//
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/Host/common/NativeRegisterContext.h"
10 
11 #include "lldb/Utility/Log.h"
12 #include "lldb/Utility/RegisterValue.h"
13 
14 #include "lldb/Host/PosixApi.h"
15 #include "lldb/Host/common/NativeProcessProtocol.h"
16 #include "lldb/Host/common/NativeThreadProtocol.h"
17 
18 using namespace lldb;
19 using namespace lldb_private;
20 
21 NativeRegisterContext::NativeRegisterContext(NativeThreadProtocol &thread)
22     : m_thread(thread) {}
23 
24 // Destructor
25 NativeRegisterContext::~NativeRegisterContext() {}
26 
27 // FIXME revisit invalidation, process stop ids, etc.  Right now we don't
28 // support caching in NativeRegisterContext.  We can do this later by utilizing
29 // NativeProcessProtocol::GetStopID () and adding a stop id to
30 // NativeRegisterContext.
31 
32 // void
33 // NativeRegisterContext::InvalidateIfNeeded (bool force) {
34 //     ProcessSP process_sp (m_thread.GetProcess());
35 //     bool invalidate = force;
36 //     uint32_t process_stop_id = UINT32_MAX;
37 
38 //     if (process_sp)
39 //         process_stop_id = process_sp->GetStopID();
40 //     else
41 //         invalidate = true;
42 
43 //     if (!invalidate)
44 //         invalidate = process_stop_id != GetStopID();
45 
46 //     if (invalidate)
47 //     {
48 //         InvalidateAllRegisters ();
49 //         SetStopID (process_stop_id);
50 //     }
51 // }
52 
53 const RegisterInfo *
54 NativeRegisterContext::GetRegisterInfoByName(llvm::StringRef reg_name,
55                                              uint32_t start_idx) {
56   if (reg_name.empty())
57     return nullptr;
58 
59   const uint32_t num_registers = GetRegisterCount();
60   for (uint32_t reg = start_idx; reg < num_registers; ++reg) {
61     const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
62 
63     if (reg_name.equals_lower(reg_info->name) ||
64         reg_name.equals_lower(reg_info->alt_name))
65       return reg_info;
66   }
67   return nullptr;
68 }
69 
70 const RegisterInfo *NativeRegisterContext::GetRegisterInfo(uint32_t kind,
71                                                            uint32_t num) {
72   const uint32_t reg_num = ConvertRegisterKindToRegisterNumber(kind, num);
73   if (reg_num == LLDB_INVALID_REGNUM)
74     return nullptr;
75   return GetRegisterInfoAtIndex(reg_num);
76 }
77 
78 const char *NativeRegisterContext::GetRegisterName(uint32_t reg) {
79   const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
80   if (reg_info)
81     return reg_info->name;
82   return nullptr;
83 }
84 
85 const char *NativeRegisterContext::GetRegisterSetNameForRegisterAtIndex(
86     uint32_t reg_index) const {
87   const RegisterInfo *const reg_info = GetRegisterInfoAtIndex(reg_index);
88   if (!reg_info)
89     return nullptr;
90 
91   for (uint32_t set_index = 0; set_index < GetRegisterSetCount(); ++set_index) {
92     const RegisterSet *const reg_set = GetRegisterSet(set_index);
93     if (!reg_set)
94       continue;
95 
96     for (uint32_t reg_num_index = 0; reg_num_index < reg_set->num_registers;
97          ++reg_num_index) {
98       const uint32_t reg_num = reg_set->registers[reg_num_index];
99       // FIXME double check we're checking the right register kind here.
100       if (reg_info->kinds[RegisterKind::eRegisterKindLLDB] == reg_num) {
101         // The given register is a member of this register set.  Return the
102         // register set name.
103         return reg_set->name;
104       }
105     }
106   }
107 
108   // Didn't find it.
109   return nullptr;
110 }
111 
112 lldb::addr_t NativeRegisterContext::GetPC(lldb::addr_t fail_value) {
113   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
114 
115   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
116                                                      LLDB_REGNUM_GENERIC_PC);
117   LLDB_LOGF(log,
118             "NativeRegisterContext::%s using reg index %" PRIu32
119             " (default %" PRIu64 ")",
120             __FUNCTION__, reg, fail_value);
121 
122   const uint64_t retval = ReadRegisterAsUnsigned(reg, fail_value);
123 
124   LLDB_LOGF(log, "NativeRegisterContext::%s " PRIu32 " retval %" PRIu64,
125             __FUNCTION__, retval);
126 
127   return retval;
128 }
129 
130 lldb::addr_t
131 NativeRegisterContext::GetPCfromBreakpointLocation(lldb::addr_t fail_value) {
132   return GetPC(fail_value);
133 }
134 
135 Status NativeRegisterContext::SetPC(lldb::addr_t pc) {
136   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
137                                                      LLDB_REGNUM_GENERIC_PC);
138   return WriteRegisterFromUnsigned(reg, pc);
139 }
140 
141 lldb::addr_t NativeRegisterContext::GetSP(lldb::addr_t fail_value) {
142   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
143                                                      LLDB_REGNUM_GENERIC_SP);
144   return ReadRegisterAsUnsigned(reg, fail_value);
145 }
146 
147 Status NativeRegisterContext::SetSP(lldb::addr_t sp) {
148   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
149                                                      LLDB_REGNUM_GENERIC_SP);
150   return WriteRegisterFromUnsigned(reg, sp);
151 }
152 
153 lldb::addr_t NativeRegisterContext::GetFP(lldb::addr_t fail_value) {
154   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
155                                                      LLDB_REGNUM_GENERIC_FP);
156   return ReadRegisterAsUnsigned(reg, fail_value);
157 }
158 
159 Status NativeRegisterContext::SetFP(lldb::addr_t fp) {
160   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
161                                                      LLDB_REGNUM_GENERIC_FP);
162   return WriteRegisterFromUnsigned(reg, fp);
163 }
164 
165 lldb::addr_t NativeRegisterContext::GetReturnAddress(lldb::addr_t fail_value) {
166   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
167                                                      LLDB_REGNUM_GENERIC_RA);
168   return ReadRegisterAsUnsigned(reg, fail_value);
169 }
170 
171 lldb::addr_t NativeRegisterContext::GetFlags(lldb::addr_t fail_value) {
172   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
173                                                      LLDB_REGNUM_GENERIC_FLAGS);
174   return ReadRegisterAsUnsigned(reg, fail_value);
175 }
176 
177 lldb::addr_t
178 NativeRegisterContext::ReadRegisterAsUnsigned(uint32_t reg,
179                                               lldb::addr_t fail_value) {
180   if (reg != LLDB_INVALID_REGNUM)
181     return ReadRegisterAsUnsigned(GetRegisterInfoAtIndex(reg), fail_value);
182   return fail_value;
183 }
184 
185 uint64_t
186 NativeRegisterContext::ReadRegisterAsUnsigned(const RegisterInfo *reg_info,
187                                               lldb::addr_t fail_value) {
188   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
189 
190   if (reg_info) {
191     RegisterValue value;
192     Status error = ReadRegister(reg_info, value);
193     if (error.Success()) {
194       LLDB_LOGF(log,
195                 "NativeRegisterContext::%s ReadRegister() succeeded, value "
196                 "%" PRIu64,
197                 __FUNCTION__, value.GetAsUInt64());
198       return value.GetAsUInt64();
199     } else {
200       LLDB_LOGF(log,
201                 "NativeRegisterContext::%s ReadRegister() failed, error %s",
202                 __FUNCTION__, error.AsCString());
203     }
204   } else {
205     LLDB_LOGF(log, "NativeRegisterContext::%s ReadRegister() null reg_info",
206               __FUNCTION__);
207   }
208   return fail_value;
209 }
210 
211 Status NativeRegisterContext::WriteRegisterFromUnsigned(uint32_t reg,
212                                                         uint64_t uval) {
213   if (reg == LLDB_INVALID_REGNUM)
214     return Status("NativeRegisterContext::%s (): reg is invalid", __FUNCTION__);
215   return WriteRegisterFromUnsigned(GetRegisterInfoAtIndex(reg), uval);
216 }
217 
218 Status
219 NativeRegisterContext::WriteRegisterFromUnsigned(const RegisterInfo *reg_info,
220                                                  uint64_t uval) {
221   assert(reg_info);
222   if (!reg_info)
223     return Status("reg_info is nullptr");
224 
225   RegisterValue value;
226   if (!value.SetUInt(uval, reg_info->byte_size))
227     return Status("RegisterValue::SetUInt () failed");
228 
229   return WriteRegister(reg_info, value);
230 }
231 
232 lldb::tid_t NativeRegisterContext::GetThreadID() const {
233   return m_thread.GetID();
234 }
235 
236 uint32_t NativeRegisterContext::NumSupportedHardwareBreakpoints() { return 0; }
237 
238 uint32_t NativeRegisterContext::SetHardwareBreakpoint(lldb::addr_t addr,
239                                                       size_t size) {
240   return LLDB_INVALID_INDEX32;
241 }
242 
243 Status NativeRegisterContext::ClearAllHardwareBreakpoints() {
244   return Status("not implemented");
245 }
246 
247 bool NativeRegisterContext::ClearHardwareBreakpoint(uint32_t hw_idx) {
248   return false;
249 }
250 
251 Status NativeRegisterContext::GetHardwareBreakHitIndex(uint32_t &bp_index,
252                                                        lldb::addr_t trap_addr) {
253   bp_index = LLDB_INVALID_INDEX32;
254   return Status("not implemented");
255 }
256 
257 uint32_t NativeRegisterContext::NumSupportedHardwareWatchpoints() { return 0; }
258 
259 uint32_t NativeRegisterContext::SetHardwareWatchpoint(lldb::addr_t addr,
260                                                       size_t size,
261                                                       uint32_t watch_flags) {
262   return LLDB_INVALID_INDEX32;
263 }
264 
265 bool NativeRegisterContext::ClearHardwareWatchpoint(uint32_t hw_index) {
266   return false;
267 }
268 
269 Status NativeRegisterContext::ClearAllHardwareWatchpoints() {
270   return Status("not implemented");
271 }
272 
273 Status NativeRegisterContext::IsWatchpointHit(uint32_t wp_index, bool &is_hit) {
274   is_hit = false;
275   return Status("not implemented");
276 }
277 
278 Status NativeRegisterContext::GetWatchpointHitIndex(uint32_t &wp_index,
279                                                     lldb::addr_t trap_addr) {
280   wp_index = LLDB_INVALID_INDEX32;
281   return Status("not implemented");
282 }
283 
284 Status NativeRegisterContext::IsWatchpointVacant(uint32_t wp_index,
285                                                  bool &is_vacant) {
286   is_vacant = false;
287   return Status("not implemented");
288 }
289 
290 lldb::addr_t NativeRegisterContext::GetWatchpointAddress(uint32_t wp_index) {
291   return LLDB_INVALID_ADDRESS;
292 }
293 
294 lldb::addr_t NativeRegisterContext::GetWatchpointHitAddress(uint32_t wp_index) {
295   return LLDB_INVALID_ADDRESS;
296 }
297 
298 bool NativeRegisterContext::HardwareSingleStep(bool enable) { return false; }
299 
300 Status NativeRegisterContext::ReadRegisterValueFromMemory(
301     const RegisterInfo *reg_info, lldb::addr_t src_addr, size_t src_len,
302     RegisterValue &reg_value) {
303   Status error;
304   if (reg_info == nullptr) {
305     error.SetErrorString("invalid register info argument.");
306     return error;
307   }
308 
309   // Moving from addr into a register
310   //
311   // Case 1: src_len == dst_len
312   //
313   //   |AABBCCDD| Address contents
314   //   |AABBCCDD| Register contents
315   //
316   // Case 2: src_len > dst_len
317   //
318   //   Status!  (The register should always be big enough to hold the data)
319   //
320   // Case 3: src_len < dst_len
321   //
322   //   |AABB| Address contents
323   //   |AABB0000| Register contents [on little-endian hardware]
324   //   |0000AABB| Register contents [on big-endian hardware]
325   if (src_len > RegisterValue::kMaxRegisterByteSize) {
326     error.SetErrorString("register too small to receive memory data");
327     return error;
328   }
329 
330   const size_t dst_len = reg_info->byte_size;
331 
332   if (src_len > dst_len) {
333     error.SetErrorStringWithFormat(
334         "%" PRIu64 " bytes is too big to store in register %s (%" PRIu64
335         " bytes)",
336         static_cast<uint64_t>(src_len), reg_info->name,
337         static_cast<uint64_t>(dst_len));
338     return error;
339   }
340 
341   NativeProcessProtocol &process = m_thread.GetProcess();
342   uint8_t src[RegisterValue::kMaxRegisterByteSize];
343 
344   // Read the memory
345   size_t bytes_read;
346   error = process.ReadMemory(src_addr, src, src_len, bytes_read);
347   if (error.Fail())
348     return error;
349 
350   // Make sure the memory read succeeded...
351   if (bytes_read != src_len) {
352     // This might happen if we read _some_ bytes but not all
353     error.SetErrorStringWithFormat("read %" PRIu64 " of %" PRIu64 " bytes",
354                                    static_cast<uint64_t>(bytes_read),
355                                    static_cast<uint64_t>(src_len));
356     return error;
357   }
358 
359   // We now have a memory buffer that contains the part or all of the register
360   // value. Set the register value using this memory data.
361   // TODO: we might need to add a parameter to this function in case the byte
362   // order of the memory data doesn't match the process. For now we are
363   // assuming they are the same.
364   reg_value.SetFromMemoryData(reg_info, src, src_len, process.GetByteOrder(),
365                               error);
366 
367   return error;
368 }
369 
370 Status NativeRegisterContext::WriteRegisterValueToMemory(
371     const RegisterInfo *reg_info, lldb::addr_t dst_addr, size_t dst_len,
372     const RegisterValue &reg_value) {
373 
374   uint8_t dst[RegisterValue::kMaxRegisterByteSize];
375 
376   Status error;
377 
378   NativeProcessProtocol &process = m_thread.GetProcess();
379 
380   // TODO: we might need to add a parameter to this function in case the byte
381   // order of the memory data doesn't match the process. For now we are
382   // assuming they are the same.
383   const size_t bytes_copied = reg_value.GetAsMemoryData(
384       reg_info, dst, dst_len, process.GetByteOrder(), error);
385 
386   if (error.Success()) {
387     if (bytes_copied == 0) {
388       error.SetErrorString("byte copy failed.");
389     } else {
390       size_t bytes_written;
391       error = process.WriteMemory(dst_addr, dst, bytes_copied, bytes_written);
392       if (error.Fail())
393         return error;
394 
395       if (bytes_written != bytes_copied) {
396         // This might happen if we read _some_ bytes but not all
397         error.SetErrorStringWithFormat("only wrote %" PRIu64 " of %" PRIu64
398                                        " bytes",
399                                        static_cast<uint64_t>(bytes_written),
400                                        static_cast<uint64_t>(bytes_copied));
401       }
402     }
403   }
404 
405   return error;
406 }
407 
408 uint32_t
409 NativeRegisterContext::ConvertRegisterKindToRegisterNumber(uint32_t kind,
410                                                            uint32_t num) const {
411   const uint32_t num_regs = GetRegisterCount();
412 
413   assert(kind < kNumRegisterKinds);
414   for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
415     const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg_idx);
416 
417     if (reg_info->kinds[kind] == num)
418       return reg_idx;
419   }
420 
421   return LLDB_INVALID_REGNUM;
422 }
423