UnwindLLDB.cpp revision 341825
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 // We want to detect an unwind that cycles erroneously and stop backtracing. 134 // Don't want this maximum unwind limit to be too low -- if you have a 135 // backtrace with an "infinitely recursing" bug, it will crash when the stack 136 // blows out and the first 35,000 frames are uninteresting - it's the top 137 // most 5 frames that you actually care about. So you can't just cap the 138 // unwind at 10,000 or something. Realistically anything over around 200,000 139 // is going to blow out the stack space. If we're still unwinding at that 140 // point, we're probably never going to finish. 141 if (cur_idx > 300000) { 142 if (log) 143 log->Printf("%*sFrame %d unwound too many frames, assuming unwind has " 144 "gone astray, stopping.", 145 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 146 return nullptr; 147 } 148 149 if (reg_ctx_sp.get() == NULL) { 150 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to 151 // that and return true. Subsequent calls to TryFallbackUnwindPlan() will 152 // return false. 153 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) { 154 // TryFallbackUnwindPlan for prev_frame succeeded and updated 155 // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame 156 // still needs to be updated. Hence updating it. 157 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa))) 158 return nullptr; 159 160 return GetOneMoreFrame(abi); 161 } 162 163 if (log) 164 log->Printf("%*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 if (log) 184 log->Printf("%*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 RegisterContextLLDB 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 if (log) 204 log->Printf( 205 "%*sFrame %d did not get CFA for this frame, stopping stack walk", 206 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 207 return nullptr; 208 } 209 if (abi && !abi->CallFrameAddressIsValid(cursor_sp->cfa)) { 210 // On Mac OS X, the _sigtramp asynchronous signal trampoline frame may not 211 // have its (constructed) CFA aligned correctly -- don't do the abi 212 // alignment check for these. 213 if (reg_ctx_sp->IsTrapHandlerFrame() == false) { 214 // See if we can find a fallback unwind plan for THIS frame. It may be 215 // that the UnwindPlan we're using for THIS frame was bad and gave us a 216 // bad CFA. If that's not it, then see if we can change the UnwindPlan 217 // for the frame below us ("NEXT") -- see if using that other UnwindPlan 218 // gets us a better unwind state. 219 if (reg_ctx_sp->TryFallbackUnwindPlan() == false || 220 reg_ctx_sp->GetCFA(cursor_sp->cfa) == false || 221 abi->CallFrameAddressIsValid(cursor_sp->cfa) == false) { 222 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) { 223 // TryFallbackUnwindPlan for prev_frame succeeded and updated 224 // reg_ctx_lldb_sp field of prev_frame. However, cfa field of 225 // prev_frame still needs to be updated. Hence updating it. 226 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa))) 227 return nullptr; 228 229 return GetOneMoreFrame(abi); 230 } 231 232 if (log) 233 log->Printf("%*sFrame %d did not get a valid CFA for this frame, " 234 "stopping stack walk", 235 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 236 return nullptr; 237 } else { 238 if (log) 239 log->Printf("%*sFrame %d had a bad CFA value but we switched the " 240 "UnwindPlan being used and got one that looks more " 241 "realistic.", 242 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 243 } 244 } 245 } 246 if (!reg_ctx_sp->ReadPC(cursor_sp->start_pc)) { 247 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to 248 // that and return true. Subsequent calls to TryFallbackUnwindPlan() will 249 // return false. 250 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) { 251 // TryFallbackUnwindPlan for prev_frame succeeded and updated 252 // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame 253 // still needs to be updated. Hence updating it. 254 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa))) 255 return nullptr; 256 257 return GetOneMoreFrame(abi); 258 } 259 260 if (log) 261 log->Printf( 262 "%*sFrame %d did not get PC for this frame, stopping stack walk", 263 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 264 return nullptr; 265 } 266 if (abi && !abi->CodeAddressIsValid(cursor_sp->start_pc)) { 267 // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to 268 // that and return true. Subsequent calls to TryFallbackUnwindPlan() will 269 // return false. 270 if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) { 271 // TryFallbackUnwindPlan for prev_frame succeeded and updated 272 // reg_ctx_lldb_sp field of prev_frame. However, cfa field of prev_frame 273 // still needs to be updated. Hence updating it. 274 if (!(prev_frame->reg_ctx_lldb_sp->GetCFA(prev_frame->cfa))) 275 return nullptr; 276 277 return GetOneMoreFrame(abi); 278 } 279 280 if (log) 281 log->Printf("%*sFrame %d did not get a valid PC, stopping stack walk", 282 cur_idx < 100 ? cur_idx : 100, "", cur_idx); 283 return nullptr; 284 } 285 // Infinite loop where the current cursor is the same as the previous one... 286 if (prev_frame->start_pc == cursor_sp->start_pc && 287 prev_frame->cfa == cursor_sp->cfa) { 288 if (log) 289 log->Printf("th%d pc of this frame is the same as the previous frame and " 290 "CFAs for both frames are identical -- stopping unwind", 291 m_thread.GetIndexID()); 292 return nullptr; 293 } 294 295 cursor_sp->reg_ctx_lldb_sp = reg_ctx_sp; 296 return cursor_sp; 297} 298 299void UnwindLLDB::UpdateUnwindPlanForFirstFrameIfInvalid(ABI *abi) { 300 // This function is called for First Frame only. 301 assert(m_frames.size() == 1 && "No. of cursor frames are not 1"); 302 303 bool old_m_unwind_complete = m_unwind_complete; 304 CursorSP old_m_candidate_frame = m_candidate_frame; 305 306 // Try to unwind 2 more frames using the Unwinder. It uses Full UnwindPlan 307 // and if Full UnwindPlan fails, then uses FallBack UnwindPlan. Also update 308 // the cfa of Frame 0 (if required). 309 AddOneMoreFrame(abi); 310 311 // Remove all the frames added by above function as the purpose of using 312 // above function was just to check whether Unwinder of Frame 0 works or not. 313 for (uint32_t i = 1; i < m_frames.size(); i++) 314 m_frames.pop_back(); 315 316 // Restore status after calling AddOneMoreFrame 317 m_unwind_complete = old_m_unwind_complete; 318 m_candidate_frame = old_m_candidate_frame; 319 return; 320} 321 322bool UnwindLLDB::AddOneMoreFrame(ABI *abi) { 323 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND)); 324 325 // Frame zero is a little different 326 if (m_frames.empty()) 327 return false; 328 329 // If we've already gotten to the end of the stack, don't bother to try 330 // again... 331 if (m_unwind_complete) 332 return false; 333 334 CursorSP new_frame = m_candidate_frame; 335 if (new_frame == nullptr) 336 new_frame = GetOneMoreFrame(abi); 337 338 if (new_frame == nullptr) { 339 if (log) 340 log->Printf("th%d Unwind of this thread is complete.", 341 m_thread.GetIndexID()); 342 m_unwind_complete = true; 343 return false; 344 } 345 346 m_frames.push_back(new_frame); 347 348 // If we can get one more frame further then accept that we get back a 349 // correct frame. 350 m_candidate_frame = GetOneMoreFrame(abi); 351 if (m_candidate_frame) 352 return true; 353 354 // We can't go further from the frame returned by GetOneMore frame. Lets try 355 // to get a different frame with using the fallback unwind plan. 356 if (!m_frames[m_frames.size() - 2] 357 ->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) { 358 // We don't have a valid fallback unwind plan. Accept the frame as it is. 359 // This is a valid situation when we are at the bottom of the stack. 360 return true; 361 } 362 363 // Remove the possibly incorrect frame from the frame list and try to add a 364 // different one with the newly selected fallback unwind plan. 365 m_frames.pop_back(); 366 CursorSP new_frame_v2 = GetOneMoreFrame(abi); 367 if (new_frame_v2 == nullptr) { 368 // We haven't got a new frame from the fallback unwind plan. Accept the 369 // frame from the original unwind plan. This is a valid situation when we 370 // are at the bottom of the stack. 371 m_frames.push_back(new_frame); 372 return true; 373 } 374 375 // Push the new frame to the list and try to continue from this frame. If we 376 // can get a new frame then accept it as the correct one. 377 m_frames.push_back(new_frame_v2); 378 m_candidate_frame = GetOneMoreFrame(abi); 379 if (m_candidate_frame) { 380 // If control reached here then TryFallbackUnwindPlan had succeeded for 381 // Cursor::m_frames[m_frames.size() - 2]. It also succeeded to Unwind next 382 // 2 frames i.e. m_frames[m_frames.size() - 1] and a frame after that. For 383 // Cursor::m_frames[m_frames.size() - 2], reg_ctx_lldb_sp field was already 384 // updated during TryFallbackUnwindPlan call above. However, cfa field 385 // still needs to be updated. Hence updating it here and then returning. 386 if (!(m_frames[m_frames.size() - 2]->reg_ctx_lldb_sp->GetCFA( 387 m_frames[m_frames.size() - 2]->cfa))) 388 return false; 389 return true; 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 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound) 472 return true; 473 else 474 return false; 475 } 476 while (frame_num >= 0) { 477 UnwindLLDB::RegisterSearchResult result; 478 result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister( 479 lldb_regnum, regloc); 480 481 // We descended down to the live register context aka stack frame 0 and are 482 // reading the value out of a live register. 483 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound && 484 regloc.type == 485 UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext) { 486 return true; 487 } 488 489 // If we have unwind instructions saying that register N is saved in 490 // register M in the middle of the stack (and N can equal M here, meaning 491 // the register was not used in this function), then change the register 492 // number we're looking for to M and keep looking for a concrete location 493 // down the stack, or an actual value from a live RegisterContext at frame 494 // 0. 495 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound && 496 regloc.type == UnwindLLDB::RegisterLocation::eRegisterInRegister && 497 frame_num > 0) { 498 result = UnwindLLDB::RegisterSearchResult::eRegisterNotFound; 499 lldb_regnum = regloc.location.register_number; 500 } 501 502 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound) 503 return true; 504 if (result == UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile) 505 return false; 506 frame_num--; 507 } 508 return false; 509} 510