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