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