1//===-- UnwindLLDB.cpp -------------------------------------*- C++ -*-===// 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/Core/Module.h" 10#include "lldb/Symbol/FuncUnwinders.h" 11#include "lldb/Symbol/Function.h" 12#include "lldb/Symbol/UnwindPlan.h" 13#include "lldb/Target/ABI.h" 14#include "lldb/Target/Process.h" 15#include "lldb/Target/RegisterContext.h" 16#include "lldb/Target/Target.h" 17#include "lldb/Target/Thread.h" 18#include "lldb/Utility/Log.h" 19 20#include "RegisterContextLLDB.h" 21#include "UnwindLLDB.h" 22 23using namespace lldb; 24using namespace lldb_private; 25 26UnwindLLDB::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 41uint32_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 71bool 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 RegisterContextLLDB( 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 104unwind_done: 105 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_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 114UnwindLLDB::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(GetLogIfAllCategoriesSet(LIBLLDB_LOG_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 RegisterContextLLDB( 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 RegisterContextLLDB 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 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 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 RegisterContextLLDB 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 RegisterContextLLDB 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 296void 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 return; 317} 318 319bool UnwindLLDB::AddOneMoreFrame(ABI *abi) { 320 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND)); 321 322 // Frame zero is a little different 323 if (m_frames.empty()) 324 return false; 325 326 // If we've already gotten to the end of the stack, don't bother to try 327 // again... 328 if (m_unwind_complete) 329 return false; 330 331 CursorSP new_frame = m_candidate_frame; 332 if (new_frame == nullptr) 333 new_frame = GetOneMoreFrame(abi); 334 335 if (new_frame == nullptr) { 336 LLDB_LOGF(log, "th%d Unwind of this thread is complete.", 337 m_thread.GetIndexID()); 338 m_unwind_complete = true; 339 return false; 340 } 341 342 m_frames.push_back(new_frame); 343 344 // If we can get one more frame further then accept that we get back a 345 // correct frame. 346 m_candidate_frame = GetOneMoreFrame(abi); 347 if (m_candidate_frame) 348 return true; 349 350 // We can't go further from the frame returned by GetOneMore frame. Lets try 351 // to get a different frame with using the fallback unwind plan. 352 if (!m_frames[m_frames.size() - 2] 353 ->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) { 354 // We don't have a valid fallback unwind plan. Accept the frame as it is. 355 // This is a valid situation when we are at the bottom of the stack. 356 return true; 357 } 358 359 // Remove the possibly incorrect frame from the frame list and try to add a 360 // different one with the newly selected fallback unwind plan. 361 m_frames.pop_back(); 362 CursorSP new_frame_v2 = GetOneMoreFrame(abi); 363 if (new_frame_v2 == nullptr) { 364 // We haven't got a new frame from the fallback unwind plan. Accept the 365 // frame from the original unwind plan. This is a valid situation when we 366 // are at the bottom of the stack. 367 m_frames.push_back(new_frame); 368 return true; 369 } 370 371 // Push the new frame to the list and try to continue from this frame. If we 372 // can get a new frame then accept it as the correct one. 373 m_frames.push_back(new_frame_v2); 374 m_candidate_frame = GetOneMoreFrame(abi); 375 if (m_candidate_frame) { 376 // If control reached here then TryFallbackUnwindPlan had succeeded for 377 // Cursor::m_frames[m_frames.size() - 2]. It also succeeded to Unwind next 378 // 2 frames i.e. m_frames[m_frames.size() - 1] and a frame after that. For 379 // Cursor::m_frames[m_frames.size() - 2], reg_ctx_lldb_sp field was already 380 // updated during TryFallbackUnwindPlan call above. However, cfa field 381 // still needs to be updated. Hence updating it here and then returning. 382 return m_frames[m_frames.size() - 2]->reg_ctx_lldb_sp->GetCFA( 383 m_frames[m_frames.size() - 2]->cfa); 384 } 385 386 // The new frame hasn't helped in unwinding. Fall back to the original one as 387 // the default unwind plan is usually more reliable then the fallback one. 388 m_frames.pop_back(); 389 m_frames.push_back(new_frame); 390 return true; 391} 392 393bool UnwindLLDB::DoGetFrameInfoAtIndex(uint32_t idx, addr_t &cfa, addr_t &pc, 394 bool &behaves_like_zeroth_frame) { 395 if (m_frames.size() == 0) { 396 if (!AddFirstFrame()) 397 return false; 398 } 399 400 ProcessSP process_sp(m_thread.GetProcess()); 401 ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr; 402 403 while (idx >= m_frames.size() && AddOneMoreFrame(abi)) 404 ; 405 406 if (idx < m_frames.size()) { 407 cfa = m_frames[idx]->cfa; 408 pc = m_frames[idx]->start_pc; 409 if (idx == 0) { 410 // Frame zero always behaves like it. 411 behaves_like_zeroth_frame = true; 412 } else if (m_frames[idx - 1]->reg_ctx_lldb_sp->IsTrapHandlerFrame()) { 413 // This could be an asynchronous signal, thus the 414 // pc might point to the interrupted instruction rather 415 // than a post-call instruction 416 behaves_like_zeroth_frame = true; 417 } else if (m_frames[idx]->reg_ctx_lldb_sp->IsTrapHandlerFrame()) { 418 // This frame may result from signal processing installing 419 // a pointer to the first byte of a signal-return trampoline 420 // in the return address slot of the frame below, so this 421 // too behaves like the zeroth frame (i.e. the pc might not 422 // be pointing just past a call in it) 423 behaves_like_zeroth_frame = true; 424 } else { 425 behaves_like_zeroth_frame = false; 426 } 427 return true; 428 } 429 return false; 430} 431 432lldb::RegisterContextSP 433UnwindLLDB::DoCreateRegisterContextForFrame(StackFrame *frame) { 434 lldb::RegisterContextSP reg_ctx_sp; 435 uint32_t idx = frame->GetConcreteFrameIndex(); 436 437 if (idx == 0) { 438 return m_thread.GetRegisterContext(); 439 } 440 441 if (m_frames.size() == 0) { 442 if (!AddFirstFrame()) 443 return reg_ctx_sp; 444 } 445 446 ProcessSP process_sp(m_thread.GetProcess()); 447 ABI *abi = process_sp ? process_sp->GetABI().get() : nullptr; 448 449 while (idx >= m_frames.size()) { 450 if (!AddOneMoreFrame(abi)) 451 break; 452 } 453 454 const uint32_t num_frames = m_frames.size(); 455 if (idx < num_frames) { 456 Cursor *frame_cursor = m_frames[idx].get(); 457 reg_ctx_sp = frame_cursor->reg_ctx_lldb_sp; 458 } 459 return reg_ctx_sp; 460} 461 462UnwindLLDB::RegisterContextLLDBSP 463UnwindLLDB::GetRegisterContextForFrameNum(uint32_t frame_num) { 464 RegisterContextLLDBSP reg_ctx_sp; 465 if (frame_num < m_frames.size()) 466 reg_ctx_sp = m_frames[frame_num]->reg_ctx_lldb_sp; 467 return reg_ctx_sp; 468} 469 470bool UnwindLLDB::SearchForSavedLocationForRegister( 471 uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation ®loc, 472 uint32_t starting_frame_num, bool pc_reg) { 473 int64_t frame_num = starting_frame_num; 474 if (static_cast<size_t>(frame_num) >= m_frames.size()) 475 return false; 476 477 // Never interrogate more than one level while looking for the saved pc 478 // value. If the value isn't saved by frame_num, none of the frames lower on 479 // the stack will have a useful value. 480 if (pc_reg) { 481 UnwindLLDB::RegisterSearchResult result; 482 result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister( 483 lldb_regnum, regloc); 484 return result == UnwindLLDB::RegisterSearchResult::eRegisterFound; 485 } 486 while (frame_num >= 0) { 487 UnwindLLDB::RegisterSearchResult result; 488 result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister( 489 lldb_regnum, regloc); 490 491 // We descended down to the live register context aka stack frame 0 and are 492 // reading the value out of a live register. 493 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound && 494 regloc.type == 495 UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext) { 496 return true; 497 } 498 499 // If we have unwind instructions saying that register N is saved in 500 // register M in the middle of the stack (and N can equal M here, meaning 501 // the register was not used in this function), then change the register 502 // number we're looking for to M and keep looking for a concrete location 503 // down the stack, or an actual value from a live RegisterContext at frame 504 // 0. 505 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound && 506 regloc.type == UnwindLLDB::RegisterLocation::eRegisterInRegister && 507 frame_num > 0) { 508 result = UnwindLLDB::RegisterSearchResult::eRegisterNotFound; 509 lldb_regnum = regloc.location.register_number; 510 } 511 512 if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound) 513 return true; 514 if (result == UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile) 515 return false; 516 frame_num--; 517 } 518 return false; 519} 520