UnwindLLDB.cpp revision 280031
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 23using namespace lldb; 24using namespace lldb_private; 25 26UnwindLLDB::UnwindLLDB (Thread &thread) : 27 Unwind (thread), 28 m_frames(), 29 m_unwind_complete(false), 30 m_user_supplied_trap_handler_functions() 31{ 32 ProcessSP process_sp(thread.GetProcess()); 33 if (process_sp) 34 { 35 Args args; 36 process_sp->GetTarget().GetUserSpecifiedTrapHandlerNames (args); 37 size_t count = args.GetArgumentCount(); 38 for (size_t i = 0; i < count; i++) 39 { 40 const char *func_name = args.GetArgumentAtIndex(i); 41 m_user_supplied_trap_handler_functions.push_back (ConstString (func_name)); 42 } 43 } 44} 45 46uint32_t 47UnwindLLDB::DoGetFrameCount() 48{ 49 if (!m_unwind_complete) 50 { 51//#define DEBUG_FRAME_SPEED 1 52#if DEBUG_FRAME_SPEED 53#define FRAME_COUNT 10000 54 TimeValue time_value (TimeValue::Now()); 55#endif 56 if (!AddFirstFrame ()) 57 return 0; 58 59 ProcessSP process_sp (m_thread.GetProcess()); 60 ABI *abi = process_sp ? process_sp->GetABI().get() : NULL; 61 62 while (AddOneMoreFrame (abi)) 63 { 64#if DEBUG_FRAME_SPEED 65 if ((m_frames.size() % FRAME_COUNT) == 0) 66 { 67 TimeValue now(TimeValue::Now()); 68 uint64_t delta_t = now - time_value; 69 printf ("%u frames in %" PRIu64 ".%09llu ms (%g frames/sec)\n", 70 FRAME_COUNT, 71 delta_t / TimeValue::NanoSecPerSec, 72 delta_t % TimeValue::NanoSecPerSec, 73 (float)FRAME_COUNT / ((float)delta_t / (float)TimeValue::NanoSecPerSec)); 74 time_value = now; 75 } 76#endif 77 } 78 } 79 return m_frames.size (); 80} 81 82bool 83UnwindLLDB::AddFirstFrame () 84{ 85 if (m_frames.size() > 0) 86 return true; 87 88 // First, set up the 0th (initial) frame 89 CursorSP first_cursor_sp(new Cursor ()); 90 RegisterContextLLDBSP reg_ctx_sp (new RegisterContextLLDB (m_thread, 91 RegisterContextLLDBSP(), 92 first_cursor_sp->sctx, 93 0, *this)); 94 if (reg_ctx_sp.get() == NULL) 95 goto unwind_done; 96 97 if (!reg_ctx_sp->IsValid()) 98 goto unwind_done; 99 100 if (!reg_ctx_sp->GetCFA (first_cursor_sp->cfa)) 101 goto unwind_done; 102 103 if (!reg_ctx_sp->ReadPC (first_cursor_sp->start_pc)) 104 goto unwind_done; 105 106 // Everything checks out, so release the auto pointer value and let the 107 // cursor own it in its shared pointer 108 first_cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp; 109 m_frames.push_back (first_cursor_sp); 110 return true; 111 112unwind_done: 113 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND)); 114 if (log) 115 { 116 log->Printf ("th%d Unwind of this thread is complete.", m_thread.GetIndexID()); 117 } 118 m_unwind_complete = true; 119 return false; 120} 121 122// For adding a non-zero stack frame to m_frames. 123bool 124UnwindLLDB::AddOneMoreFrame (ABI *abi) 125{ 126 // If we've already gotten to the end of the stack, don't bother to try again... 127 if (m_unwind_complete) 128 return false; 129 130 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND)); 131 CursorSP cursor_sp(new Cursor ()); 132 133 // Frame zero is a little different 134 if (m_frames.size() == 0) 135 return false; 136 137 uint32_t cur_idx = m_frames.size (); 138 RegisterContextLLDBSP reg_ctx_sp(new RegisterContextLLDB (m_thread, 139 m_frames[cur_idx - 1]->reg_ctx_lldb_sp, 140 cursor_sp->sctx, 141 cur_idx, 142 *this)); 143 144 // We want to detect an unwind that cycles erronously and stop backtracing. 145 // Don't want this maximum unwind limit to be too low -- if you have a backtrace 146 // with an "infinitely recursing" bug, it will crash when the stack blows out 147 // and the first 35,000 frames are uninteresting - it's the top most 5 frames that 148 // you actually care about. So you can't just cap the unwind at 10,000 or something. 149 // Realistically anything over around 200,000 is going to blow out the stack space. 150 // If we're still unwinding at that point, we're probably never going to finish. 151 if (cur_idx > 300000) 152 { 153 if (log) 154 log->Printf ("%*sFrame %d unwound too many frames, assuming unwind has gone astray, stopping.", 155 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 156 goto unwind_done; 157 } 158 159 if (reg_ctx_sp.get() == NULL) 160 { 161 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to that and return 162 // true. Subsequent calls to TryFallbackUnwindPlan() will return false. 163 if (m_frames[cur_idx - 1]->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) 164 { 165 return AddOneMoreFrame (abi); 166 } 167 if (log) 168 log->Printf ("%*sFrame %d did not get a RegisterContext, stopping.", 169 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 170 goto unwind_done; 171 } 172 173 if (!reg_ctx_sp->IsValid()) 174 { 175 // We failed to get a valid RegisterContext. 176 // See if the regctx below this on the stack has a fallback unwind plan it can use. 177 // Subsequent calls to TryFallbackUnwindPlan() will return false. 178 if (m_frames[cur_idx - 1]->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) 179 { 180 return AddOneMoreFrame (abi); 181 } 182 if (log) 183 { 184 log->Printf("%*sFrame %d invalid RegisterContext for this frame, stopping stack walk", 185 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 186 } 187 goto unwind_done; 188 } 189 if (!reg_ctx_sp->GetCFA (cursor_sp->cfa)) 190 { 191 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to that and return 192 // true. Subsequent calls to TryFallbackUnwindPlan() will return false. 193 if (m_frames[cur_idx - 1]->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) 194 { 195 return AddOneMoreFrame (abi); 196 } 197 if (log) 198 { 199 log->Printf("%*sFrame %d did not get CFA for this frame, stopping stack walk", 200 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 201 } 202 goto unwind_done; 203 } 204 if (abi && !abi->CallFrameAddressIsValid(cursor_sp->cfa)) 205 { 206 // On Mac OS X, the _sigtramp asynchronous signal trampoline frame may not have 207 // its (constructed) CFA aligned correctly -- don't do the abi alignment check for 208 // these. 209 if (reg_ctx_sp->IsTrapHandlerFrame() == false) 210 { 211 // See if we can find a fallback unwind plan for THIS frame. It may be 212 // that the UnwindPlan we're using for THIS frame was bad and gave us a 213 // bad CFA. 214 // If that's not it, then see if we can change the UnwindPlan for the frame 215 // below us ("NEXT") -- see if using that other UnwindPlan gets us a better 216 // unwind state. 217 if (reg_ctx_sp->TryFallbackUnwindPlan() == false 218 || reg_ctx_sp->GetCFA (cursor_sp->cfa) == false 219 || abi->CallFrameAddressIsValid(cursor_sp->cfa) == false) 220 { 221 if (m_frames[cur_idx - 1]->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) 222 { 223 return AddOneMoreFrame (abi); 224 } 225 if (log) 226 { 227 log->Printf("%*sFrame %d did not get a valid CFA for this frame, stopping stack walk", 228 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 229 } 230 goto unwind_done; 231 } 232 else 233 { 234 if (log) 235 { 236 log->Printf("%*sFrame %d had a bad CFA value but we switched the UnwindPlan being used and got one that looks more realistic.", 237 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 238 } 239 } 240 } 241 } 242 if (!reg_ctx_sp->ReadPC (cursor_sp->start_pc)) 243 { 244 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to that and return 245 // true. Subsequent calls to TryFallbackUnwindPlan() will return false. 246 if (m_frames[cur_idx - 1]->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) 247 { 248 return AddOneMoreFrame (abi); 249 } 250 if (log) 251 { 252 log->Printf("%*sFrame %d did not get PC for this frame, stopping stack walk", 253 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 254 } 255 goto unwind_done; 256 } 257 if (abi && !abi->CodeAddressIsValid (cursor_sp->start_pc)) 258 { 259 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to that and return 260 // true. Subsequent calls to TryFallbackUnwindPlan() will return false. 261 if (m_frames[cur_idx - 1]->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) 262 { 263 return AddOneMoreFrame (abi); 264 } 265 if (log) 266 { 267 log->Printf("%*sFrame %d did not get a valid PC, stopping stack walk", 268 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 269 } 270 goto unwind_done; 271 } 272 if (!m_frames.empty()) 273 { 274 // Infinite loop where the current cursor is the same as the previous one... 275 if (m_frames.back()->start_pc == cursor_sp->start_pc && m_frames.back()->cfa == cursor_sp->cfa) 276 { 277 if (log) 278 log->Printf ("th%d pc of this frame is the same as the previous frame and CFAs for both frames are identical -- stopping unwind", m_thread.GetIndexID()); 279 goto unwind_done; 280 } 281 } 282 283 cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp; 284 m_frames.push_back (cursor_sp); 285 return true; 286 287unwind_done: 288 if (log) 289 { 290 log->Printf ("th%d Unwind of this thread is complete.", m_thread.GetIndexID()); 291 } 292 m_unwind_complete = true; 293 return false; 294} 295 296bool 297UnwindLLDB::DoGetFrameInfoAtIndex (uint32_t idx, addr_t& cfa, addr_t& pc) 298{ 299 if (m_frames.size() == 0) 300 { 301 if (!AddFirstFrame()) 302 return false; 303 } 304 305 ProcessSP process_sp (m_thread.GetProcess()); 306 ABI *abi = process_sp ? process_sp->GetABI().get() : NULL; 307 308 while (idx >= m_frames.size() && AddOneMoreFrame (abi)) 309 ; 310 311 if (idx < m_frames.size ()) 312 { 313 cfa = m_frames[idx]->cfa; 314 pc = m_frames[idx]->start_pc; 315 return true; 316 } 317 return false; 318} 319 320lldb::RegisterContextSP 321UnwindLLDB::DoCreateRegisterContextForFrame (StackFrame *frame) 322{ 323 lldb::RegisterContextSP reg_ctx_sp; 324 uint32_t idx = frame->GetConcreteFrameIndex (); 325 326 if (idx == 0) 327 { 328 return m_thread.GetRegisterContext(); 329 } 330 331 if (m_frames.size() == 0) 332 { 333 if (!AddFirstFrame()) 334 return reg_ctx_sp; 335 } 336 337 ProcessSP process_sp (m_thread.GetProcess()); 338 ABI *abi = process_sp ? process_sp->GetABI().get() : NULL; 339 340 while (idx >= m_frames.size()) 341 { 342 if (!AddOneMoreFrame (abi)) 343 break; 344 } 345 346 const uint32_t num_frames = m_frames.size(); 347 if (idx < num_frames) 348 { 349 Cursor *frame_cursor = m_frames[idx].get(); 350 reg_ctx_sp = frame_cursor->reg_ctx_lldb_sp; 351 } 352 return reg_ctx_sp; 353} 354 355UnwindLLDB::RegisterContextLLDBSP 356UnwindLLDB::GetRegisterContextForFrameNum (uint32_t frame_num) 357{ 358 RegisterContextLLDBSP reg_ctx_sp; 359 if (frame_num < m_frames.size()) 360 reg_ctx_sp = m_frames[frame_num]->reg_ctx_lldb_sp; 361 return reg_ctx_sp; 362} 363 364bool 365UnwindLLDB::SearchForSavedLocationForRegister (uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation ®loc, uint32_t starting_frame_num, bool pc_reg) 366{ 367 int64_t frame_num = starting_frame_num; 368 if (static_cast<size_t>(frame_num) >= m_frames.size()) 369 return false; 370 371 // Never interrogate more than one level while looking for the saved pc value. If the value 372 // isn't saved by frame_num, none of the frames lower on the stack will have a useful value. 373 if (pc_reg) 374 { 375 UnwindLLDB::RegisterSearchResult result; 376 result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister (lldb_regnum, regloc); 377 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound) 378 return true; 379 else 380 return false; 381 } 382 while (frame_num >= 0) 383 { 384 UnwindLLDB::RegisterSearchResult result; 385 result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister (lldb_regnum, regloc); 386 387 // We descended down to the live register context aka stack frame 0 and are reading the value 388 // out of a live register. 389 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound 390 && regloc.type == UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext) 391 { 392 return true; 393 } 394 395 // If we have unwind instructions saying that register N is saved in register M in the middle of 396 // the stack (and N can equal M here, meaning the register was not used in this function), then 397 // change the register number we're looking for to M and keep looking for a concrete location 398 // down the stack, or an actual value from a live RegisterContext at frame 0. 399 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound 400 && regloc.type == UnwindLLDB::RegisterLocation::eRegisterInRegister 401 && frame_num > 0) 402 { 403 result = UnwindLLDB::RegisterSearchResult::eRegisterNotFound; 404 lldb_regnum = regloc.location.register_number; 405 } 406 407 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound) 408 return true; 409 if (result == UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile) 410 return false; 411 frame_num--; 412 } 413 return false; 414} 415