1 //===-- UnwindLLDB.cpp -------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/Core/Module.h"
11 #include "lldb/Symbol/FuncUnwinders.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"
16 #include "lldb/Target/RegisterContext.h"
17 #include "lldb/Target/Target.h"
18 #include "lldb/Target/Thread.h"
19 #include "lldb/Utility/Log.h"
21 #include "RegisterContextLLDB.h"
22 #include "UnwindLLDB.h"
25 using namespace lldb_private;
27 UnwindLLDB::UnwindLLDB(Thread &thread)
28 : Unwind(thread), m_frames(), m_unwind_complete(false),
29 m_user_supplied_trap_handler_functions() {
30 ProcessSP process_sp(thread.GetProcess());
33 process_sp->GetTarget().GetUserSpecifiedTrapHandlerNames(args);
34 size_t count = args.GetArgumentCount();
35 for (size_t i = 0; i < count; i++) {
36 const char *func_name = args.GetArgumentAtIndex(i);
37 m_user_supplied_trap_handler_functions.push_back(ConstString(func_name));
42 uint32_t UnwindLLDB::DoGetFrameCount() {
43 if (!m_unwind_complete) {
44 //#define DEBUG_FRAME_SPEED 1
46 #define FRAME_COUNT 10000
47 using namespace std::chrono;
48 auto time_value = steady_clock::now();
53 ProcessSP process_sp(m_thread.GetProcess());
54 ABI *abi = process_sp ? process_sp->GetABI().get() : NULL;
56 while (AddOneMoreFrame(abi)) {
58 if ((m_frames.size() % FRAME_COUNT) == 0) {
59 const auto now = steady_clock::now();
60 const auto delta_t = now - time_value;
61 printf("%u frames in %.9f ms (%g frames/sec)\n", FRAME_COUNT,
62 duration<double, std::milli>(delta_t).count(),
63 (float)FRAME_COUNT / duration<double>(delta_t).count());
69 return m_frames.size();
72 bool UnwindLLDB::AddFirstFrame() {
73 if (m_frames.size() > 0)
76 ProcessSP process_sp(m_thread.GetProcess());
77 ABI *abi = process_sp ? process_sp->GetABI().get() : NULL;
79 // First, set up the 0th (initial) frame
80 CursorSP first_cursor_sp(new Cursor());
81 RegisterContextLLDBSP reg_ctx_sp(new RegisterContextLLDB(
82 m_thread, RegisterContextLLDBSP(), first_cursor_sp->sctx, 0, *this));
83 if (reg_ctx_sp.get() == NULL)
86 if (!reg_ctx_sp->IsValid())
89 if (!reg_ctx_sp->GetCFA(first_cursor_sp->cfa))
92 if (!reg_ctx_sp->ReadPC(first_cursor_sp->start_pc))
95 // Everything checks out, so release the auto pointer value and let the
96 // cursor own it in its shared pointer
97 first_cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp;
98 m_frames.push_back(first_cursor_sp);
100 // Update the Full Unwind Plan for this frame if not valid
101 UpdateUnwindPlanForFirstFrameIfInvalid(abi);
106 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
108 log->Printf("th%d Unwind of this thread is complete.",
109 m_thread.GetIndexID());
111 m_unwind_complete = true;
115 UnwindLLDB::CursorSP UnwindLLDB::GetOneMoreFrame(ABI *abi) {
116 assert(m_frames.size() != 0 &&
117 "Get one more frame called with empty frame list");
119 // If we've already gotten to the end of the stack, don't bother to try
121 if (m_unwind_complete)
124 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
126 CursorSP prev_frame = m_frames.back();
127 uint32_t cur_idx = m_frames.size();
129 CursorSP cursor_sp(new Cursor());
130 RegisterContextLLDBSP reg_ctx_sp(new RegisterContextLLDB(
131 m_thread, prev_frame->reg_ctx_lldb_sp, cursor_sp->sctx, cur_idx, *this));
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
136 // with an "infinitely recursing" bug, it will crash when the stack blows out
137 // and the first 35,000 frames are uninteresting - it's the top most 5 frames
139 // you actually care about. So you can't just cap the unwind at 10,000 or
141 // Realistically anything over around 200,000 is going to blow out the stack
143 // If we're still unwinding at that point, we're probably never going to
145 if (cur_idx > 300000) {
147 log->Printf("%*sFrame %d unwound too many frames, assuming unwind has "
148 "gone astray, stopping.",
149 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
153 if (reg_ctx_sp.get() == NULL) {
154 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
156 // true. Subsequent calls to TryFallbackUnwindPlan() will return false.
157 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
158 // TryFallbackUnwindPlan for prev_frame succeeded and updated
159 // reg_ctx_lldb_sp field of
160 // prev_frame. However, cfa field of prev_frame still needs to be updated.
161 // Hence updating it.
162 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
165 return GetOneMoreFrame(abi);
169 log->Printf("%*sFrame %d did not get a RegisterContext, stopping.",
170 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
174 if (!reg_ctx_sp->IsValid()) {
175 // We failed to get a valid RegisterContext.
176 // See if the regctx below this on the stack has a fallback unwind plan it
178 // Subsequent calls to TryFallbackUnwindPlan() will return false.
179 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
180 // TryFallbackUnwindPlan for prev_frame succeeded and updated
181 // reg_ctx_lldb_sp field of
182 // prev_frame. However, cfa field of prev_frame still needs to be updated.
183 // Hence updating it.
184 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
187 return GetOneMoreFrame(abi);
191 log->Printf("%*sFrame %d invalid RegisterContext for this frame, "
192 "stopping stack walk",
193 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
196 if (!reg_ctx_sp->GetCFA(cursor_sp->cfa)) {
197 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
199 // true. Subsequent calls to TryFallbackUnwindPlan() will return false.
200 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
201 // TryFallbackUnwindPlan for prev_frame succeeded and updated
202 // reg_ctx_lldb_sp field of
203 // prev_frame. However, cfa field of prev_frame still needs to be updated.
204 // Hence updating it.
205 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
208 return GetOneMoreFrame(abi);
213 "%*sFrame %d did not get CFA for this frame, stopping stack walk",
214 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
217 if (abi && !abi->CallFrameAddressIsValid(cursor_sp->cfa)) {
218 // On Mac OS X, the _sigtramp asynchronous signal trampoline frame may not
220 // its (constructed) CFA aligned correctly -- don't do the abi alignment
223 if (reg_ctx_sp->IsTrapHandlerFrame() == false) {
224 // See if we can find a fallback unwind plan for THIS frame. It may be
225 // that the UnwindPlan we're using for THIS frame was bad and gave us a
227 // If that's not it, then see if we can change the UnwindPlan for the
229 // below us ("NEXT") -- see if using that other UnwindPlan gets us a
232 if (reg_ctx_sp->TryFallbackUnwindPlan() == false ||
233 reg_ctx_sp->GetCFA(cursor_sp->cfa) == false ||
234 abi->CallFrameAddressIsValid(cursor_sp->cfa) == false) {
235 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
236 // TryFallbackUnwindPlan for prev_frame succeeded and updated
237 // reg_ctx_lldb_sp field of
238 // prev_frame. However, cfa field of prev_frame still needs to be
239 // updated. Hence updating it.
240 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
243 return GetOneMoreFrame(abi);
247 log->Printf("%*sFrame %d did not get a valid CFA for this frame, "
248 "stopping stack walk",
249 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
253 log->Printf("%*sFrame %d had a bad CFA value but we switched the "
254 "UnwindPlan being used and got one that looks more "
256 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
260 if (!reg_ctx_sp->ReadPC(cursor_sp->start_pc)) {
261 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
263 // true. Subsequent calls to TryFallbackUnwindPlan() will return false.
264 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
265 // TryFallbackUnwindPlan for prev_frame succeeded and updated
266 // reg_ctx_lldb_sp field of
267 // prev_frame. However, cfa field of prev_frame still needs to be updated.
268 // Hence updating it.
269 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
272 return GetOneMoreFrame(abi);
277 "%*sFrame %d did not get PC for this frame, stopping stack walk",
278 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
281 if (abi && !abi->CodeAddressIsValid(cursor_sp->start_pc)) {
282 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
284 // true. Subsequent calls to TryFallbackUnwindPlan() will return false.
285 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
286 // TryFallbackUnwindPlan for prev_frame succeeded and updated
287 // reg_ctx_lldb_sp field of
288 // prev_frame. However, cfa field of prev_frame still needs to be updated.
289 // Hence updating it.
290 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
293 return GetOneMoreFrame(abi);
297 log->Printf("%*sFrame %d did not get a valid PC, stopping stack walk",
298 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
301 // Infinite loop where the current cursor is the same as the previous one...
302 if (prev_frame->start_pc == cursor_sp->start_pc &&
303 prev_frame->cfa == cursor_sp->cfa) {
305 log->Printf("th%d pc of this frame is the same as the previous frame and "
306 "CFAs for both frames are identical -- stopping unwind",
307 m_thread.GetIndexID());
311 cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp;
315 void UnwindLLDB::UpdateUnwindPlanForFirstFrameIfInvalid(ABI *abi) {
316 // This function is called for First Frame only.
317 assert(m_frames.size() == 1 && "No. of cursor frames are not 1");
319 bool old_m_unwind_complete = m_unwind_complete;
320 CursorSP old_m_candidate_frame = m_candidate_frame;
322 // Try to unwind 2 more frames using the Unwinder. It uses Full UnwindPlan
323 // and if Full UnwindPlan fails, then uses FallBack UnwindPlan. Also
324 // update the cfa of Frame 0 (if required).
325 AddOneMoreFrame(abi);
327 // Remove all the frames added by above function as the purpose of
328 // using above function was just to check whether Unwinder of Frame 0
330 for (uint32_t i = 1; i < m_frames.size(); i++)
333 // Restore status after calling AddOneMoreFrame
334 m_unwind_complete = old_m_unwind_complete;
335 m_candidate_frame = old_m_candidate_frame;
339 bool UnwindLLDB::AddOneMoreFrame(ABI *abi) {
340 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
342 // Frame zero is a little different
343 if (m_frames.empty())
346 // If we've already gotten to the end of the stack, don't bother to try
348 if (m_unwind_complete)
351 CursorSP new_frame = m_candidate_frame;
352 if (new_frame == nullptr)
353 new_frame = GetOneMoreFrame(abi);
355 if (new_frame == nullptr) {
357 log->Printf("th%d Unwind of this thread is complete.",
358 m_thread.GetIndexID());
359 m_unwind_complete = true;
363 m_frames.push_back(new_frame);
365 // If we can get one more frame further then accept that we get back a correct
367 m_candidate_frame = GetOneMoreFrame(abi);
368 if (m_candidate_frame)
371 // We can't go further from the frame returned by GetOneMore frame. Lets try
373 // different frame with using the fallback unwind plan.
374 if (!m_frames[m_frames.size() - 2]
375 ->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
376 // We don't have a valid fallback unwind plan. Accept the frame as it is.
378 // valid situation when we are at the bottom of the stack.
382 // Remove the possibly incorrect frame from the frame list and try to add a
383 // different one with
384 // the newly selected fallback unwind plan.
386 CursorSP new_frame_v2 = GetOneMoreFrame(abi);
387 if (new_frame_v2 == nullptr) {
388 // We haven't got a new frame from the fallback unwind plan. Accept the
390 // original unwind plan. This is a valid situation when we are at the bottom
392 m_frames.push_back(new_frame);
396 // Push the new frame to the list and try to continue from this frame. If we
397 // can get a new frame
398 // then accept it as the correct one.
399 m_frames.push_back(new_frame_v2);
400 m_candidate_frame = GetOneMoreFrame(abi);
401 if (m_candidate_frame) {
402 // If control reached here then TryFallbackUnwindPlan had succeeded for
403 // Cursor::m_frames[m_frames.size() - 2].
404 // It also succeeded to Unwind next 2 frames i.e. m_frames[m_frames.size() -
405 // 1] and a frame after that.
406 // For Cursor::m_frames[m_frames.size() - 2], reg_ctx_lldb_sp field was
407 // already updated during TryFallbackUnwindPlan
408 // call above. However, cfa field still needs to be updated. Hence updating
409 // it here and then returning.
410 if (!(m_frames[m_frames.size() - 2]->reg_ctx_lldb_sp->GetCFA(
411 m_frames[m_frames.size() - 2]->cfa)))
416 // The new frame hasn't helped in unwinding. Fall back to the original one as
417 // the default unwind
418 // plan is usually more reliable then the fallback one.
420 m_frames.push_back(new_frame);
424 bool UnwindLLDB::DoGetFrameInfoAtIndex(uint32_t idx, addr_t &cfa, addr_t &pc) {
425 if (m_frames.size() == 0) {
426 if (!AddFirstFrame())
430 ProcessSP process_sp(m_thread.GetProcess());
431 ABI *abi = process_sp ? process_sp->GetABI().get() : NULL;
433 while (idx >= m_frames.size() && AddOneMoreFrame(abi))
436 if (idx < m_frames.size()) {
437 cfa = m_frames[idx]->cfa;
438 pc = m_frames[idx]->start_pc;
444 lldb::RegisterContextSP
445 UnwindLLDB::DoCreateRegisterContextForFrame(StackFrame *frame) {
446 lldb::RegisterContextSP reg_ctx_sp;
447 uint32_t idx = frame->GetConcreteFrameIndex();
450 return m_thread.GetRegisterContext();
453 if (m_frames.size() == 0) {
454 if (!AddFirstFrame())
458 ProcessSP process_sp(m_thread.GetProcess());
459 ABI *abi = process_sp ? process_sp->GetABI().get() : NULL;
461 while (idx >= m_frames.size()) {
462 if (!AddOneMoreFrame(abi))
466 const uint32_t num_frames = m_frames.size();
467 if (idx < num_frames) {
468 Cursor *frame_cursor = m_frames[idx].get();
469 reg_ctx_sp = frame_cursor->reg_ctx_lldb_sp;
474 UnwindLLDB::RegisterContextLLDBSP
475 UnwindLLDB::GetRegisterContextForFrameNum(uint32_t frame_num) {
476 RegisterContextLLDBSP reg_ctx_sp;
477 if (frame_num < m_frames.size())
478 reg_ctx_sp = m_frames[frame_num]->reg_ctx_lldb_sp;
482 bool UnwindLLDB::SearchForSavedLocationForRegister(
483 uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation ®loc,
484 uint32_t starting_frame_num, bool pc_reg) {
485 int64_t frame_num = starting_frame_num;
486 if (static_cast<size_t>(frame_num) >= m_frames.size())
489 // Never interrogate more than one level while looking for the saved pc value.
491 // isn't saved by frame_num, none of the frames lower on the stack will have a
494 UnwindLLDB::RegisterSearchResult result;
495 result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister(
496 lldb_regnum, regloc);
497 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound)
502 while (frame_num >= 0) {
503 UnwindLLDB::RegisterSearchResult result;
504 result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister(
505 lldb_regnum, regloc);
507 // We descended down to the live register context aka stack frame 0 and are
509 // out of a live register.
510 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound &&
512 UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext) {
516 // If we have unwind instructions saying that register N is saved in
517 // register M in the middle of
518 // the stack (and N can equal M here, meaning the register was not used in
519 // this function), then
520 // change the register number we're looking for to M and keep looking for a
522 // down the stack, or an actual value from a live RegisterContext at frame
524 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound &&
525 regloc.type == UnwindLLDB::RegisterLocation::eRegisterInRegister &&
527 result = UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
528 lldb_regnum = regloc.location.register_number;
531 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound)
533 if (result == UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile)