LLDB  mainline
ThreadPlanStepOverRange.cpp
Go to the documentation of this file.
1 //===-- ThreadPlanStepOverRange.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/Symbol/Block.h"
12 #include "lldb/Symbol/Function.h"
13 #include "lldb/Symbol/LineTable.h"
14 #include "lldb/Target/Process.h"
16 #include "lldb/Target/Target.h"
17 #include "lldb/Target/Thread.h"
20 #include "lldb/Utility/LLDBLog.h"
21 #include "lldb/Utility/Log.h"
22 #include "lldb/Utility/Stream.h"
23 
24 using namespace lldb_private;
25 using namespace lldb;
26 
28 
29 // ThreadPlanStepOverRange: Step through a stack range, either stepping over or
30 // into based on the value of \a type.
31 
33  Thread &thread, const AddressRange &range,
34  const SymbolContext &addr_context, lldb::RunMode stop_others,
35  LazyBool step_out_avoids_code_without_debug_info)
36  : ThreadPlanStepRange(ThreadPlan::eKindStepOverRange,
37  "Step range stepping over", thread, range,
38  addr_context, stop_others),
39  ThreadPlanShouldStopHere(this), m_first_resume(true) {
41  SetupAvoidNoDebug(step_out_avoids_code_without_debug_info);
42 }
43 
45 
47  lldb::DescriptionLevel level) {
48  auto PrintFailureIfAny = [&]() {
49  if (m_status.Success())
50  return;
51  s->Printf(" failed (%s)", m_status.AsCString());
52  };
53 
54  if (level == lldb::eDescriptionLevelBrief) {
55  s->Printf("step over");
56  PrintFailureIfAny();
57  return;
58  }
59 
60  s->Printf("Stepping over");
61  bool printed_line_info = false;
63  s->Printf(" line ");
65  printed_line_info = true;
66  }
67 
68  if (!printed_line_info || level == eDescriptionLevelVerbose) {
69  s->Printf(" using ranges: ");
70  DumpRanges(s);
71  }
72 
73  PrintFailureIfAny();
74 
75  s->PutChar('.');
76 }
77 
79  LazyBool step_out_avoids_code_without_debug_info) {
80  bool avoid_nodebug = true;
81  switch (step_out_avoids_code_without_debug_info) {
82  case eLazyBoolYes:
83  avoid_nodebug = true;
84  break;
85  case eLazyBoolNo:
86  avoid_nodebug = false;
87  break;
88  case eLazyBoolCalculate:
89  avoid_nodebug = GetThread().GetStepOutAvoidsNoDebug();
90  break;
91  }
92  if (avoid_nodebug)
94  else
96  // Step Over plans should always avoid no-debug on step in. Seems like you
97  // shouldn't have to say this, but a tail call looks more like a step in that
98  // a step out, so we want to catch this case.
100 }
101 
103  const SymbolContext &context) {
104  // Match as much as is specified in the m_addr_context: This is a fairly
105  // loose sanity check. Note, sometimes the target doesn't get filled in so I
106  // left out the target check. And sometimes the module comes in as the .o
107  // file from the inlined range, so I left that out too...
109  if (m_addr_context.comp_unit != context.comp_unit)
110  return false;
111  if (m_addr_context.function) {
112  if (m_addr_context.function != context.function)
113  return false;
114  // It is okay to return to a different block of a straight function, we
115  // only have to be more careful if returning from one inlined block to
116  // another.
117  if (m_addr_context.block->GetInlinedFunctionInfo() == nullptr &&
118  context.block->GetInlinedFunctionInfo() == nullptr)
119  return true;
120  return m_addr_context.block == context.block;
121  }
122  }
123  // Fall back to symbol if we have no decision from comp_unit/function/block.
124  return m_addr_context.symbol && m_addr_context.symbol == context.symbol;
125 }
126 
128  Log *log = GetLog(LLDBLog::Step);
129  Thread &thread = GetThread();
130 
131  if (log) {
132  StreamString s;
133  DumpAddress(s.AsRawOstream(), thread.GetRegisterContext()->GetPC(),
134  GetTarget().GetArchitecture().GetAddressByteSize());
135  LLDB_LOGF(log, "ThreadPlanStepOverRange reached %s.", s.GetData());
136  }
137 
138  // If we're out of the range but in the same frame or in our caller's frame
139  // then we should stop. When stepping out we only stop others if we are
140  // forcing running one thread.
141  bool stop_others = (m_stop_others == lldb::eOnlyThisThread);
142  ThreadPlanSP new_plan_sp;
144 
145  if (frame_order == eFrameCompareOlder) {
146  // If we're in an older frame then we should stop.
147  //
148  // A caveat to this is if we think the frame is older but we're actually in
149  // a trampoline.
150  // I'm going to make the assumption that you wouldn't RETURN to a
151  // trampoline. So if we are in a trampoline we think the frame is older
152  // because the trampoline confused the backtracer. As below, we step
153  // through first, and then try to figure out how to get back out again.
154 
155  new_plan_sp = thread.QueueThreadPlanForStepThrough(m_stack_id, false,
156  stop_others, m_status);
157 
158  if (new_plan_sp && log)
159  LLDB_LOGF(log,
160  "Thought I stepped out, but in fact arrived at a trampoline.");
161  } else if (frame_order == eFrameCompareYounger) {
162  // Make sure we really are in a new frame. Do that by unwinding and seeing
163  // if the start function really is our start function...
164  for (uint32_t i = 1;; ++i) {
165  StackFrameSP older_frame_sp = thread.GetStackFrameAtIndex(i);
166  if (!older_frame_sp) {
167  // We can't unwind the next frame we should just get out of here &
168  // stop...
169  break;
170  }
171 
172  const SymbolContext &older_context =
173  older_frame_sp->GetSymbolContext(eSymbolContextEverything);
174  if (IsEquivalentContext(older_context)) {
175  // If we have the next-branch-breakpoint in the range, we can just
176  // rely on that breakpoint to trigger once we return to the range.
178  return false;
179  new_plan_sp = thread.QueueThreadPlanForStepOutNoShouldStop(
180  false, nullptr, true, stop_others, eVoteNo, eVoteNoOpinion, 0,
181  m_status, true);
182  break;
183  } else {
184  new_plan_sp = thread.QueueThreadPlanForStepThrough(
185  m_stack_id, false, stop_others, m_status);
186  // If we found a way through, then we should stop recursing.
187  if (new_plan_sp)
188  break;
189  }
190  }
191  } else {
192  // If we're still in the range, keep going.
193  if (InRange()) {
195  return false;
196  }
197 
198  if (!InSymbol()) {
199  // This one is a little tricky. Sometimes we may be in a stub or
200  // something similar, in which case we need to get out of there. But if
201  // we are in a stub then it's likely going to be hard to get out from
202  // here. It is probably easiest to step into the stub, and then it will
203  // be straight-forward to step out.
204  new_plan_sp = thread.QueueThreadPlanForStepThrough(m_stack_id, false,
205  stop_others, m_status);
206  } else {
207  // The current clang (at least through 424) doesn't always get the
208  // address range for the DW_TAG_inlined_subroutines right, so that when
209  // you leave the inlined range the line table says you are still in the
210  // source file of the inlining function. This is bad, because now you
211  // are missing the stack frame for the function containing the inlining,
212  // and if you sensibly do "finish" to get out of this function you will
213  // instead exit the containing function. To work around this, we check
214  // whether we are still in the source file we started in, and if not
215  // assume it is an error, and push a plan to get us out of this line and
216  // back to the containing file.
217 
219  SymbolContext sc;
220  StackFrameSP frame_sp = thread.GetStackFrameAtIndex(0);
221  sc = frame_sp->GetSymbolContext(eSymbolContextEverything);
222  if (sc.line_entry.IsValid()) {
223  if (sc.line_entry.original_file !=
227  // Okay, find the next occurrence of this file in the line table:
229  if (line_table) {
230  Address cur_address = frame_sp->GetFrameCodeAddress();
231  uint32_t entry_idx;
232  LineEntry line_entry;
233  if (line_table->FindLineEntryByAddress(cur_address, line_entry,
234  &entry_idx)) {
235  LineEntry next_line_entry;
236  bool step_past_remaining_inline = false;
237  if (entry_idx > 0) {
238  // We require the previous line entry and the current line
239  // entry come from the same file. The other requirement is
240  // that the previous line table entry be part of an inlined
241  // block, we don't want to step past cases where people have
242  // inlined some code fragment by using #include <source-
243  // fragment.c> directly.
244  LineEntry prev_line_entry;
245  if (line_table->GetLineEntryAtIndex(entry_idx - 1,
246  prev_line_entry) &&
247  prev_line_entry.original_file ==
248  line_entry.original_file) {
249  SymbolContext prev_sc;
250  Address prev_address =
251  prev_line_entry.range.GetBaseAddress();
252  prev_address.CalculateSymbolContext(&prev_sc);
253  if (prev_sc.block) {
254  Block *inlined_block =
255  prev_sc.block->GetContainingInlinedBlock();
256  if (inlined_block) {
257  AddressRange inline_range;
258  inlined_block->GetRangeContainingAddress(prev_address,
259  inline_range);
260  if (!inline_range.ContainsFileAddress(cur_address)) {
261 
262  step_past_remaining_inline = true;
263  }
264  }
265  }
266  }
267  }
268 
269  if (step_past_remaining_inline) {
270  uint32_t look_ahead_step = 1;
271  while (line_table->GetLineEntryAtIndex(
272  entry_idx + look_ahead_step, next_line_entry)) {
273  // Make sure we haven't wandered out of the function we
274  // started from...
275  Address next_line_address =
276  next_line_entry.range.GetBaseAddress();
277  Function *next_line_function =
278  next_line_address.CalculateSymbolContextFunction();
279  if (next_line_function != m_addr_context.function)
280  break;
281 
282  if (next_line_entry.original_file ==
284  const bool abort_other_plans = false;
285  const RunMode stop_other_threads = RunMode::eAllThreads;
286  lldb::addr_t cur_pc = thread.GetStackFrameAtIndex(0)
287  ->GetRegisterContext()
288  ->GetPC();
289  AddressRange step_range(
290  cur_pc,
291  next_line_address.GetLoadAddress(&GetTarget()) -
292  cur_pc);
293 
294  new_plan_sp = thread.QueueThreadPlanForStepOverRange(
295  abort_other_plans, step_range, sc, stop_other_threads,
296  m_status);
297  break;
298  }
299  look_ahead_step++;
300  }
301  }
302  }
303  }
304  }
305  }
306  }
307  }
308  }
309 
310  // If we get to this point, we're not going to use a previously set "next
311  // branch" breakpoint, so delete it:
313 
314  // If we haven't figured out something to do yet, then ask the ShouldStopHere
315  // callback:
316  if (!new_plan_sp) {
317  new_plan_sp = CheckShouldStopHereAndQueueStepOut(frame_order, m_status);
318  }
319 
320  if (!new_plan_sp)
321  m_no_more_plans = true;
322  else {
323  // Any new plan will be an implementation plan, so mark it private:
324  new_plan_sp->SetPrivate(true);
325  m_no_more_plans = false;
326  }
327 
328  if (!new_plan_sp) {
329  // For efficiencies sake, we know we're done here so we don't have to do
330  // this calculation again in MischiefManaged.
332  return true;
333  } else
334  return false;
335 }
336 
338  // For crashes, breakpoint hits, signals, etc, let the base plan (or some
339  // plan above us) handle the stop. That way the user can see the stop, step
340  // around, and then when they are done, continue and have their step
341  // complete. The exception is if we've hit our "run to next branch"
342  // breakpoint. Note, unlike the step in range plan, we don't mark ourselves
343  // complete if we hit an unexplained breakpoint/crash.
344 
345  Log *log = GetLog(LLDBLog::Step);
346  StopInfoSP stop_info_sp = GetPrivateStopInfo();
347  bool return_value;
348 
349  if (stop_info_sp) {
350  StopReason reason = stop_info_sp->GetStopReason();
351 
352  if (reason == eStopReasonTrace) {
353  return_value = true;
354  } else if (reason == eStopReasonBreakpoint) {
355  return_value = NextRangeBreakpointExplainsStop(stop_info_sp);
356  } else {
357  if (log)
358  log->PutCString("ThreadPlanStepInRange got asked if it explains the "
359  "stop for some reason other than step.");
360  return_value = false;
361  }
362  } else
363  return_value = true;
364 
365  return return_value;
366 }
367 
369  bool current_plan) {
370  if (resume_state != eStateSuspended && m_first_resume) {
371  m_first_resume = false;
372  if (resume_state == eStateStepping && current_plan) {
373  Thread &thread = GetThread();
374  // See if we are about to step over an inlined call in the middle of the
375  // inlined stack, if so figure out its extents and reset our range to
376  // step over that.
377  bool in_inlined_stack = thread.DecrementCurrentInlinedDepth();
378  if (in_inlined_stack) {
379  Log *log = GetLog(LLDBLog::Step);
380  LLDB_LOGF(log,
381  "ThreadPlanStepInRange::DoWillResume: adjusting range to "
382  "the frame at inlined depth %d.",
383  thread.GetCurrentInlinedDepth());
384  StackFrameSP stack_sp = thread.GetStackFrameAtIndex(0);
385  if (stack_sp) {
386  Block *frame_block = stack_sp->GetFrameBlock();
387  lldb::addr_t curr_pc = thread.GetRegisterContext()->GetPC();
388  AddressRange my_range;
389  if (frame_block->GetRangeContainingLoadAddress(
390  curr_pc, m_process.GetTarget(), my_range)) {
391  m_address_ranges.clear();
392  m_address_ranges.push_back(my_range);
393  if (log) {
394  StreamString s;
395  const InlineFunctionInfo *inline_info =
396  frame_block->GetInlinedFunctionInfo();
397  const char *name;
398  if (inline_info)
399  name = inline_info->GetName().AsCString();
400  else
401  name = "<unknown-notinlined>";
402 
403  s.Printf(
404  "Stepping over inlined function \"%s\" in inlined stack: ",
405  name);
406  DumpRanges(&s);
407  log->PutString(s.GetString());
408  }
409  }
410  }
411  }
412  }
413  }
414 
415  return true;
416 }
lldb_private::LineTable::FindLineEntryByAddress
bool FindLineEntryByAddress(const Address &so_addr, LineEntry &line_entry, uint32_t *index_ptr=nullptr)
Find a line entry that contains the section offset address so_addr.
Definition: LineTable.cpp:188
lldb_private::AddressRange::GetBaseAddress
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:209
Block.h
lldb_private::Block::GetRangeContainingAddress
bool GetRangeContainingAddress(const Address &addr, AddressRange &range)
Definition: Block.cpp:250
lldb_private::SymbolContext::block
Block * block
The Block for a given query.
Definition: SymbolContext.h:321
lldb_private::SymbolContext::comp_unit
CompileUnit * comp_unit
The CompileUnit for a given query.
Definition: SymbolContext.h:319
lldb_private::Thread::GetCurrentInlinedDepth
uint32_t GetCurrentInlinedDepth()
Definition: Thread.h:409
lldb_private::Log::PutString
void PutString(llvm::StringRef str)
Definition: Log.cpp:134
ThreadPlanStepOverRange.h
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:867
lldb_private::ThreadPlanStepOverRange::SetupAvoidNoDebug
void SetupAvoidNoDebug(LazyBool step_out_avoids_code_without_debug_info)
Definition: ThreadPlanStepOverRange.cpp:78
lldb_private::LineEntry::DumpStopContext
bool DumpStopContext(Stream *s, bool show_fullpaths) const
Dumps information specific to a process that stops at this line entry to the supplied stream s.
Definition: LineEntry.cpp:50
lldb_private::Event
Definition: Event.h:182
lldb_private::InlineFunctionInfo
Definition: Function.h:125
CompileUnit.h
lldb_private::LineEntry::IsValid
bool IsValid() const
Check if a line entry object is valid.
Definition: LineEntry.cpp:46
lldb_private::Address::CalculateSymbolContextFunction
Function * CalculateSymbolContextFunction() const
Definition: Address.cpp:865
ThreadPlanStepOut.h
lldb_private::Thread::QueueThreadPlanForStepOverRange
virtual lldb::ThreadPlanSP QueueThreadPlanForStepOverRange(bool abort_other_plans, const AddressRange &range, const SymbolContext &addr_context, lldb::RunMode stop_other_threads, Status &status, LazyBool step_out_avoids_code_without_debug_info=eLazyBoolCalculate)
Queues the plan used to step through an address range, stepping over function calls.
Definition: Thread.cpp:1246
lldb_private::ThreadPlanStepOverRange::ThreadPlanStepOverRange
ThreadPlanStepOverRange(Thread &thread, const AddressRange &range, const SymbolContext &addr_context, lldb::RunMode stop_others, LazyBool step_out_avoids_no_debug)
Definition: ThreadPlanStepOverRange.cpp:32
lldb_private::Thread::QueueThreadPlanForStepOutNoShouldStop
virtual lldb::ThreadPlanSP QueueThreadPlanForStepOutNoShouldStop(bool abort_other_plans, SymbolContext *addr_context, bool first_insn, bool stop_other_threads, Vote report_stop_vote, Vote report_run_vote, uint32_t frame_idx, Status &status, bool continue_to_next_branch=false)
Queue the plan used to step out of the function at the current PC of a thread.
Definition: Thread.cpp:1316
lldb_private::ThreadPlanStepRange::m_addr_context
SymbolContext m_addr_context
Definition: ThreadPlanStepRange.h:65
lldb_private::eLazyBoolYes
@ eLazyBoolYes
Definition: lldb-private-enumerations.h:115
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:343
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::Flags::Clear
ValueType Clear(ValueType mask=~static_cast< ValueType >(0))
Clear one or more flags.
Definition: Flags.h:61
lldb_private::LineTable::GetLineEntryAtIndex
bool GetLineEntryAtIndex(uint32_t idx, LineEntry &line_entry)
Get the line entry from the line table at index idx.
Definition: LineTable.cpp:179
lldb_private::Process::GetTarget
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1206
lldb_private::Thread::DecrementCurrentInlinedDepth
bool DecrementCurrentInlinedDepth()
Definition: Thread.h:405
lldb::StopReason
StopReason
Thread stop reasons.
Definition: lldb-enumerations.h:239
lldb_private::ThreadPlanStepRange
Definition: ThreadPlanStepRange.h:20
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:193
lldb_private::eVoteNoOpinion
@ eVoteNoOpinion
Definition: lldb-private-enumerations.h:59
lldb_private::Stream
Definition: Stream.h:28
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
ThreadPlanStepThrough.h
lldb_private::LazyBool
LazyBool
Definition: lldb-private-enumerations.h:115
lldb::eStopReasonTrace
@ eStopReasonTrace
Definition: lldb-enumerations.h:242
lldb_private::ThreadPlanStepOverRange::SetFlagsToDefault
void SetFlagsToDefault() override
Definition: ThreadPlanStepOverRange.h:36
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::StreamString::GetString
llvm::StringRef GetString() const
Definition: StreamString.cpp:51
Process.h
Target.h
lldb_private::ThreadPlanStepOverRange::m_first_resume
bool m_first_resume
Definition: ThreadPlanStepOverRange.h:46
lldb_private::ThreadPlanStepOverRange::DoPlanExplainsStop
bool DoPlanExplainsStop(Event *event_ptr) override
Definition: ThreadPlanStepOverRange.cpp:337
lldb_private::SymbolContext::symbol
Symbol * symbol
The Symbol for a given query.
Definition: SymbolContext.h:323
lldb_private::Status::Success
bool Success() const
Test for success condition.
Definition: Status.cpp:287
lldb_private::LineTable
Definition: LineTable.h:40
lldb_private::Function
Definition: Function.h:409
lldb_private::ThreadPlan::GetTarget
Target & GetTarget()
Definition: ThreadPlan.cpp:38
lldb_private::ThreadPlan
Definition: ThreadPlan.h:287
lldb_private::eVoteNo
@ eVoteNo
Definition: lldb-private-enumerations.h:59
Log.h
lldb_private::ThreadPlanStepRange::m_no_more_plans
bool m_no_more_plans
Definition: ThreadPlanStepRange.h:71
lldb_private::DumpAddress
void DumpAddress(llvm::raw_ostream &s, uint64_t addr, uint32_t addr_size, const char *prefix=nullptr, const char *suffix=nullptr)
Output an address value to this stream.
Definition: Stream.cpp:81
lldb_private::Thread
Definition: Thread.h:61
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::ThreadPlanStepOverRange::ShouldStop
bool ShouldStop(Event *event_ptr) override
Definition: ThreadPlanStepOverRange.cpp:127
lldb_private::ThreadPlanShouldStopHere::eStepInAvoidNoDebug
@ eStepInAvoidNoDebug
Definition: ThreadPlanShouldStopHere.h:61
lldb_private::Thread::QueueThreadPlanForStepThrough
virtual lldb::ThreadPlanSP QueueThreadPlanForStepThrough(StackID &return_stack_id, bool abort_other_plans, bool stop_other_threads, Status &status)
Gets the plan used to step through the code that steps from a function call site at the current PC in...
Definition: Thread.cpp:1335
lldb_private::StreamString
Definition: StreamString.h:23
lldb_private::AddressRange
Definition: AddressRange.h:25
lldb_private::ThreadPlanStepOverRange::DoWillResume
bool DoWillResume(lldb::StateType resume_state, bool current_plan) override
Definition: ThreadPlanStepOverRange.cpp:368
lldb_private::InlineFunctionInfo::GetName
ConstString GetName() const
Definition: Function.cpp:96
lldb_private::ThreadPlanStepRange::ClearNextBranchBreakpoint
void ClearNextBranchBreakpoint()
Definition: ThreadPlanStepRange.cpp:295
lldb_private::ThreadPlanStepOverRange::s_default_flag_values
static uint32_t s_default_flag_values
Definition: ThreadPlanStepOverRange.h:41
lldb::eFrameCompareYounger
@ eFrameCompareYounger
Definition: lldb-enumerations.h:872
lldb_private::ThreadPlanShouldStopHere
Definition: ThreadPlanShouldStopHere.h:34
lldb_private::CompileUnit::GetLineTable
LineTable * GetLineTable()
Get the line table for the compile unit.
Definition: CompileUnit.cpp:161
lldb_private::ThreadProperties::GetStepOutAvoidsNoDebug
bool GetStepOutAvoidsNoDebug() const
Definition: Thread.cpp:138
Thread.h
lldb_private::Stream::PutChar
size_t PutChar(char ch)
Definition: Stream.cpp:104
lldb_private::ThreadPlanStepRange::InSymbol
bool InSymbol()
Definition: ThreadPlanStepRange.cpp:196
lldb_private::ThreadPlanShouldStopHere::GetFlags
lldb_private::Flags & GetFlags()
Definition: ThreadPlanShouldStopHere.h:104
lldb_private::LLDBLog::Step
@ Step
lldb_private::ThreadPlan::m_status
Status m_status
Definition: ThreadPlan.h:527
lldb_private::LineEntry::original_file
FileSpec original_file
The original source file, from debug info.
Definition: LineEntry.h:142
lldb::RunMode
RunMode
Thread Run Modes.
Definition: lldb-enumerations.h:135
lldb_private::AddressRange::ContainsFileAddress
bool ContainsFileAddress(const Address &so_addr) const
Check if a section offset address is contained in this range.
Definition: AddressRange.cpp:62
lldb::eStateStepping
@ eStateStepping
Process or thread is in the process of stepping and can not be examined.
Definition: lldb-enumerations.h:86
lldb::eStateSuspended
@ eStateSuspended
Process or thread is in a suspended state as far as the debugger is concerned while other processes o...
Definition: lldb-enumerations.h:91
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::Block
Definition: Block.h:41
uint32_t
lldb_private::eLazyBoolNo
@ eLazyBoolNo
Definition: lldb-private-enumerations.h:115
lldb_private::Address
Definition: Address.h:59
lldb_private::ThreadPlanStepRange::CompareCurrentFrameToStartFrame
lldb::FrameComparison CompareCurrentFrameToStartFrame()
Definition: ThreadPlanStepRange.cpp:216
lldb_private::ThreadPlanStepRange::DumpRanges
void DumpRanges(Stream *s)
Definition: ThreadPlanStepRange.cpp:89
LineTable.h
lldb_private::Address::GetLoadAddress
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:311
lldb_private::Stream::AsRawOstream
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition: Stream.h:357
lldb_private::LineEntry::range
AddressRange range
The section offset address range for this line entry.
Definition: LineEntry.h:139
lldb::eStopReasonBreakpoint
@ eStopReasonBreakpoint
Definition: lldb-enumerations.h:243
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::Block::GetRangeContainingLoadAddress
bool GetRangeContainingLoadAddress(lldb::addr_t load_addr, Target &target, AddressRange &range)
Definition: Block.cpp:278
lldb_private::ThreadPlanStepRange::m_stop_others
lldb::RunMode m_stop_others
Definition: ThreadPlanStepRange.h:67
lldb_private::ThreadPlanShouldStopHere::eStepOutAvoidNoDebug
@ eStepOutAvoidNoDebug
Definition: ThreadPlanShouldStopHere.h:62
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb::eDescriptionLevelVerbose
@ eDescriptionLevelVerbose
Definition: lldb-enumerations.h:210
lldb_private::eLazyBoolCalculate
@ eLazyBoolCalculate
Definition: lldb-private-enumerations.h:115
lldb_private::Flags::Set
ValueType Set(ValueType mask)
Set one or more flags by logical OR'ing mask with the current flags.
Definition: Flags.h:73
lldb::eAllThreads
@ eAllThreads
Definition: lldb-enumerations.h:135
lldb_private::ThreadPlanStepRange::m_address_ranges
std::vector< AddressRange > m_address_ranges
Definition: ThreadPlanStepRange.h:66
lldb::StateType
StateType
Process and Thread States.
Definition: lldb-enumerations.h:73
Stream.h
lldb_private::Log
Definition: Log.h:115
lldb_private::Block::GetInlinedFunctionInfo
const InlineFunctionInfo * GetInlinedFunctionInfo() const
Get const accessor for any inlined function information.
Definition: Block.h:276
lldb_private::ThreadPlanStepOverRange::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level) override
Print a description of this thread to the stream s.
Definition: ThreadPlanStepOverRange.cpp:46
lldb_private::Thread::GetStackFrameAtIndex
virtual lldb::StackFrameSP GetStackFrameAtIndex(uint32_t idx)
Definition: Thread.h:398
lldb_private::ThreadPlanStepOverRange::~ThreadPlanStepOverRange
~ThreadPlanStepOverRange() override
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::ThreadPlan::GetPrivateStopInfo
lldb::StopInfoSP GetPrivateStopInfo()
Definition: ThreadPlan.h:515
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:308
lldb_private::ThreadPlan::m_process
Process & m_process
Definition: ThreadPlan.h:528
lldb_private::ThreadPlanStepOverRange::IsEquivalentContext
bool IsEquivalentContext(const SymbolContext &context)
Definition: ThreadPlanStepOverRange.cpp:102
lldb
Definition: SBAddress.h:15
RegisterContext.h
lldb_private::ThreadPlanShouldStopHere::CheckShouldStopHereAndQueueStepOut
lldb::ThreadPlanSP CheckShouldStopHereAndQueueStepOut(lldb::FrameComparison operation, Status &status)
Definition: ThreadPlanShouldStopHere.cpp:155
LLDBLog.h
lldb_private::Address::CalculateSymbolContext
uint32_t CalculateSymbolContext(SymbolContext *sc, lldb::SymbolContextItem resolve_scope=lldb::eSymbolContextEverything) const
Reconstruct a symbol context from an address.
Definition: Address.cpp:825
lldb_private::LineEntry
Definition: LineEntry.h:20
lldb_private::Block::GetContainingInlinedBlock
Block * GetContainingInlinedBlock()
Get the inlined block that contains this block.
Definition: Block.cpp:208
lldb::eDescriptionLevelBrief
@ eDescriptionLevelBrief
Definition: lldb-enumerations.h:208
lldb::eFrameCompareOlder
@ eFrameCompareOlder
Definition: lldb-enumerations.h:873
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:207
lldb::eOnlyThisThread
@ eOnlyThisThread
Definition: lldb-enumerations.h:135
lldb_private::Status::AsCString
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:130
lldb_private::Log::PutCString
void PutCString(const char *cstr)
Definition: Log.cpp:133