1 //===-- StackFrameList.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/Target/StackFrameList.h" 11 12 // C Includes 13 // C++ Includes 14 // Other libraries and framework includes 15 // Project includes 16 #include "lldb/Breakpoint/BreakpointLocation.h" 17 #include "lldb/Breakpoint/Breakpoint.h" 18 #include "lldb/Core/Log.h" 19 #include "lldb/Core/StreamFile.h" 20 #include "lldb/Core/SourceManager.h" 21 #include "lldb/Symbol/Block.h" 22 #include "lldb/Symbol/Function.h" 23 #include "lldb/Symbol/Symbol.h" 24 #include "lldb/Target/Process.h" 25 #include "lldb/Target/RegisterContext.h" 26 #include "lldb/Target/StackFrame.h" 27 #include "lldb/Target/StopInfo.h" 28 #include "lldb/Target/Target.h" 29 #include "lldb/Target/Thread.h" 30 #include "lldb/Target/Unwind.h" 31 32 //#define DEBUG_STACK_FRAMES 1 33 34 using namespace lldb; 35 using namespace lldb_private; 36 37 //---------------------------------------------------------------------- 38 // StackFrameList constructor 39 //---------------------------------------------------------------------- 40 StackFrameList::StackFrameList 41 ( 42 Thread &thread, 43 const lldb::StackFrameListSP &prev_frames_sp, 44 bool show_inline_frames 45 ) : 46 m_thread (thread), 47 m_prev_frames_sp (prev_frames_sp), 48 m_mutex (Mutex::eMutexTypeRecursive), 49 m_frames (), 50 m_selected_frame_idx (0), 51 m_concrete_frames_fetched (0), 52 m_current_inlined_depth (UINT32_MAX), 53 m_current_inlined_pc (LLDB_INVALID_ADDRESS), 54 m_show_inlined_frames (show_inline_frames) 55 { 56 if (prev_frames_sp) 57 { 58 m_current_inlined_depth = prev_frames_sp->m_current_inlined_depth; 59 m_current_inlined_pc = prev_frames_sp->m_current_inlined_pc; 60 } 61 } 62 63 //---------------------------------------------------------------------- 64 // Destructor 65 //---------------------------------------------------------------------- 66 StackFrameList::~StackFrameList() 67 { 68 // Call clear since this takes a lock and clears the stack frame list 69 // in case another thread is currently using this stack frame list 70 Clear(); 71 } 72 73 void 74 StackFrameList::CalculateCurrentInlinedDepth() 75 { 76 uint32_t cur_inlined_depth = GetCurrentInlinedDepth(); 77 if (cur_inlined_depth == UINT32_MAX) 78 { 79 ResetCurrentInlinedDepth(); 80 } 81 } 82 83 uint32_t 84 StackFrameList::GetCurrentInlinedDepth () 85 { 86 if (m_show_inlined_frames && m_current_inlined_pc != LLDB_INVALID_ADDRESS) 87 { 88 lldb::addr_t cur_pc = m_thread.GetRegisterContext()->GetPC(); 89 if (cur_pc != m_current_inlined_pc) 90 { 91 m_current_inlined_pc = LLDB_INVALID_ADDRESS; 92 m_current_inlined_depth = UINT32_MAX; 93 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 94 if (log && log->GetVerbose()) 95 log->Printf ("GetCurrentInlinedDepth: invalidating current inlined depth.\n"); 96 } 97 return m_current_inlined_depth; 98 } 99 else 100 { 101 return UINT32_MAX; 102 } 103 } 104 105 void 106 StackFrameList::ResetCurrentInlinedDepth () 107 { 108 if (m_show_inlined_frames) 109 { 110 GetFramesUpTo(0); 111 if (!m_frames[0]->IsInlined()) 112 { 113 m_current_inlined_depth = UINT32_MAX; 114 m_current_inlined_pc = LLDB_INVALID_ADDRESS; 115 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 116 if (log && log->GetVerbose()) 117 log->Printf ("ResetCurrentInlinedDepth: Invalidating current inlined depth.\n"); 118 } 119 else 120 { 121 // We only need to do something special about inlined blocks when we 122 // are at the beginning of an inlined function: 123 // FIXME: We probably also have to do something special if the PC is at the END 124 // of an inlined function, which coincides with the end of either its containing 125 // function or another inlined function. 126 127 lldb::addr_t curr_pc = m_thread.GetRegisterContext()->GetPC(); 128 Block *block_ptr = m_frames[0]->GetFrameBlock(); 129 if (block_ptr) 130 { 131 Address pc_as_address; 132 pc_as_address.SetLoadAddress(curr_pc, &(m_thread.GetProcess()->GetTarget())); 133 AddressRange containing_range; 134 if (block_ptr->GetRangeContainingAddress(pc_as_address, containing_range)) 135 { 136 if (pc_as_address == containing_range.GetBaseAddress()) 137 { 138 // If we got here because of a breakpoint hit, then set the inlined depth depending on where 139 // the breakpoint was set. 140 // If we got here because of a crash, then set the inlined depth to the deepest most block. 141 // Otherwise, we stopped here naturally as the result of a step, so set ourselves in the 142 // containing frame of the whole set of nested inlines, so the user can then "virtually" 143 // step into the frames one by one, or next over the whole mess. 144 // Note: We don't have to handle being somewhere in the middle of the stack here, since 145 // ResetCurrentInlinedDepth doesn't get called if there is a valid inlined depth set. 146 StopInfoSP stop_info_sp = m_thread.GetStopInfo(); 147 if (stop_info_sp) 148 { 149 switch (stop_info_sp->GetStopReason()) 150 { 151 case eStopReasonWatchpoint: 152 case eStopReasonException: 153 case eStopReasonExec: 154 case eStopReasonSignal: 155 // In all these cases we want to stop in the deepest most frame. 156 m_current_inlined_pc = curr_pc; 157 m_current_inlined_depth = 0; 158 break; 159 case eStopReasonBreakpoint: 160 { 161 // FIXME: Figure out what this break point is doing, and set the inline depth 162 // appropriately. Be careful to take into account breakpoints that implement 163 // step over prologue, since that should do the default calculation. 164 // For now, if the breakpoints corresponding to this hit are all internal, 165 // I set the stop location to the top of the inlined stack, since that will make 166 // things like stepping over prologues work right. But if there are any non-internal 167 // breakpoints I do to the bottom of the stack, since that was the old behavior. 168 uint32_t bp_site_id = stop_info_sp->GetValue(); 169 BreakpointSiteSP bp_site_sp(m_thread.GetProcess()->GetBreakpointSiteList().FindByID(bp_site_id)); 170 bool all_internal = true; 171 if (bp_site_sp) 172 { 173 uint32_t num_owners = bp_site_sp->GetNumberOfOwners(); 174 for (uint32_t i = 0; i < num_owners; i++) 175 { 176 Breakpoint &bp_ref = bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint(); 177 if (!bp_ref.IsInternal()) 178 { 179 all_internal = false; 180 } 181 } 182 } 183 if (!all_internal) 184 { 185 m_current_inlined_pc = curr_pc; 186 m_current_inlined_depth = 0; 187 break; 188 } 189 } 190 default: 191 { 192 // Otherwise, we should set ourselves at the container of the inlining, so that the 193 // user can descend into them. 194 // So first we check whether we have more than one inlined block sharing this PC: 195 int num_inlined_functions = 0; 196 197 for (Block *container_ptr = block_ptr->GetInlinedParent(); 198 container_ptr != NULL; 199 container_ptr = container_ptr->GetInlinedParent()) 200 { 201 if (!container_ptr->GetRangeContainingAddress(pc_as_address, containing_range)) 202 break; 203 if (pc_as_address != containing_range.GetBaseAddress()) 204 break; 205 206 num_inlined_functions++; 207 } 208 m_current_inlined_pc = curr_pc; 209 m_current_inlined_depth = num_inlined_functions + 1; 210 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 211 if (log && log->GetVerbose()) 212 log->Printf ("ResetCurrentInlinedDepth: setting inlined depth: %d 0x%" PRIx64 ".\n", m_current_inlined_depth, curr_pc); 213 214 } 215 break; 216 } 217 } 218 } 219 } 220 } 221 } 222 } 223 } 224 225 bool 226 StackFrameList::DecrementCurrentInlinedDepth () 227 { 228 if (m_show_inlined_frames) 229 { 230 uint32_t current_inlined_depth = GetCurrentInlinedDepth(); 231 if (current_inlined_depth != UINT32_MAX) 232 { 233 if (current_inlined_depth > 0) 234 { 235 m_current_inlined_depth--; 236 return true; 237 } 238 } 239 } 240 return false; 241 } 242 243 void 244 StackFrameList::SetCurrentInlinedDepth (uint32_t new_depth) 245 { 246 m_current_inlined_depth = new_depth; 247 if (new_depth == UINT32_MAX) 248 m_current_inlined_pc = LLDB_INVALID_ADDRESS; 249 else 250 m_current_inlined_pc = m_thread.GetRegisterContext()->GetPC(); 251 } 252 253 void 254 StackFrameList::GetFramesUpTo(uint32_t end_idx) 255 { 256 // this makes sure we do not fetch frames for an invalid thread 257 if (m_thread.IsValid() == false) 258 return; 259 260 // We've already gotten more frames than asked for, or we've already finished unwinding, return. 261 if (m_frames.size() > end_idx || GetAllFramesFetched()) 262 return; 263 264 Unwind *unwinder = m_thread.GetUnwinder (); 265 266 if (m_show_inlined_frames) 267 { 268 #if defined (DEBUG_STACK_FRAMES) 269 StreamFile s(stdout, false); 270 #endif 271 // If we are hiding some frames from the outside world, we need to add those onto the total count of 272 // frames to fetch. However, we don't need to do that if end_idx is 0 since in that case we always 273 // get the first concrete frame and all the inlined frames below it... And of course, if end_idx is 274 // UINT32_MAX that means get all, so just do that... 275 276 uint32_t inlined_depth = 0; 277 if (end_idx > 0 && end_idx != UINT32_MAX) 278 { 279 inlined_depth = GetCurrentInlinedDepth(); 280 if (inlined_depth != UINT32_MAX) 281 { 282 if (end_idx > 0) 283 end_idx += inlined_depth; 284 } 285 } 286 287 StackFrameSP unwind_frame_sp; 288 do 289 { 290 uint32_t idx = m_concrete_frames_fetched++; 291 lldb::addr_t pc = LLDB_INVALID_ADDRESS; 292 lldb::addr_t cfa = LLDB_INVALID_ADDRESS; 293 if (idx == 0) 294 { 295 // We might have already created frame zero, only create it 296 // if we need to 297 if (m_frames.empty()) 298 { 299 RegisterContextSP reg_ctx_sp (m_thread.GetRegisterContext()); 300 301 if (reg_ctx_sp) 302 { 303 304 const bool success = unwinder && unwinder->GetFrameInfoAtIndex(idx, cfa, pc); 305 // There shouldn't be any way not to get the frame info for frame 0. 306 // But if the unwinder can't make one, lets make one by hand with the 307 // SP as the CFA and see if that gets any further. 308 if (!success) 309 { 310 cfa = reg_ctx_sp->GetSP(); 311 pc = reg_ctx_sp->GetPC(); 312 } 313 314 unwind_frame_sp.reset (new StackFrame (m_thread.shared_from_this(), 315 m_frames.size(), 316 idx, 317 reg_ctx_sp, 318 cfa, 319 pc, 320 NULL)); 321 m_frames.push_back (unwind_frame_sp); 322 } 323 } 324 else 325 { 326 unwind_frame_sp = m_frames.front(); 327 cfa = unwind_frame_sp->m_id.GetCallFrameAddress(); 328 } 329 } 330 else 331 { 332 const bool success = unwinder && unwinder->GetFrameInfoAtIndex(idx, cfa, pc); 333 if (!success) 334 { 335 // We've gotten to the end of the stack. 336 SetAllFramesFetched(); 337 break; 338 } 339 const bool cfa_is_valid = true; 340 const bool stop_id_is_valid = false; 341 const bool is_history_frame = false; 342 unwind_frame_sp.reset (new StackFrame (m_thread.shared_from_this(), m_frames.size(), idx, cfa, cfa_is_valid, pc, 0, stop_id_is_valid, is_history_frame, NULL)); 343 m_frames.push_back (unwind_frame_sp); 344 } 345 346 assert(unwind_frame_sp); 347 SymbolContext unwind_sc = unwind_frame_sp->GetSymbolContext (eSymbolContextBlock | eSymbolContextFunction); 348 Block *unwind_block = unwind_sc.block; 349 if (unwind_block) 350 { 351 Address curr_frame_address (unwind_frame_sp->GetFrameCodeAddress()); 352 // Be sure to adjust the frame address to match the address 353 // that was used to lookup the symbol context above. If we are 354 // in the first concrete frame, then we lookup using the current 355 // address, else we decrement the address by one to get the correct 356 // location. 357 if (idx > 0) 358 curr_frame_address.Slide(-1); 359 360 SymbolContext next_frame_sc; 361 Address next_frame_address; 362 363 while (unwind_sc.GetParentOfInlinedScope(curr_frame_address, next_frame_sc, next_frame_address)) 364 { 365 StackFrameSP frame_sp(new StackFrame (m_thread.shared_from_this(), 366 m_frames.size(), 367 idx, 368 unwind_frame_sp->GetRegisterContextSP (), 369 cfa, 370 next_frame_address, 371 &next_frame_sc)); 372 373 m_frames.push_back (frame_sp); 374 unwind_sc = next_frame_sc; 375 curr_frame_address = next_frame_address; 376 } 377 } 378 } while (m_frames.size() - 1 < end_idx); 379 380 // Don't try to merge till you've calculated all the frames in this stack. 381 if (GetAllFramesFetched() && m_prev_frames_sp) 382 { 383 StackFrameList *prev_frames = m_prev_frames_sp.get(); 384 StackFrameList *curr_frames = this; 385 386 //curr_frames->m_current_inlined_depth = prev_frames->m_current_inlined_depth; 387 //curr_frames->m_current_inlined_pc = prev_frames->m_current_inlined_pc; 388 //printf ("GetFramesUpTo: Copying current inlined depth: %d 0x%" PRIx64 ".\n", curr_frames->m_current_inlined_depth, curr_frames->m_current_inlined_pc); 389 390 #if defined (DEBUG_STACK_FRAMES) 391 s.PutCString("\nprev_frames:\n"); 392 prev_frames->Dump (&s); 393 s.PutCString("\ncurr_frames:\n"); 394 curr_frames->Dump (&s); 395 s.EOL(); 396 #endif 397 size_t curr_frame_num, prev_frame_num; 398 399 for (curr_frame_num = curr_frames->m_frames.size(), prev_frame_num = prev_frames->m_frames.size(); 400 curr_frame_num > 0 && prev_frame_num > 0; 401 --curr_frame_num, --prev_frame_num) 402 { 403 const size_t curr_frame_idx = curr_frame_num-1; 404 const size_t prev_frame_idx = prev_frame_num-1; 405 StackFrameSP curr_frame_sp (curr_frames->m_frames[curr_frame_idx]); 406 StackFrameSP prev_frame_sp (prev_frames->m_frames[prev_frame_idx]); 407 408 #if defined (DEBUG_STACK_FRAMES) 409 s.Printf("\n\nCurr frame #%u ", curr_frame_idx); 410 if (curr_frame_sp) 411 curr_frame_sp->Dump (&s, true, false); 412 else 413 s.PutCString("NULL"); 414 s.Printf("\nPrev frame #%u ", prev_frame_idx); 415 if (prev_frame_sp) 416 prev_frame_sp->Dump (&s, true, false); 417 else 418 s.PutCString("NULL"); 419 #endif 420 421 StackFrame *curr_frame = curr_frame_sp.get(); 422 StackFrame *prev_frame = prev_frame_sp.get(); 423 424 if (curr_frame == NULL || prev_frame == NULL) 425 break; 426 427 // Check the stack ID to make sure they are equal 428 if (curr_frame->GetStackID() != prev_frame->GetStackID()) 429 break; 430 431 prev_frame->UpdatePreviousFrameFromCurrentFrame (*curr_frame); 432 // Now copy the fixed up previous frame into the current frames 433 // so the pointer doesn't change 434 m_frames[curr_frame_idx] = prev_frame_sp; 435 //curr_frame->UpdateCurrentFrameFromPreviousFrame (*prev_frame); 436 437 #if defined (DEBUG_STACK_FRAMES) 438 s.Printf("\n Copying previous frame to current frame"); 439 #endif 440 } 441 // We are done with the old stack frame list, we can release it now 442 m_prev_frames_sp.reset(); 443 } 444 445 #if defined (DEBUG_STACK_FRAMES) 446 s.PutCString("\n\nNew frames:\n"); 447 Dump (&s); 448 s.EOL(); 449 #endif 450 } 451 else 452 { 453 if (end_idx < m_concrete_frames_fetched) 454 return; 455 456 if (unwinder) 457 { 458 uint32_t num_frames = unwinder->GetFramesUpTo(end_idx); 459 if (num_frames <= end_idx + 1) 460 { 461 //Done unwinding. 462 m_concrete_frames_fetched = UINT32_MAX; 463 } 464 m_frames.resize(num_frames); 465 } 466 } 467 } 468 469 uint32_t 470 StackFrameList::GetNumFrames (bool can_create) 471 { 472 Mutex::Locker locker (m_mutex); 473 474 if (can_create) 475 GetFramesUpTo (UINT32_MAX); 476 477 uint32_t inlined_depth = GetCurrentInlinedDepth(); 478 if (inlined_depth == UINT32_MAX) 479 return m_frames.size(); 480 else 481 return m_frames.size() - inlined_depth; 482 } 483 484 void 485 StackFrameList::Dump (Stream *s) 486 { 487 if (s == NULL) 488 return; 489 Mutex::Locker locker (m_mutex); 490 491 const_iterator pos, begin = m_frames.begin(), end = m_frames.end(); 492 for (pos = begin; pos != end; ++pos) 493 { 494 StackFrame *frame = (*pos).get(); 495 s->Printf("%p: ", static_cast<void*>(frame)); 496 if (frame) 497 { 498 frame->GetStackID().Dump (s); 499 frame->DumpUsingSettingsFormat (s); 500 } 501 else 502 s->Printf("frame #%u", (uint32_t)std::distance (begin, pos)); 503 s->EOL(); 504 } 505 s->EOL(); 506 } 507 508 StackFrameSP 509 StackFrameList::GetFrameAtIndex (uint32_t idx) 510 { 511 StackFrameSP frame_sp; 512 Mutex::Locker locker (m_mutex); 513 uint32_t original_idx = idx; 514 515 uint32_t inlined_depth = GetCurrentInlinedDepth(); 516 if (inlined_depth != UINT32_MAX) 517 idx += inlined_depth; 518 519 if (idx < m_frames.size()) 520 frame_sp = m_frames[idx]; 521 522 if (frame_sp) 523 return frame_sp; 524 525 // GetFramesUpTo will fill m_frames with as many frames as you asked for, 526 // if there are that many. If there weren't then you asked for too many 527 // frames. 528 GetFramesUpTo (idx); 529 if (idx < m_frames.size()) 530 { 531 if (m_show_inlined_frames) 532 { 533 // When inline frames are enabled we actually create all the frames in GetFramesUpTo. 534 frame_sp = m_frames[idx]; 535 } 536 else 537 { 538 Unwind *unwinder = m_thread.GetUnwinder (); 539 if (unwinder) 540 { 541 addr_t pc, cfa; 542 if (unwinder->GetFrameInfoAtIndex(idx, cfa, pc)) 543 { 544 const bool cfa_is_valid = true; 545 const bool stop_id_is_valid = false; 546 const bool is_history_frame = false; 547 frame_sp.reset (new StackFrame (m_thread.shared_from_this(), idx, idx, cfa, cfa_is_valid, pc, 0, stop_id_is_valid, is_history_frame, NULL)); 548 549 Function *function = frame_sp->GetSymbolContext (eSymbolContextFunction).function; 550 if (function) 551 { 552 // When we aren't showing inline functions we always use 553 // the top most function block as the scope. 554 frame_sp->SetSymbolContextScope (&function->GetBlock(false)); 555 } 556 else 557 { 558 // Set the symbol scope from the symbol regardless if it is NULL or valid. 559 frame_sp->SetSymbolContextScope (frame_sp->GetSymbolContext (eSymbolContextSymbol).symbol); 560 } 561 SetFrameAtIndex(idx, frame_sp); 562 } 563 } 564 } 565 } 566 else if (original_idx == 0) 567 { 568 // There should ALWAYS be a frame at index 0. If something went wrong with the CurrentInlinedDepth such that 569 // there weren't as many frames as we thought taking that into account, then reset the current inlined depth 570 // and return the real zeroth frame. 571 if (m_frames.size() > 0) 572 { 573 ResetCurrentInlinedDepth(); 574 frame_sp = m_frames[original_idx]; 575 } 576 else 577 { 578 // Why do we have a thread with zero frames, that should not ever happen... 579 if (m_thread.IsValid()) 580 assert ("A valid thread has no frames."); 581 582 } 583 } 584 585 return frame_sp; 586 } 587 588 StackFrameSP 589 StackFrameList::GetFrameWithConcreteFrameIndex (uint32_t unwind_idx) 590 { 591 // First try assuming the unwind index is the same as the frame index. The 592 // unwind index is always greater than or equal to the frame index, so it 593 // is a good place to start. If we have inlined frames we might have 5 594 // concrete frames (frame unwind indexes go from 0-4), but we might have 15 595 // frames after we make all the inlined frames. Most of the time the unwind 596 // frame index (or the concrete frame index) is the same as the frame index. 597 uint32_t frame_idx = unwind_idx; 598 StackFrameSP frame_sp (GetFrameAtIndex (frame_idx)); 599 while (frame_sp) 600 { 601 if (frame_sp->GetFrameIndex() == unwind_idx) 602 break; 603 frame_sp = GetFrameAtIndex (++frame_idx); 604 } 605 return frame_sp; 606 } 607 608 static bool 609 CompareStackID (const StackFrameSP &stack_sp, const StackID &stack_id) 610 { 611 return stack_sp->GetStackID() < stack_id; 612 } 613 614 StackFrameSP 615 StackFrameList::GetFrameWithStackID (const StackID &stack_id) 616 { 617 StackFrameSP frame_sp; 618 619 if (stack_id.IsValid()) 620 { 621 Mutex::Locker locker (m_mutex); 622 uint32_t frame_idx = 0; 623 // Do a binary search in case the stack frame is already in our cache 624 collection::const_iterator begin = m_frames.begin(); 625 collection::const_iterator end = m_frames.end(); 626 if (begin != end) 627 { 628 collection::const_iterator pos = std::lower_bound (begin, end, stack_id, CompareStackID); 629 if (pos != end) 630 { 631 if ((*pos)->GetStackID() == stack_id) 632 return *pos; 633 } 634 635 // if (m_frames.back()->GetStackID() < stack_id) 636 // frame_idx = m_frames.size(); 637 } 638 do 639 { 640 frame_sp = GetFrameAtIndex (frame_idx); 641 if (frame_sp && frame_sp->GetStackID() == stack_id) 642 break; 643 frame_idx++; 644 } 645 while (frame_sp); 646 } 647 return frame_sp; 648 } 649 650 bool 651 StackFrameList::SetFrameAtIndex (uint32_t idx, StackFrameSP &frame_sp) 652 { 653 if (idx >= m_frames.size()) 654 m_frames.resize(idx + 1); 655 // Make sure allocation succeeded by checking bounds again 656 if (idx < m_frames.size()) 657 { 658 m_frames[idx] = frame_sp; 659 return true; 660 } 661 return false; // resize failed, out of memory? 662 } 663 664 uint32_t 665 StackFrameList::GetSelectedFrameIndex () const 666 { 667 Mutex::Locker locker (m_mutex); 668 return m_selected_frame_idx; 669 } 670 671 672 uint32_t 673 StackFrameList::SetSelectedFrame (lldb_private::StackFrame *frame) 674 { 675 Mutex::Locker locker (m_mutex); 676 const_iterator pos; 677 const_iterator begin = m_frames.begin(); 678 const_iterator end = m_frames.end(); 679 m_selected_frame_idx = 0; 680 for (pos = begin; pos != end; ++pos) 681 { 682 if (pos->get() == frame) 683 { 684 m_selected_frame_idx = std::distance (begin, pos); 685 uint32_t inlined_depth = GetCurrentInlinedDepth(); 686 if (inlined_depth != UINT32_MAX) 687 m_selected_frame_idx -= inlined_depth; 688 break; 689 } 690 } 691 SetDefaultFileAndLineToSelectedFrame(); 692 return m_selected_frame_idx; 693 } 694 695 // Mark a stack frame as the current frame using the frame index 696 bool 697 StackFrameList::SetSelectedFrameByIndex (uint32_t idx) 698 { 699 Mutex::Locker locker (m_mutex); 700 StackFrameSP frame_sp (GetFrameAtIndex (idx)); 701 if (frame_sp) 702 { 703 SetSelectedFrame(frame_sp.get()); 704 return true; 705 } 706 else 707 return false; 708 } 709 710 void 711 StackFrameList::SetDefaultFileAndLineToSelectedFrame() 712 { 713 if (m_thread.GetID() == m_thread.GetProcess()->GetThreadList().GetSelectedThread()->GetID()) 714 { 715 StackFrameSP frame_sp (GetFrameAtIndex (GetSelectedFrameIndex())); 716 if (frame_sp) 717 { 718 SymbolContext sc = frame_sp->GetSymbolContext(eSymbolContextLineEntry); 719 if (sc.line_entry.file) 720 m_thread.CalculateTarget()->GetSourceManager().SetDefaultFileAndLine (sc.line_entry.file, 721 sc.line_entry.line); 722 } 723 } 724 } 725 726 // The thread has been run, reset the number stack frames to zero so we can 727 // determine how many frames we have lazily. 728 void 729 StackFrameList::Clear () 730 { 731 Mutex::Locker locker (m_mutex); 732 m_frames.clear(); 733 m_concrete_frames_fetched = 0; 734 } 735 736 void 737 StackFrameList::InvalidateFrames (uint32_t start_idx) 738 { 739 Mutex::Locker locker (m_mutex); 740 if (m_show_inlined_frames) 741 { 742 Clear(); 743 } 744 else 745 { 746 const size_t num_frames = m_frames.size(); 747 while (start_idx < num_frames) 748 { 749 m_frames[start_idx].reset(); 750 ++start_idx; 751 } 752 } 753 } 754 755 void 756 StackFrameList::Merge (std::unique_ptr<StackFrameList>& curr_ap, lldb::StackFrameListSP& prev_sp) 757 { 758 Mutex::Locker curr_locker (curr_ap.get() ? &curr_ap->m_mutex : NULL); 759 Mutex::Locker prev_locker (prev_sp.get() ? &prev_sp->m_mutex : NULL); 760 761 #if defined (DEBUG_STACK_FRAMES) 762 StreamFile s(stdout, false); 763 s.PutCString("\n\nStackFrameList::Merge():\nPrev:\n"); 764 if (prev_sp.get()) 765 prev_sp->Dump (&s); 766 else 767 s.PutCString ("NULL"); 768 s.PutCString("\nCurr:\n"); 769 if (curr_ap.get()) 770 curr_ap->Dump (&s); 771 else 772 s.PutCString ("NULL"); 773 s.EOL(); 774 #endif 775 776 if (curr_ap.get() == NULL || curr_ap->GetNumFrames (false) == 0) 777 { 778 #if defined (DEBUG_STACK_FRAMES) 779 s.PutCString("No current frames, leave previous frames alone...\n"); 780 #endif 781 curr_ap.release(); 782 return; 783 } 784 785 if (prev_sp.get() == NULL || prev_sp->GetNumFrames (false) == 0) 786 { 787 #if defined (DEBUG_STACK_FRAMES) 788 s.PutCString("No previous frames, so use current frames...\n"); 789 #endif 790 // We either don't have any previous frames, or since we have more than 791 // one current frames it means we have all the frames and can safely 792 // replace our previous frames. 793 prev_sp.reset (curr_ap.release()); 794 return; 795 } 796 797 const uint32_t num_curr_frames = curr_ap->GetNumFrames (false); 798 799 if (num_curr_frames > 1) 800 { 801 #if defined (DEBUG_STACK_FRAMES) 802 s.PutCString("We have more than one current frame, so use current frames...\n"); 803 #endif 804 // We have more than one current frames it means we have all the frames 805 // and can safely replace our previous frames. 806 prev_sp.reset (curr_ap.release()); 807 808 #if defined (DEBUG_STACK_FRAMES) 809 s.PutCString("\nMerged:\n"); 810 prev_sp->Dump (&s); 811 #endif 812 return; 813 } 814 815 StackFrameSP prev_frame_zero_sp(prev_sp->GetFrameAtIndex (0)); 816 StackFrameSP curr_frame_zero_sp(curr_ap->GetFrameAtIndex (0)); 817 StackID curr_stack_id (curr_frame_zero_sp->GetStackID()); 818 StackID prev_stack_id (prev_frame_zero_sp->GetStackID()); 819 820 #if defined (DEBUG_STACK_FRAMES) 821 const uint32_t num_prev_frames = prev_sp->GetNumFrames (false); 822 s.Printf("\n%u previous frames with one current frame\n", num_prev_frames); 823 #endif 824 825 // We have only a single current frame 826 // Our previous stack frames only had a single frame as well... 827 if (curr_stack_id == prev_stack_id) 828 { 829 #if defined (DEBUG_STACK_FRAMES) 830 s.Printf("\nPrevious frame #0 is same as current frame #0, merge the cached data\n"); 831 #endif 832 833 curr_frame_zero_sp->UpdateCurrentFrameFromPreviousFrame (*prev_frame_zero_sp); 834 // prev_frame_zero_sp->UpdatePreviousFrameFromCurrentFrame (*curr_frame_zero_sp); 835 // prev_sp->SetFrameAtIndex (0, prev_frame_zero_sp); 836 } 837 else if (curr_stack_id < prev_stack_id) 838 { 839 #if defined (DEBUG_STACK_FRAMES) 840 s.Printf("\nCurrent frame #0 has a stack ID that is less than the previous frame #0, insert current frame zero in front of previous\n"); 841 #endif 842 prev_sp->m_frames.insert (prev_sp->m_frames.begin(), curr_frame_zero_sp); 843 } 844 845 curr_ap.release(); 846 847 #if defined (DEBUG_STACK_FRAMES) 848 s.PutCString("\nMerged:\n"); 849 prev_sp->Dump (&s); 850 #endif 851 852 853 } 854 855 lldb::StackFrameSP 856 StackFrameList::GetStackFrameSPForStackFramePtr (StackFrame *stack_frame_ptr) 857 { 858 const_iterator pos; 859 const_iterator begin = m_frames.begin(); 860 const_iterator end = m_frames.end(); 861 lldb::StackFrameSP ret_sp; 862 863 for (pos = begin; pos != end; ++pos) 864 { 865 if (pos->get() == stack_frame_ptr) 866 { 867 ret_sp = (*pos); 868 break; 869 } 870 } 871 return ret_sp; 872 } 873 874 size_t 875 StackFrameList::GetStatus (Stream& strm, 876 uint32_t first_frame, 877 uint32_t num_frames, 878 bool show_frame_info, 879 uint32_t num_frames_with_source, 880 const char *selected_frame_marker) 881 { 882 size_t num_frames_displayed = 0; 883 884 if (num_frames == 0) 885 return 0; 886 887 StackFrameSP frame_sp; 888 uint32_t frame_idx = 0; 889 uint32_t last_frame; 890 891 // Don't let the last frame wrap around... 892 if (num_frames == UINT32_MAX) 893 last_frame = UINT32_MAX; 894 else 895 last_frame = first_frame + num_frames; 896 897 StackFrameSP selected_frame_sp = m_thread.GetSelectedFrame(); 898 const char *unselected_marker = NULL; 899 std::string buffer; 900 if (selected_frame_marker) 901 { 902 size_t len = strlen(selected_frame_marker); 903 buffer.insert(buffer.begin(), len, ' '); 904 unselected_marker = buffer.c_str(); 905 } 906 const char *marker = NULL; 907 908 for (frame_idx = first_frame; frame_idx < last_frame; ++frame_idx) 909 { 910 frame_sp = GetFrameAtIndex(frame_idx); 911 if (frame_sp.get() == NULL) 912 break; 913 914 if (selected_frame_marker != NULL) 915 { 916 if (frame_sp == selected_frame_sp) 917 marker = selected_frame_marker; 918 else 919 marker = unselected_marker; 920 } 921 922 if (!frame_sp->GetStatus (strm, 923 show_frame_info, 924 num_frames_with_source > (first_frame - frame_idx), marker)) 925 break; 926 ++num_frames_displayed; 927 } 928 929 strm.IndentLess(); 930 return num_frames_displayed; 931 } 932 933