1 //===-- UnwindLLDB.cpp -------------------------------------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 #include "lldb/Core/Module.h"
10 #include "lldb/Symbol/FuncUnwinders.h"
11 #include "lldb/Symbol/Function.h"
12 #include "lldb/Symbol/UnwindPlan.h"
13 #include "lldb/Target/ABI.h"
14 #include "lldb/Target/Process.h"
15 #include "lldb/Target/RegisterContext.h"
16 #include "lldb/Target/Target.h"
17 #include "lldb/Target/Thread.h"
18 #include "lldb/Utility/Log.h"
20 #include "RegisterContextLLDB.h"
21 #include "UnwindLLDB.h"
24 using namespace lldb_private;
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());
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);
36 m_user_supplied_trap_handler_functions.push_back(ConstString(func_name));
41 uint32_t UnwindLLDB::DoGetFrameCount() {
42 if (!m_unwind_complete) {
43 //#define DEBUG_FRAME_SPEED 1
45 #define FRAME_COUNT 10000
46 using namespace std::chrono;
47 auto time_value = steady_clock::now();
52 ProcessSP process_sp(m_thread.GetProcess());
53 ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
55 while (AddOneMoreFrame(abi)) {
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());
68 return m_frames.size();
71 bool UnwindLLDB::AddFirstFrame() {
72 if (m_frames.size() > 0)
75 ProcessSP process_sp(m_thread.GetProcess());
76 ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
78 // First, set up the 0th (initial) frame
79 CursorSP first_cursor_sp(new Cursor());
80 RegisterContextLLDBSP reg_ctx_sp(new RegisterContextLLDB(
81 m_thread, RegisterContextLLDBSP(), first_cursor_sp->sctx, 0, *this));
82 if (reg_ctx_sp.get() == nullptr)
85 if (!reg_ctx_sp->IsValid())
88 if (!reg_ctx_sp->GetCFA(first_cursor_sp->cfa))
91 if (!reg_ctx_sp->ReadPC(first_cursor_sp->start_pc))
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);
99 // Update the Full Unwind Plan for this frame if not valid
100 UpdateUnwindPlanForFirstFrameIfInvalid(abi);
105 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
107 log->Printf("th%d Unwind of this thread is complete.",
108 m_thread.GetIndexID());
110 m_unwind_complete = true;
114 UnwindLLDB::CursorSP UnwindLLDB::GetOneMoreFrame(ABI *abi) {
115 assert(m_frames.size() != 0 &&
116 "Get one more frame called with empty frame list");
118 // If we've already gotten to the end of the stack, don't bother to try
120 if (m_unwind_complete)
123 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
125 CursorSP prev_frame = m_frames.back();
126 uint32_t cur_idx = m_frames.size();
128 CursorSP cursor_sp(new Cursor());
129 RegisterContextLLDBSP reg_ctx_sp(new RegisterContextLLDB(
130 m_thread, prev_frame->reg_ctx_lldb_sp, cursor_sp->sctx, cur_idx, *this));
132 uint64_t max_stack_depth = m_thread.GetMaxBacktraceDepth();
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) {
144 log->Printf("%*sFrame %d unwound too many frames, assuming unwind has "
145 "gone astray, stopping.",
146 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
150 if (reg_ctx_sp.get() == nullptr) {
151 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
152 // that and return true. Subsequent calls to TryFallbackUnwindPlan() will
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)))
161 return GetOneMoreFrame(abi);
165 log->Printf("%*sFrame %d did not get a RegisterContext, stopping.",
166 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
170 if (!reg_ctx_sp->IsValid()) {
171 // We failed to get a valid RegisterContext. See if the regctx below this
172 // on the stack has a fallback unwind plan it can use. Subsequent calls to
173 // TryFallbackUnwindPlan() will return false.
174 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
175 // TryFallbackUnwindPlan for prev_frame succeeded and updated
176 // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
177 // still needs to be updated. Hence updating it.
178 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
181 return GetOneMoreFrame(abi);
185 log->Printf("%*sFrame %d invalid RegisterContext for this frame, "
186 "stopping stack walk",
187 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
190 if (!reg_ctx_sp->GetCFA(cursor_sp->cfa)) {
191 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
192 // that and return true. Subsequent calls to TryFallbackUnwindPlan() will
194 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
195 // TryFallbackUnwindPlan for prev_frame succeeded and updated
196 // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
197 // still needs to be updated. Hence updating it.
198 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
201 return GetOneMoreFrame(abi);
206 "%*sFrame %d did not get CFA for this frame, stopping stack walk",
207 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
210 if (abi && !abi->CallFrameAddressIsValid(cursor_sp->cfa)) {
211 // On Mac OS X, the _sigtramp asynchronous signal trampoline frame may not
212 // have its (constructed) CFA aligned correctly -- don't do the abi
213 // alignment check for these.
214 if (!reg_ctx_sp->IsTrapHandlerFrame()) {
215 // See if we can find a fallback unwind plan for THIS frame. It may be
216 // that the UnwindPlan we're using for THIS frame was bad and gave us a
217 // bad CFA. If that's not it, then see if we can change the UnwindPlan
218 // for the frame below us ("NEXT") -- see if using that other UnwindPlan
219 // gets us a better unwind state.
220 if (!reg_ctx_sp->TryFallbackUnwindPlan() ||
221 !reg_ctx_sp->GetCFA(cursor_sp->cfa) ||
222 !abi->CallFrameAddressIsValid(cursor_sp->cfa)) {
223 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
224 // TryFallbackUnwindPlan for prev_frame succeeded and updated
225 // reg_ctx_lldb_sp field of prev_frame. However, cfa field of
226 // prev_frame still needs to be updated. Hence updating it.
227 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
230 return GetOneMoreFrame(abi);
234 log->Printf("%*sFrame %d did not get a valid CFA for this frame, "
235 "stopping stack walk",
236 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
240 log->Printf("%*sFrame %d had a bad CFA value but we switched the "
241 "UnwindPlan being used and got one that looks more "
243 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
247 if (!reg_ctx_sp->ReadPC(cursor_sp->start_pc)) {
248 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
249 // that and return true. Subsequent calls to TryFallbackUnwindPlan() will
251 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
252 // TryFallbackUnwindPlan for prev_frame succeeded and updated
253 // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
254 // still needs to be updated. Hence updating it.
255 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
258 return GetOneMoreFrame(abi);
263 "%*sFrame %d did not get PC for this frame, stopping stack walk",
264 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
267 if (abi && !abi->CodeAddressIsValid(cursor_sp->start_pc)) {
268 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to
269 // that and return true. Subsequent calls to TryFallbackUnwindPlan() will
271 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
272 // TryFallbackUnwindPlan for prev_frame succeeded and updated
273 // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame
274 // still needs to be updated. Hence updating it.
275 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa)))
278 return GetOneMoreFrame(abi);
282 log->Printf("%*sFrame %d did not get a valid PC, stopping stack walk",
283 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
286 // Infinite loop where the current cursor is the same as the previous one...
287 if (prev_frame->start_pc == cursor_sp->start_pc &&
288 prev_frame->cfa == cursor_sp->cfa) {
290 log->Printf("th%d pc of this frame is the same as the previous frame and "
291 "CFAs for both frames are identical -- stopping unwind",
292 m_thread.GetIndexID());
296 cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp;
300 void UnwindLLDB::UpdateUnwindPlanForFirstFrameIfInvalid(ABI *abi) {
301 // This function is called for First Frame only.
302 assert(m_frames.size() == 1 && "No. of cursor frames are not 1");
304 bool old_m_unwind_complete = m_unwind_complete;
305 CursorSP old_m_candidate_frame = m_candidate_frame;
307 // Try to unwind 2 more frames using the Unwinder. It uses Full UnwindPlan
308 // and if Full UnwindPlan fails, then uses FallBack UnwindPlan. Also update
309 // the cfa of Frame 0 (if required).
310 AddOneMoreFrame(abi);
312 // Remove all the frames added by above function as the purpose of using
313 // above function was just to check whether Unwinder of Frame 0 works or not.
314 for (uint32_t i = 1; i < m_frames.size(); i++)
317 // Restore status after calling AddOneMoreFrame
318 m_unwind_complete = old_m_unwind_complete;
319 m_candidate_frame = old_m_candidate_frame;
323 bool UnwindLLDB::AddOneMoreFrame(ABI *abi) {
324 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
326 // Frame zero is a little different
327 if (m_frames.empty())
330 // If we've already gotten to the end of the stack, don't bother to try
332 if (m_unwind_complete)
335 CursorSP new_frame = m_candidate_frame;
336 if (new_frame == nullptr)
337 new_frame = GetOneMoreFrame(abi);
339 if (new_frame == nullptr) {
341 log->Printf("th%d Unwind of this thread is complete.",
342 m_thread.GetIndexID());
343 m_unwind_complete = true;
347 m_frames.push_back(new_frame);
349 // If we can get one more frame further then accept that we get back a
351 m_candidate_frame = GetOneMoreFrame(abi);
352 if (m_candidate_frame)
355 // We can't go further from the frame returned by GetOneMore frame. Lets try
356 // to get a different frame with using the fallback unwind plan.
357 if (!m_frames[m_frames.size() - 2]
358 ->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
359 // We don't have a valid fallback unwind plan. Accept the frame as it is.
360 // This is a valid situation when we are at the bottom of the stack.
364 // Remove the possibly incorrect frame from the frame list and try to add a
365 // different one with the newly selected fallback unwind plan.
367 CursorSP new_frame_v2 = GetOneMoreFrame(abi);
368 if (new_frame_v2 == nullptr) {
369 // We haven't got a new frame from the fallback unwind plan. Accept the
370 // frame from the original unwind plan. This is a valid situation when we
371 // are at the bottom of the stack.
372 m_frames.push_back(new_frame);
376 // Push the new frame to the list and try to continue from this frame. If we
377 // can get a new frame then accept it as the correct one.
378 m_frames.push_back(new_frame_v2);
379 m_candidate_frame = GetOneMoreFrame(abi);
380 if (m_candidate_frame) {
381 // If control reached here then TryFallbackUnwindPlan had succeeded for
382 // Cursor::m_frames[m_frames.size() - 2]. It also succeeded to Unwind next
383 // 2 frames i.e. m_frames[m_frames.size() - 1] and a frame after that. For
384 // Cursor::m_frames[m_frames.size() - 2], reg_ctx_lldb_sp field was already
385 // updated during TryFallbackUnwindPlan call above. However, cfa field
386 // still needs to be updated. Hence updating it here and then returning.
387 return m_frames[m_frames.size() - 2]->reg_ctx_lldb_sp->GetCFA(
388 m_frames[m_frames.size() - 2]->cfa);
391 // The new frame hasn't helped in unwinding. Fall back to the original one as
392 // the default unwind plan is usually more reliable then the fallback one.
394 m_frames.push_back(new_frame);
398 bool UnwindLLDB::DoGetFrameInfoAtIndex(uint32_t idx, addr_t &cfa, addr_t &pc) {
399 if (m_frames.size() == 0) {
400 if (!AddFirstFrame())
404 ProcessSP process_sp(m_thread.GetProcess());
405 ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
407 while (idx >= m_frames.size() && AddOneMoreFrame(abi))
410 if (idx < m_frames.size()) {
411 cfa = m_frames[idx]->cfa;
412 pc = m_frames[idx]->start_pc;
418 lldb::RegisterContextSP
419 UnwindLLDB::DoCreateRegisterContextForFrame(StackFrame *frame) {
420 lldb::RegisterContextSP reg_ctx_sp;
421 uint32_t idx = frame->GetConcreteFrameIndex();
424 return m_thread.GetRegisterContext();
427 if (m_frames.size() == 0) {
428 if (!AddFirstFrame())
432 ProcessSP process_sp(m_thread.GetProcess());
433 ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr;
435 while (idx >= m_frames.size()) {
436 if (!AddOneMoreFrame(abi))
440 const uint32_t num_frames = m_frames.size();
441 if (idx < num_frames) {
442 Cursor *frame_cursor = m_frames[idx].get();
443 reg_ctx_sp = frame_cursor->reg_ctx_lldb_sp;
448 UnwindLLDB::RegisterContextLLDBSP
449 UnwindLLDB::GetRegisterContextForFrameNum(uint32_t frame_num) {
450 RegisterContextLLDBSP reg_ctx_sp;
451 if (frame_num < m_frames.size())
452 reg_ctx_sp = m_frames[frame_num]->reg_ctx_lldb_sp;
456 bool UnwindLLDB::SearchForSavedLocationForRegister(
457 uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation ®loc,
458 uint32_t starting_frame_num, bool pc_reg) {
459 int64_t frame_num = starting_frame_num;
460 if (static_cast<size_t>(frame_num) >= m_frames.size())
463 // Never interrogate more than one level while looking for the saved pc
464 // value. If the value isn't saved by frame_num, none of the frames lower on
465 // the stack will have a useful value.
467 UnwindLLDB::RegisterSearchResult result;
468 result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister(
469 lldb_regnum, regloc);
470 return result == UnwindLLDB::RegisterSearchResult::eRegisterFound;
472 while (frame_num >= 0) {
473 UnwindLLDB::RegisterSearchResult result;
474 result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister(
475 lldb_regnum, regloc);
477 // We descended down to the live register context aka stack frame 0 and are
478 // reading the value out of a live register.
479 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound &&
481 UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext) {
485 // If we have unwind instructions saying that register N is saved in
486 // register M in the middle of the stack (and N can equal M here, meaning
487 // the register was not used in this function), then change the register
488 // number we're looking for to M and keep looking for a concrete location
489 // down the stack, or an actual value from a live RegisterContext at frame
491 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound &&
492 regloc.type == UnwindLLDB::RegisterLocation::eRegisterInRegister &&
494 result = UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
495 lldb_regnum = regloc.location.register_number;
498 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound)
500 if (result == UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile)