LLDB  mainline
ThreadPlanStepRange.cpp
Go to the documentation of this file.
1 //===-- ThreadPlanStepRange.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 
12 #include "lldb/Core/Disassembler.h"
13 #include "lldb/Symbol/Function.h"
14 #include "lldb/Symbol/Symbol.h"
16 #include "lldb/Target/Process.h"
18 #include "lldb/Target/StopInfo.h"
19 #include "lldb/Target/Target.h"
20 #include "lldb/Target/Thread.h"
22 #include "lldb/Utility/LLDBLog.h"
23 #include "lldb/Utility/Log.h"
24 #include "lldb/Utility/Stream.h"
25 
26 using namespace lldb;
27 using namespace lldb_private;
28 
29 // ThreadPlanStepRange: Step through a stack range, either stepping over or
30 // into based on the value of \a type.
31 
32 ThreadPlanStepRange::ThreadPlanStepRange(ThreadPlanKind kind, const char *name,
33  Thread &thread,
34  const AddressRange &range,
35  const SymbolContext &addr_context,
36  lldb::RunMode stop_others,
37  bool given_ranges_only)
38  : ThreadPlan(kind, name, thread, eVoteNoOpinion, eVoteNoOpinion),
39  m_addr_context(addr_context), m_address_ranges(),
40  m_stop_others(stop_others), m_stack_id(), m_parent_stack_id(),
41  m_no_more_plans(false), m_first_run_event(true), m_use_fast_step(false),
42  m_given_ranges_only(given_ranges_only) {
44  AddRange(range);
45  m_stack_id = thread.GetStackFrameAtIndex(0)->GetStackID();
46  StackFrameSP parent_stack = thread.GetStackFrameAtIndex(1);
47  if (parent_stack)
48  m_parent_stack_id = parent_stack->GetStackID();
49 }
50 
52 
54  // See if we can find a "next range" breakpoint:
56 }
57 
60  if (error)
61  error->PutCString(
62  "Could not create hardware breakpoint for thread plan.");
63  return false;
64  }
65  return true;
66 }
67 
69  Log *log = GetLog(LLDBLog::Step);
70 
71  const Vote vote = IsPlanComplete() ? eVoteYes : eVoteNo;
72  LLDB_LOGF(log, "ThreadPlanStepRange::ShouldReportStop() returning vote %i\n",
73  vote);
74  return vote;
75 }
76 
78  // For now I'm just adding the ranges. At some point we may want to condense
79  // the ranges if they overlap, though I don't think it is likely to be very
80  // important.
81  m_address_ranges.push_back(new_range);
82 
83  // Fill the slot for this address range with an empty DisassemblerSP in the
84  // instruction ranges. I want the indices to match, but I don't want to do
85  // the work to disassemble this range if I don't step into it.
86  m_instruction_ranges.push_back(DisassemblerSP());
87 }
88 
90  size_t num_ranges = m_address_ranges.size();
91  if (num_ranges == 1) {
93  } else {
94  for (size_t i = 0; i < num_ranges; i++) {
95  s->Printf(" %" PRIu64 ": ", uint64_t(i));
97  }
98  }
99 }
100 
102  Log *log = GetLog(LLDBLog::Step);
103  bool ret_value = false;
104  Thread &thread = GetThread();
105  lldb::addr_t pc_load_addr = thread.GetRegisterContext()->GetPC();
106 
107  size_t num_ranges = m_address_ranges.size();
108  for (size_t i = 0; i < num_ranges; i++) {
109  ret_value =
110  m_address_ranges[i].ContainsLoadAddress(pc_load_addr, &GetTarget());
111  if (ret_value)
112  break;
113  }
114 
115  if (!ret_value && !m_given_ranges_only) {
116  // See if we've just stepped to another part of the same line number...
117  StackFrame *frame = thread.GetStackFrameAtIndex(0).get();
118 
119  SymbolContext new_context(
120  frame->GetSymbolContext(eSymbolContextEverything));
122  new_context.line_entry.IsValid()) {
124  new_context.line_entry.original_file) {
125  if (m_addr_context.line_entry.line == new_context.line_entry.line) {
126  m_addr_context = new_context;
127  const bool include_inlined_functions =
130  include_inlined_functions));
131  ret_value = true;
132  if (log) {
133  StreamString s;
137 
138  LLDB_LOGF(
139  log,
140  "Step range plan stepped to another range of same line: %s",
141  s.GetData());
142  }
143  } else if (new_context.line_entry.line == 0) {
145  m_addr_context = new_context;
146  const bool include_inlined_functions =
149  include_inlined_functions));
150  ret_value = true;
151  if (log) {
152  StreamString s;
156 
157  LLDB_LOGF(log,
158  "Step range plan stepped to a range at linenumber 0 "
159  "stepping through that range: %s",
160  s.GetData());
161  }
162  } else if (new_context.line_entry.range.GetBaseAddress().GetLoadAddress(
163  &GetTarget()) != pc_load_addr) {
164  // Another thing that sometimes happens here is that we step out of
165  // one line into the MIDDLE of another line. So far I mostly see
166  // this due to bugs in the debug information. But we probably don't
167  // want to be in the middle of a line range, so in that case reset
168  // the stepping range to the line we've stepped into the middle of
169  // and continue.
170  m_addr_context = new_context;
171  m_address_ranges.clear();
173  ret_value = true;
174  if (log) {
175  StreamString s;
179 
180  LLDB_LOGF(log,
181  "Step range plan stepped to the middle of new "
182  "line(%d): %s, continuing to clear this line.",
183  new_context.line_entry.line, s.GetData());
184  }
185  }
186  }
187  }
188  }
189 
190  if (!ret_value && log)
191  LLDB_LOGF(log, "Step range plan out of range to 0x%" PRIx64, pc_load_addr);
192 
193  return ret_value;
194 }
195 
197  lldb::addr_t cur_pc = GetThread().GetRegisterContext()->GetPC();
198  if (m_addr_context.function != nullptr) {
200  cur_pc, &GetTarget());
204  return range.ContainsLoadAddress(cur_pc, &GetTarget());
205  }
206  return false;
207 }
208 
209 // FIXME: This should also handle inlining if we aren't going to do inlining in
210 // the
211 // main stack.
212 //
213 // Ideally we should remember the whole stack frame list, and then compare that
214 // to the current list.
215 
217  FrameComparison frame_order;
218  Thread &thread = GetThread();
219  StackID cur_frame_id = thread.GetStackFrameAtIndex(0)->GetStackID();
220 
221  if (cur_frame_id == m_stack_id) {
222  frame_order = eFrameCompareEqual;
223  } else if (cur_frame_id < m_stack_id) {
224  frame_order = eFrameCompareYounger;
225  } else {
226  StackFrameSP cur_parent_frame = thread.GetStackFrameAtIndex(1);
227  StackID cur_parent_id;
228  if (cur_parent_frame)
229  cur_parent_id = cur_parent_frame->GetStackID();
230  if (m_parent_stack_id.IsValid() && cur_parent_id.IsValid() &&
231  m_parent_stack_id == cur_parent_id)
232  frame_order = eFrameCompareSameParent;
233  else
234  frame_order = eFrameCompareOlder;
235  }
236  return frame_order;
237 }
238 
240  switch (m_stop_others) {
242  return true;
244  // If there is a call in the range of the next branch breakpoint,
245  // then we should always run all threads, since a call can execute
246  // arbitrary code which might for instance take a lock that's held
247  // by another thread.
248  return !m_found_calls;
249  case lldb::eAllThreads:
250  return false;
251  }
252  llvm_unreachable("Unhandled run mode!");
253 }
254 
256  lldb::addr_t addr, size_t &range_index, size_t &insn_offset) {
257  size_t num_ranges = m_address_ranges.size();
258  for (size_t i = 0; i < num_ranges; i++) {
259  if (m_address_ranges[i].ContainsLoadAddress(addr, &GetTarget())) {
260  // Some joker added a zero size range to the stepping range...
261  if (m_address_ranges[i].GetByteSize() == 0)
262  return nullptr;
263 
264  if (!m_instruction_ranges[i]) {
265  // Disassemble the address range given:
266  const char *plugin_name = nullptr;
267  const char *flavor = nullptr;
269  GetTarget().GetArchitecture(), plugin_name, flavor, GetTarget(),
270  m_address_ranges[i]);
271  }
272  if (!m_instruction_ranges[i])
273  return nullptr;
274  else {
275  // Find where we are in the instruction list as well. If we aren't at
276  // an instruction, return nullptr. In this case, we're probably lost,
277  // and shouldn't try to do anything fancy.
278 
279  insn_offset =
281  ->GetInstructionList()
282  .GetIndexOfInstructionAtLoadAddress(addr, GetTarget());
283  if (insn_offset == UINT32_MAX)
284  return nullptr;
285  else {
286  range_index = i;
287  return &m_instruction_ranges[i]->GetInstructionList();
288  }
289  }
290  }
291  }
292  return nullptr;
293 }
294 
296  if (m_next_branch_bp_sp) {
297  Log *log = GetLog(LLDBLog::Step);
298  LLDB_LOGF(log, "Removing next branch breakpoint: %d.",
299  m_next_branch_bp_sp->GetID());
301  m_next_branch_bp_sp.reset();
303  m_found_calls = false;
304  }
305 }
306 
309  return true;
310 
311  Log *log = GetLog(LLDBLog::Step);
312  // Stepping through ranges using breakpoints doesn't work yet, but with this
313  // off we fall back to instruction single stepping.
314  if (!m_use_fast_step)
315  return false;
316 
317  // clear the m_found_calls, we'll rediscover it for this range.
318  m_found_calls = false;
319 
320  lldb::addr_t cur_addr = GetThread().GetRegisterContext()->GetPC();
321  // Find the current address in our address ranges, and fetch the disassembly
322  // if we haven't already:
323  size_t pc_index;
324  size_t range_index;
325  InstructionList *instructions =
326  GetInstructionsForAddress(cur_addr, range_index, pc_index);
327  if (instructions == nullptr)
328  return false;
329  else {
330  const bool ignore_calls = GetKind() == eKindStepOverRange;
331  uint32_t branch_index = instructions->GetIndexOfNextBranchInstruction(
332  pc_index, ignore_calls, &m_found_calls);
333  Address run_to_address;
334 
335  // If we didn't find a branch, run to the end of the range.
336  if (branch_index == UINT32_MAX) {
337  uint32_t last_index = instructions->GetSize() - 1;
338  if (last_index - pc_index > 1) {
339  InstructionSP last_inst =
340  instructions->GetInstructionAtIndex(last_index);
341  size_t last_inst_size = last_inst->GetOpcode().GetByteSize();
342  run_to_address = last_inst->GetAddress();
343  run_to_address.Slide(last_inst_size);
344  }
345  } else if (branch_index - pc_index > 1) {
346  run_to_address =
347  instructions->GetInstructionAtIndex(branch_index)->GetAddress();
348  }
349 
350  if (run_to_address.IsValid()) {
351  const bool is_internal = true;
353  GetTarget().CreateBreakpoint(run_to_address, is_internal, false);
354  if (m_next_branch_bp_sp) {
355 
356  if (m_next_branch_bp_sp->IsHardware() &&
357  !m_next_branch_bp_sp->HasResolvedLocations())
359 
360  if (log) {
362  BreakpointLocationSP bp_loc =
363  m_next_branch_bp_sp->GetLocationAtIndex(0);
364  if (bp_loc) {
365  BreakpointSiteSP bp_site = bp_loc->GetBreakpointSite();
366  if (bp_site) {
367  bp_site_id = bp_site->GetID();
368  }
369  }
370  LLDB_LOGF(log,
371  "ThreadPlanStepRange::SetNextBranchBreakpoint - Setting "
372  "breakpoint %d (site %d) to run to address 0x%" PRIx64,
373  m_next_branch_bp_sp->GetID(), bp_site_id,
374  run_to_address.GetLoadAddress(&m_process.GetTarget()));
375  }
376 
377  m_next_branch_bp_sp->SetThreadID(m_tid);
378  m_next_branch_bp_sp->SetBreakpointKind("next-branch-location");
379 
380  return true;
381  } else
382  return false;
383  }
384  }
385  return false;
386 }
387 
389  lldb::StopInfoSP stop_info_sp) {
390  Log *log = GetLog(LLDBLog::Step);
391  if (!m_next_branch_bp_sp)
392  return false;
393 
394  break_id_t bp_site_id = stop_info_sp->GetValue();
395  BreakpointSiteSP bp_site_sp =
397  if (!bp_site_sp)
398  return false;
399  else if (!bp_site_sp->IsBreakpointAtThisSite(m_next_branch_bp_sp->GetID()))
400  return false;
401  else {
402  // If we've hit the next branch breakpoint, then clear it.
403  size_t num_owners = bp_site_sp->GetNumberOfOwners();
404  bool explains_stop = true;
405  // If all the owners are internal, then we are probably just stepping over
406  // this range from multiple threads, or multiple frames, so we want to
407  // continue. If one is not internal, then we should not explain the stop,
408  // and let the user breakpoint handle the stop.
409  for (size_t i = 0; i < num_owners; i++) {
410  if (!bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint().IsInternal()) {
411  explains_stop = false;
412  break;
413  }
414  }
415  LLDB_LOGF(log,
416  "ThreadPlanStepRange::NextRangeBreakpointExplainsStop - Hit "
417  "next range breakpoint which has %" PRIu64
418  " owners - explains stop: %u.",
419  (uint64_t)num_owners, explains_stop);
421  return explains_stop;
422  }
423 }
424 
425 bool ThreadPlanStepRange::WillStop() { return true; }
426 
429  return eStateRunning;
430  else
431  return eStateStepping;
432 }
433 
435  // If we have pushed some plans between ShouldStop & MischiefManaged, then
436  // we're not done...
437  // I do this check first because we might have stepped somewhere that will
438  // fool InRange into
439  // thinking it needs to step past the end of that line. This happens, for
440  // instance, when stepping over inlined code that is in the middle of the
441  // current line.
442 
443  if (!m_no_more_plans)
444  return false;
445 
446  bool done = true;
447  if (!IsPlanComplete()) {
448  if (InRange()) {
449  done = false;
450  } else {
452  done = (frame_order != eFrameCompareOlder) ? m_no_more_plans : true;
453  }
454  }
455 
456  if (done) {
457  Log *log = GetLog(LLDBLog::Step);
458  LLDB_LOGF(log, "Completed step through range plan.");
461  return true;
462  } else {
463  return false;
464  }
465 }
466 
468  Log *log = GetLog(LLDBLog::Step);
470 
471  if (frame_order == eFrameCompareOlder) {
472  if (log) {
473  LLDB_LOGF(log, "ThreadPlanStepRange::IsPlanStale returning true, we've "
474  "stepped out.");
475  }
476  return true;
477  } else if (frame_order == eFrameCompareEqual && InSymbol()) {
478  // If we are not in a place we should step through, we've gotten stale. One
479  // tricky bit here is that some stubs don't push a frame, so we should.
480  // check that we are in the same symbol.
481  if (!InRange()) {
482  // Set plan Complete when we reach next instruction just after the range
483  lldb::addr_t addr = GetThread().GetRegisterContext()->GetPC() - 1;
484  size_t num_ranges = m_address_ranges.size();
485  for (size_t i = 0; i < num_ranges; i++) {
486  bool in_range =
487  m_address_ranges[i].ContainsLoadAddress(addr, &GetTarget());
488  if (in_range) {
489  SetPlanComplete();
490  }
491  }
492  return true;
493  }
494  }
495  return false;
496 }
lldb::eFrameCompareEqual
@ eFrameCompareEqual
Definition: lldb-enumerations.h:881
lldb_private::AddressRange::GetBaseAddress
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:209
lldb_private::ThreadPlan::GetThread
Thread & GetThread()
Returns the Thread that is using this thread plan.
Definition: ThreadPlan.cpp:42
lldb::FrameComparison
FrameComparison
This is the return value for frame comparisons.
Definition: lldb-enumerations.h:878
lldb_private::Address::IsValid
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:345
lldb_private::Event
Definition: Event.h:182
lldb_private::ThreadPlan::IsPlanComplete
bool IsPlanComplete()
Definition: ThreadPlan.cpp:61
lldb_private::LineEntry::IsValid
bool IsValid() const
Check if a line entry object is valid.
Definition: LineEntry.cpp:46
lldb_private::Function::GetAddressRange
const AddressRange & GetAddressRange()
Definition: Function.h:457
lldb_private::Symbol::ValueIsAddress
bool ValueIsAddress() const
Definition: Symbol.cpp:117
lldb_private::eVoteYes
@ eVoteYes
Definition: lldb-private-enumerations.h:59
lldb_private::ThreadPlanStepRange::GetPlanRunState
lldb::StateType GetPlanRunState() override
Definition: ThreadPlanStepRange.cpp:427
lldb_private::ThreadPlanStepRange::m_addr_context
SymbolContext m_addr_context
Definition: ThreadPlanStepRange.h:65
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:344
lldb_private::ThreadPlan::GetKind
ThreadPlanKind GetKind() const
Definition: ThreadPlan.h:425
lldb_private::ThreadPlanStepRange::SetNextBranchBreakpoint
bool SetNextBranchBreakpoint()
Definition: ThreadPlanStepRange.cpp:307
lldb_private::ThreadPlanStepRange::m_next_branch_bp_sp
lldb::BreakpointSP m_next_branch_bp_sp
Definition: ThreadPlanStepRange.h:76
lldb_private::Process::GetBreakpointSiteList
BreakpointSiteList & GetBreakpointSiteList()
Definition: Process.cpp:1565
lldb_private::ThreadPlanStepRange::IsPlanStale
bool IsPlanStale() override
Definition: ThreadPlanStepRange.cpp:467
BreakpointLocation.h
lldb_private::Process::GetTarget
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1219
lldb_private::ThreadPlan::eKindStepOverRange
@ eKindStepOverRange
Definition: ThreadPlan.h:301
lldb_private::LineEntry::GetSameLineContiguousAddressRange
AddressRange GetSameLineContiguousAddressRange(bool include_inlined_functions) const
Give the range for this LineEntry + any additional LineEntries for this same source line that are con...
Definition: LineEntry.cpp:192
Disassembler.h
lldb_private::eVoteNoOpinion
@ eVoteNoOpinion
Definition: lldb-private-enumerations.h:59
lldb_private::InstructionList::GetInstructionAtIndex
lldb::InstructionSP GetInstructionAtIndex(size_t idx) const
Definition: Disassembler.cpp:981
lldb_private::Stream
Definition: Stream.h:28
lldb_private::Target::CreateBreakpoint
lldb::BreakpointSP CreateBreakpoint(const FileSpecList *containingModules, const FileSpec &file, uint32_t line_no, uint32_t column, lldb::addr_t offset, LazyBool check_inlines, LazyBool skip_prologue, bool internal, bool request_hardware, LazyBool move_to_nearest_code)
Definition: Target.cpp:353
lldb_private::ThreadPlanStepRange::m_instruction_ranges
std::vector< lldb::DisassemblerSP > m_instruction_ranges
Definition: ThreadPlanStepRange.h:87
lldb_private::ThreadPlanStepRange::NextRangeBreakpointExplainsStop
bool NextRangeBreakpointExplainsStop(lldb::StopInfoSP stop_info_sp)
Definition: ThreadPlanStepRange.cpp:388
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::SymbolContext
Definition: SymbolContext.h:33
Process.h
lldb_private::ThreadPlanStepRange::m_given_ranges_only
bool m_given_ranges_only
Definition: ThreadPlanStepRange.h:78
Target.h
lldb_private::ThreadPlan::ThreadPlanKind
ThreadPlanKind
Definition: ThreadPlan.h:292
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::SymbolContext::symbol
Symbol * symbol
The Symbol for a given query.
Definition: SymbolContext.h:323
lldb_private::LineEntry::Dump
bool Dump(Stream *s, Target *target, bool show_file, Address::DumpStyle style, Address::DumpStyle fallback_style, bool show_range) const
Dump a description of this object to a Stream.
Definition: LineEntry.cpp:70
lldb_private::ThreadPlan::GetTarget
Target & GetTarget()
Definition: ThreadPlan.cpp:38
lldb_private::ThreadPlan
Definition: ThreadPlan.h:287
lldb_private::InstructionList
Definition: Disassembler.h:283
lldb_private::eVoteNo
@ eVoteNo
Definition: lldb-private-enumerations.h:59
ThreadPlanStepRange.h
lldb_private::Disassembler::DisassembleRange
static lldb::DisassemblerSP DisassembleRange(const ArchSpec &arch, const char *plugin_name, const char *flavor, Target &target, const AddressRange &disasm_range, bool force_live_memory=false)
Definition: Disassembler.cpp:122
lldb_private::Address::DumpStyleLoadAddress
@ DumpStyleLoadAddress
Display as the load address (if resolved).
Definition: Address.h:96
Log.h
lldb_private::ThreadPlanStepRange::m_parent_stack_id
StackID m_parent_stack_id
Definition: ThreadPlanStepRange.h:69
lldb_private::ThreadPlanStepRange::m_no_more_plans
bool m_no_more_plans
Definition: ThreadPlanStepRange.h:71
lldb_private::ThreadPlan::MischiefManaged
virtual bool MischiefManaged()
Definition: ThreadPlan.cpp:72
lldb_private::Thread
Definition: Thread.h:61
lldb::eFrameCompareSameParent
@ eFrameCompareSameParent
Definition: lldb-enumerations.h:882
lldb_private::StreamString::GetData
const char * GetData() const
Definition: StreamString.h:43
lldb_private::SymbolContext::function
Function * function
The Function for a given query.
Definition: SymbolContext.h:320
lldb_private::Symbol::GetAddressRef
Address & GetAddressRef()
Definition: Symbol.h:57
lldb::break_id_t
int32_t break_id_t
Definition: lldb-types.h:88
lldb_private::StreamString
Definition: StreamString.h:23
lldb_private::AddressRange
Definition: AddressRange.h:25
lldb_private::ThreadPlanStepRange::DidPush
void DidPush() override
Definition: ThreadPlanStepRange.cpp:53
lldb_private::BreakpointSiteList::FindByID
lldb::BreakpointSiteSP FindByID(lldb::break_id_t breakID)
Returns a shared pointer to the breakpoint site with id breakID.
Definition: BreakpointSiteList.cpp:111
lldb_private::ThreadPlanStepRange::AddRange
void AddRange(const AddressRange &new_range)
Definition: ThreadPlanStepRange.cpp:77
lldb_private::InstructionList::GetIndexOfNextBranchInstruction
uint32_t GetIndexOfNextBranchInstruction(uint32_t start, bool ignore_calls, bool *found_calls) const
Get the index of the next branch instruction.
Definition: Disassembler.cpp:1029
lldb_private::ThreadPlanStepRange::ClearNextBranchBreakpoint
void ClearNextBranchBreakpoint()
Definition: ThreadPlanStepRange.cpp:295
ThreadPlanRunToAddress.h
lldb::eFrameCompareYounger
@ eFrameCompareYounger
Definition: lldb-enumerations.h:883
Thread.h
lldb_private::ThreadPlanStepRange::InSymbol
bool InSymbol()
Definition: ThreadPlanStepRange.cpp:196
lldb_private::LLDBLog::Step
@ Step
lldb_private::ThreadPlanStepRange::GetInstructionsForAddress
InstructionList * GetInstructionsForAddress(lldb::addr_t addr, size_t &range_index, size_t &insn_offset)
Definition: ThreadPlanStepRange.cpp:255
lldb_private::LineEntry::original_file
FileSpec original_file
The original source file, from debug info.
Definition: LineEntry.h:142
lldb_private::LineEntry::line
uint32_t line
The source line number, or zero if there is no line number information.
Definition: LineEntry.h:143
lldb::RunMode
RunMode
Thread Run Modes.
Definition: lldb-enumerations.h:136
LLDB_INVALID_BREAK_ID
#define LLDB_INVALID_BREAK_ID
Definition: lldb-defines.h:37
Symbol.h
lldb::eStateStepping
@ eStateStepping
Process or thread is in the process of stepping and can not be examined.
Definition: lldb-enumerations.h:87
lldb_private::ThreadPlan::SetPlanComplete
void SetPlanComplete(bool success=true)
Definition: ThreadPlan.cpp:66
lldb_private::ThreadPlanStepRange::m_stack_id
StackID m_stack_id
Definition: ThreadPlanStepRange.h:68
lldb_private::ThreadPlanStepRange::~ThreadPlanStepRange
~ThreadPlanStepRange() override
Definition: ThreadPlanStepRange.cpp:51
uint32_t
lldb_private::ThreadPlanStepRange::ShouldReportStop
Vote ShouldReportStop(Event *event_ptr) override
Definition: ThreadPlanStepRange.cpp:68
lldb_private::Address
Definition: Address.h:59
lldb_private::ThreadPlanStepRange::m_use_fast_step
bool m_use_fast_step
Definition: ThreadPlanStepRange.h:77
lldb::eOnlyDuringStepping
@ eOnlyDuringStepping
Definition: lldb-enumerations.h:136
lldb_private::ThreadPlan::m_could_not_resolve_hw_bp
bool m_could_not_resolve_hw_bp
Definition: ThreadPlan.h:535
lldb_private::ThreadPlanStepRange::CompareCurrentFrameToStartFrame
lldb::FrameComparison CompareCurrentFrameToStartFrame()
Definition: ThreadPlanStepRange.cpp:216
lldb_private::ThreadPlanStepRange::DumpRanges
void DumpRanges(Stream *s)
Definition: ThreadPlanStepRange.cpp:89
lldb_private::Address::GetLoadAddress
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:311
lldb_private::Symbol::GetByteSize
lldb::addr_t GetByteSize() const
Definition: Symbol.cpp:414
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:19
lldb_private::LineEntry::range
AddressRange range
The section offset address range for this line entry.
Definition: LineEntry.h:139
lldb_private::TargetProperties::GetUseFastStepping
bool GetUseFastStepping() const
Definition: Target.cpp:4565
StopInfo.h
lldb_private::Vote
Vote
Definition: lldb-private-enumerations.h:59
lldb_private::Target::RemoveBreakpointByID
bool RemoveBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:953
lldb_private::ThreadPlanStepRange::ValidatePlan
bool ValidatePlan(Stream *error) override
Returns whether this plan could be successfully created.
Definition: ThreadPlanStepRange.cpp:58
Function.h
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb_private::InstructionList::GetSize
size_t GetSize() const
Definition: Disassembler.cpp:967
lldb_private::ThreadPlanStepRange::m_stop_others
lldb::RunMode m_stop_others
Definition: ThreadPlanStepRange.h:67
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::StackID::IsValid
bool IsValid() const
Definition: StackID.h:47
lldb_private::ThreadPlan::m_tid
lldb::tid_t m_tid
Definition: ThreadPlan.h:531
lldb::eAllThreads
@ eAllThreads
Definition: lldb-enumerations.h:136
lldb_private::StackID
Definition: StackID.h:17
lldb_private::ThreadPlanStepRange::m_address_ranges
std::vector< AddressRange > m_address_ranges
Definition: ThreadPlanStepRange.h:66
BreakpointSite.h
lldb::StateType
StateType
Process and Thread States.
Definition: lldb-enumerations.h:74
Stream.h
lldb_private::Log
Definition: Log.h:115
lldb_private::ThreadPlanStepRange::m_found_calls
bool m_found_calls
Definition: ThreadPlanStepRange.h:79
lldb_private::Thread::GetStackFrameAtIndex
virtual lldb::StackFrameSP GetStackFrameAtIndex(uint32_t idx)
Definition: Thread.h:399
lldb_private::ThreadPlanStepRange::InRange
bool InRange()
Definition: ThreadPlanStepRange.cpp:101
lldb_private::SymbolContext::line_entry
LineEntry line_entry
The LineEntry for a given query.
Definition: SymbolContext.h:322
lldb_private::ThreadPlanStepRange::MischiefManaged
bool MischiefManaged() override
Definition: ThreadPlanStepRange.cpp:434
lldb_private::Thread::GetRegisterContext
virtual lldb::RegisterContextSP GetRegisterContext()=0
lldb_private::GetLog
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:309
lldb_private::ThreadPlan::m_process
Process & m_process
Definition: ThreadPlan.h:530
lldb_private::AddressRange::ContainsLoadAddress
bool ContainsLoadAddress(const Address &so_addr, Target *target) const
Check if a section offset so_addr when represented as a load address is contained within this object'...
Definition: AddressRange.cpp:93
lldb_private::ThreadPlanStepRange::StopOthers
bool StopOthers() override
Definition: ThreadPlanStepRange.cpp:239
lldb_private::StackFrame
Definition: StackFrame.h:40
lldb_private::Address::Slide
bool Slide(int64_t offset)
Definition: Address.h:449
lldb
Definition: SBAddress.h:15
lldb_private::ThreadPlanStepRange::WillStop
bool WillStop() override
Definition: ThreadPlanStepRange.cpp:425
lldb::eStateRunning
@ eStateRunning
Process or thread is running and can't be examined.
Definition: lldb-enumerations.h:86
RegisterContext.h
lldb_private::StackFrame::GetSymbolContext
const SymbolContext & GetSymbolContext(lldb::SymbolContextItem resolve_scope)
Provide a SymbolContext for this StackFrame's current pc value.
Definition: StackFrame.cpp:300
LLDBLog.h
ExecutionContext.h
lldb::eFrameCompareOlder
@ eFrameCompareOlder
Definition: lldb-enumerations.h:884
lldb::eOnlyThisThread
@ eOnlyThisThread
Definition: lldb-enumerations.h:136