UnwindLLDB.cpp revision 344779
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/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" 20 21#include "RegisterContextLLDB.h" 22#include "UnwindLLDB.h" 23 24using namespace lldb; 25using namespace lldb_private; 26 27UnwindLLDB::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()); 31 if (process_sp) { 32 Args args; 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)); 38 } 39 } 40} 41 42uint32_t UnwindLLDB::DoGetFrameCount() { 43 if (!m_unwind_complete) { 44//#define DEBUG_FRAME_SPEED 1 45#if DEBUG_FRAME_SPEED 46#define FRAME_COUNT 10000 47 using namespace std::chrono; 48 auto time_value = steady_clock::now(); 49#endif 50 if (!AddFirstFrame()) 51 return 0; 52 53 ProcessSP process_sp(m_thread.GetProcess()); 54 ABI *abi = process_sp ? process_sp->GetABI().get() : NULL; 55 56 while (AddOneMoreFrame(abi)) { 57#if DEBUG_FRAME_SPEED 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()); 64 time_value = now; 65 } 66#endif 67 } 68 } 69 return m_frames.size(); 70} 71 72bool UnwindLLDB::AddFirstFrame() { 73 if (m_frames.size() > 0) 74 return true; 75 76 ProcessSP process_sp(m_thread.GetProcess()); 77 ABI *abi = process_sp ? process_sp->GetABI().get() : NULL; 78 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) 84 goto unwind_done; 85 86 if (!reg_ctx_sp->IsValid()) 87 goto unwind_done; 88 89 if (!reg_ctx_sp->GetCFA(first_cursor_sp->cfa)) 90 goto unwind_done; 91 92 if (!reg_ctx_sp->ReadPC(first_cursor_sp->start_pc)) 93 goto unwind_done; 94 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); 99 100 // Update the Full Unwind Plan for this frame if not valid 101 UpdateUnwindPlanForFirstFrameIfInvalid(abi); 102 103 return true; 104 105unwind_done: 106 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND)); 107 if (log) { 108 log->Printf("th%d Unwind of this thread is complete.", 109 m_thread.GetIndexID()); 110 } 111 m_unwind_complete = true; 112 return false; 113} 114 115UnwindLLDB::CursorSP UnwindLLDB::GetOneMoreFrame(ABI *abi) { 116 assert(m_frames.size() != 0 && 117 "Get one more frame called with empty frame list"); 118 119 // If we've already gotten to the end of the stack, don't bother to try 120 // again... 121 if (m_unwind_complete) 122 return nullptr; 123 124 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND)); 125 126 CursorSP prev_frame = m_frames.back(); 127 uint32_t cur_idx = m_frames.size(); 128 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)); 132 133 uint64_t max_stack_depth = m_thread.GetMaxBacktraceDepth(); 134 135 // We want to detect an unwind that cycles erroneously and stop backtracing. 136 // Don't want this maximum unwind limit to be too low -- if you have a 137 // backtrace with an "infinitely recursing" bug, it will crash when the stack 138 // blows out and the first 35,000 frames are uninteresting - it's the top 139 // most 5 frames that you actually care about. So you can't just cap the 140 // unwind at 10,000 or something. Realistically anything over around 200,000 141 // is going to blow out the stack space. If we're still unwinding at that 142 // point, we're probably never going to finish. 143 if (cur_idx >= max_stack_depth) { 144 if (log) 145 log->Printf("%*sFrame %d unwound too many frames, assuming unwind has " 146 "gone astray, stopping.", 147 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 148 return nullptr; 149 } 150 151 if (reg_ctx_sp.get() == NULL) { 152 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to 153 // that and return true. Subsequent calls to TryFallbackUnwindPlan() will 154 // return false. 155 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) { 156 // TryFallbackUnwindPlan for prev_frame succeeded and updated 157 // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame 158 // still needs to be updated. Hence updating it. 159 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa))) 160 return nullptr; 161 162 return GetOneMoreFrame(abi); 163 } 164 165 if (log) 166 log->Printf("%*sFrame %d did not get a RegisterContext, stopping.", 167 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 168 return nullptr; 169 } 170 171 if (!reg_ctx_sp->IsValid()) { 172 // We failed to get a valid RegisterContext. See if the regctx below this 173 // on the stack has a fallback unwind plan it can use. Subsequent calls to 174 // TryFallbackUnwindPlan() will return false. 175 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) { 176 // TryFallbackUnwindPlan for prev_frame succeeded and updated 177 // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame 178 // still needs to be updated. Hence updating it. 179 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa))) 180 return nullptr; 181 182 return GetOneMoreFrame(abi); 183 } 184 185 if (log) 186 log->Printf("%*sFrame %d invalid RegisterContext for this frame, " 187 "stopping stack walk", 188 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 189 return nullptr; 190 } 191 if (!reg_ctx_sp->GetCFA(cursor_sp->cfa)) { 192 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to 193 // that and return true. Subsequent calls to TryFallbackUnwindPlan() will 194 // return false. 195 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) { 196 // TryFallbackUnwindPlan for prev_frame succeeded and updated 197 // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame 198 // still needs to be updated. Hence updating it. 199 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa))) 200 return nullptr; 201 202 return GetOneMoreFrame(abi); 203 } 204 205 if (log) 206 log->Printf( 207 "%*sFrame %d did not get CFA for this frame, stopping stack walk", 208 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 209 return nullptr; 210 } 211 if (abi && !abi->CallFrameAddressIsValid(cursor_sp->cfa)) { 212 // On Mac OS X, the _sigtramp asynchronous signal trampoline frame may not 213 // have its (constructed) CFA aligned correctly -- don't do the abi 214 // alignment check for these. 215 if (!reg_ctx_sp->IsTrapHandlerFrame()) { 216 // See if we can find a fallback unwind plan for THIS frame. It may be 217 // that the UnwindPlan we're using for THIS frame was bad and gave us a 218 // bad CFA. If that's not it, then see if we can change the UnwindPlan 219 // for the frame below us ("NEXT") -- see if using that other UnwindPlan 220 // gets us a better unwind state. 221 if (!reg_ctx_sp->TryFallbackUnwindPlan() || 222 !reg_ctx_sp->GetCFA(cursor_sp->cfa) || 223 !abi->CallFrameAddressIsValid(cursor_sp->cfa)) { 224 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) { 225 // TryFallbackUnwindPlan for prev_frame succeeded and updated 226 // reg_ctx_lldb_sp field of prev_frame. However, cfa field of 227 // prev_frame still needs to be updated. Hence updating it. 228 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa))) 229 return nullptr; 230 231 return GetOneMoreFrame(abi); 232 } 233 234 if (log) 235 log->Printf("%*sFrame %d did not get a valid CFA for this frame, " 236 "stopping stack walk", 237 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 238 return nullptr; 239 } else { 240 if (log) 241 log->Printf("%*sFrame %d had a bad CFA value but we switched the " 242 "UnwindPlan being used and got one that looks more " 243 "realistic.", 244 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 245 } 246 } 247 } 248 if (!reg_ctx_sp->ReadPC(cursor_sp->start_pc)) { 249 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to 250 // that and return true. Subsequent calls to TryFallbackUnwindPlan() will 251 // return false. 252 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) { 253 // TryFallbackUnwindPlan for prev_frame succeeded and updated 254 // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame 255 // still needs to be updated. Hence updating it. 256 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa))) 257 return nullptr; 258 259 return GetOneMoreFrame(abi); 260 } 261 262 if (log) 263 log->Printf( 264 "%*sFrame %d did not get PC for this frame, stopping stack walk", 265 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 266 return nullptr; 267 } 268 if (abi && !abi->CodeAddressIsValid(cursor_sp->start_pc)) { 269 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to 270 // that and return true. Subsequent calls to TryFallbackUnwindPlan() will 271 // return false. 272 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) { 273 // TryFallbackUnwindPlan for prev_frame succeeded and updated 274 // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame 275 // still needs to be updated. Hence updating it. 276 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa))) 277 return nullptr; 278 279 return GetOneMoreFrame(abi); 280 } 281 282 if (log) 283 log->Printf("%*sFrame %d did not get a valid PC, stopping stack walk", 284 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 285 return nullptr; 286 } 287 // Infinite loop where the current cursor is the same as the previous one... 288 if (prev_frame->start_pc == cursor_sp->start_pc && 289 prev_frame->cfa == cursor_sp->cfa) { 290 if (log) 291 log->Printf("th%d pc of this frame is the same as the previous frame and " 292 "CFAs for both frames are identical -- stopping unwind", 293 m_thread.GetIndexID()); 294 return nullptr; 295 } 296 297 cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp; 298 return cursor_sp; 299} 300 301void UnwindLLDB::UpdateUnwindPlanForFirstFrameIfInvalid(ABI *abi) { 302 // This function is called for First Frame only. 303 assert(m_frames.size() == 1 && "No. of cursor frames are not 1"); 304 305 bool old_m_unwind_complete = m_unwind_complete; 306 CursorSP old_m_candidate_frame = m_candidate_frame; 307 308 // Try to unwind 2 more frames using the Unwinder. It uses Full UnwindPlan 309 // and if Full UnwindPlan fails, then uses FallBack UnwindPlan. Also update 310 // the cfa of Frame 0 (if required). 311 AddOneMoreFrame(abi); 312 313 // Remove all the frames added by above function as the purpose of using 314 // above function was just to check whether Unwinder of Frame 0 works or not. 315 for (uint32_t i = 1; i < m_frames.size(); i++) 316 m_frames.pop_back(); 317 318 // Restore status after calling AddOneMoreFrame 319 m_unwind_complete = old_m_unwind_complete; 320 m_candidate_frame = old_m_candidate_frame; 321 return; 322} 323 324bool UnwindLLDB::AddOneMoreFrame(ABI *abi) { 325 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND)); 326 327 // Frame zero is a little different 328 if (m_frames.empty()) 329 return false; 330 331 // If we've already gotten to the end of the stack, don't bother to try 332 // again... 333 if (m_unwind_complete) 334 return false; 335 336 CursorSP new_frame = m_candidate_frame; 337 if (new_frame == nullptr) 338 new_frame = GetOneMoreFrame(abi); 339 340 if (new_frame == nullptr) { 341 if (log) 342 log->Printf("th%d Unwind of this thread is complete.", 343 m_thread.GetIndexID()); 344 m_unwind_complete = true; 345 return false; 346 } 347 348 m_frames.push_back(new_frame); 349 350 // If we can get one more frame further then accept that we get back a 351 // correct frame. 352 m_candidate_frame = GetOneMoreFrame(abi); 353 if (m_candidate_frame) 354 return true; 355 356 // We can't go further from the frame returned by GetOneMore frame. Lets try 357 // to get a different frame with using the fallback unwind plan. 358 if (!m_frames[m_frames.size() - 2] 359 ->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) { 360 // We don't have a valid fallback unwind plan. Accept the frame as it is. 361 // This is a valid situation when we are at the bottom of the stack. 362 return true; 363 } 364 365 // Remove the possibly incorrect frame from the frame list and try to add a 366 // different one with the newly selected fallback unwind plan. 367 m_frames.pop_back(); 368 CursorSP new_frame_v2 = GetOneMoreFrame(abi); 369 if (new_frame_v2 == nullptr) { 370 // We haven't got a new frame from the fallback unwind plan. Accept the 371 // frame from the original unwind plan. This is a valid situation when we 372 // are at the bottom of the stack. 373 m_frames.push_back(new_frame); 374 return true; 375 } 376 377 // Push the new frame to the list and try to continue from this frame. If we 378 // can get a new frame then accept it as the correct one. 379 m_frames.push_back(new_frame_v2); 380 m_candidate_frame = GetOneMoreFrame(abi); 381 if (m_candidate_frame) { 382 // If control reached here then TryFallbackUnwindPlan had succeeded for 383 // Cursor::m_frames[m_frames.size() - 2]. It also succeeded to Unwind next 384 // 2 frames i.e. m_frames[m_frames.size() - 1] and a frame after that. For 385 // Cursor::m_frames[m_frames.size() - 2], reg_ctx_lldb_sp field was already 386 // updated during TryFallbackUnwindPlan call above. However, cfa field 387 // still needs to be updated. Hence updating it here and then returning. 388 return m_frames[m_frames.size() - 2]->reg_ctx_lldb_sp->GetCFA( 389 m_frames[m_frames.size() - 2]->cfa); 390 } 391 392 // The new frame hasn't helped in unwinding. Fall back to the original one as 393 // the default unwind plan is usually more reliable then the fallback one. 394 m_frames.pop_back(); 395 m_frames.push_back(new_frame); 396 return true; 397} 398 399bool UnwindLLDB::DoGetFrameInfoAtIndex(uint32_t idx, addr_t &cfa, addr_t &pc) { 400 if (m_frames.size() == 0) { 401 if (!AddFirstFrame()) 402 return false; 403 } 404 405 ProcessSP process_sp(m_thread.GetProcess()); 406 ABI *abi = process_sp ? process_sp->GetABI().get() : NULL; 407 408 while (idx >= m_frames.size() && AddOneMoreFrame(abi)) 409 ; 410 411 if (idx < m_frames.size()) { 412 cfa = m_frames[idx]->cfa; 413 pc = m_frames[idx]->start_pc; 414 return true; 415 } 416 return false; 417} 418 419lldb::RegisterContextSP 420UnwindLLDB::DoCreateRegisterContextForFrame(StackFrame *frame) { 421 lldb::RegisterContextSP reg_ctx_sp; 422 uint32_t idx = frame->GetConcreteFrameIndex(); 423 424 if (idx == 0) { 425 return m_thread.GetRegisterContext(); 426 } 427 428 if (m_frames.size() == 0) { 429 if (!AddFirstFrame()) 430 return reg_ctx_sp; 431 } 432 433 ProcessSP process_sp(m_thread.GetProcess()); 434 ABI *abi = process_sp ? process_sp->GetABI().get() : NULL; 435 436 while (idx >= m_frames.size()) { 437 if (!AddOneMoreFrame(abi)) 438 break; 439 } 440 441 const uint32_t num_frames = m_frames.size(); 442 if (idx < num_frames) { 443 Cursor *frame_cursor = m_frames[idx].get(); 444 reg_ctx_sp = frame_cursor->reg_ctx_lldb_sp; 445 } 446 return reg_ctx_sp; 447} 448 449UnwindLLDB::RegisterContextLLDBSP 450UnwindLLDB::GetRegisterContextForFrameNum(uint32_t frame_num) { 451 RegisterContextLLDBSP reg_ctx_sp; 452 if (frame_num < m_frames.size()) 453 reg_ctx_sp = m_frames[frame_num]->reg_ctx_lldb_sp; 454 return reg_ctx_sp; 455} 456 457bool UnwindLLDB::SearchForSavedLocationForRegister( 458 uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation ®loc, 459 uint32_t starting_frame_num, bool pc_reg) { 460 int64_t frame_num = starting_frame_num; 461 if (static_cast<size_t>(frame_num) >= m_frames.size()) 462 return false; 463 464 // Never interrogate more than one level while looking for the saved pc 465 // value. If the value isn't saved by frame_num, none of the frames lower on 466 // the stack will have a useful value. 467 if (pc_reg) { 468 UnwindLLDB::RegisterSearchResult result; 469 result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister( 470 lldb_regnum, regloc); 471 return result == UnwindLLDB::RegisterSearchResult::eRegisterFound; 472 } 473 while (frame_num >= 0) { 474 UnwindLLDB::RegisterSearchResult result; 475 result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister( 476 lldb_regnum, regloc); 477 478 // We descended down to the live register context aka stack frame 0 and are 479 // reading the value out of a live register. 480 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound && 481 regloc.type == 482 UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext) { 483 return true; 484 } 485 486 // If we have unwind instructions saying that register N is saved in 487 // register M in the middle of the stack (and N can equal M here, meaning 488 // the register was not used in this function), then change the register 489 // number we're looking for to M and keep looking for a concrete location 490 // down the stack, or an actual value from a live RegisterContext at frame 491 // 0. 492 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound && 493 regloc.type == UnwindLLDB::RegisterLocation::eRegisterInRegister && 494 frame_num > 0) { 495 result = UnwindLLDB::RegisterSearchResult::eRegisterNotFound; 496 lldb_regnum = regloc.location.register_number; 497 } 498 499 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound) 500 return true; 501 if (result == UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile) 502 return false; 503 frame_num--; 504 } 505 return false; 506} 507