LLDB  mainline
ThreadPlanStepOut.cpp
Go to the documentation of this file.
1 //===-- ThreadPlanStepOut.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 
11 #include "lldb/Core/Value.h"
13 #include "lldb/Symbol/Block.h"
14 #include "lldb/Symbol/Function.h"
15 #include "lldb/Symbol/Symbol.h"
16 #include "lldb/Symbol/Type.h"
17 #include "lldb/Target/ABI.h"
18 #include "lldb/Target/Process.h"
20 #include "lldb/Target/StopInfo.h"
21 #include "lldb/Target/Target.h"
24 #include "lldb/Utility/LLDBLog.h"
25 #include "lldb/Utility/Log.h"
26 
27 #include <memory>
28 
29 using namespace lldb;
30 using namespace lldb_private;
31 
32 uint32_t ThreadPlanStepOut::s_default_flag_values = 0;
33 
34 // ThreadPlanStepOut: Step out of the current frame
35 ThreadPlanStepOut::ThreadPlanStepOut(
36  Thread &thread, SymbolContext *context, bool first_insn, bool stop_others,
37  Vote report_stop_vote, Vote report_run_vote, uint32_t frame_idx,
38  LazyBool step_out_avoids_code_without_debug_info,
39  bool continue_to_next_branch, bool gather_return_value)
40  : ThreadPlan(ThreadPlan::eKindStepOut, "Step out", thread, report_stop_vote,
41  report_run_vote),
42  ThreadPlanShouldStopHere(this), m_step_from_insn(LLDB_INVALID_ADDRESS),
43  m_return_bp_id(LLDB_INVALID_BREAK_ID),
44  m_return_addr(LLDB_INVALID_ADDRESS), m_stop_others(stop_others),
45  m_immediate_step_from_function(nullptr),
46  m_calculate_return_value(gather_return_value) {
47  Log *log = GetLog(LLDBLog::Step);
49  SetupAvoidNoDebug(step_out_avoids_code_without_debug_info);
50 
51  m_step_from_insn = thread.GetRegisterContext()->GetPC(0);
52 
53  uint32_t return_frame_index = frame_idx + 1;
54  StackFrameSP return_frame_sp(thread.GetStackFrameAtIndex(return_frame_index));
55  StackFrameSP immediate_return_from_sp(thread.GetStackFrameAtIndex(frame_idx));
56 
57  if (!return_frame_sp || !immediate_return_from_sp)
58  return; // we can't do anything here. ValidatePlan() will return false.
59 
60  // While stepping out, behave as-if artificial frames are not present.
61  while (return_frame_sp->IsArtificial()) {
62  m_stepped_past_frames.push_back(return_frame_sp);
63 
64  ++return_frame_index;
65  return_frame_sp = thread.GetStackFrameAtIndex(return_frame_index);
66 
67  // We never expect to see an artificial frame without a regular ancestor.
68  // If this happens, log the issue and defensively refuse to step out.
69  if (!return_frame_sp) {
70  LLDB_LOG(log, "Can't step out of frame with artificial ancestors");
71  return;
72  }
73  }
74 
75  m_step_out_to_id = return_frame_sp->GetStackID();
76  m_immediate_step_from_id = immediate_return_from_sp->GetStackID();
77 
78  // If the frame directly below the one we are returning to is inlined, we
79  // have to be a little more careful. It is non-trivial to determine the real
80  // "return code address" for an inlined frame, so we have to work our way to
81  // that frame and then step out.
82  if (immediate_return_from_sp->IsInlined()) {
83  if (frame_idx > 0) {
84  // First queue a plan that gets us to this inlined frame, and when we get
85  // there we'll queue a second plan that walks us out of this frame.
86  m_step_out_to_inline_plan_sp = std::make_shared<ThreadPlanStepOut>(
87  thread, nullptr, false, stop_others, eVoteNoOpinion, eVoteNoOpinion,
88  frame_idx - 1, eLazyBoolNo, continue_to_next_branch);
90  ->SetShouldStopHereCallbacks(nullptr, nullptr);
91  m_step_out_to_inline_plan_sp->SetPrivate(true);
92  } else {
93  // If we're already at the inlined frame we're stepping through, then
94  // just do that now.
95  QueueInlinedStepPlan(false);
96  }
97  } else {
98  // Find the return address and set a breakpoint there:
99  // FIXME - can we do this more securely if we know first_insn?
100 
101  Address return_address(return_frame_sp->GetFrameCodeAddress());
102  if (continue_to_next_branch) {
103  SymbolContext return_address_sc;
104  AddressRange range;
105  Address return_address_decr_pc = return_address;
106  if (return_address_decr_pc.GetOffset() > 0)
107  return_address_decr_pc.Slide(-1);
108 
109  return_address_decr_pc.CalculateSymbolContext(
110  &return_address_sc, lldb::eSymbolContextLineEntry);
111  if (return_address_sc.line_entry.IsValid()) {
112  const bool include_inlined_functions = false;
113  range = return_address_sc.line_entry.GetSameLineContiguousAddressRange(
114  include_inlined_functions);
115  if (range.GetByteSize() > 0) {
117  return_address, range);
118  }
119  }
120  }
121  m_return_addr = return_address.GetLoadAddress(&m_process.GetTarget());
122 
124  return;
125 
126  // Perform some additional validation on the return address.
127  uint32_t permissions = 0;
129  LLDB_LOGF(log, "ThreadPlanStepOut(%p): Return address (0x%" PRIx64
130  ") permissions not found.", static_cast<void *>(this),
131  m_return_addr);
132  } else if (!(permissions & ePermissionsExecutable)) {
133  m_constructor_errors.Printf("Return address (0x%" PRIx64
134  ") did not point to executable memory.",
135  m_return_addr);
136  LLDB_LOGF(log, "ThreadPlanStepOut(%p): %s", static_cast<void *>(this),
138  return;
139  }
140 
141  Breakpoint *return_bp =
142  GetTarget().CreateBreakpoint(m_return_addr, true, false).get();
143 
144  if (return_bp != nullptr) {
145  if (return_bp->IsHardware() && !return_bp->HasResolvedLocations())
147  return_bp->SetThreadID(m_tid);
148  m_return_bp_id = return_bp->GetID();
149  return_bp->SetBreakpointKind("step-out");
150  }
151 
152  if (immediate_return_from_sp) {
153  const SymbolContext &sc =
154  immediate_return_from_sp->GetSymbolContext(eSymbolContextFunction);
155  if (sc.function) {
157  }
158  }
159  }
160 }
161 
163  LazyBool step_out_avoids_code_without_debug_info) {
164  bool avoid_nodebug = true;
165  switch (step_out_avoids_code_without_debug_info) {
166  case eLazyBoolYes:
167  avoid_nodebug = true;
168  break;
169  case eLazyBoolNo:
170  avoid_nodebug = false;
171  break;
172  case eLazyBoolCalculate:
173  avoid_nodebug = GetThread().GetStepOutAvoidsNoDebug();
174  break;
175  }
176  if (avoid_nodebug)
178  else
180 }
181 
183  Thread &thread = GetThread();
188 }
189 
193 }
194 
196  lldb::DescriptionLevel level) {
197  if (level == lldb::eDescriptionLevelBrief)
198  s->Printf("step out");
199  else {
201  s->Printf("Stepping out to inlined frame so we can walk through it.");
203  s->Printf("Stepping out by stepping through inlined function.");
204  else {
205  s->Printf("Stepping out from ");
206  Address tmp_address;
207  if (tmp_address.SetLoadAddress(m_step_from_insn, &GetTarget())) {
210  } else {
211  s->Printf("address 0x%" PRIx64 "", (uint64_t)m_step_from_insn);
212  }
213 
214  // FIXME: find some useful way to present the m_return_id, since there may
215  // be multiple copies of the
216  // same function on the stack.
217 
218  s->Printf(" returning to frame at ");
219  if (tmp_address.SetLoadAddress(m_return_addr, &GetTarget())) {
222  } else {
223  s->Printf("address 0x%" PRIx64 "", (uint64_t)m_return_addr);
224  }
225 
226  if (level == eDescriptionLevelVerbose)
227  s->Printf(" using breakpoint site %d", m_return_bp_id);
228  }
229  }
230 
231  if (m_stepped_past_frames.empty())
232  return;
233 
234  s->Printf("\n");
235  for (StackFrameSP frame_sp : m_stepped_past_frames) {
236  s->Printf("Stepped out past: ");
237  frame_sp->DumpUsingSettingsFormat(s);
238  }
239 }
240 
243  return m_step_out_to_inline_plan_sp->ValidatePlan(error);
244 
246  return m_step_through_inline_plan_sp->ValidatePlan(error);
247 
249  if (error)
250  error->PutCString(
251  "Could not create hardware breakpoint for thread plan.");
252  return false;
253  }
254 
256  if (error) {
257  error->PutCString("Could not create return address breakpoint.");
258  if (m_constructor_errors.GetSize() > 0) {
259  error->PutCString(" ");
260  error->PutCString(m_constructor_errors.GetString());
261  }
262  }
263  return false;
264  }
265 
266  return true;
267 }
268 
270  // If the step out plan is done, then we just need to step through the
271  // inlined frame.
273  return m_step_out_to_inline_plan_sp->MischiefManaged();
274  } else if (m_step_through_inline_plan_sp) {
275  if (m_step_through_inline_plan_sp->MischiefManaged()) {
277  SetPlanComplete();
278  return true;
279  } else
280  return false;
281  } else if (m_step_out_further_plan_sp) {
282  return m_step_out_further_plan_sp->MischiefManaged();
283  }
284 
285  // We don't explain signals or breakpoints (breakpoints that handle stepping
286  // in or out will be handled by a child plan.
287 
288  StopInfoSP stop_info_sp = GetPrivateStopInfo();
289  if (stop_info_sp) {
290  StopReason reason = stop_info_sp->GetStopReason();
291  if (reason == eStopReasonBreakpoint) {
292  // If this is OUR breakpoint, we're fine, otherwise we don't know why
293  // this happened...
294  BreakpointSiteSP site_sp(
295  m_process.GetBreakpointSiteList().FindByID(stop_info_sp->GetValue()));
296  if (site_sp && site_sp->IsBreakpointAtThisSite(m_return_bp_id)) {
297  bool done;
298 
299  StackID frame_zero_id =
300  GetThread().GetStackFrameAtIndex(0)->GetStackID();
301 
302  if (m_step_out_to_id == frame_zero_id)
303  done = true;
304  else if (m_step_out_to_id < frame_zero_id) {
305  // Either we stepped past the breakpoint, or the stack ID calculation
306  // was incorrect and we should probably stop.
307  done = true;
308  } else {
309  done = (m_immediate_step_from_id < frame_zero_id);
310  }
311 
312  if (done) {
315  SetPlanComplete();
316  }
317  }
318 
319  // If there was only one owner, then we're done. But if we also hit
320  // some user breakpoint on our way out, we should mark ourselves as
321  // done, but also not claim to explain the stop, since it is more
322  // important to report the user breakpoint than the step out
323  // completion.
324 
325  if (site_sp->GetNumberOfOwners() == 1)
326  return true;
327  }
328  return false;
329  } else if (IsUsuallyUnexplainedStopReason(reason))
330  return false;
331  else
332  return true;
333  }
334  return true;
335 }
336 
338  if (IsPlanComplete())
339  return true;
340 
341  bool done = false;
343  if (m_step_out_to_inline_plan_sp->MischiefManaged()) {
344  // Now step through the inlined stack we are in:
345  if (QueueInlinedStepPlan(true)) {
346  // If we can't queue a plan to do this, then just call ourselves done.
348  SetPlanComplete(false);
349  return true;
350  } else
351  done = true;
352  } else
353  return m_step_out_to_inline_plan_sp->ShouldStop(event_ptr);
354  } else if (m_step_through_inline_plan_sp) {
355  if (m_step_through_inline_plan_sp->MischiefManaged())
356  done = true;
357  else
358  return m_step_through_inline_plan_sp->ShouldStop(event_ptr);
359  } else if (m_step_out_further_plan_sp) {
360  if (m_step_out_further_plan_sp->MischiefManaged())
362  else
363  return m_step_out_further_plan_sp->ShouldStop(event_ptr);
364  }
365 
366  if (!done) {
367  StackID frame_zero_id = GetThread().GetStackFrameAtIndex(0)->GetStackID();
368  done = !(frame_zero_id < m_step_out_to_id);
369  }
370 
371  // The normal step out computations think we are done, so all we need to do
372  // is consult the ShouldStopHere, and we are done.
373 
374  if (done) {
377  SetPlanComplete();
378  } else {
381  done = false;
382  }
383  }
384 
385  return done;
386 }
387 
389 
391 
393  bool current_plan) {
395  return true;
396 
398  return false;
399 
400  if (current_plan) {
402  if (return_bp != nullptr)
403  return_bp->SetEnabled(true);
404  }
405  return true;
406 }
407 
411  if (return_bp != nullptr)
412  return_bp->SetEnabled(false);
413  }
414 
415  return true;
416 }
417 
419  if (IsPlanComplete()) {
420  // Did I reach my breakpoint? If so I'm done.
421  //
422  // I also check the stack depth, since if we've blown past the breakpoint
423  // for some
424  // reason and we're now stopping for some other reason altogether, then
425  // we're done with this step out operation.
426 
427  Log *log = GetLog(LLDBLog::Step);
428  if (log)
429  LLDB_LOGF(log, "Completed step out plan.");
433  }
434 
436  return true;
437  } else {
438  return false;
439  }
440 }
441 
443  // Now figure out the range of this inlined block, and set up a "step through
444  // range" plan for that. If we've been provided with a context, then use the
445  // block in that context.
446  Thread &thread = GetThread();
447  StackFrameSP immediate_return_from_sp(thread.GetStackFrameAtIndex(0));
448  if (!immediate_return_from_sp)
449  return false;
450 
451  Log *log = GetLog(LLDBLog::Step);
452  if (log) {
453  StreamString s;
454  immediate_return_from_sp->Dump(&s, true, false);
455  LLDB_LOGF(log, "Queuing inlined frame to step past: %s.", s.GetData());
456  }
457 
458  Block *from_block = immediate_return_from_sp->GetFrameBlock();
459  if (from_block) {
460  Block *inlined_block = from_block->GetContainingInlinedBlock();
461  if (inlined_block) {
462  size_t num_ranges = inlined_block->GetNumRanges();
463  AddressRange inline_range;
464  if (inlined_block->GetRangeAtIndex(0, inline_range)) {
465  SymbolContext inlined_sc;
466  inlined_block->CalculateSymbolContext(&inlined_sc);
467  inlined_sc.target_sp = GetTarget().shared_from_this();
468  RunMode run_mode =
470  const LazyBool avoid_no_debug = eLazyBoolNo;
471 
473  std::make_shared<ThreadPlanStepOverRange>(
474  thread, inline_range, inlined_sc, run_mode, avoid_no_debug);
475  ThreadPlanStepOverRange *step_through_inline_plan_ptr =
476  static_cast<ThreadPlanStepOverRange *>(
478  m_step_through_inline_plan_sp->SetPrivate(true);
479 
480  step_through_inline_plan_ptr->SetOkayToDiscard(true);
481  StreamString errors;
482  if (!step_through_inline_plan_ptr->ValidatePlan(&errors)) {
483  // FIXME: Log this failure.
484  delete step_through_inline_plan_ptr;
485  return false;
486  }
487 
488  for (size_t i = 1; i < num_ranges; i++) {
489  if (inlined_block->GetRangeAtIndex(i, inline_range))
490  step_through_inline_plan_ptr->AddRange(inline_range);
491  }
492 
493  if (queue_now)
495  return true;
496  }
497  }
498  }
499 
500  return false;
501 }
502 
504  if (m_return_valobj_sp)
505  return;
506 
508  return;
509 
510  if (m_immediate_step_from_function != nullptr) {
511  CompilerType return_compiler_type =
514  if (return_compiler_type) {
515  lldb::ABISP abi_sp = m_process.GetABI();
516  if (abi_sp)
518  abi_sp->GetReturnValueObject(GetThread(), return_compiler_type);
519  }
520  }
521 }
522 
524  // If we are still lower on the stack than the frame we are returning to,
525  // then there's something for us to do. Otherwise, we're stale.
526 
527  StackID frame_zero_id = GetThread().GetStackFrameAtIndex(0)->GetStackID();
528  return !(frame_zero_id < m_step_out_to_id);
529 }
lldb_private::ThreadPlanShouldStopHere::eStepOutAvoidNoDebug
@ eStepOutAvoidNoDebug
Definition: ThreadPlanShouldStopHere.h:62
lldb_private::ThreadPlanStepOut::ValidatePlan
bool ValidatePlan(Stream *error) override
Returns whether this plan could be successfully created.
Definition: ThreadPlanStepOut.cpp:241
lldb_private::Breakpoint::HasResolvedLocations
bool HasResolvedLocations() const
Return whether this breakpoint has any resolved locations.
Definition: Breakpoint.cpp:843
lldb_private::Address::SetLoadAddress
bool SetLoadAddress(lldb::addr_t load_addr, Target *target, bool allow_section_end=false)
Set the address to represent load_addr.
Definition: Address.cpp:1040
Block.h
lldb_private::ThreadPlanStepOut::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level) override
Print a description of this thread to the stream s.
Definition: ThreadPlanStepOut.cpp:195
ThreadPlanStepOverRange.h
lldb_private::ThreadPlan::GetThread
Thread & GetThread()
Returns the Thread that is using this thread plan.
Definition: ThreadPlan.cpp:42
lldb_private::Stoppoint::GetID
lldb::break_id_t GetID() const
Definition: Stoppoint.cpp:22
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::ThreadPlanStepOut::WillStop
bool WillStop() override
Definition: ThreadPlanStepOut.cpp:408
lldb_private::ThreadPlanStepOut::m_step_through_inline_plan_sp
lldb::ThreadPlanSP m_step_through_inline_plan_sp
Definition: ThreadPlanStepOut.h:66
lldb_private::ThreadPlanStepOut::SetupAvoidNoDebug
void SetupAvoidNoDebug(LazyBool step_out_avoids_code_without_debug_info)
Definition: ThreadPlanStepOut.cpp:162
lldb_private::ThreadPlanStepOut::m_return_bp_id
lldb::break_id_t m_return_bp_id
Definition: ThreadPlanStepOut.h:59
lldb_private::SymbolContext::target_sp
lldb::TargetSP target_sp
The Target for a given query.
Definition: SymbolContext.h:317
ThreadPlanStepOut.h
lldb_private::ThreadPlan::SetOkayToDiscard
void SetOkayToDiscard(bool value)
Definition: ThreadPlan.h:406
lldb_private::ThreadPlanStepOut::m_return_addr
lldb::addr_t m_return_addr
Definition: ThreadPlanStepOut.h:60
lldb_private::Breakpoint::SetBreakpointKind
void SetBreakpointKind(const char *kind)
Set the "kind" description for a breakpoint.
Definition: Breakpoint.h:453
lldb_private::ThreadPlanShouldStopHere::m_flags
lldb_private::Flags m_flags
Definition: ThreadPlanShouldStopHere.h:130
lldb_private::ThreadPlanStepOut::m_immediate_step_from_id
StackID m_immediate_step_from_id
Definition: ThreadPlanStepOut.h:58
lldb_private::ThreadPlanStepOut::m_calculate_return_value
bool m_calculate_return_value
Definition: ThreadPlanStepOut.h:74
lldb_private::eLazyBoolYes
@ eLazyBoolYes
Definition: lldb-private-enumerations.h:115
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:344
lldb_private::ThreadPlanStepOut
Definition: ThreadPlanStepOut.h:18
lldb_private::Flags::Clear
ValueType Clear(ValueType mask=~static_cast< ValueType >(0))
Clear one or more flags.
Definition: Flags.h:61
lldb_private::AddressRange::GetByteSize
lldb::addr_t GetByteSize() const
Get accessor for the byte size of this range.
Definition: AddressRange.h:221
lldb_private::Process::GetBreakpointSiteList
BreakpointSiteList & GetBreakpointSiteList()
Definition: Process.cpp:1565
lldb_private::Process::GetTarget
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1219
lldb_private::ThreadPlanStepOut::m_constructor_errors
StreamString m_constructor_errors
Definition: ThreadPlanStepOut.h:75
lldb::StopReason
StopReason
Thread stop reasons.
Definition: lldb-enumerations.h:240
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
lldb_private::eVoteNoOpinion
@ eVoteNoOpinion
Definition: lldb-private-enumerations.h:59
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::ThreadPlanStepOut::MischiefManaged
bool MischiefManaged() override
Definition: ThreadPlanStepOut.cpp:418
ThreadPlanStepThrough.h
lldb_private::LazyBool
LazyBool
Definition: lldb-private-enumerations.h:115
lldb_private::SymbolContext
Definition: SymbolContext.h:33
ABI.h
lldb_private::StreamString::GetString
llvm::StringRef GetString() const
Definition: StreamString.cpp:51
lldb_private::ThreadPlanStepOut::ShouldStop
bool ShouldStop(Event *event_ptr) override
Definition: ThreadPlanStepOut.cpp:337
Process.h
Target.h
lldb_private::ThreadPlanStepOut::QueueInlinedStepPlan
bool QueueInlinedStepPlan(bool queue_now)
Definition: ThreadPlanStepOut.cpp:442
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::StreamString::GetSize
size_t GetSize() const
Definition: StreamString.cpp:38
lldb_private::ThreadPlan::GetTarget
Target & GetTarget()
Definition: ThreadPlan.cpp:38
lldb_private::ThreadPlan
Definition: ThreadPlan.h:287
lldb_private::Address::DumpStyleLoadAddress
@ DumpStyleLoadAddress
Display as the load address (if resolved).
Definition: Address.h:96
Log.h
lldb_private::ThreadPlan::MischiefManaged
virtual bool MischiefManaged()
Definition: ThreadPlan.cpp:72
lldb_private::Thread
Definition: Thread.h:61
lldb_private::StreamString::GetData
const char * GetData() const
Definition: StreamString.h:43
lldb_private::ThreadPlanStepOverRange
Definition: ThreadPlanStepOverRange.h:19
lldb_private::SymbolContext::function
Function * function
The Function for a given query.
Definition: SymbolContext.h:320
Type.h
lldb_private::ThreadPlanStepOut::m_step_out_to_id
StackID m_step_out_to_id
Definition: ThreadPlanStepOut.h:57
lldb_private::StreamString
Definition: StreamString.h:23
lldb_private::AddressRange
Definition: AddressRange.h:25
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::ThreadPlanStepOut::m_step_from_insn
lldb::addr_t m_step_from_insn
Definition: ThreadPlanStepOut.h:56
lldb_private::ThreadPlanShouldStopHere::QueueStepOutFromHerePlan
virtual lldb::ThreadPlanSP QueueStepOutFromHerePlan(Flags &flags, lldb::FrameComparison operation, Status &status)
Definition: ThreadPlanShouldStopHere.cpp:144
lldb_private::ThreadPlanStepOut::IsPlanStale
bool IsPlanStale() override
Definition: ThreadPlanStepOut.cpp:523
lldb_private::ThreadPlanShouldStopHere
Definition: ThreadPlanShouldStopHere.h:34
lldb_private::ThreadProperties::GetStepOutAvoidsNoDebug
bool GetStepOutAvoidsNoDebug() const
Definition: Thread.cpp:138
lldb_private::CompilerType::GetFunctionReturnType
CompilerType GetFunctionReturnType() const
Definition: CompilerType.cpp:427
lldb_private::ThreadPlanShouldStopHere::GetFlags
lldb_private::Flags & GetFlags()
Definition: ThreadPlanShouldStopHere.h:104
lldb_private::LLDBLog::Step
@ Step
lldb_private::Breakpoint::SetThreadID
void SetThreadID(lldb::tid_t thread_id)
Set the valid thread to be checked when the breakpoint is hit.
Definition: Breakpoint.cpp:346
lldb_private::ThreadPlan::m_status
Status m_status
Definition: ThreadPlan.h:529
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
lldb_private::ThreadPlanStepOut::StopOthers
bool StopOthers() override
Definition: ThreadPlanStepOut.cpp:388
ValueObjectConstResult.h
Symbol.h
lldb_private::Breakpoint::SetEnabled
void SetEnabled(bool enable) override
If enable is true, enable the breakpoint, if false disable it.
Definition: Breakpoint.cpp:295
lldb_private::ThreadPlanStepOut::GetPlanRunState
lldb::StateType GetPlanRunState() override
Definition: ThreadPlanStepOut.cpp:390
lldb_private::ThreadPlan::SetPlanComplete
void SetPlanComplete(bool success=true)
Definition: ThreadPlan.cpp:66
lldb_private::ThreadPlanStepOut::DidPush
void DidPush() override
Definition: ThreadPlanStepOut.cpp:182
lldb_private::Address::DumpStyleResolvedDescription
@ DumpStyleResolvedDescription
Display the details about what an address resolves to.
Definition: Address.h:101
lldb_private::Address::Dump
bool Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style, DumpStyle fallback_style=DumpStyleInvalid, uint32_t addr_byte_size=UINT32_MAX, bool all_ranges=false) const
Dump a description of this object to a Stream.
Definition: Address.cpp:406
lldb_private::ThreadPlanStepOut::SetFlagsToDefault
void SetFlagsToDefault() override
Definition: ThreadPlanStepOut.h:44
lldb_private::Block
Definition: Block.h:41
lldb_private::ThreadPlan::IsUsuallyUnexplainedStopReason
bool IsUsuallyUnexplainedStopReason(lldb::StopReason)
Definition: ThreadPlan.cpp:166
uint32_t
lldb_private::eLazyBoolNo
@ eLazyBoolNo
Definition: lldb-private-enumerations.h:115
lldb_private::Address
Definition: Address.h:59
lldb_private::ThreadPlan::m_could_not_resolve_hw_bp
bool m_could_not_resolve_hw_bp
Definition: ThreadPlan.h:535
lldb_private::Thread::QueueThreadPlan
Status QueueThreadPlan(lldb::ThreadPlanSP &plan_sp, bool abort_other_plans)
Queues a generic thread plan.
Definition: Thread.cpp:1171
lldb_private::Block::GetRangeAtIndex
bool GetRangeAtIndex(uint32_t range_idx, AddressRange &range)
Definition: Block.cpp:303
lldb_private::ThreadPlanStepOut::DoWillResume
bool DoWillResume(lldb::StateType resume_state, bool current_plan) override
Definition: ThreadPlanStepOut.cpp:392
lldb_private::Address::GetLoadAddress
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:311
lldb_private::Process::AdvanceAddressToNextBranchInstruction
Address AdvanceAddressToNextBranchInstruction(Address default_stop_addr, AddressRange range_bounds)
Find the next branch instruction to set a breakpoint on.
Definition: Process.cpp:5826
lldb_private::ThreadPlanStepOut::CalculateReturnValue
void CalculateReturnValue()
Definition: ThreadPlanStepOut.cpp:503
StopInfo.h
lldb::eStopReasonBreakpoint
@ eStopReasonBreakpoint
Definition: lldb-enumerations.h:244
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_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:74
LLDB_LOG
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:337
lldb_private::ThreadPlanStepRange::ValidatePlan
bool ValidatePlan(Stream *error) override
Returns whether this plan could be successfully created.
Definition: ThreadPlanStepRange.cpp:58
lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition: CompilerType.h:35
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::ThreadPlanStepOut::m_stop_others
bool m_stop_others
Definition: ThreadPlanStepOut.h:61
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb::eDescriptionLevelVerbose
@ eDescriptionLevelVerbose
Definition: lldb-enumerations.h:211
lldb_private::ThreadPlanShouldStopHere::InvokeShouldStopHereCallback
bool InvokeShouldStopHereCallback(lldb::FrameComparison operation, Status &status)
Definition: ThreadPlanShouldStopHere.cpp:39
lldb_private::eLazyBoolCalculate
@ eLazyBoolCalculate
Definition: lldb-private-enumerations.h:115
lldb_private::ThreadPlanStepOut::DoPlanExplainsStop
bool DoPlanExplainsStop(Event *event_ptr) override
Definition: ThreadPlanStepOut.cpp:269
lldb_private::Breakpoint::IsHardware
bool IsHardware() const
Definition: Breakpoint.h:521
lldb_private::ThreadPlanShouldStopHere::SetShouldStopHereCallbacks
void SetShouldStopHereCallbacks(const ThreadPlanShouldStopHereCallbacks *callbacks, void *baton)
Definition: ThreadPlanShouldStopHere.h:79
Breakpoint.h
lldb_private::ThreadPlanStepOut::~ThreadPlanStepOut
~ThreadPlanStepOut() override
Definition: ThreadPlanStepOut.cpp:190
lldb_private::ThreadPlanStepOut::m_immediate_step_from_function
Function * m_immediate_step_from_function
Definition: ThreadPlanStepOut.h:71
lldb_private::Function::GetCompilerType
CompilerType GetCompilerType()
Definition: Function.cpp:521
lldb_private::ThreadPlan::m_tid
lldb::tid_t m_tid
Definition: ThreadPlan.h:531
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:136
lldb_private::StackID
Definition: StackID.h:17
lldb_private::Process::GetABI
const lldb::ABISP & GetABI()
Definition: Process.cpp:1486
lldb_private::Address::GetOffset
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition: Address.h:319
lldb::StateType
StateType
Process and Thread States.
Definition: lldb-enumerations.h:74
lldb_private::Log
Definition: Log.h:115
lldb_private::ThreadPlanStepOut::m_step_out_to_inline_plan_sp
lldb::ThreadPlanSP m_step_out_to_inline_plan_sp
Definition: ThreadPlanStepOut.h:62
lldb_private::Target::GetBreakpointByID
lldb::BreakpointSP GetBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:325
lldb_private::Thread::GetStackFrameAtIndex
virtual lldb::StackFrameSP GetStackFrameAtIndex(uint32_t idx)
Definition: Thread.h:399
lldb_private::ThreadPlanStepOut::m_stepped_past_frames
std::vector< lldb::StackFrameSP > m_stepped_past_frames
Definition: ThreadPlanStepOut.h:72
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:517
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::Block::GetNumRanges
size_t GetNumRanges() const
Definition: Block.h:343
lldb_private::ThreadPlan::m_process
Process & m_process
Definition: ThreadPlan.h:530
lldb_private::Address::Slide
bool Slide(int64_t offset)
Definition: Address.h:449
lldb
Definition: SBAddress.h:15
lldb::eStateRunning
@ eStateRunning
Process or thread is running and can't be examined.
Definition: lldb-enumerations.h:86
lldb_private::ThreadPlanStepOut::m_step_out_further_plan_sp
lldb::ThreadPlanSP m_step_out_further_plan_sp
Definition: ThreadPlanStepOut.h:68
RegisterContext.h
Value.h
lldb_private::Block::CalculateSymbolContext
void CalculateSymbolContext(SymbolContext *sc) override
Reconstruct the object's symbol context into sc.
Definition: Block.cpp:136
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::Block::GetContainingInlinedBlock
Block * GetContainingInlinedBlock()
Get the inlined block that contains this block.
Definition: Block.cpp:208
lldb::eDescriptionLevelBrief
@ eDescriptionLevelBrief
Definition: lldb-enumerations.h:209
lldb::eFrameCompareOlder
@ eFrameCompareOlder
Definition: lldb-enumerations.h:884
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:208
lldb_private::Breakpoint
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
Definition: Breakpoint.h:80
lldb::eOnlyThisThread
@ eOnlyThisThread
Definition: lldb-enumerations.h:136
lldb_private::Process::GetLoadAddressPermissions
virtual bool GetLoadAddressPermissions(lldb::addr_t load_addr, uint32_t &permissions)
Attempt to get the attributes for a region of memory in the process.
Definition: Process.cpp:2377
lldb_private::ThreadPlanStepOut::m_return_valobj_sp
lldb::ValueObjectSP m_return_valobj_sp
Definition: ThreadPlanStepOut.h:73