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   const uint32_t dst_len = reg_info->byte_size;
324 
325   if (src_len > dst_len) {
326     error.SetErrorStringWithFormat(
327         "%u bytes is too big to store in register %s (%u bytes)", src_len,
328         reg_info->name, dst_len);
329     return error;
330   }
331 
332   ProcessSP process_sp(m_thread.GetProcess());
333   if (process_sp) {
334     RegisterValue::BytesContainer src(src_len);
335 
336     // Read the memory
337     const uint32_t bytes_read =
338         process_sp->ReadMemory(src_addr, src.data(), src_len, error);
339 
340     // Make sure the memory read succeeded...
341     if (bytes_read != src_len) {
342       if (error.Success()) {
343         // This might happen if we read _some_ bytes but not all
344         error.SetErrorStringWithFormat("read %u of %u bytes", bytes_read,
345                                        src_len);
346       }
347       return error;
348     }
349 
350     // We now have a memory buffer that contains the part or all of the
351     // register value. Set the register value using this memory data.
352     // TODO: we might need to add a parameter to this function in case the byte
353     // order of the memory data doesn't match the process. For now we are
354     // assuming they are the same.
355     reg_value.SetFromMemoryData(*reg_info, src.data(), src_len,
356                                 process_sp->GetByteOrder(), error);
357   } else
358     error.SetErrorString("invalid process");
359 
360   return error;
361 }
362 
363 Status RegisterContext::WriteRegisterValueToMemory(
364     const RegisterInfo *reg_info, lldb::addr_t dst_addr, uint32_t dst_len,
365     const RegisterValue &reg_value) {
366   Status error;
367   ProcessSP process_sp(m_thread.GetProcess());
368 
369   if (!process_sp) {
370     error.SetErrorString("invalid process");
371     return error;
372   }
373 
374   if (reg_info == nullptr) {
375     error.SetErrorString("Invalid register info argument.");
376     return error;
377   }
378 
379   // TODO: we might need to add a parameter to this function in case the byte
380   // order of the memory data doesn't match the process. For now we are
381   // assuming they are the same.
382   RegisterValue::BytesContainer dst(dst_len);
383   const uint32_t bytes_copied = reg_value.GetAsMemoryData(
384       *reg_info, dst.data(), dst_len, process_sp->GetByteOrder(), error);
385 
386   if (error.Success()) {
387     if (bytes_copied == 0) {
388       error.SetErrorString("byte copy failed.");
389     } else {
390       const uint32_t bytes_written =
391           process_sp->WriteMemory(dst_addr, dst.data(), bytes_copied, error);
392       if (bytes_written != bytes_copied) {
393         if (error.Success()) {
394           // This might happen if we read _some_ bytes but not all
395           error.SetErrorStringWithFormat("only wrote %u of %u bytes",
396                                          bytes_written, bytes_copied);
397         }
398       }
399     }
400   }
401 
402   return error;
403 }
404 
405 lldb::ByteOrder RegisterContext::GetByteOrder() {
406   // Get the target process whose privileged thread was used for the register
407   // read.
408   lldb::ByteOrder byte_order = lldb::eByteOrderInvalid;
409   lldb_private::Process *process = CalculateProcess().get();
410 
411   if (process)
412     byte_order = process->GetByteOrder();
413   return byte_order;
414 }
415 
416 bool RegisterContext::ReadAllRegisterValues(
417     lldb_private::RegisterCheckpoint &reg_checkpoint) {
418   return ReadAllRegisterValues(reg_checkpoint.GetData());
419 }
420 
421 bool RegisterContext::WriteAllRegisterValues(
422     const lldb_private::RegisterCheckpoint &reg_checkpoint) {
423   return WriteAllRegisterValues(reg_checkpoint.GetData());
424 }
425 
426 TargetSP RegisterContext::CalculateTarget() {
427   return m_thread.CalculateTarget();
428 }
429 
430 ProcessSP RegisterContext::CalculateProcess() {
431   return m_thread.CalculateProcess();
432 }
433 
434 ThreadSP RegisterContext::CalculateThread() {
435   return m_thread.shared_from_this();
436 }
437 
438 StackFrameSP RegisterContext::CalculateStackFrame() {
439   // Register contexts might belong to many frames if we have inlined functions
440   // inside a frame since all inlined functions share the same registers, so we
441   // can't definitively say which frame we come from...
442   return StackFrameSP();
443 }
444 
445 void RegisterContext::CalculateExecutionContext(ExecutionContext &exe_ctx) {
446   m_thread.CalculateExecutionContext(exe_ctx);
447 }
448 
449 bool RegisterContext::ConvertBetweenRegisterKinds(lldb::RegisterKind source_rk,
450                                                   uint32_t source_regnum,
451                                                   lldb::RegisterKind target_rk,
452                                                   uint32_t &target_regnum) {
453   const uint32_t num_registers = GetRegisterCount();
454   for (uint32_t reg = 0; reg < num_registers; ++reg) {
455     const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
456 
457     if (reg_info->kinds[source_rk] == source_regnum) {
458       target_regnum = reg_info->kinds[target_rk];
459       return (target_regnum != LLDB_INVALID_REGNUM);
460     }
461   }
462   return false;
463 }
464