1 //===-- RegisterContext.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/RegisterContext.h"
10 #include "lldb/Core/Module.h"
11 #include "lldb/Core/Value.h"
12 #include "lldb/Expression/DWARFExpression.h"
13 #include "lldb/Target/ExecutionContext.h"
14 #include "lldb/Target/Process.h"
15 #include "lldb/Target/StackFrame.h"
16 #include "lldb/Target/Target.h"
17 #include "lldb/Target/Thread.h"
18 #include "lldb/Utility/DataExtractor.h"
19 #include "lldb/Utility/Endian.h"
20 #include "lldb/Utility/RegisterValue.h"
21 #include "lldb/Utility/Scalar.h"
22 
23 using namespace lldb;
24 using namespace lldb_private;
25 
26 RegisterContext::RegisterContext(Thread &thread, uint32_t concrete_frame_idx)
27     : m_thread(thread), m_concrete_frame_idx(concrete_frame_idx),
28       m_stop_id(thread.GetProcess()->GetStopID()) {}
29 
30 RegisterContext::~RegisterContext() = default;
31 
32 void RegisterContext::InvalidateIfNeeded(bool force) {
33   ProcessSP process_sp(m_thread.GetProcess());
34   bool invalidate = force;
35   uint32_t process_stop_id = UINT32_MAX;
36 
37   if (process_sp)
38     process_stop_id = process_sp->GetStopID();
39   else
40     invalidate = true;
41 
42   if (!invalidate)
43     invalidate = process_stop_id != GetStopID();
44 
45   if (invalidate) {
46     InvalidateAllRegisters();
47     SetStopID(process_stop_id);
48   }
49 }
50 
51 const RegisterInfo *
52 RegisterContext::GetRegisterInfoByName(llvm::StringRef reg_name,
53                                        uint32_t start_idx) {
54   if (reg_name.empty())
55     return nullptr;
56 
57   // Generic register names take precedence over specific register names.
58   // For example, on x86 we want "sp" to refer to the complete RSP/ESP register
59   // rather than the 16-bit SP pseudo-register.
60   uint32_t generic_reg = Args::StringToGenericRegister(reg_name);
61   if (generic_reg != LLDB_INVALID_REGNUM) {
62     const RegisterInfo *reg_info =
63         GetRegisterInfo(eRegisterKindGeneric, generic_reg);
64     if (reg_info)
65       return reg_info;
66   }
67 
68   const uint32_t num_registers = GetRegisterCount();
69   for (uint32_t reg = start_idx; reg < num_registers; ++reg) {
70     const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
71 
72     if (reg_name.equals_insensitive(reg_info->name) ||
73         reg_name.equals_insensitive(reg_info->alt_name))
74       return reg_info;
75   }
76 
77   return nullptr;
78 }
79 
80 const RegisterInfo *RegisterContext::GetRegisterInfo(lldb::RegisterKind kind,
81                                                      uint32_t num) {
82   const uint32_t reg_num = ConvertRegisterKindToRegisterNumber(kind, num);
83   if (reg_num == LLDB_INVALID_REGNUM)
84     return nullptr;
85   return GetRegisterInfoAtIndex(reg_num);
86 }
87 
88 const char *RegisterContext::GetRegisterName(uint32_t reg) {
89   const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
90   if (reg_info)
91     return reg_info->name;
92   return nullptr;
93 }
94 
95 uint64_t RegisterContext::GetPC(uint64_t fail_value) {
96   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
97                                                      LLDB_REGNUM_GENERIC_PC);
98   uint64_t pc = ReadRegisterAsUnsigned(reg, fail_value);
99 
100   if (pc != fail_value) {
101     TargetSP target_sp = m_thread.CalculateTarget();
102     if (target_sp) {
103       Target *target = target_sp.get();
104       if (target)
105         pc = target->GetOpcodeLoadAddress(pc, AddressClass::eCode);
106     }
107   }
108 
109   return pc;
110 }
111 
112 bool RegisterContext::SetPC(uint64_t pc) {
113   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
114                                                      LLDB_REGNUM_GENERIC_PC);
115   bool success = WriteRegisterFromUnsigned(reg, pc);
116   if (success) {
117     StackFrameSP frame_sp(
118         m_thread.GetFrameWithConcreteFrameIndex(m_concrete_frame_idx));
119     if (frame_sp)
120       frame_sp->ChangePC(pc);
121     else
122       m_thread.ClearStackFrames();
123   }
124   return success;
125 }
126 
127 bool RegisterContext::GetPCForSymbolication(Address &address) {
128   addr_t pc = GetPC(LLDB_INVALID_ADDRESS);
129   if (pc == LLDB_INVALID_ADDRESS)
130     return false;
131   TargetSP target_sp = m_thread.CalculateTarget();
132   if (!target_sp.get())
133     return false;
134 
135   if (!BehavesLikeZerothFrame() && pc != 0)
136     pc--;
137   address.SetLoadAddress(pc, target_sp.get());
138   return true;
139 }
140 
141 bool RegisterContext::SetPC(Address addr) {
142   TargetSP target_sp = m_thread.CalculateTarget();
143   Target *target = target_sp.get();
144 
145   lldb::addr_t callAddr = addr.GetCallableLoadAddress(target);
146   if (callAddr == LLDB_INVALID_ADDRESS)
147     return false;
148 
149   return SetPC(callAddr);
150 }
151 
152 uint64_t RegisterContext::GetSP(uint64_t fail_value) {
153   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
154                                                      LLDB_REGNUM_GENERIC_SP);
155   return ReadRegisterAsUnsigned(reg, fail_value);
156 }
157 
158 bool RegisterContext::SetSP(uint64_t sp) {
159   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
160                                                      LLDB_REGNUM_GENERIC_SP);
161   return WriteRegisterFromUnsigned(reg, sp);
162 }
163 
164 uint64_t RegisterContext::GetFP(uint64_t fail_value) {
165   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
166                                                      LLDB_REGNUM_GENERIC_FP);
167   return ReadRegisterAsUnsigned(reg, fail_value);
168 }
169 
170 bool RegisterContext::SetFP(uint64_t fp) {
171   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
172                                                      LLDB_REGNUM_GENERIC_FP);
173   return WriteRegisterFromUnsigned(reg, fp);
174 }
175 
176 uint64_t RegisterContext::GetReturnAddress(uint64_t fail_value) {
177   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
178                                                      LLDB_REGNUM_GENERIC_RA);
179   return ReadRegisterAsUnsigned(reg, fail_value);
180 }
181 
182 uint64_t RegisterContext::GetFlags(uint64_t fail_value) {
183   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
184                                                      LLDB_REGNUM_GENERIC_FLAGS);
185   return ReadRegisterAsUnsigned(reg, fail_value);
186 }
187 
188 uint64_t RegisterContext::ReadRegisterAsUnsigned(uint32_t reg,
189                                                  uint64_t fail_value) {
190   if (reg != LLDB_INVALID_REGNUM)
191     return ReadRegisterAsUnsigned(GetRegisterInfoAtIndex(reg), fail_value);
192   return fail_value;
193 }
194 
195 uint64_t RegisterContext::ReadRegisterAsUnsigned(const RegisterInfo *reg_info,
196                                                  uint64_t fail_value) {
197   if (reg_info) {
198     RegisterValue value;
199     if (ReadRegister(reg_info, value))
200       return value.GetAsUInt64();
201   }
202   return fail_value;
203 }
204 
205 bool RegisterContext::WriteRegisterFromUnsigned(uint32_t reg, uint64_t uval) {
206   if (reg == LLDB_INVALID_REGNUM)
207     return false;
208   return WriteRegisterFromUnsigned(GetRegisterInfoAtIndex(reg), uval);
209 }
210 
211 bool RegisterContext::WriteRegisterFromUnsigned(const RegisterInfo *reg_info,
212                                                 uint64_t uval) {
213   if (reg_info) {
214     RegisterValue value;
215     if (value.SetUInt(uval, reg_info->byte_size))
216       return WriteRegister(reg_info, value);
217   }
218   return false;
219 }
220 
221 bool RegisterContext::CopyFromRegisterContext(lldb::RegisterContextSP context) {
222   uint32_t num_register_sets = context->GetRegisterSetCount();
223   // We don't know that two threads have the same register context, so require
224   // the threads to be the same.
225   if (context->GetThreadID() != GetThreadID())
226     return false;
227 
228   if (num_register_sets != GetRegisterSetCount())
229     return false;
230 
231   RegisterContextSP frame_zero_context = m_thread.GetRegisterContext();
232 
233   for (uint32_t set_idx = 0; set_idx < num_register_sets; ++set_idx) {
234     const RegisterSet *const reg_set = GetRegisterSet(set_idx);
235 
236     const uint32_t num_registers = reg_set->num_registers;
237     for (uint32_t reg_idx = 0; reg_idx < num_registers; ++reg_idx) {
238       const uint32_t reg = reg_set->registers[reg_idx];
239       const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
240       if (!reg_info || reg_info->value_regs)
241         continue;
242       RegisterValue reg_value;
243 
244       // If we can reconstruct the register from the frame we are copying from,
245       // then do so, otherwise use the value from frame 0.
246       if (context->ReadRegister(reg_info, reg_value)) {
247         WriteRegister(reg_info, reg_value);
248       } else if (frame_zero_context->ReadRegister(reg_info, reg_value)) {
249         WriteRegister(reg_info, reg_value);
250       }
251     }
252   }
253   return true;
254 }
255 
256 lldb::tid_t RegisterContext::GetThreadID() const { return m_thread.GetID(); }
257 
258 uint32_t RegisterContext::NumSupportedHardwareBreakpoints() { return 0; }
259 
260 uint32_t RegisterContext::SetHardwareBreakpoint(lldb::addr_t addr,
261                                                 size_t size) {
262   return LLDB_INVALID_INDEX32;
263 }
264 
265 // Used when parsing DWARF and EH frame information and any other object file
266 // sections that contain register numbers in them.
267 uint32_t
268 RegisterContext::ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
269                                                      uint32_t num) {
270   const uint32_t num_regs = GetRegisterCount();
271 
272   assert(kind < kNumRegisterKinds);
273   for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
274     const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg_idx);
275 
276     if (reg_info->kinds[kind] == num)
277       return reg_idx;
278   }
279 
280   return LLDB_INVALID_REGNUM;
281 }
282 
283 bool RegisterContext::ClearHardwareBreakpoint(uint32_t hw_idx) { return false; }
284 
285 uint32_t RegisterContext::NumSupportedHardwareWatchpoints() { return 0; }
286 
287 uint32_t RegisterContext::SetHardwareWatchpoint(lldb::addr_t addr, size_t size,
288                                                 bool read, bool write) {
289   return LLDB_INVALID_INDEX32;
290 }
291 
292 bool RegisterContext::ClearHardwareWatchpoint(uint32_t hw_index) {
293   return false;
294 }
295 
296 bool RegisterContext::HardwareSingleStep(bool enable) { return false; }
297 
298 Status RegisterContext::ReadRegisterValueFromMemory(
299     const RegisterInfo *reg_info, lldb::addr_t src_addr, uint32_t src_len,
300     RegisterValue &reg_value) {
301   Status error;
302   if (reg_info == nullptr) {
303     error.SetErrorString("invalid register info argument.");
304     return error;
305   }
306 
307   // Moving from addr into a register
308   //
309   // Case 1: src_len == dst_len
310   //
311   //   |AABBCCDD| Address contents
312   //   |AABBCCDD| Register contents
313   //
314   // Case 2: src_len > dst_len
315   //
316   //   Status!  (The register should always be big enough to hold the data)
317   //
318   // Case 3: src_len < dst_len
319   //
320   //   |AABB| Address contents
321   //   |AABB0000| Register contents [on little-endian hardware]
322   //   |0000AABB| Register contents [on big-endian hardware]
323   if (src_len > RegisterValue::kMaxRegisterByteSize) {
324     error.SetErrorString("register too small to receive memory data");
325     return error;
326   }
327 
328   const uint32_t dst_len = reg_info->byte_size;
329 
330   if (src_len > dst_len) {
331     error.SetErrorStringWithFormat(
332         "%u bytes is too big to store in register %s (%u bytes)", src_len,
333         reg_info->name, dst_len);
334     return error;
335   }
336 
337   ProcessSP process_sp(m_thread.GetProcess());
338   if (process_sp) {
339     uint8_t src[RegisterValue::kMaxRegisterByteSize];
340 
341     // Read the memory
342     const uint32_t bytes_read =
343         process_sp->ReadMemory(src_addr, src, src_len, error);
344 
345     // Make sure the memory read succeeded...
346     if (bytes_read != src_len) {
347       if (error.Success()) {
348         // This might happen if we read _some_ bytes but not all
349         error.SetErrorStringWithFormat("read %u of %u bytes", bytes_read,
350                                        src_len);
351       }
352       return error;
353     }
354 
355     // We now have a memory buffer that contains the part or all of the
356     // register value. Set the register value using this memory data.
357     // TODO: we might need to add a parameter to this function in case the byte
358     // order of the memory data doesn't match the process. For now we are
359     // assuming they are the same.
360     reg_value.SetFromMemoryData(*reg_info, src, src_len,
361                                 process_sp->GetByteOrder(), error);
362   } else
363     error.SetErrorString("invalid process");
364 
365   return error;
366 }
367 
368 Status RegisterContext::WriteRegisterValueToMemory(
369     const RegisterInfo *reg_info, lldb::addr_t dst_addr, uint32_t dst_len,
370     const RegisterValue &reg_value) {
371   Status error;
372   ProcessSP process_sp(m_thread.GetProcess());
373 
374   if (!process_sp) {
375     error.SetErrorString("invalid process");
376     return error;
377   }
378 
379   if (reg_info == nullptr) {
380     error.SetErrorString("Invalid register info argument.");
381     return error;
382   }
383 
384   // TODO: we might need to add a parameter to this function in case the byte
385   // order of the memory data doesn't match the process. For now we are
386   // assuming they are the same.
387   uint8_t dst[RegisterValue::kMaxRegisterByteSize];
388   const uint32_t bytes_copied = reg_value.GetAsMemoryData(
389       *reg_info, dst, dst_len, process_sp->GetByteOrder(), error);
390 
391   if (error.Success()) {
392     if (bytes_copied == 0) {
393       error.SetErrorString("byte copy failed.");
394     } else {
395       const uint32_t bytes_written =
396           process_sp->WriteMemory(dst_addr, dst, bytes_copied, error);
397       if (bytes_written != bytes_copied) {
398         if (error.Success()) {
399           // This might happen if we read _some_ bytes but not all
400           error.SetErrorStringWithFormat("only wrote %u of %u bytes",
401                                          bytes_written, bytes_copied);
402         }
403       }
404     }
405   }
406 
407   return error;
408 }
409 
410 lldb::ByteOrder RegisterContext::GetByteOrder() {
411   // Get the target process whose privileged thread was used for the register
412   // read.
413   lldb::ByteOrder byte_order = lldb::eByteOrderInvalid;
414   lldb_private::Process *process = CalculateProcess().get();
415 
416   if (process)
417     byte_order = process->GetByteOrder();
418   return byte_order;
419 }
420 
421 bool RegisterContext::ReadAllRegisterValues(
422     lldb_private::RegisterCheckpoint &reg_checkpoint) {
423   return ReadAllRegisterValues(reg_checkpoint.GetData());
424 }
425 
426 bool RegisterContext::WriteAllRegisterValues(
427     const lldb_private::RegisterCheckpoint &reg_checkpoint) {
428   return WriteAllRegisterValues(reg_checkpoint.GetData());
429 }
430 
431 TargetSP RegisterContext::CalculateTarget() {
432   return m_thread.CalculateTarget();
433 }
434 
435 ProcessSP RegisterContext::CalculateProcess() {
436   return m_thread.CalculateProcess();
437 }
438 
439 ThreadSP RegisterContext::CalculateThread() {
440   return m_thread.shared_from_this();
441 }
442 
443 StackFrameSP RegisterContext::CalculateStackFrame() {
444   // Register contexts might belong to many frames if we have inlined functions
445   // inside a frame since all inlined functions share the same registers, so we
446   // can't definitively say which frame we come from...
447   return StackFrameSP();
448 }
449 
450 void RegisterContext::CalculateExecutionContext(ExecutionContext &exe_ctx) {
451   m_thread.CalculateExecutionContext(exe_ctx);
452 }
453 
454 bool RegisterContext::ConvertBetweenRegisterKinds(lldb::RegisterKind source_rk,
455                                                   uint32_t source_regnum,
456                                                   lldb::RegisterKind target_rk,
457                                                   uint32_t &target_regnum) {
458   const uint32_t num_registers = GetRegisterCount();
459   for (uint32_t reg = 0; reg < num_registers; ++reg) {
460     const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
461 
462     if (reg_info->kinds[source_rk] == source_regnum) {
463       target_regnum = reg_info->kinds[target_rk];
464       return (target_regnum != LLDB_INVALID_REGNUM);
465     }
466   }
467   return false;
468 }
469