xref: /freebsd/contrib/llvm-project/lldb/source/Target/UnwindLLDB.cpp (revision 5ca8e32633c4ffbbcd6762e5888b6a4ba0708c6c)
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 
9 #include "lldb/Target/UnwindLLDB.h"
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/RegisterContextUnwind.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);
36       m_user_supplied_trap_handler_functions.push_back(ConstString(func_name));
37     }
38   }
39 }
40 
41 uint32_t UnwindLLDB::DoGetFrameCount() {
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 
71 bool UnwindLLDB::AddFirstFrame() {
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());
80   RegisterContextLLDBSP reg_ctx_sp(new RegisterContextUnwind(
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
100   UpdateUnwindPlanForFirstFrameIfInvalid(abi);
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 
114 UnwindLLDB::CursorSP UnwindLLDB::GetOneMoreFrame(ABI *abi) {
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());
129   RegisterContextLLDBSP reg_ctx_sp(new RegisterContextUnwind(
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 
296 void UnwindLLDB::UpdateUnwindPlanForFirstFrameIfInvalid(ABI *abi) {
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 
318 bool UnwindLLDB::AddOneMoreFrame(ABI *abi) {
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.
345   m_candidate_frame = GetOneMoreFrame(abi);
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);
373   m_candidate_frame = GetOneMoreFrame(abi);
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 
392 bool UnwindLLDB::DoGetFrameInfoAtIndex(uint32_t idx, addr_t &cfa, addr_t &pc,
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
434 UnwindLLDB::DoCreateRegisterContextForFrame(StackFrame *frame) {
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 
463 UnwindLLDB::RegisterContextLLDBSP
464 UnwindLLDB::GetRegisterContextForFrameNum(uint32_t frame_num) {
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 
471 bool UnwindLLDB::SearchForSavedLocationForRegister(
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) {
482     UnwindLLDB::RegisterSearchResult result;
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) {
488     UnwindLLDB::RegisterSearchResult result;
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 ==
496             UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext) {
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 &&
507         regloc.type == UnwindLLDB::RegisterLocation::eRegisterInRegister &&
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 }
521