LLDB  mainline
UnwindLLDB.cpp
Go to the documentation of this file.
1 //===-- UnwindLLDB.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/Core/Module.h"
12 #include "lldb/Symbol/Function.h"
13 #include "lldb/Symbol/UnwindPlan.h"
14 #include "lldb/Target/ABI.h"
15 #include "lldb/Target/Process.h"
18 #include "lldb/Target/Target.h"
19 #include "lldb/Target/Thread.h"
20 #include "lldb/Utility/Log.h"
21 
22 using namespace lldb;
23 using namespace lldb_private;
24 
25 UnwindLLDB::UnwindLLDB(Thread &thread)
26  : Unwind(thread), m_frames(), m_unwind_complete(false),
27  m_user_supplied_trap_handler_functions() {
28  ProcessSP process_sp(thread.GetProcess());
29  if (process_sp) {
30  Args args;
31  process_sp->GetTarget().GetUserSpecifiedTrapHandlerNames(args);
32  size_t count = args.GetArgumentCount();
33  for (size_t i = 0; i < count; i++) {
34  const char *func_name = args.GetArgumentAtIndex(i);
36  }
37  }
38 }
39 
41  if (!m_unwind_complete) {
42 //#define DEBUG_FRAME_SPEED 1
43 #if DEBUG_FRAME_SPEED
44 #define FRAME_COUNT 10000
45  using namespace std::chrono;
46  auto time_value = steady_clock::now();
47 #endif
48  if (!AddFirstFrame())
49  return 0;
50 
51  ProcessSP process_sp(m_thread.GetProcess());
52  ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
53 
54  while (AddOneMoreFrame(abi)) {
55 #if DEBUG_FRAME_SPEED
56  if ((m_frames.size() % FRAME_COUNT) == 0) {
57  const auto now = steady_clock::now();
58  const auto delta_t = now - time_value;
59  printf("%u frames in %.9f ms (%g frames/sec)\n", FRAME_COUNT,
60  duration<double, std::milli>(delta_t).count(),
61  (float)FRAME_COUNT / duration<double>(delta_t).count());
62  time_value = now;
63  }
64 #endif
65  }
66  }
67  return m_frames.size();
68 }
69 
71  if (m_frames.size() > 0)
72  return true;
73 
74  ProcessSP process_sp(m_thread.GetProcess());
75  ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
76 
77  // First, set up the 0th (initial) frame
78  CursorSP first_cursor_sp(new Cursor());
80  m_thread, RegisterContextLLDBSP(), first_cursor_sp->sctx, 0, *this));
81  if (reg_ctx_sp.get() == nullptr)
82  goto unwind_done;
83 
84  if (!reg_ctx_sp->IsValid())
85  goto unwind_done;
86 
87  if (!reg_ctx_sp->GetCFA(first_cursor_sp->cfa))
88  goto unwind_done;
89 
90  if (!reg_ctx_sp->ReadPC(first_cursor_sp->start_pc))
91  goto unwind_done;
92 
93  // Everything checks out, so release the auto pointer value and let the
94  // cursor own it in its shared pointer
95  first_cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp;
96  m_frames.push_back(first_cursor_sp);
97 
98  // Update the Full Unwind Plan for this frame if not valid
100 
101  return true;
102 
103 unwind_done:
105  if (log) {
106  LLDB_LOGF(log, "th%d Unwind of this thread is complete.",
107  m_thread.GetIndexID());
108  }
109  m_unwind_complete = true;
110  return false;
111 }
112 
114  assert(m_frames.size() != 0 &&
115  "Get one more frame called with empty frame list");
116 
117  // If we've already gotten to the end of the stack, don't bother to try
118  // again...
119  if (m_unwind_complete)
120  return nullptr;
121 
123 
124  CursorSP prev_frame = m_frames.back();
125  uint32_t cur_idx = m_frames.size();
126 
127  CursorSP cursor_sp(new Cursor());
129  m_thread, prev_frame->reg_ctx_lldb_sp, cursor_sp->sctx, cur_idx, *this));
130 
131  uint64_t max_stack_depth = m_thread.GetMaxBacktraceDepth();
132 
133  // We want to detect an unwind that cycles erroneously and stop backtracing.
134  // Don't want this maximum unwind limit to be too low -- if you have a
135  // backtrace with an "infinitely recursing" bug, it will crash when the stack
136  // blows out and the first 35,000 frames are uninteresting - it's the top
137  // most 5 frames that you actually care about. So you can't just cap the
138  // unwind at 10,000 or something. Realistically anything over around 200,000
139  // is going to blow out the stack space. If we're still unwinding at that
140  // point, we're probably never going to finish.
141  if (cur_idx >= max_stack_depth) {
142  LLDB_LOGF(log,
143  "%*sFrame %d unwound too many frames, assuming unwind has "
144  "gone astray, stopping.",
145  cur_idx < 100 ? cur_idx : 100, "", cur_idx);
146  return nullptr;
147  }
148 
149  if (reg_ctx_sp.get() == nullptr) {
150  // If the RegisterContextUnwind has a fallback UnwindPlan, it will switch to
151  // that and return true. Subsequent calls to TryFallbackUnwindPlan() will
152  // return false.
153  if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
154  // TryFallbackUnwindPlan for prev_frame succeeded and updated
155  // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
156  // still needs to be updated. Hence updating it.
157  if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
158  return nullptr;
159 
160  return GetOneMoreFrame(abi);
161  }
162 
163  LLDB_LOGF(log, "%*sFrame %d did not get a RegisterContext, stopping.",
164  cur_idx < 100 ? cur_idx : 100, "", cur_idx);
165  return nullptr;
166  }
167 
168  if (!reg_ctx_sp->IsValid()) {
169  // We failed to get a valid RegisterContext. See if the regctx below this
170  // on the stack has a fallback unwind plan it can use. Subsequent calls to
171  // TryFallbackUnwindPlan() will return false.
172  if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
173  // TryFallbackUnwindPlan for prev_frame succeeded and updated
174  // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
175  // still needs to be updated. Hence updating it.
176  if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
177  return nullptr;
178 
179  return GetOneMoreFrame(abi);
180  }
181 
182  LLDB_LOGF(log,
183  "%*sFrame %d invalid RegisterContext for this frame, "
184  "stopping stack walk",
185  cur_idx < 100 ? cur_idx : 100, "", cur_idx);
186  return nullptr;
187  }
188  if (!reg_ctx_sp->GetCFA(cursor_sp->cfa)) {
189  // If the RegisterContextUnwind has a fallback UnwindPlan, it will switch to
190  // that and return true. Subsequent calls to TryFallbackUnwindPlan() will
191  // return false.
192  if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
193  // TryFallbackUnwindPlan for prev_frame succeeded and updated
194  // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
195  // still needs to be updated. Hence updating it.
196  if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
197  return nullptr;
198 
199  return GetOneMoreFrame(abi);
200  }
201 
202  LLDB_LOGF(log,
203  "%*sFrame %d did not get CFA for this frame, stopping stack walk",
204  cur_idx < 100 ? cur_idx : 100, "", cur_idx);
205  return nullptr;
206  }
207  if (abi && !abi->CallFrameAddressIsValid(cursor_sp->cfa)) {
208  // On Mac OS X, the _sigtramp asynchronous signal trampoline frame may not
209  // have its (constructed) CFA aligned correctly -- don't do the abi
210  // alignment check for these.
211  if (!reg_ctx_sp->IsTrapHandlerFrame()) {
212  // See if we can find a fallback unwind plan for THIS frame. It may be
213  // that the UnwindPlan we're using for THIS frame was bad and gave us a
214  // bad CFA. If that's not it, then see if we can change the UnwindPlan
215  // for the frame below us ("NEXT") -- see if using that other UnwindPlan
216  // gets us a better unwind state.
217  if (!reg_ctx_sp->TryFallbackUnwindPlan() ||
218  !reg_ctx_sp->GetCFA(cursor_sp->cfa) ||
219  !abi->CallFrameAddressIsValid(cursor_sp->cfa)) {
220  if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
221  // TryFallbackUnwindPlan for prev_frame succeeded and updated
222  // reg_ctx_lldb_sp field of prev_frame. However, cfa field of
223  // prev_frame still needs to be updated. Hence updating it.
224  if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
225  return nullptr;
226 
227  return GetOneMoreFrame(abi);
228  }
229 
230  LLDB_LOGF(log,
231  "%*sFrame %d did not get a valid CFA for this frame, "
232  "stopping stack walk",
233  cur_idx < 100 ? cur_idx : 100, "", cur_idx);
234  return nullptr;
235  } else {
236  LLDB_LOGF(log,
237  "%*sFrame %d had a bad CFA value but we switched the "
238  "UnwindPlan being used and got one that looks more "
239  "realistic.",
240  cur_idx < 100 ? cur_idx : 100, "", cur_idx);
241  }
242  }
243  }
244  if (!reg_ctx_sp->ReadPC(cursor_sp->start_pc)) {
245  // If the RegisterContextUnwind has a fallback UnwindPlan, it will switch to
246  // that and return true. Subsequent calls to TryFallbackUnwindPlan() will
247  // return false.
248  if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
249  // TryFallbackUnwindPlan for prev_frame succeeded and updated
250  // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
251  // still needs to be updated. Hence updating it.
252  if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
253  return nullptr;
254 
255  return GetOneMoreFrame(abi);
256  }
257 
258  LLDB_LOGF(log,
259  "%*sFrame %d did not get PC for this frame, stopping stack walk",
260  cur_idx < 100 ? cur_idx : 100, "", cur_idx);
261  return nullptr;
262  }
263  if (abi && !abi->CodeAddressIsValid(cursor_sp->start_pc)) {
264  // If the RegisterContextUnwind has a fallback UnwindPlan, it will switch to
265  // that and return true. Subsequent calls to TryFallbackUnwindPlan() will
266  // return false.
267  if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
268  // TryFallbackUnwindPlan for prev_frame succeeded and updated
269  // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
270  // still needs to be updated. Hence updating it.
271  if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
272  return nullptr;
273 
274  return GetOneMoreFrame(abi);
275  }
276 
277  LLDB_LOGF(log, "%*sFrame %d did not get a valid PC, stopping stack walk",
278  cur_idx < 100 ? cur_idx : 100, "", cur_idx);
279  return nullptr;
280  }
281  // Infinite loop where the current cursor is the same as the previous one...
282  if (prev_frame->start_pc == cursor_sp->start_pc &&
283  prev_frame->cfa == cursor_sp->cfa) {
284  LLDB_LOGF(log,
285  "th%d pc of this frame is the same as the previous frame and "
286  "CFAs for both frames are identical -- stopping unwind",
287  m_thread.GetIndexID());
288  return nullptr;
289  }
290 
291  cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp;
292  return cursor_sp;
293 }
294 
296  // This function is called for First Frame only.
297  assert(m_frames.size() == 1 && "No. of cursor frames are not 1");
298 
299  bool old_m_unwind_complete = m_unwind_complete;
300  CursorSP old_m_candidate_frame = m_candidate_frame;
301 
302  // Try to unwind 2 more frames using the Unwinder. It uses Full UnwindPlan
303  // and if Full UnwindPlan fails, then uses FallBack UnwindPlan. Also update
304  // the cfa of Frame 0 (if required).
305  AddOneMoreFrame(abi);
306 
307  // Remove all the frames added by above function as the purpose of using
308  // above function was just to check whether Unwinder of Frame 0 works or not.
309  for (uint32_t i = 1; i < m_frames.size(); i++)
310  m_frames.pop_back();
311 
312  // Restore status after calling AddOneMoreFrame
313  m_unwind_complete = old_m_unwind_complete;
314  m_candidate_frame = old_m_candidate_frame;
315 }
316 
319 
320  // Frame zero is a little different
321  if (m_frames.empty())
322  return false;
323 
324  // If we've already gotten to the end of the stack, don't bother to try
325  // again...
326  if (m_unwind_complete)
327  return false;
328 
329  CursorSP new_frame = m_candidate_frame;
330  if (new_frame == nullptr)
331  new_frame = GetOneMoreFrame(abi);
332 
333  if (new_frame == nullptr) {
334  LLDB_LOGF(log, "th%d Unwind of this thread is complete.",
335  m_thread.GetIndexID());
336  m_unwind_complete = true;
337  return false;
338  }
339 
340  m_frames.push_back(new_frame);
341 
342  // If we can get one more frame further then accept that we get back a
343  // correct frame.
345  if (m_candidate_frame)
346  return true;
347 
348  // We can't go further from the frame returned by GetOneMore frame. Lets try
349  // to get a different frame with using the fallback unwind plan.
350  if (!m_frames[m_frames.size() - 2]
351  ->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
352  // We don't have a valid fallback unwind plan. Accept the frame as it is.
353  // This is a valid situation when we are at the bottom of the stack.
354  return true;
355  }
356 
357  // Remove the possibly incorrect frame from the frame list and try to add a
358  // different one with the newly selected fallback unwind plan.
359  m_frames.pop_back();
360  CursorSP new_frame_v2 = GetOneMoreFrame(abi);
361  if (new_frame_v2 == nullptr) {
362  // We haven't got a new frame from the fallback unwind plan. Accept the
363  // frame from the original unwind plan. This is a valid situation when we
364  // are at the bottom of the stack.
365  m_frames.push_back(new_frame);
366  return true;
367  }
368 
369  // Push the new frame to the list and try to continue from this frame. If we
370  // can get a new frame then accept it as the correct one.
371  m_frames.push_back(new_frame_v2);
373  if (m_candidate_frame) {
374  // If control reached here then TryFallbackUnwindPlan had succeeded for
375  // Cursor::m_frames[m_frames.size() - 2]. It also succeeded to Unwind next
376  // 2 frames i.e. m_frames[m_frames.size() - 1] and a frame after that. For
377  // Cursor::m_frames[m_frames.size() - 2], reg_ctx_lldb_sp field was already
378  // updated during TryFallbackUnwindPlan call above. However, cfa field
379  // still needs to be updated. Hence updating it here and then returning.
380  return m_frames[m_frames.size() - 2]->reg_ctx_lldb_sp->GetCFA(
381  m_frames[m_frames.size() - 2]->cfa);
382  }
383 
384  // The new frame hasn't helped in unwinding. Fall back to the original one as
385  // the default unwind plan is usually more reliable then the fallback one.
386  m_frames.pop_back();
387  m_frames.push_back(new_frame);
388  return true;
389 }
390 
392  bool &behaves_like_zeroth_frame) {
393  if (m_frames.size() == 0) {
394  if (!AddFirstFrame())
395  return false;
396  }
397 
398  ProcessSP process_sp(m_thread.GetProcess());
399  ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
400 
401  while (idx >= m_frames.size() && AddOneMoreFrame(abi))
402  ;
403 
404  if (idx < m_frames.size()) {
405  cfa = m_frames[idx]->cfa;
406  pc = m_frames[idx]->start_pc;
407  if (idx == 0) {
408  // Frame zero always behaves like it.
409  behaves_like_zeroth_frame = true;
410  } else if (m_frames[idx - 1]->reg_ctx_lldb_sp->IsTrapHandlerFrame()) {
411  // This could be an asynchronous signal, thus the
412  // pc might point to the interrupted instruction rather
413  // than a post-call instruction
414  behaves_like_zeroth_frame = true;
415  } else if (m_frames[idx]->reg_ctx_lldb_sp->IsTrapHandlerFrame()) {
416  // This frame may result from signal processing installing
417  // a pointer to the first byte of a signal-return trampoline
418  // in the return address slot of the frame below, so this
419  // too behaves like the zeroth frame (i.e. the pc might not
420  // be pointing just past a call in it)
421  behaves_like_zeroth_frame = true;
422  } else if (m_frames[idx]->reg_ctx_lldb_sp->BehavesLikeZerothFrame()) {
423  behaves_like_zeroth_frame = true;
424  } else {
425  behaves_like_zeroth_frame = false;
426  }
427  return true;
428  }
429  return false;
430 }
431 
432 lldb::RegisterContextSP
434  lldb::RegisterContextSP reg_ctx_sp;
435  uint32_t idx = frame->GetConcreteFrameIndex();
436 
437  if (idx == 0) {
438  return m_thread.GetRegisterContext();
439  }
440 
441  if (m_frames.size() == 0) {
442  if (!AddFirstFrame())
443  return reg_ctx_sp;
444  }
445 
446  ProcessSP process_sp(m_thread.GetProcess());
447  ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
448 
449  while (idx >= m_frames.size()) {
450  if (!AddOneMoreFrame(abi))
451  break;
452  }
453 
454  const uint32_t num_frames = m_frames.size();
455  if (idx < num_frames) {
456  Cursor *frame_cursor = m_frames[idx].get();
457  reg_ctx_sp = frame_cursor->reg_ctx_lldb_sp;
458  }
459  return reg_ctx_sp;
460 }
461 
464  RegisterContextLLDBSP reg_ctx_sp;
465  if (frame_num < m_frames.size())
466  reg_ctx_sp = m_frames[frame_num]->reg_ctx_lldb_sp;
467  return reg_ctx_sp;
468 }
469 
472  uint32_t starting_frame_num, bool pc_reg) {
473  int64_t frame_num = starting_frame_num;
474  if (static_cast<size_t>(frame_num) >= m_frames.size())
475  return false;
476 
477  // Never interrogate more than one level while looking for the saved pc
478  // value. If the value isn't saved by frame_num, none of the frames lower on
479  // the stack will have a useful value.
480  if (pc_reg) {
482  result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister(
483  lldb_regnum, regloc);
484  return result == UnwindLLDB::RegisterSearchResult::eRegisterFound;
485  }
486  while (frame_num >= 0) {
488  result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister(
489  lldb_regnum, regloc);
490 
491  // We descended down to the live register context aka stack frame 0 and are
492  // reading the value out of a live register.
493  if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound &&
494  regloc.type ==
496  return true;
497  }
498 
499  // If we have unwind instructions saying that register N is saved in
500  // register M in the middle of the stack (and N can equal M here, meaning
501  // the register was not used in this function), then change the register
502  // number we're looking for to M and keep looking for a concrete location
503  // down the stack, or an actual value from a live RegisterContext at frame
504  // 0.
505  if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound &&
507  frame_num > 0) {
508  result = UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
509  lldb_regnum = regloc.location.register_number;
510  }
511 
512  if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound)
513  return true;
514  if (result == UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile)
515  return false;
516  frame_num--;
517  }
518  return false;
519 }
lldb_private::UnwindLLDB::CursorSP
std::shared_ptr< Cursor > CursorSP
Definition: UnwindLLDB.h:129
lldb_private::UnwindLLDB::RegisterLocation::type
int type
Definition: UnwindLLDB.h:56
lldb_private::UnwindLLDB::Cursor::reg_ctx_lldb_sp
RegisterContextLLDBSP reg_ctx_lldb_sp
Definition: UnwindLLDB.h:120
lldb_private::ABI
Definition: ABI.h:27
lldb_private::Thread::GetIndexID
uint32_t GetIndexID() const
Definition: Thread.cpp:1379
UnwindLLDB.h
lldb_private::UnwindLLDB::m_candidate_frame
CursorSP m_candidate_frame
Definition: UnwindLLDB.h:131
lldb_private::ABI::CodeAddressIsValid
virtual bool CodeAddressIsValid(lldb::addr_t pc)=0
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:247
lldb_private::UnwindLLDB::GetOneMoreFrame
CursorSP GetOneMoreFrame(ABI *abi)
Definition: UnwindLLDB.cpp:113
Module.h
lldb_private::UnwindLLDB::m_user_supplied_trap_handler_functions
std::vector< ConstString > m_user_supplied_trap_handler_functions
Definition: UnwindLLDB.h:138
lldb_private::Unwind::m_thread
Thread & m_thread
Definition: Unwind.h:76
lldb_private::UnwindLLDB::UpdateUnwindPlanForFirstFrameIfInvalid
void UpdateUnwindPlanForFirstFrameIfInvalid(ABI *abi)
Definition: UnwindLLDB.cpp:295
lldb_private::UnwindLLDB::RegisterLocation::register_number
uint32_t register_number
Definition: UnwindLLDB.h:60
lldb_private::Args
Definition: Args.h:33
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
pc
@ pc
Definition: CompactUnwindInfo.cpp:1250
ABI.h
Process.h
lldb_private::UnwindLLDB::RegisterContextLLDBSP
std::shared_ptr< RegisterContextUnwind > RegisterContextLLDBSP
Definition: UnwindLLDB.h:82
lldb_private::UnwindLLDB::m_unwind_complete
bool m_unwind_complete
Definition: UnwindLLDB.h:132
Target.h
lldb_private::StackFrame::GetConcreteFrameIndex
uint32_t GetConcreteFrameIndex() const
Query this frame to find what frame it is in this Thread's StackFrameList, not counting inlined frame...
Definition: StackFrame.h:407
lldb_private::Thread::GetProcess
lldb::ProcessSP GetProcess() const
Definition: Thread.h:152
lldb_private::UnwindLLDB::RegisterSearchResult
RegisterSearchResult
Definition: UnwindLLDB.h:32
Log.h
lldb_private::Thread
Definition: Thread.h:60
lldb_private::UnwindLLDB::DoGetFrameInfoAtIndex
bool DoGetFrameInfoAtIndex(uint32_t frame_idx, lldb::addr_t &cfa, lldb::addr_t &start_pc, bool &behaves_like_zeroth_frame) override
Definition: UnwindLLDB.cpp:391
lldb_private::UnwindLLDB::RegisterLocation
Definition: UnwindLLDB.h:41
lldb_private::ConstString
Definition: ConstString.h:40
lldb_private::GetLogIfAllCategoriesSet
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:58
lldb_private::UnwindLLDB::DoGetFrameCount
uint32_t DoGetFrameCount() override
Definition: UnwindLLDB.cpp:40
lldb_private::ThreadProperties::GetMaxBacktraceDepth
uint64_t GetMaxBacktraceDepth() const
Definition: Thread.cpp:142
RegisterContextUnwind.h
lldb_private::UnwindLLDB::Cursor
Definition: UnwindLLDB.h:111
lldb_private::UnwindLLDB::SearchForSavedLocationForRegister
bool SearchForSavedLocationForRegister(uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation &regloc, uint32_t starting_frame_num, bool pc_register)
Definition: UnwindLLDB.cpp:470
Thread.h
lldb_private::UnwindLLDB::RegisterLocation::eRegisterInRegister
@ eRegisterInRegister
Definition: UnwindLLDB.h:47
UnwindPlan.h
lldb_private::UnwindLLDB::DoCreateRegisterContextForFrame
lldb::RegisterContextSP DoCreateRegisterContextForFrame(lldb_private::StackFrame *frame) override
Definition: UnwindLLDB.cpp:433
FuncUnwinders.h
lldb_private::UnwindLLDB::RegisterLocation::location
union lldb_private::UnwindLLDB::RegisterLocation::@40 location
lldb_private::Args::GetArgumentAtIndex
const char * GetArgumentAtIndex(size_t idx) const
Gets the NULL terminated C string argument pointer for the argument at index idx.
Definition: Args.cpp:259
uint32_t
lldb_private::ABI::CallFrameAddressIsValid
virtual bool CallFrameAddressIsValid(lldb::addr_t cfa)=0
lldb_private::UnwindLLDB::GetRegisterContextForFrameNum
RegisterContextLLDBSP GetRegisterContextForFrameNum(uint32_t frame_num)
Definition: UnwindLLDB.cpp:463
Function.h
lldb_private::UnwindLLDB::AddOneMoreFrame
bool AddOneMoreFrame(ABI *abi)
Definition: UnwindLLDB.cpp:317
lldb_private::RegisterContextUnwind
Definition: RegisterContextUnwind.h:25
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext
@ eRegisterInLiveRegisterContext
Definition: UnwindLLDB.h:53
lldb_private::UnwindLLDB::m_frames
std::vector< CursorSP > m_frames
Definition: UnwindLLDB.h:130
lldb_private::Log
Definition: Log.h:49
lldb_private::Thread::GetRegisterContext
virtual lldb::RegisterContextSP GetRegisterContext()=0
lldb_private::StackFrame
Definition: StackFrame.h:40
lldb_private::Unwind
Definition: Unwind.h:18
lldb_private::Args::GetArgumentCount
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
Definition: Args.h:118
lldb
Definition: SBAddress.h:15
RegisterContext.h
LIBLLDB_LOG_UNWIND
#define LIBLLDB_LOG_UNWIND
Definition: Logging.h:29
lldb_private::UnwindLLDB::AddFirstFrame
bool AddFirstFrame()
Definition: UnwindLLDB.cpp:70