1 //===-- NativeRegisterContext.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/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() = default;
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   // Generic register names take precedence over specific register names.
60   // For example, on x86 we want "sp" to refer to the complete RSP/ESP register
61   // rather than the 16-bit SP pseudo-register.
62   uint32_t generic_reg = Args::StringToGenericRegister(reg_name);
63   if (generic_reg != LLDB_INVALID_REGNUM) {
64     const RegisterInfo *reg_info =
65         GetRegisterInfo(eRegisterKindGeneric, generic_reg);
66     if (reg_info)
67       return reg_info;
68   }
69 
70   const uint32_t num_registers = GetRegisterCount();
71   for (uint32_t reg = start_idx; reg < num_registers; ++reg) {
72     const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
73 
74     if (reg_name.equals_insensitive(reg_info->name) ||
75         reg_name.equals_insensitive(reg_info->alt_name))
76       return reg_info;
77   }
78 
79   return nullptr;
80 }
81 
82 const RegisterInfo *NativeRegisterContext::GetRegisterInfo(uint32_t kind,
83                                                            uint32_t num) {
84   const uint32_t reg_num = ConvertRegisterKindToRegisterNumber(kind, num);
85   if (reg_num == LLDB_INVALID_REGNUM)
86     return nullptr;
87   return GetRegisterInfoAtIndex(reg_num);
88 }
89 
90 const char *NativeRegisterContext::GetRegisterName(uint32_t reg) {
91   const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
92   if (reg_info)
93     return reg_info->name;
94   return nullptr;
95 }
96 
97 const char *NativeRegisterContext::GetRegisterSetNameForRegisterAtIndex(
98     uint32_t reg_index) const {
99   const RegisterInfo *const reg_info = GetRegisterInfoAtIndex(reg_index);
100   if (!reg_info)
101     return nullptr;
102 
103   for (uint32_t set_index = 0; set_index < GetRegisterSetCount(); ++set_index) {
104     const RegisterSet *const reg_set = GetRegisterSet(set_index);
105     if (!reg_set)
106       continue;
107 
108     for (uint32_t reg_num_index = 0; reg_num_index < reg_set->num_registers;
109          ++reg_num_index) {
110       const uint32_t reg_num = reg_set->registers[reg_num_index];
111       // FIXME double check we're checking the right register kind here.
112       if (reg_info->kinds[RegisterKind::eRegisterKindLLDB] == reg_num) {
113         // The given register is a member of this register set.  Return the
114         // register set name.
115         return reg_set->name;
116       }
117     }
118   }
119 
120   // Didn't find it.
121   return nullptr;
122 }
123 
124 lldb::addr_t NativeRegisterContext::GetPC(lldb::addr_t fail_value) {
125   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
126 
127   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
128                                                      LLDB_REGNUM_GENERIC_PC);
129   LLDB_LOGF(log,
130             "NativeRegisterContext::%s using reg index %" PRIu32
131             " (default %" PRIu64 ")",
132             __FUNCTION__, reg, fail_value);
133 
134   const uint64_t retval = ReadRegisterAsUnsigned(reg, fail_value);
135 
136   LLDB_LOGF(log, "NativeRegisterContext::%s " PRIu32 " retval %" PRIu64,
137             __FUNCTION__, retval);
138 
139   return retval;
140 }
141 
142 lldb::addr_t
143 NativeRegisterContext::GetPCfromBreakpointLocation(lldb::addr_t fail_value) {
144   return GetPC(fail_value);
145 }
146 
147 Status NativeRegisterContext::SetPC(lldb::addr_t pc) {
148   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
149                                                      LLDB_REGNUM_GENERIC_PC);
150   return WriteRegisterFromUnsigned(reg, pc);
151 }
152 
153 lldb::addr_t NativeRegisterContext::GetSP(lldb::addr_t fail_value) {
154   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
155                                                      LLDB_REGNUM_GENERIC_SP);
156   return ReadRegisterAsUnsigned(reg, fail_value);
157 }
158 
159 Status NativeRegisterContext::SetSP(lldb::addr_t sp) {
160   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
161                                                      LLDB_REGNUM_GENERIC_SP);
162   return WriteRegisterFromUnsigned(reg, sp);
163 }
164 
165 lldb::addr_t NativeRegisterContext::GetFP(lldb::addr_t fail_value) {
166   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
167                                                      LLDB_REGNUM_GENERIC_FP);
168   return ReadRegisterAsUnsigned(reg, fail_value);
169 }
170 
171 Status NativeRegisterContext::SetFP(lldb::addr_t fp) {
172   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
173                                                      LLDB_REGNUM_GENERIC_FP);
174   return WriteRegisterFromUnsigned(reg, fp);
175 }
176 
177 lldb::addr_t NativeRegisterContext::GetReturnAddress(lldb::addr_t fail_value) {
178   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
179                                                      LLDB_REGNUM_GENERIC_RA);
180   return ReadRegisterAsUnsigned(reg, fail_value);
181 }
182 
183 lldb::addr_t NativeRegisterContext::GetFlags(lldb::addr_t fail_value) {
184   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
185                                                      LLDB_REGNUM_GENERIC_FLAGS);
186   return ReadRegisterAsUnsigned(reg, fail_value);
187 }
188 
189 lldb::addr_t
190 NativeRegisterContext::ReadRegisterAsUnsigned(uint32_t reg,
191                                               lldb::addr_t fail_value) {
192   if (reg != LLDB_INVALID_REGNUM)
193     return ReadRegisterAsUnsigned(GetRegisterInfoAtIndex(reg), fail_value);
194   return fail_value;
195 }
196 
197 uint64_t
198 NativeRegisterContext::ReadRegisterAsUnsigned(const RegisterInfo *reg_info,
199                                               lldb::addr_t fail_value) {
200   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
201 
202   if (reg_info) {
203     RegisterValue value;
204     Status error = ReadRegister(reg_info, value);
205     if (error.Success()) {
206       LLDB_LOGF(log,
207                 "NativeRegisterContext::%s ReadRegister() succeeded, value "
208                 "%" PRIu64,
209                 __FUNCTION__, value.GetAsUInt64());
210       return value.GetAsUInt64();
211     } else {
212       LLDB_LOGF(log,
213                 "NativeRegisterContext::%s ReadRegister() failed, error %s",
214                 __FUNCTION__, error.AsCString());
215     }
216   } else {
217     LLDB_LOGF(log, "NativeRegisterContext::%s ReadRegister() null reg_info",
218               __FUNCTION__);
219   }
220   return fail_value;
221 }
222 
223 Status NativeRegisterContext::WriteRegisterFromUnsigned(uint32_t reg,
224                                                         uint64_t uval) {
225   if (reg == LLDB_INVALID_REGNUM)
226     return Status("NativeRegisterContext::%s (): reg is invalid", __FUNCTION__);
227   return WriteRegisterFromUnsigned(GetRegisterInfoAtIndex(reg), uval);
228 }
229 
230 Status
231 NativeRegisterContext::WriteRegisterFromUnsigned(const RegisterInfo *reg_info,
232                                                  uint64_t uval) {
233   assert(reg_info);
234   if (!reg_info)
235     return Status("reg_info is nullptr");
236 
237   RegisterValue value;
238   if (!value.SetUInt(uval, reg_info->byte_size))
239     return Status("RegisterValue::SetUInt () failed");
240 
241   return WriteRegister(reg_info, value);
242 }
243 
244 lldb::tid_t NativeRegisterContext::GetThreadID() const {
245   return m_thread.GetID();
246 }
247 
248 uint32_t NativeRegisterContext::NumSupportedHardwareBreakpoints() { return 0; }
249 
250 uint32_t NativeRegisterContext::SetHardwareBreakpoint(lldb::addr_t addr,
251                                                       size_t size) {
252   return LLDB_INVALID_INDEX32;
253 }
254 
255 Status NativeRegisterContext::ClearAllHardwareBreakpoints() {
256   return Status("not implemented");
257 }
258 
259 bool NativeRegisterContext::ClearHardwareBreakpoint(uint32_t hw_idx) {
260   return false;
261 }
262 
263 Status NativeRegisterContext::GetHardwareBreakHitIndex(uint32_t &bp_index,
264                                                        lldb::addr_t trap_addr) {
265   bp_index = LLDB_INVALID_INDEX32;
266   return Status("not implemented");
267 }
268 
269 uint32_t NativeRegisterContext::NumSupportedHardwareWatchpoints() { return 0; }
270 
271 uint32_t NativeRegisterContext::SetHardwareWatchpoint(lldb::addr_t addr,
272                                                       size_t size,
273                                                       uint32_t watch_flags) {
274   return LLDB_INVALID_INDEX32;
275 }
276 
277 bool NativeRegisterContext::ClearHardwareWatchpoint(uint32_t hw_index) {
278   return false;
279 }
280 
281 Status NativeRegisterContext::ClearWatchpointHit(uint32_t hw_index) {
282   return Status("not implemented");
283 }
284 
285 Status NativeRegisterContext::ClearAllHardwareWatchpoints() {
286   return Status("not implemented");
287 }
288 
289 Status NativeRegisterContext::IsWatchpointHit(uint32_t wp_index, bool &is_hit) {
290   is_hit = false;
291   return Status("not implemented");
292 }
293 
294 Status NativeRegisterContext::GetWatchpointHitIndex(uint32_t &wp_index,
295                                                     lldb::addr_t trap_addr) {
296   wp_index = LLDB_INVALID_INDEX32;
297   return Status("not implemented");
298 }
299 
300 Status NativeRegisterContext::IsWatchpointVacant(uint32_t wp_index,
301                                                  bool &is_vacant) {
302   is_vacant = false;
303   return Status("not implemented");
304 }
305 
306 lldb::addr_t NativeRegisterContext::GetWatchpointAddress(uint32_t wp_index) {
307   return LLDB_INVALID_ADDRESS;
308 }
309 
310 lldb::addr_t NativeRegisterContext::GetWatchpointHitAddress(uint32_t wp_index) {
311   return LLDB_INVALID_ADDRESS;
312 }
313 
314 bool NativeRegisterContext::HardwareSingleStep(bool enable) { return false; }
315 
316 Status NativeRegisterContext::ReadRegisterValueFromMemory(
317     const RegisterInfo *reg_info, lldb::addr_t src_addr, size_t src_len,
318     RegisterValue &reg_value) {
319   Status error;
320   if (reg_info == nullptr) {
321     error.SetErrorString("invalid register info argument.");
322     return error;
323   }
324 
325   // Moving from addr into a register
326   //
327   // Case 1: src_len == dst_len
328   //
329   //   |AABBCCDD| Address contents
330   //   |AABBCCDD| Register contents
331   //
332   // Case 2: src_len > dst_len
333   //
334   //   Status!  (The register should always be big enough to hold the data)
335   //
336   // Case 3: src_len < dst_len
337   //
338   //   |AABB| Address contents
339   //   |AABB0000| Register contents [on little-endian hardware]
340   //   |0000AABB| Register contents [on big-endian hardware]
341   if (src_len > RegisterValue::kMaxRegisterByteSize) {
342     error.SetErrorString("register too small to receive memory data");
343     return error;
344   }
345 
346   const size_t dst_len = reg_info->byte_size;
347 
348   if (src_len > dst_len) {
349     error.SetErrorStringWithFormat(
350         "%" PRIu64 " bytes is too big to store in register %s (%" PRIu64
351         " bytes)",
352         static_cast<uint64_t>(src_len), reg_info->name,
353         static_cast<uint64_t>(dst_len));
354     return error;
355   }
356 
357   NativeProcessProtocol &process = m_thread.GetProcess();
358   uint8_t src[RegisterValue::kMaxRegisterByteSize];
359 
360   // Read the memory
361   size_t bytes_read;
362   error = process.ReadMemory(src_addr, src, src_len, bytes_read);
363   if (error.Fail())
364     return error;
365 
366   // Make sure the memory read succeeded...
367   if (bytes_read != src_len) {
368     // This might happen if we read _some_ bytes but not all
369     error.SetErrorStringWithFormat("read %" PRIu64 " of %" PRIu64 " bytes",
370                                    static_cast<uint64_t>(bytes_read),
371                                    static_cast<uint64_t>(src_len));
372     return error;
373   }
374 
375   // We now have a memory buffer that contains the part or all of the register
376   // value. Set the register value using this memory data.
377   // TODO: we might need to add a parameter to this function in case the byte
378   // order of the memory data doesn't match the process. For now we are
379   // assuming they are the same.
380   reg_value.SetFromMemoryData(reg_info, src, src_len, process.GetByteOrder(),
381                               error);
382 
383   return error;
384 }
385 
386 Status NativeRegisterContext::WriteRegisterValueToMemory(
387     const RegisterInfo *reg_info, lldb::addr_t dst_addr, size_t dst_len,
388     const RegisterValue &reg_value) {
389 
390   uint8_t dst[RegisterValue::kMaxRegisterByteSize];
391 
392   Status error;
393 
394   NativeProcessProtocol &process = m_thread.GetProcess();
395 
396   // TODO: we might need to add a parameter to this function in case the byte
397   // order of the memory data doesn't match the process. For now we are
398   // assuming they are the same.
399   const size_t bytes_copied = reg_value.GetAsMemoryData(
400       reg_info, dst, dst_len, process.GetByteOrder(), error);
401 
402   if (error.Success()) {
403     if (bytes_copied == 0) {
404       error.SetErrorString("byte copy failed.");
405     } else {
406       size_t bytes_written;
407       error = process.WriteMemory(dst_addr, dst, bytes_copied, bytes_written);
408       if (error.Fail())
409         return error;
410 
411       if (bytes_written != bytes_copied) {
412         // This might happen if we read _some_ bytes but not all
413         error.SetErrorStringWithFormat("only wrote %" PRIu64 " of %" PRIu64
414                                        " bytes",
415                                        static_cast<uint64_t>(bytes_written),
416                                        static_cast<uint64_t>(bytes_copied));
417       }
418     }
419   }
420 
421   return error;
422 }
423 
424 uint32_t
425 NativeRegisterContext::ConvertRegisterKindToRegisterNumber(uint32_t kind,
426                                                            uint32_t num) const {
427   const uint32_t num_regs = GetRegisterCount();
428 
429   assert(kind < kNumRegisterKinds);
430   for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
431     const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg_idx);
432 
433     if (reg_info->kinds[kind] == num)
434       return reg_idx;
435   }
436 
437   return LLDB_INVALID_REGNUM;
438 }
439 
440 std::vector<uint32_t>
441 NativeRegisterContext::GetExpeditedRegisters(ExpeditedRegs expType) const {
442   if (expType == ExpeditedRegs::Minimal) {
443     // Expedite only a minimum set of important generic registers.
444     static const uint32_t k_expedited_registers[] = {
445         LLDB_REGNUM_GENERIC_PC, LLDB_REGNUM_GENERIC_SP, LLDB_REGNUM_GENERIC_FP,
446         LLDB_REGNUM_GENERIC_RA};
447 
448     std::vector<uint32_t> expedited_reg_nums;
449     for (uint32_t gen_reg : k_expedited_registers) {
450       uint32_t reg_num =
451           ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, gen_reg);
452       if (reg_num == LLDB_INVALID_REGNUM)
453         continue; // Target does not support the given register.
454       else
455         expedited_reg_nums.push_back(reg_num);
456     }
457 
458     return expedited_reg_nums;
459   }
460 
461   if (GetRegisterSetCount() > 0 && expType == ExpeditedRegs::Full)
462     return std::vector<uint32_t>(GetRegisterSet(0)->registers,
463                                  GetRegisterSet(0)->registers +
464                                      GetRegisterSet(0)->num_registers);
465 
466   return std::vector<uint32_t>();
467 }
468