1 //===-- UnwindLLDB.cpp -------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "lldb/Core/Module.h"
11 #include "lldb/Core/Log.h"
12 #include "lldb/Symbol/FuncUnwinders.h"
13 #include "lldb/Symbol/Function.h"
14 #include "lldb/Symbol/UnwindPlan.h"
15 #include "lldb/Target/Thread.h"
16 #include "lldb/Target/Target.h"
17 #include "lldb/Target/Process.h"
18 #include "lldb/Target/RegisterContext.h"
19
20 #include "UnwindLLDB.h"
21 #include "RegisterContextLLDB.h"
22
23 using namespace lldb;
24 using namespace lldb_private;
25
UnwindLLDB(Thread & thread)26 UnwindLLDB::UnwindLLDB (Thread &thread) :
27 Unwind (thread),
28 m_frames(),
29 m_unwind_complete(false)
30 {
31 }
32
33 uint32_t
DoGetFrameCount()34 UnwindLLDB::DoGetFrameCount()
35 {
36 if (!m_unwind_complete)
37 {
38 //#define DEBUG_FRAME_SPEED 1
39 #if DEBUG_FRAME_SPEED
40 #define FRAME_COUNT 10000
41 TimeValue time_value (TimeValue::Now());
42 #endif
43 if (!AddFirstFrame ())
44 return 0;
45
46 ProcessSP process_sp (m_thread.GetProcess());
47 ABI *abi = process_sp ? process_sp->GetABI().get() : NULL;
48
49 while (AddOneMoreFrame (abi))
50 {
51 #if DEBUG_FRAME_SPEED
52 if ((m_frames.size() % FRAME_COUNT) == 0)
53 {
54 TimeValue now(TimeValue::Now());
55 uint64_t delta_t = now - time_value;
56 printf ("%u frames in %" PRIu64 ".%09llu ms (%g frames/sec)\n",
57 FRAME_COUNT,
58 delta_t / TimeValue::NanoSecPerSec,
59 delta_t % TimeValue::NanoSecPerSec,
60 (float)FRAME_COUNT / ((float)delta_t / (float)TimeValue::NanoSecPerSec));
61 time_value = now;
62 }
63 #endif
64 }
65 }
66 return m_frames.size ();
67 }
68
69 bool
AddFirstFrame()70 UnwindLLDB::AddFirstFrame ()
71 {
72 if (m_frames.size() > 0)
73 return true;
74
75 // First, set up the 0th (initial) frame
76 CursorSP first_cursor_sp(new Cursor ());
77 RegisterContextLLDBSP reg_ctx_sp (new RegisterContextLLDB (m_thread,
78 RegisterContextLLDBSP(),
79 first_cursor_sp->sctx,
80 0, *this));
81 if (reg_ctx_sp.get() == NULL)
82 goto unwind_done;
83
84 if (!reg_ctx_sp->IsValid())
85 goto unwind_done;
86
87 if (!reg_ctx_sp->GetCFA (first_cursor_sp->cfa))
88 goto unwind_done;
89
90 if (!reg_ctx_sp->ReadPC (first_cursor_sp->start_pc))
91 goto unwind_done;
92
93 // Everything checks out, so release the auto pointer value and let the
94 // cursor own it in its shared pointer
95 first_cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp;
96 m_frames.push_back (first_cursor_sp);
97 return true;
98 unwind_done:
99 m_unwind_complete = true;
100 return false;
101 }
102
103 // For adding a non-zero stack frame to m_frames.
104 bool
AddOneMoreFrame(ABI * abi)105 UnwindLLDB::AddOneMoreFrame (ABI *abi)
106 {
107 // If we've already gotten to the end of the stack, don't bother to try again...
108 if (m_unwind_complete)
109 return false;
110
111 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
112 CursorSP cursor_sp(new Cursor ());
113
114 // Frame zero is a little different
115 if (m_frames.size() == 0)
116 return false;
117
118 uint32_t cur_idx = m_frames.size ();
119 RegisterContextLLDBSP reg_ctx_sp(new RegisterContextLLDB (m_thread,
120 m_frames[cur_idx - 1]->reg_ctx_lldb_sp,
121 cursor_sp->sctx,
122 cur_idx,
123 *this));
124
125 // We want to detect an unwind that cycles erronously and stop backtracing.
126 // Don't want this maximum unwind limit to be too low -- if you have a backtrace
127 // with an "infinitely recursing" bug, it will crash when the stack blows out
128 // and the first 35,000 frames are uninteresting - it's the top most 5 frames that
129 // you actually care about. So you can't just cap the unwind at 10,000 or something.
130 // Realistically anything over around 200,000 is going to blow out the stack space.
131 // If we're still unwinding at that point, we're probably never going to finish.
132 if (cur_idx > 300000)
133 {
134 if (log)
135 log->Printf ("%*sFrame %d unwound too many frames, assuming unwind has gone astray, stopping.",
136 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
137 goto unwind_done;
138 }
139
140 if (reg_ctx_sp.get() == NULL)
141 goto unwind_done;
142
143 if (!reg_ctx_sp->IsValid())
144 {
145 if (log)
146 {
147 log->Printf("%*sFrame %d invalid RegisterContext for this frame, stopping stack walk",
148 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
149 }
150 goto unwind_done;
151 }
152 if (!reg_ctx_sp->GetCFA (cursor_sp->cfa))
153 {
154 if (log)
155 {
156 log->Printf("%*sFrame %d did not get CFA for this frame, stopping stack walk",
157 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
158 }
159 goto unwind_done;
160 }
161 if (abi && !abi->CallFrameAddressIsValid(cursor_sp->cfa))
162 {
163 if (log)
164 {
165 log->Printf("%*sFrame %d did not get a valid CFA for this frame, stopping stack walk",
166 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
167 }
168 goto unwind_done;
169 }
170 if (!reg_ctx_sp->ReadPC (cursor_sp->start_pc))
171 {
172 if (log)
173 {
174 log->Printf("%*sFrame %d did not get PC for this frame, stopping stack walk",
175 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
176 }
177 goto unwind_done;
178 }
179 if (abi && !abi->CodeAddressIsValid (cursor_sp->start_pc))
180 {
181 if (log)
182 {
183 log->Printf("%*sFrame %d did not get a valid PC, stopping stack walk",
184 cur_idx < 100 ? cur_idx : 100, "", cur_idx);
185 }
186 goto unwind_done;
187 }
188 if (!m_frames.empty())
189 {
190 if (m_frames.back()->start_pc == cursor_sp->start_pc)
191 {
192 if (m_frames.back()->cfa == cursor_sp->cfa)
193 goto unwind_done; // Infinite loop where the current cursor is the same as the previous one...
194 else if (abi && abi->StackUsesFrames())
195 {
196 // We might have a CFA that is not using the frame pointer and
197 // we want to validate that the frame pointer is valid.
198 if (reg_ctx_sp->GetFP() == 0)
199 goto unwind_done;
200 }
201 }
202 }
203 cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp;
204 m_frames.push_back (cursor_sp);
205 return true;
206
207 unwind_done:
208 m_unwind_complete = true;
209 return false;
210 }
211
212 bool
DoGetFrameInfoAtIndex(uint32_t idx,addr_t & cfa,addr_t & pc)213 UnwindLLDB::DoGetFrameInfoAtIndex (uint32_t idx, addr_t& cfa, addr_t& pc)
214 {
215 if (m_frames.size() == 0)
216 {
217 if (!AddFirstFrame())
218 return false;
219 }
220
221 ProcessSP process_sp (m_thread.GetProcess());
222 ABI *abi = process_sp ? process_sp->GetABI().get() : NULL;
223
224 while (idx >= m_frames.size() && AddOneMoreFrame (abi))
225 ;
226
227 if (idx < m_frames.size ())
228 {
229 cfa = m_frames[idx]->cfa;
230 pc = m_frames[idx]->start_pc;
231 return true;
232 }
233 return false;
234 }
235
236 lldb::RegisterContextSP
DoCreateRegisterContextForFrame(StackFrame * frame)237 UnwindLLDB::DoCreateRegisterContextForFrame (StackFrame *frame)
238 {
239 lldb::RegisterContextSP reg_ctx_sp;
240 uint32_t idx = frame->GetConcreteFrameIndex ();
241
242 if (idx == 0)
243 {
244 return m_thread.GetRegisterContext();
245 }
246
247 if (m_frames.size() == 0)
248 {
249 if (!AddFirstFrame())
250 return reg_ctx_sp;
251 }
252
253 ProcessSP process_sp (m_thread.GetProcess());
254 ABI *abi = process_sp ? process_sp->GetABI().get() : NULL;
255
256 while (idx >= m_frames.size())
257 {
258 if (!AddOneMoreFrame (abi))
259 break;
260 }
261
262 const uint32_t num_frames = m_frames.size();
263 if (idx < num_frames)
264 {
265 Cursor *frame_cursor = m_frames[idx].get();
266 reg_ctx_sp = frame_cursor->reg_ctx_lldb_sp;
267 }
268 return reg_ctx_sp;
269 }
270
271 UnwindLLDB::RegisterContextLLDBSP
GetRegisterContextForFrameNum(uint32_t frame_num)272 UnwindLLDB::GetRegisterContextForFrameNum (uint32_t frame_num)
273 {
274 RegisterContextLLDBSP reg_ctx_sp;
275 if (frame_num < m_frames.size())
276 reg_ctx_sp = m_frames[frame_num]->reg_ctx_lldb_sp;
277 return reg_ctx_sp;
278 }
279
280 bool
SearchForSavedLocationForRegister(uint32_t lldb_regnum,lldb_private::UnwindLLDB::RegisterLocation & regloc,uint32_t starting_frame_num,bool pc_reg)281 UnwindLLDB::SearchForSavedLocationForRegister (uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation ®loc, uint32_t starting_frame_num, bool pc_reg)
282 {
283 int64_t frame_num = starting_frame_num;
284 if (frame_num >= m_frames.size())
285 return false;
286
287 // Never interrogate more than one level while looking for the saved pc value. If the value
288 // isn't saved by frame_num, none of the frames lower on the stack will have a useful value.
289 if (pc_reg)
290 {
291 UnwindLLDB::RegisterSearchResult result;
292 result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister (lldb_regnum, regloc);
293 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound)
294 return true;
295 else
296 return false;
297 }
298 while (frame_num >= 0)
299 {
300 UnwindLLDB::RegisterSearchResult result;
301 result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister (lldb_regnum, regloc);
302
303 // If we have unwind instructions saying that register N is saved in register M in the middle of
304 // the stack (and N can equal M here, meaning the register was not used in this function), then
305 // change the register number we're looking for to M and keep looking for a concrete location
306 // down the stack, or an actual value from a live RegisterContext at frame 0.
307 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound
308 && regloc.type == UnwindLLDB::RegisterLocation::eRegisterInRegister
309 && frame_num > 0)
310 {
311 result = UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
312 lldb_regnum = regloc.location.register_number;
313 }
314
315 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound)
316 return true;
317 if (result == UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile)
318 return false;
319 frame_num--;
320 }
321 return false;
322 }
323