contrib/llvm/tools/lldb/source/Target/StackFrameList.cpp

   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             SymbolContext unwind_sc = unwind_frame_sp->GetSymbolContext (eSymbolContextBlock | eSymbolContextFunction);
 347             Block *unwind_block = unwind_sc.block;
 348             if (unwind_block)
 349             {
 350                 Address curr_frame_address (unwind_frame_sp->GetFrameCodeAddress());
 351                 // Be sure to adjust the frame address to match the address
 352                 // that was used to lookup the symbol context above. If we are
 353                 // in the first concrete frame, then we lookup using the current
 354                 // address, else we decrement the address by one to get the correct
 355                 // location.
 356                 if (idx > 0)
 357                     curr_frame_address.Slide(-1);
 358
 359                 SymbolContext next_frame_sc;
 360                 Address next_frame_address;
 361
 362                 while (unwind_sc.GetParentOfInlinedScope(curr_frame_address, next_frame_sc, next_frame_address))
 363                 {
 364                         StackFrameSP frame_sp(new StackFrame (m_thread.shared_from_this(),
 365                                                               m_frames.size(),
 366                                                               idx,
 367                                                               unwind_frame_sp->GetRegisterContextSP (),
 368                                                               cfa,
 369                                                               next_frame_address,
 370                                                               &next_frame_sc));
 371
 372                         m_frames.push_back (frame_sp);
 373                         unwind_sc = next_frame_sc;
 374                         curr_frame_address = next_frame_address;
 375                 }
 376             }
 377         } while (m_frames.size() - 1 < end_idx);
 378
 379         // Don't try to merge till you've calculated all the frames in this stack.
 380         if (GetAllFramesFetched() && m_prev_frames_sp)
 381         {
 382             StackFrameList *prev_frames = m_prev_frames_sp.get();
 383             StackFrameList *curr_frames = this;
 384
 385             //curr_frames->m_current_inlined_depth = prev_frames->m_current_inlined_depth;
 386             //curr_frames->m_current_inlined_pc = prev_frames->m_current_inlined_pc;
 387             //printf ("GetFramesUpTo: Copying current inlined depth: %d 0x%" PRIx64 ".\n", curr_frames->m_current_inlined_depth, curr_frames->m_current_inlined_pc);
 388
 389 #if defined (DEBUG_STACK_FRAMES)
 390             s.PutCString("\nprev_frames:\n");
 391             prev_frames->Dump (&s);
 392             s.PutCString("\ncurr_frames:\n");
 393             curr_frames->Dump (&s);
 394             s.EOL();
 395 #endif
 396             size_t curr_frame_num, prev_frame_num;
 397
 398             for (curr_frame_num = curr_frames->m_frames.size(), prev_frame_num = prev_frames->m_frames.size();
 399                  curr_frame_num > 0 && prev_frame_num > 0;
 400                  --curr_frame_num, --prev_frame_num)
 401             {
 402                 const size_t curr_frame_idx = curr_frame_num-1;
 403                 const size_t prev_frame_idx = prev_frame_num-1;
 404                 StackFrameSP curr_frame_sp (curr_frames->m_frames[curr_frame_idx]);
 405                 StackFrameSP prev_frame_sp (prev_frames->m_frames[prev_frame_idx]);
 406
 407 #if defined (DEBUG_STACK_FRAMES)
 408                 s.Printf("\n\nCurr frame #%u ", curr_frame_idx);
 409                 if (curr_frame_sp)
 410                     curr_frame_sp->Dump (&s, true, false);
 411                 else
 412                     s.PutCString("NULL");
 413                 s.Printf("\nPrev frame #%u ", prev_frame_idx);
 414                 if (prev_frame_sp)
 415                     prev_frame_sp->Dump (&s, true, false);
 416                 else
 417                     s.PutCString("NULL");
 418 #endif
 419
 420                 StackFrame *curr_frame = curr_frame_sp.get();
 421                 StackFrame *prev_frame = prev_frame_sp.get();
 422
 423                 if (curr_frame == NULL || prev_frame == NULL)
 424                     break;
 425
 426                 // Check the stack ID to make sure they are equal
 427                 if (curr_frame->GetStackID() != prev_frame->GetStackID())
 428                     break;
 429
 430                 prev_frame->UpdatePreviousFrameFromCurrentFrame (*curr_frame);
 431                 // Now copy the fixed up previous frame into the current frames
 432                 // so the pointer doesn't change
 433                 m_frames[curr_frame_idx] = prev_frame_sp;
 434                 //curr_frame->UpdateCurrentFrameFromPreviousFrame (*prev_frame);
 435
 436 #if defined (DEBUG_STACK_FRAMES)
 437                 s.Printf("\n    Copying previous frame to current frame");
 438 #endif
 439             }
 440             // We are done with the old stack frame list, we can release it now
 441             m_prev_frames_sp.reset();
 442         }
 443
 444 #if defined (DEBUG_STACK_FRAMES)
 445             s.PutCString("\n\nNew frames:\n");
 446             Dump (&s);
 447             s.EOL();
 448 #endif
 449     }
 450     else
 451     {
 452         if (end_idx < m_concrete_frames_fetched)
 453             return;
 454
 455         if (unwinder)
 456         {
 457             uint32_t num_frames = unwinder->GetFramesUpTo(end_idx);
 458             if (num_frames <= end_idx + 1)
 459             {
 460                 //Done unwinding.
 461                 m_concrete_frames_fetched = UINT32_MAX;
 462             }
 463             m_frames.resize(num_frames);
 464         }
 465     }
 466 }
 467
 468 uint32_t
 469 StackFrameList::GetNumFrames (bool can_create)
 470 {
 471     Mutex::Locker locker (m_mutex);
 472
 473     if (can_create)
 474         GetFramesUpTo (UINT32_MAX);
 475
 476     uint32_t inlined_depth = GetCurrentInlinedDepth();
 477     if (inlined_depth == UINT32_MAX)
 478         return m_frames.size();
 479     else
 480         return m_frames.size() - inlined_depth;
 481 }
 482
 483 void
 484 StackFrameList::Dump (Stream *s)
 485 {
 486     if (s == NULL)
 487         return;
 488     Mutex::Locker locker (m_mutex);
 489
 490     const_iterator pos, begin = m_frames.begin(), end = m_frames.end();
 491     for (pos = begin; pos != end; ++pos)
 492     {
 493         StackFrame *frame = (*pos).get();
 494         s->Printf("%p: ", static_cast<void*>(frame));
 495         if (frame)
 496         {
 497             frame->GetStackID().Dump (s);
 498             frame->DumpUsingSettingsFormat (s);
 499         }
 500         else
 501             s->Printf("frame #%u", (uint32_t)std::distance (begin, pos));
 502         s->EOL();
 503     }
 504     s->EOL();
 505 }
 506
 507 StackFrameSP
 508 StackFrameList::GetFrameAtIndex (uint32_t idx)
 509 {
 510     StackFrameSP frame_sp;
 511     Mutex::Locker locker (m_mutex);
 512     uint32_t original_idx = idx;
 513
 514     uint32_t inlined_depth = GetCurrentInlinedDepth();
 515     if (inlined_depth != UINT32_MAX)
 516         idx += inlined_depth;
 517
 518     if (idx < m_frames.size())
 519         frame_sp = m_frames[idx];
 520
 521     if (frame_sp)
 522         return frame_sp;
 523
 524     // GetFramesUpTo will fill m_frames with as many frames as you asked for,
 525     // if there are that many.  If there weren't then you asked for too many
 526     // frames.
 527     GetFramesUpTo (idx);
 528     if (idx < m_frames.size())
 529     {
 530         if (m_show_inlined_frames)
 531         {
 532             // When inline frames are enabled we actually create all the frames in GetFramesUpTo.
 533             frame_sp = m_frames[idx];
 534         }
 535         else
 536         {
 537             Unwind *unwinder = m_thread.GetUnwinder ();
 538             if (unwinder)
 539             {
 540                 addr_t pc, cfa;
 541                 if (unwinder->GetFrameInfoAtIndex(idx, cfa, pc))
 542                 {
 543                     const bool cfa_is_valid = true;
 544                     const bool stop_id_is_valid = false;
 545                     const bool is_history_frame = false;
 546                     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));
 547
 548                     Function *function = frame_sp->GetSymbolContext (eSymbolContextFunction).function;
 549                     if (function)
 550                     {
 551                         // When we aren't showing inline functions we always use
 552                         // the top most function block as the scope.
 553                         frame_sp->SetSymbolContextScope (&function->GetBlock(false));
 554                     }
 555                     else
 556                     {
 557                         // Set the symbol scope from the symbol regardless if it is NULL or valid.
 558                         frame_sp->SetSymbolContextScope (frame_sp->GetSymbolContext (eSymbolContextSymbol).symbol);
 559                     }
 560                     SetFrameAtIndex(idx, frame_sp);
 561                 }
 562             }
 563         }
 564     }
 565     else if (original_idx == 0)
 566     {
 567         // There should ALWAYS be a frame at index 0.  If something went wrong with the CurrentInlinedDepth such that
 568         // there weren't as many frames as we thought taking that into account, then reset the current inlined depth
 569         // and return the real zeroth frame.
 570         if (m_frames.size() > 0)
 571         {
 572             ResetCurrentInlinedDepth();
 573             frame_sp = m_frames[original_idx];
 574         }
 575         else
 576         {
 577             // Why do we have a thread with zero frames, that should not ever happen...
 578             if (m_thread.IsValid())
 579                 assert ("A valid thread has no frames.");
 580
 581         }
 582     }
 583
 584     return frame_sp;
 585 }
 586
 587 StackFrameSP
 588 StackFrameList::GetFrameWithConcreteFrameIndex (uint32_t unwind_idx)
 589 {
 590     // First try assuming the unwind index is the same as the frame index. The
 591     // unwind index is always greater than or equal to the frame index, so it
 592     // is a good place to start. If we have inlined frames we might have 5
 593     // concrete frames (frame unwind indexes go from 0-4), but we might have 15
 594     // frames after we make all the inlined frames. Most of the time the unwind
 595     // frame index (or the concrete frame index) is the same as the frame index.
 596     uint32_t frame_idx = unwind_idx;
 597     StackFrameSP frame_sp (GetFrameAtIndex (frame_idx));
 598     while (frame_sp)
 599     {
 600         if (frame_sp->GetFrameIndex() == unwind_idx)
 601             break;
 602         frame_sp = GetFrameAtIndex (++frame_idx);
 603     }
 604     return frame_sp;
 605 }
 606
 607 static bool
 608 CompareStackID (const StackFrameSP &stack_sp, const StackID &stack_id)
 609 {
 610     return stack_sp->GetStackID() < stack_id;
 611 }
 612
 613 StackFrameSP
 614 StackFrameList::GetFrameWithStackID (const StackID &stack_id)
 615 {
 616     StackFrameSP frame_sp;
 617
 618     if (stack_id.IsValid())
 619     {
 620         Mutex::Locker locker (m_mutex);
 621         uint32_t frame_idx = 0;
 622         // Do a binary search in case the stack frame is already in our cache
 623         collection::const_iterator begin = m_frames.begin();
 624         collection::const_iterator end = m_frames.end();
 625         if (begin != end)
 626         {
 627             collection::const_iterator pos = std::lower_bound (begin, end, stack_id, CompareStackID);
 628             if (pos != end)
 629             {
 630                 if ((*pos)->GetStackID() == stack_id)
 631                     return *pos;
 632             }
 633
 634 //            if (m_frames.back()->GetStackID() < stack_id)
 635 //                frame_idx = m_frames.size();
 636         }
 637         do
 638         {
 639             frame_sp = GetFrameAtIndex (frame_idx);
 640             if (frame_sp && frame_sp->GetStackID() == stack_id)
 641                 break;
 642             frame_idx++;
 643         }
 644         while (frame_sp);
 645     }
 646     return frame_sp;
 647 }
 648
 649 bool
 650 StackFrameList::SetFrameAtIndex (uint32_t idx, StackFrameSP &frame_sp)
 651 {
 652     if (idx >= m_frames.size())
 653         m_frames.resize(idx + 1);
 654     // Make sure allocation succeeded by checking bounds again
 655     if (idx < m_frames.size())
 656     {
 657         m_frames[idx] = frame_sp;
 658         return true;
 659     }
 660     return false;   // resize failed, out of memory?
 661 }
 662
 663 uint32_t
 664 StackFrameList::GetSelectedFrameIndex () const
 665 {
 666     Mutex::Locker locker (m_mutex);
 667     return m_selected_frame_idx;
 668 }
 669
 670
 671 uint32_t
 672 StackFrameList::SetSelectedFrame (lldb_private::StackFrame *frame)
 673 {
 674     Mutex::Locker locker (m_mutex);
 675     const_iterator pos;
 676     const_iterator begin = m_frames.begin();
 677     const_iterator end = m_frames.end();
 678     m_selected_frame_idx = 0;
 679     for (pos = begin; pos != end; ++pos)
 680     {
 681         if (pos->get() == frame)
 682         {
 683             m_selected_frame_idx = std::distance (begin, pos);
 684             uint32_t inlined_depth = GetCurrentInlinedDepth();
 685             if (inlined_depth != UINT32_MAX)
 686                 m_selected_frame_idx -= inlined_depth;
 687             break;
 688         }
 689     }
 690     SetDefaultFileAndLineToSelectedFrame();
 691     return m_selected_frame_idx;
 692 }
 693
 694 // Mark a stack frame as the current frame using the frame index
 695 bool
 696 StackFrameList::SetSelectedFrameByIndex (uint32_t idx)
 697 {
 698     Mutex::Locker locker (m_mutex);
 699     StackFrameSP frame_sp (GetFrameAtIndex (idx));
 700     if (frame_sp)
 701     {
 702         SetSelectedFrame(frame_sp.get());
 703         return true;
 704     }
 705     else
 706         return false;
 707 }
 708
 709 void
 710 StackFrameList::SetDefaultFileAndLineToSelectedFrame()
 711 {
 712     if (m_thread.GetID() == m_thread.GetProcess()->GetThreadList().GetSelectedThread()->GetID())
 713     {
 714         StackFrameSP frame_sp (GetFrameAtIndex (GetSelectedFrameIndex()));
 715         if (frame_sp)
 716         {
 717             SymbolContext sc = frame_sp->GetSymbolContext(eSymbolContextLineEntry);
 718             if (sc.line_entry.file)
 719                 m_thread.CalculateTarget()->GetSourceManager().SetDefaultFileAndLine (sc.line_entry.file,
 720                                                                                             sc.line_entry.line);
 721         }
 722     }
 723 }
 724
 725 // The thread has been run, reset the number stack frames to zero so we can
 726 // determine how many frames we have lazily.
 727 void
 728 StackFrameList::Clear ()
 729 {
 730     Mutex::Locker locker (m_mutex);
 731     m_frames.clear();
 732     m_concrete_frames_fetched = 0;
 733 }
 734
 735 void
 736 StackFrameList::InvalidateFrames (uint32_t start_idx)
 737 {
 738     Mutex::Locker locker (m_mutex);
 739     if (m_show_inlined_frames)
 740     {
 741         Clear();
 742     }
 743     else
 744     {
 745         const size_t num_frames = m_frames.size();
 746         while (start_idx < num_frames)
 747         {
 748             m_frames[start_idx].reset();
 749             ++start_idx;
 750         }
 751     }
 752 }
 753
 754 void
 755 StackFrameList::Merge (std::unique_ptr<StackFrameList>& curr_ap, lldb::StackFrameListSP& prev_sp)
 756 {
 757     Mutex::Locker curr_locker (curr_ap.get() ? &curr_ap->m_mutex : NULL);
 758     Mutex::Locker prev_locker (prev_sp.get() ? &prev_sp->m_mutex : NULL);
 759
 760 #if defined (DEBUG_STACK_FRAMES)
 761     StreamFile s(stdout, false);
 762     s.PutCString("\n\nStackFrameList::Merge():\nPrev:\n");
 763     if (prev_sp.get())
 764         prev_sp->Dump (&s);
 765     else
 766         s.PutCString ("NULL");
 767     s.PutCString("\nCurr:\n");
 768     if (curr_ap.get())
 769         curr_ap->Dump (&s);
 770     else
 771         s.PutCString ("NULL");
 772     s.EOL();
 773 #endif
 774
 775     if (curr_ap.get() == NULL || curr_ap->GetNumFrames (false) == 0)
 776     {
 777 #if defined (DEBUG_STACK_FRAMES)
 778         s.PutCString("No current frames, leave previous frames alone...\n");
 779 #endif
 780         curr_ap.release();
 781         return;
 782     }
 783
 784     if (prev_sp.get() == NULL || prev_sp->GetNumFrames (false) == 0)
 785     {
 786 #if defined (DEBUG_STACK_FRAMES)
 787         s.PutCString("No previous frames, so use current frames...\n");
 788 #endif
 789         // We either don't have any previous frames, or since we have more than
 790         // one current frames it means we have all the frames and can safely
 791         // replace our previous frames.
 792         prev_sp.reset (curr_ap.release());
 793         return;
 794     }
 795
 796     const uint32_t num_curr_frames = curr_ap->GetNumFrames (false);
 797
 798     if (num_curr_frames > 1)
 799     {
 800 #if defined (DEBUG_STACK_FRAMES)
 801         s.PutCString("We have more than one current frame, so use current frames...\n");
 802 #endif
 803         // We have more than one current frames it means we have all the frames
 804         // and can safely replace our previous frames.
 805         prev_sp.reset (curr_ap.release());
 806
 807 #if defined (DEBUG_STACK_FRAMES)
 808         s.PutCString("\nMerged:\n");
 809         prev_sp->Dump (&s);
 810 #endif
 811         return;
 812     }
 813
 814     StackFrameSP prev_frame_zero_sp(prev_sp->GetFrameAtIndex (0));
 815     StackFrameSP curr_frame_zero_sp(curr_ap->GetFrameAtIndex (0));
 816     StackID curr_stack_id (curr_frame_zero_sp->GetStackID());
 817     StackID prev_stack_id (prev_frame_zero_sp->GetStackID());
 818
 819 #if defined (DEBUG_STACK_FRAMES)
 820     const uint32_t num_prev_frames = prev_sp->GetNumFrames (false);
 821     s.Printf("\n%u previous frames with one current frame\n", num_prev_frames);
 822 #endif
 823
 824     // We have only a single current frame
 825     // Our previous stack frames only had a single frame as well...
 826     if (curr_stack_id == prev_stack_id)
 827     {
 828 #if defined (DEBUG_STACK_FRAMES)
 829         s.Printf("\nPrevious frame #0 is same as current frame #0, merge the cached data\n");
 830 #endif
 831
 832         curr_frame_zero_sp->UpdateCurrentFrameFromPreviousFrame (*prev_frame_zero_sp);
 833 //        prev_frame_zero_sp->UpdatePreviousFrameFromCurrentFrame (*curr_frame_zero_sp);
 834 //        prev_sp->SetFrameAtIndex (0, prev_frame_zero_sp);
 835     }
 836     else if (curr_stack_id < prev_stack_id)
 837     {
 838 #if defined (DEBUG_STACK_FRAMES)
 839         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");
 840 #endif
 841         prev_sp->m_frames.insert (prev_sp->m_frames.begin(), curr_frame_zero_sp);
 842     }
 843
 844     curr_ap.release();
 845
 846 #if defined (DEBUG_STACK_FRAMES)
 847     s.PutCString("\nMerged:\n");
 848     prev_sp->Dump (&s);
 849 #endif
 850
 851
 852 }
 853
 854 lldb::StackFrameSP
 855 StackFrameList::GetStackFrameSPForStackFramePtr (StackFrame *stack_frame_ptr)
 856 {
 857     const_iterator pos;
 858     const_iterator begin = m_frames.begin();
 859     const_iterator end = m_frames.end();
 860     lldb::StackFrameSP ret_sp;
 861
 862     for (pos = begin; pos != end; ++pos)
 863     {
 864         if (pos->get() == stack_frame_ptr)
 865         {
 866             ret_sp = (*pos);
 867             break;
 868         }
 869     }
 870     return ret_sp;
 871 }
 872
 873 size_t
 874 StackFrameList::GetStatus (Stream& strm,
 875                            uint32_t first_frame,
 876                            uint32_t num_frames,
 877                            bool show_frame_info,
 878                            uint32_t num_frames_with_source,
 879                            const char *selected_frame_marker)
 880 {
 881     size_t num_frames_displayed = 0;
 882
 883     if (num_frames == 0)
 884         return 0;
 885
 886     StackFrameSP frame_sp;
 887     uint32_t frame_idx = 0;
 888     uint32_t last_frame;
 889
 890     // Don't let the last frame wrap around...
 891     if (num_frames == UINT32_MAX)
 892         last_frame = UINT32_MAX;
 893     else
 894         last_frame = first_frame + num_frames;
 895
 896     StackFrameSP selected_frame_sp = m_thread.GetSelectedFrame();
 897     const char *unselected_marker = NULL;
 898     std::string buffer;
 899     if (selected_frame_marker)
 900     {
 901         size_t len = strlen(selected_frame_marker);
 902         buffer.insert(buffer.begin(), len, ' ');
 903         unselected_marker = buffer.c_str();
 904     }
 905     const char *marker = NULL;
 906
 907     for (frame_idx = first_frame; frame_idx < last_frame; ++frame_idx)
 908     {
 909         frame_sp = GetFrameAtIndex(frame_idx);
 910         if (frame_sp.get() == NULL)
 911             break;
 912
 913         if (selected_frame_marker != NULL)
 914         {
 915             if (frame_sp == selected_frame_sp)
 916                 marker = selected_frame_marker;
 917             else
 918                 marker = unselected_marker;
 919         }
 920
 921         if (!frame_sp->GetStatus (strm,
 922                                   show_frame_info,
 923                                   num_frames_with_source > (first_frame - frame_idx), marker))
 924             break;
 925         ++num_frames_displayed;
 926     }
 927
 928     strm.IndentLess();
 929     return num_frames_displayed;
 930 }
 931