LLDB  mainline
NativeRegisterContext.cpp
Go to the documentation of this file.
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 
10 
11 #include "lldb/Utility/Log.h"
13 
14 #include "lldb/Host/PosixApi.h"
17 
18 using namespace lldb;
19 using namespace lldb_private;
20 
21 NativeRegisterContext::NativeRegisterContext(NativeThreadProtocol &thread)
22  : m_thread(thread) {}
23 
24 // Destructor
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 *
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 
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 
79  const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
80  if (reg_info)
81  return reg_info->name;
82  return nullptr;
83 }
84 
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 
114 
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 
132  return GetPC(fail_value);
133 }
134 
138  return WriteRegisterFromUnsigned(reg, pc);
139 }
140 
144  return ReadRegisterAsUnsigned(reg, fail_value);
145 }
146 
150  return WriteRegisterFromUnsigned(reg, sp);
151 }
152 
156  return ReadRegisterAsUnsigned(reg, fail_value);
157 }
158 
162  return WriteRegisterFromUnsigned(reg, fp);
163 }
164 
168  return ReadRegisterAsUnsigned(reg, fail_value);
169 }
170 
174  return ReadRegisterAsUnsigned(reg, fail_value);
175 }
176 
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
187  lldb::addr_t fail_value) {
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 
212  uint64_t uval) {
213  if (reg == LLDB_INVALID_REGNUM)
214  return Status("NativeRegisterContext::%s (): reg is invalid", __FUNCTION__);
216 }
217 
218 Status
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 
233  return m_thread.GetID();
234 }
235 
237 
239  size_t size) {
240  return LLDB_INVALID_INDEX32;
241 }
242 
244  return Status("not implemented");
245 }
246 
248  return false;
249 }
250 
252  lldb::addr_t trap_addr) {
253  bp_index = LLDB_INVALID_INDEX32;
254  return Status("not implemented");
255 }
256 
258 
260  size_t size,
261  uint32_t watch_flags) {
262  return LLDB_INVALID_INDEX32;
263 }
264 
266  return false;
267 }
268 
270  return Status("not implemented");
271 }
272 
274  is_hit = false;
275  return Status("not implemented");
276 }
277 
279  lldb::addr_t trap_addr) {
280  wp_index = LLDB_INVALID_INDEX32;
281  return Status("not implemented");
282 }
283 
285  bool &is_vacant) {
286  is_vacant = false;
287  return Status("not implemented");
288 }
289 
291  return LLDB_INVALID_ADDRESS;
292 }
293 
295  return LLDB_INVALID_ADDRESS;
296 }
297 
298 bool NativeRegisterContext::HardwareSingleStep(bool enable) { return false; }
299 
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) {
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 
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 
371  const RegisterInfo *reg_info, lldb::addr_t dst_addr, size_t dst_len,
372  const RegisterValue &reg_value) {
373 
375 
376  Status error;
377 
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
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 }
virtual Status WriteMemory(lldb::addr_t addr, const void *buf, size_t size, size_t &bytes_written)=0
Status WriteRegisterFromUnsigned(uint32_t reg, uint64_t uval)
uint32_t ConvertRegisterKindToRegisterNumber(uint32_t kind, uint32_t num) const
#define LLDB_REGNUM_GENERIC_PC
Definition: lldb-defines.h:63
lldb::addr_t GetFlags(lldb::addr_t fail_value=0)
virtual uint32_t GetRegisterCount() const =0
virtual lldb::addr_t GetWatchpointHitAddress(uint32_t wp_index)
lldb::addr_t ReadRegisterAsUnsigned(uint32_t reg, lldb::addr_t fail_value)
A class that represents a running process on the host machine.
lldb::addr_t GetFP(lldb::addr_t fail_value=LLDB_INVALID_ADDRESS)
insn ptr reg, stack ptr reg, etc not specific to any particular target
#define LLDB_REGNUM_GENERIC_RA
Definition: lldb-defines.h:66
virtual Status IsWatchpointHit(uint32_t wp_index, bool &is_hit)
uint32_t GetAsMemoryData(const RegisterInfo *reg_info, void *dst, uint32_t dst_len, lldb::ByteOrder dst_byte_order, Status &error) const
virtual const RegisterInfo * GetRegisterInfoAtIndex(uint32_t reg) const =0
virtual Status GetWatchpointHitIndex(uint32_t &wp_index, lldb::addr_t trap_addr)
virtual bool ClearHardwareWatchpoint(uint32_t hw_index)
lldb::addr_t GetSP(lldb::addr_t fail_value=LLDB_INVALID_ADDRESS)
virtual lldb::addr_t GetPCfromBreakpointLocation(lldb::addr_t fail_value=LLDB_INVALID_ADDRESS)
#define LLDB_REGNUM_GENERIC_SP
Definition: lldb-defines.h:64
virtual uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size, uint32_t watch_flags)
uint64_t GetAsUInt64(uint64_t fail_value=UINT64_MAX, bool *success_ptr=nullptr) const
lldb::addr_t GetReturnAddress(lldb::addr_t fail_value=LLDB_INVALID_ADDRESS)
bool SetUInt(uint64_t uint, uint32_t byte_size)
#define LLDB_REGNUM_GENERIC_FP
Definition: lldb-defines.h:65
virtual Status ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value)=0
#define LLDB_INVALID_ADDRESS
Invalid value definitions.
Definition: lldb-defines.h:85
#define LLDB_INVALID_INDEX32
Definition: lldb-defines.h:86
lldb&#39;s internal register numbers
static llvm::raw_ostream & error(Stream &strm)
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:58
NativeProcessProtocol & GetProcess()
#define LIBLLDB_LOG_THREAD
Definition: Logging.h:16
virtual Status ReadMemory(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read)=0
lldb::addr_t GetPC(lldb::addr_t fail_value=LLDB_INVALID_ADDRESS)
const RegisterInfo * GetRegisterInfoByName(llvm::StringRef reg_name, uint32_t start_idx=0)
const char * GetRegisterSetNameForRegisterAtIndex(uint32_t reg_index) const
uint64_t tid_t
Definition: lldb-types.h:86
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:242
#define LLDB_REGNUM_GENERIC_FLAGS
Definition: lldb-defines.h:67
bool Success() const
Test for success condition.
Definition: Status.cpp:288
virtual Status WriteRegisterValueToMemory(const lldb_private::RegisterInfo *reg_info, lldb::addr_t dst_addr, size_t dst_len, const RegisterValue &reg_value)
#define LLDB_LOGF(log,...)
Definition: Log.h:249
uint64_t addr_t
Definition: lldb-types.h:83
virtual uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size)
bool Fail() const
Test for error condition.
Definition: Status.cpp:182
virtual bool ClearHardwareBreakpoint(uint32_t hw_idx)
Definition: SBAddress.h:15
virtual lldb::addr_t GetWatchpointAddress(uint32_t wp_index)
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:256
virtual Status IsWatchpointVacant(uint32_t wp_index, bool &is_vacant)
virtual const RegisterSet * GetRegisterSet(uint32_t set_index) const =0
uint32_t SetFromMemoryData(const RegisterInfo *reg_info, const void *src, uint32_t src_len, lldb::ByteOrder src_byte_order, Status &error)
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:131
virtual bool HardwareSingleStep(bool enable)
virtual Status ReadRegisterValueFromMemory(const lldb_private::RegisterInfo *reg_info, lldb::addr_t src_addr, size_t src_len, RegisterValue &reg_value)
virtual Status GetHardwareBreakHitIndex(uint32_t &bp_index, lldb::addr_t trap_addr)
virtual Status WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value)=0
const char * GetRegisterName(uint32_t reg)
virtual uint32_t GetRegisterSetCount() const =0
const RegisterInfo * GetRegisterInfo(uint32_t reg_kind, uint32_t reg_num)
An error handling class.
Definition: Status.h:44
#define LLDB_INVALID_REGNUM
Definition: lldb-defines.h:90