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"
14#include "lldb/Target/ABI.h"
15#include "lldb/Target/Process.h"
18#include "lldb/Target/Target.h"
19#include "lldb/Target/Thread.h"
21#include "lldb/Utility/Log.h"
22
23using namespace lldb;
24using namespace lldb_private;
25
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
104unwind_done:
105 Log *log = GetLog(LLDBLog::Unwind);
106 if (log) {
107 LLDB_LOGF(log, "th%d Unwind of this thread is complete.",
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...
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",
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...
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.",
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.
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
435 lldb::RegisterContextSP reg_ctx_sp;
436 uint32_t idx = frame->GetConcreteFrameIndex();
437
438 if (idx == 0) {
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
472 uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation &regloc,
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);
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.
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.
508 frame_num > 0) {
510 lldb_regnum = regloc.location.register_number;
511 }
512
514 return true;
516 return false;
517 frame_num--;
518 }
519 return false;
520}
#define LLDB_LOGF(log,...)
Definition: Log.h:349
virtual bool CodeAddressIsValid(lldb::addr_t pc)=0
virtual bool CallFrameAddressIsValid(lldb::addr_t cfa)=0
A command line argument class.
Definition: Args.h:33
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
Definition: Args.h:116
const char * GetArgumentAtIndex(size_t idx) const
Gets the NULL terminated C string argument pointer for the argument at index idx.
Definition: Args.cpp:263
A uniqued constant string class.
Definition: ConstString.h:40
This base class provides an interface to stack frames.
Definition: StackFrame.h:42
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:428
uint64_t GetMaxBacktraceDepth() const
Definition: Thread.cpp:140
virtual lldb::RegisterContextSP GetRegisterContext()=0
uint32_t GetIndexID() const
Definition: Thread.cpp:1379
lldb::ProcessSP GetProcess() const
Definition: Thread.h:153
void UpdateUnwindPlanForFirstFrameIfInvalid(ABI *abi)
Definition: UnwindLLDB.cpp:296
std::vector< ConstString > m_user_supplied_trap_handler_functions
Definition: UnwindLLDB.h:138
std::vector< CursorSP > m_frames
Definition: UnwindLLDB.h:130
RegisterContextLLDBSP GetRegisterContextForFrameNum(uint32_t frame_num)
Definition: UnwindLLDB.cpp:464
lldb::RegisterContextSP DoCreateRegisterContextForFrame(lldb_private::StackFrame *frame) override
Definition: UnwindLLDB.cpp:434
UnwindLLDB(lldb_private::Thread &thread)
Definition: UnwindLLDB.cpp:26
friend class lldb_private::RegisterContextUnwind
Definition: UnwindLLDB.h:39
std::shared_ptr< Cursor > CursorSP
Definition: UnwindLLDB.h:129
bool AddOneMoreFrame(ABI *abi)
Definition: UnwindLLDB.cpp:318
CursorSP GetOneMoreFrame(ABI *abi)
Definition: UnwindLLDB.cpp:114
std::shared_ptr< RegisterContextUnwind > RegisterContextLLDBSP
Definition: UnwindLLDB.h:82
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
bool SearchForSavedLocationForRegister(uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation &regloc, uint32_t starting_frame_num, bool pc_register)
Definition: UnwindLLDB.cpp:471
uint32_t DoGetFrameCount() override
Definition: UnwindLLDB.cpp:41
Thread & m_thread
Definition: Unwind.h:76
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:314
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:377
uint64_t addr_t
Definition: lldb-types.h:79
std::shared_ptr< lldb_private::RegisterContext > RegisterContextSP
Definition: lldb-forward.h:382
RegisterContextLLDBSP reg_ctx_lldb_sp
Definition: UnwindLLDB.h:120
union lldb_private::UnwindLLDB::RegisterLocation::@38 location