//===-- StackFrameList.cpp --------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Target/StackFrameList.h"
#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/SourceManager.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Symbol/Block.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/Unwind.h"
#include "lldb/Utility/Log.h"

//#define DEBUG_STACK_FRAMES 1

using namespace lldb;
using namespace lldb_private;

//----------------------------------------------------------------------
// StackFrameList constructor
//----------------------------------------------------------------------
StackFrameList::StackFrameList(Thread &thread,
                               const lldb::StackFrameListSP &prev_frames_sp,
                               bool show_inline_frames)
    : m_thread(thread), m_prev_frames_sp(prev_frames_sp), m_mutex(), m_frames(),
      m_selected_frame_idx(0), m_concrete_frames_fetched(0),
      m_current_inlined_depth(UINT32_MAX),
      m_current_inlined_pc(LLDB_INVALID_ADDRESS),
      m_show_inlined_frames(show_inline_frames) {
  if (prev_frames_sp) {
    m_current_inlined_depth = prev_frames_sp->m_current_inlined_depth;
    m_current_inlined_pc = prev_frames_sp->m_current_inlined_pc;
  }
}

StackFrameList::~StackFrameList() {
  // Call clear since this takes a lock and clears the stack frame list
  // in case another thread is currently using this stack frame list
  Clear();
}

void StackFrameList::CalculateCurrentInlinedDepth() {
  uint32_t cur_inlined_depth = GetCurrentInlinedDepth();
  if (cur_inlined_depth == UINT32_MAX) {
    ResetCurrentInlinedDepth();
  }
}

uint32_t StackFrameList::GetCurrentInlinedDepth() {
  if (m_show_inlined_frames && m_current_inlined_pc != LLDB_INVALID_ADDRESS) {
    lldb::addr_t cur_pc = m_thread.GetRegisterContext()->GetPC();
    if (cur_pc != m_current_inlined_pc) {
      m_current_inlined_pc = LLDB_INVALID_ADDRESS;
      m_current_inlined_depth = UINT32_MAX;
      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
      if (log && log->GetVerbose())
        log->Printf(
            "GetCurrentInlinedDepth: invalidating current inlined depth.\n");
    }
    return m_current_inlined_depth;
  } else {
    return UINT32_MAX;
  }
}

void StackFrameList::ResetCurrentInlinedDepth() {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);

  if (m_show_inlined_frames) {
    GetFramesUpTo(0);
    if (m_frames.empty())
      return;
    if (!m_frames[0]->IsInlined()) {
      m_current_inlined_depth = UINT32_MAX;
      m_current_inlined_pc = LLDB_INVALID_ADDRESS;
      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
      if (log && log->GetVerbose())
        log->Printf(
            "ResetCurrentInlinedDepth: Invalidating current inlined depth.\n");
    } else {
      // We only need to do something special about inlined blocks when we
      // are at the beginning of an inlined function:
      // FIXME: We probably also have to do something special if the PC is at
      // the END
      // of an inlined function, which coincides with the end of either its
      // containing
      // function or another inlined function.

      lldb::addr_t curr_pc = m_thread.GetRegisterContext()->GetPC();
      Block *block_ptr = m_frames[0]->GetFrameBlock();
      if (block_ptr) {
        Address pc_as_address;
        pc_as_address.SetLoadAddress(curr_pc,
                                     &(m_thread.GetProcess()->GetTarget()));
        AddressRange containing_range;
        if (block_ptr->GetRangeContainingAddress(pc_as_address,
                                                 containing_range)) {
          if (pc_as_address == containing_range.GetBaseAddress()) {
            // If we got here because of a breakpoint hit, then set the inlined
            // depth depending on where
            // the breakpoint was set.
            // If we got here because of a crash, then set the inlined depth to
            // the deepest most block.
            // Otherwise, we stopped here naturally as the result of a step, so
            // set ourselves in the
            // containing frame of the whole set of nested inlines, so the user
            // can then "virtually"
            // step into the frames one by one, or next over the whole mess.
            // Note: We don't have to handle being somewhere in the middle of
            // the stack here, since
            // ResetCurrentInlinedDepth doesn't get called if there is a valid
            // inlined depth set.
            StopInfoSP stop_info_sp = m_thread.GetStopInfo();
            if (stop_info_sp) {
              switch (stop_info_sp->GetStopReason()) {
              case eStopReasonWatchpoint:
              case eStopReasonException:
              case eStopReasonExec:
              case eStopReasonSignal:
                // In all these cases we want to stop in the deepest most frame.
                m_current_inlined_pc = curr_pc;
                m_current_inlined_depth = 0;
                break;
              case eStopReasonBreakpoint: {
                // FIXME: Figure out what this break point is doing, and set the
                // inline depth
                // appropriately.  Be careful to take into account breakpoints
                // that implement
                // step over prologue, since that should do the default
                // calculation.
                // For now, if the breakpoints corresponding to this hit are all
                // internal,
                // I set the stop location to the top of the inlined stack,
                // since that will make
                // things like stepping over prologues work right.  But if there
                // are any non-internal
                // breakpoints I do to the bottom of the stack, since that was
                // the old behavior.
                uint32_t bp_site_id = stop_info_sp->GetValue();
                BreakpointSiteSP bp_site_sp(
                    m_thread.GetProcess()->GetBreakpointSiteList().FindByID(
                        bp_site_id));
                bool all_internal = true;
                if (bp_site_sp) {
                  uint32_t num_owners = bp_site_sp->GetNumberOfOwners();
                  for (uint32_t i = 0; i < num_owners; i++) {
                    Breakpoint &bp_ref =
                        bp_site_sp->GetOwnerAtIndex(i)->GetBreakpoint();
                    if (!bp_ref.IsInternal()) {
                      all_internal = false;
                    }
                  }
                }
                if (!all_internal) {
                  m_current_inlined_pc = curr_pc;
                  m_current_inlined_depth = 0;
                  break;
                }
              }
                LLVM_FALLTHROUGH;
              default: {
                // Otherwise, we should set ourselves at the container of the
                // inlining, so that the
                // user can descend into them.
                // So first we check whether we have more than one inlined block
                // sharing this PC:
                int num_inlined_functions = 0;

                for (Block *container_ptr = block_ptr->GetInlinedParent();
                     container_ptr != nullptr;
                     container_ptr = container_ptr->GetInlinedParent()) {
                  if (!container_ptr->GetRangeContainingAddress(
                          pc_as_address, containing_range))
                    break;
                  if (pc_as_address != containing_range.GetBaseAddress())
                    break;

                  num_inlined_functions++;
                }
                m_current_inlined_pc = curr_pc;
                m_current_inlined_depth = num_inlined_functions + 1;
                Log *log(
                    lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
                if (log && log->GetVerbose())
                  log->Printf("ResetCurrentInlinedDepth: setting inlined "
                              "depth: %d 0x%" PRIx64 ".\n",
                              m_current_inlined_depth, curr_pc);

              } break;
              }
            }
          }
        }
      }
    }
  }
}

bool StackFrameList::DecrementCurrentInlinedDepth() {
  if (m_show_inlined_frames) {
    uint32_t current_inlined_depth = GetCurrentInlinedDepth();
    if (current_inlined_depth != UINT32_MAX) {
      if (current_inlined_depth > 0) {
        m_current_inlined_depth--;
        return true;
      }
    }
  }
  return false;
}

void StackFrameList::SetCurrentInlinedDepth(uint32_t new_depth) {
  m_current_inlined_depth = new_depth;
  if (new_depth == UINT32_MAX)
    m_current_inlined_pc = LLDB_INVALID_ADDRESS;
  else
    m_current_inlined_pc = m_thread.GetRegisterContext()->GetPC();
}

void StackFrameList::GetFramesUpTo(uint32_t end_idx) {
  // this makes sure we do not fetch frames for an invalid thread
  if (!m_thread.IsValid())
    return;

  // We've already gotten more frames than asked for, or we've already finished
  // unwinding, return.
  if (m_frames.size() > end_idx || GetAllFramesFetched())
    return;

  Unwind *unwinder = m_thread.GetUnwinder();

  if (m_show_inlined_frames) {
#if defined(DEBUG_STACK_FRAMES)
    StreamFile s(stdout, false);
#endif
    // If we are hiding some frames from the outside world, we need to add those
    // onto the total count of
    // frames to fetch.  However, we don't need to do that if end_idx is 0 since
    // in that case we always
    // get the first concrete frame and all the inlined frames below it...  And
    // of course, if end_idx is
    // UINT32_MAX that means get all, so just do that...

    uint32_t inlined_depth = 0;
    if (end_idx > 0 && end_idx != UINT32_MAX) {
      inlined_depth = GetCurrentInlinedDepth();
      if (inlined_depth != UINT32_MAX) {
        if (end_idx > 0)
          end_idx += inlined_depth;
      }
    }

    StackFrameSP unwind_frame_sp;
    do {
      uint32_t idx = m_concrete_frames_fetched++;
      lldb::addr_t pc = LLDB_INVALID_ADDRESS;
      lldb::addr_t cfa = LLDB_INVALID_ADDRESS;
      if (idx == 0) {
        // We might have already created frame zero, only create it
        // if we need to
        if (m_frames.empty()) {
          RegisterContextSP reg_ctx_sp(m_thread.GetRegisterContext());

          if (reg_ctx_sp) {
            const bool success =
                unwinder && unwinder->GetFrameInfoAtIndex(idx, cfa, pc);
            // There shouldn't be any way not to get the frame info for frame 0.
            // But if the unwinder can't make one, lets make one by hand with
            // the
            // SP as the CFA and see if that gets any further.
            if (!success) {
              cfa = reg_ctx_sp->GetSP();
              pc = reg_ctx_sp->GetPC();
            }

            unwind_frame_sp.reset(new StackFrame(m_thread.shared_from_this(),
                                                 m_frames.size(), idx,
                                                 reg_ctx_sp, cfa, pc, nullptr));
            m_frames.push_back(unwind_frame_sp);
          }
        } else {
          unwind_frame_sp = m_frames.front();
          cfa = unwind_frame_sp->m_id.GetCallFrameAddress();
        }
      } else {
        const bool success =
            unwinder && unwinder->GetFrameInfoAtIndex(idx, cfa, pc);
        if (!success) {
          // We've gotten to the end of the stack.
          SetAllFramesFetched();
          break;
        }
        const bool cfa_is_valid = true;
        const bool stop_id_is_valid = false;
        const bool is_history_frame = false;
        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, nullptr));
        m_frames.push_back(unwind_frame_sp);
      }

      assert(unwind_frame_sp);
      SymbolContext unwind_sc = unwind_frame_sp->GetSymbolContext(
          eSymbolContextBlock | eSymbolContextFunction);
      Block *unwind_block = unwind_sc.block;
      if (unwind_block) {
        Address curr_frame_address(unwind_frame_sp->GetFrameCodeAddress());
        TargetSP target_sp = m_thread.CalculateTarget();
        // Be sure to adjust the frame address to match the address
        // that was used to lookup the symbol context above. If we are
        // in the first concrete frame, then we lookup using the current
        // address, else we decrement the address by one to get the correct
        // location.
        if (idx > 0) {
          if (curr_frame_address.GetOffset() == 0) {
            // If curr_frame_address points to the first address in a section
            // then after
            // adjustment it will point to an other section. In that case
            // resolve the
            // address again to the correct section plus offset form.
            addr_t load_addr = curr_frame_address.GetOpcodeLoadAddress(
                target_sp.get(), eAddressClassCode);
            curr_frame_address.SetOpcodeLoadAddress(
                load_addr - 1, target_sp.get(), eAddressClassCode);
          } else {
            curr_frame_address.Slide(-1);
          }
        }

        SymbolContext next_frame_sc;
        Address next_frame_address;

        while (unwind_sc.GetParentOfInlinedScope(
            curr_frame_address, next_frame_sc, next_frame_address)) {
          next_frame_sc.line_entry.ApplyFileMappings(target_sp);
          StackFrameSP frame_sp(
              new StackFrame(m_thread.shared_from_this(), m_frames.size(), idx,
                             unwind_frame_sp->GetRegisterContextSP(), cfa,
                             next_frame_address, &next_frame_sc));

          m_frames.push_back(frame_sp);
          unwind_sc = next_frame_sc;
          curr_frame_address = next_frame_address;
        }
      }
    } while (m_frames.size() - 1 < end_idx);

    // Don't try to merge till you've calculated all the frames in this stack.
    if (GetAllFramesFetched() && m_prev_frames_sp) {
      StackFrameList *prev_frames = m_prev_frames_sp.get();
      StackFrameList *curr_frames = this;

// curr_frames->m_current_inlined_depth = prev_frames->m_current_inlined_depth;
// curr_frames->m_current_inlined_pc = prev_frames->m_current_inlined_pc;
// printf ("GetFramesUpTo: Copying current inlined depth: %d 0x%" PRIx64 ".\n",
// curr_frames->m_current_inlined_depth, curr_frames->m_current_inlined_pc);

#if defined(DEBUG_STACK_FRAMES)
      s.PutCString("\nprev_frames:\n");
      prev_frames->Dump(&s);
      s.PutCString("\ncurr_frames:\n");
      curr_frames->Dump(&s);
      s.EOL();
#endif
      size_t curr_frame_num, prev_frame_num;

      for (curr_frame_num = curr_frames->m_frames.size(),
          prev_frame_num = prev_frames->m_frames.size();
           curr_frame_num > 0 && prev_frame_num > 0;
           --curr_frame_num, --prev_frame_num) {
        const size_t curr_frame_idx = curr_frame_num - 1;
        const size_t prev_frame_idx = prev_frame_num - 1;
        StackFrameSP curr_frame_sp(curr_frames->m_frames[curr_frame_idx]);
        StackFrameSP prev_frame_sp(prev_frames->m_frames[prev_frame_idx]);

#if defined(DEBUG_STACK_FRAMES)
        s.Printf("\n\nCurr frame #%u ", curr_frame_idx);
        if (curr_frame_sp)
          curr_frame_sp->Dump(&s, true, false);
        else
          s.PutCString("NULL");
        s.Printf("\nPrev frame #%u ", prev_frame_idx);
        if (prev_frame_sp)
          prev_frame_sp->Dump(&s, true, false);
        else
          s.PutCString("NULL");
#endif

        StackFrame *curr_frame = curr_frame_sp.get();
        StackFrame *prev_frame = prev_frame_sp.get();

        if (curr_frame == nullptr || prev_frame == nullptr)
          break;

        // Check the stack ID to make sure they are equal
        if (curr_frame->GetStackID() != prev_frame->GetStackID())
          break;

        prev_frame->UpdatePreviousFrameFromCurrentFrame(*curr_frame);
        // Now copy the fixed up previous frame into the current frames
        // so the pointer doesn't change
        m_frames[curr_frame_idx] = prev_frame_sp;
// curr_frame->UpdateCurrentFrameFromPreviousFrame (*prev_frame);

#if defined(DEBUG_STACK_FRAMES)
        s.Printf("\n    Copying previous frame to current frame");
#endif
      }
      // We are done with the old stack frame list, we can release it now
      m_prev_frames_sp.reset();
    }

#if defined(DEBUG_STACK_FRAMES)
    s.PutCString("\n\nNew frames:\n");
    Dump(&s);
    s.EOL();
#endif
  } else {
    if (end_idx < m_concrete_frames_fetched)
      return;

    if (unwinder) {
      uint32_t num_frames = unwinder->GetFramesUpTo(end_idx);
      if (num_frames <= end_idx + 1) {
        // Done unwinding.
        m_concrete_frames_fetched = UINT32_MAX;
      }
      m_frames.resize(num_frames);
    }
  }
}

uint32_t StackFrameList::GetNumFrames(bool can_create) {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);

  if (can_create)
    GetFramesUpTo(UINT32_MAX);

  uint32_t inlined_depth = GetCurrentInlinedDepth();
  if (inlined_depth == UINT32_MAX)
    return m_frames.size();
  else
    return m_frames.size() - inlined_depth;
}

void StackFrameList::Dump(Stream *s) {
  if (s == nullptr)
    return;

  std::lock_guard<std::recursive_mutex> guard(m_mutex);

  const_iterator pos, begin = m_frames.begin(), end = m_frames.end();
  for (pos = begin; pos != end; ++pos) {
    StackFrame *frame = (*pos).get();
    s->Printf("%p: ", static_cast<void *>(frame));
    if (frame) {
      frame->GetStackID().Dump(s);
      frame->DumpUsingSettingsFormat(s);
    } else
      s->Printf("frame #%u", (uint32_t)std::distance(begin, pos));
    s->EOL();
  }
  s->EOL();
}

StackFrameSP StackFrameList::GetFrameAtIndex(uint32_t idx) {
  StackFrameSP frame_sp;
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  uint32_t original_idx = idx;

  uint32_t inlined_depth = GetCurrentInlinedDepth();
  if (inlined_depth != UINT32_MAX)
    idx += inlined_depth;

  if (idx < m_frames.size())
    frame_sp = m_frames[idx];

  if (frame_sp)
    return frame_sp;

  // GetFramesUpTo will fill m_frames with as many frames as you asked for,
  // if there are that many.  If there weren't then you asked for too many
  // frames.
  GetFramesUpTo(idx);
  if (idx < m_frames.size()) {
    if (m_show_inlined_frames) {
      // When inline frames are enabled we actually create all the frames in
      // GetFramesUpTo.
      frame_sp = m_frames[idx];
    } else {
      Unwind *unwinder = m_thread.GetUnwinder();
      if (unwinder) {
        addr_t pc, cfa;
        if (unwinder->GetFrameInfoAtIndex(idx, cfa, pc)) {
          const bool cfa_is_valid = true;
          const bool stop_id_is_valid = false;
          const bool is_history_frame = false;
          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, nullptr));

          Function *function =
              frame_sp->GetSymbolContext(eSymbolContextFunction).function;
          if (function) {
            // When we aren't showing inline functions we always use
            // the top most function block as the scope.
            frame_sp->SetSymbolContextScope(&function->GetBlock(false));
          } else {
            // Set the symbol scope from the symbol regardless if it is nullptr
            // or valid.
            frame_sp->SetSymbolContextScope(
                frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol);
          }
          SetFrameAtIndex(idx, frame_sp);
        }
      }
    }
  } else if (original_idx == 0) {
    // There should ALWAYS be a frame at index 0.  If something went wrong with
    // the CurrentInlinedDepth such that
    // there weren't as many frames as we thought taking that into account, then
    // reset the current inlined depth
    // and return the real zeroth frame.
    if (m_frames.empty()) {
      // Why do we have a thread with zero frames, that should not ever
      // happen...
      assert(!m_thread.IsValid() && "A valid thread has no frames.");
    } else {
      ResetCurrentInlinedDepth();
      frame_sp = m_frames[original_idx];
    }
  }

  return frame_sp;
}

StackFrameSP
StackFrameList::GetFrameWithConcreteFrameIndex(uint32_t unwind_idx) {
  // First try assuming the unwind index is the same as the frame index. The
  // unwind index is always greater than or equal to the frame index, so it
  // is a good place to start. If we have inlined frames we might have 5
  // concrete frames (frame unwind indexes go from 0-4), but we might have 15
  // frames after we make all the inlined frames. Most of the time the unwind
  // frame index (or the concrete frame index) is the same as the frame index.
  uint32_t frame_idx = unwind_idx;
  StackFrameSP frame_sp(GetFrameAtIndex(frame_idx));
  while (frame_sp) {
    if (frame_sp->GetFrameIndex() == unwind_idx)
      break;
    frame_sp = GetFrameAtIndex(++frame_idx);
  }
  return frame_sp;
}

static bool CompareStackID(const StackFrameSP &stack_sp,
                           const StackID &stack_id) {
  return stack_sp->GetStackID() < stack_id;
}

StackFrameSP StackFrameList::GetFrameWithStackID(const StackID &stack_id) {
  StackFrameSP frame_sp;

  if (stack_id.IsValid()) {
    std::lock_guard<std::recursive_mutex> guard(m_mutex);
    uint32_t frame_idx = 0;
    // Do a binary search in case the stack frame is already in our cache
    collection::const_iterator begin = m_frames.begin();
    collection::const_iterator end = m_frames.end();
    if (begin != end) {
      collection::const_iterator pos =
          std::lower_bound(begin, end, stack_id, CompareStackID);
      if (pos != end) {
        if ((*pos)->GetStackID() == stack_id)
          return *pos;
      }

      //            if (m_frames.back()->GetStackID() < stack_id)
      //                frame_idx = m_frames.size();
    }
    do {
      frame_sp = GetFrameAtIndex(frame_idx);
      if (frame_sp && frame_sp->GetStackID() == stack_id)
        break;
      frame_idx++;
    } while (frame_sp);
  }
  return frame_sp;
}

bool StackFrameList::SetFrameAtIndex(uint32_t idx, StackFrameSP &frame_sp) {
  if (idx >= m_frames.size())
    m_frames.resize(idx + 1);
  // Make sure allocation succeeded by checking bounds again
  if (idx < m_frames.size()) {
    m_frames[idx] = frame_sp;
    return true;
  }
  return false; // resize failed, out of memory?
}

uint32_t StackFrameList::GetSelectedFrameIndex() const {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  return m_selected_frame_idx;
}

uint32_t StackFrameList::SetSelectedFrame(lldb_private::StackFrame *frame) {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  const_iterator pos;
  const_iterator begin = m_frames.begin();
  const_iterator end = m_frames.end();
  m_selected_frame_idx = 0;
  for (pos = begin; pos != end; ++pos) {
    if (pos->get() == frame) {
      m_selected_frame_idx = std::distance(begin, pos);
      uint32_t inlined_depth = GetCurrentInlinedDepth();
      if (inlined_depth != UINT32_MAX)
        m_selected_frame_idx -= inlined_depth;
      break;
    }
  }
  SetDefaultFileAndLineToSelectedFrame();
  return m_selected_frame_idx;
}

// Mark a stack frame as the current frame using the frame index
bool StackFrameList::SetSelectedFrameByIndex(uint32_t idx) {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  StackFrameSP frame_sp(GetFrameAtIndex(idx));
  if (frame_sp) {
    SetSelectedFrame(frame_sp.get());
    return true;
  } else
    return false;
}

void StackFrameList::SetDefaultFileAndLineToSelectedFrame() {
  if (m_thread.GetID() ==
      m_thread.GetProcess()->GetThreadList().GetSelectedThread()->GetID()) {
    StackFrameSP frame_sp(GetFrameAtIndex(GetSelectedFrameIndex()));
    if (frame_sp) {
      SymbolContext sc = frame_sp->GetSymbolContext(eSymbolContextLineEntry);
      if (sc.line_entry.file)
        m_thread.CalculateTarget()->GetSourceManager().SetDefaultFileAndLine(
            sc.line_entry.file, sc.line_entry.line);
    }
  }
}

// The thread has been run, reset the number stack frames to zero so we can
// determine how many frames we have lazily.
void StackFrameList::Clear() {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  m_frames.clear();
  m_concrete_frames_fetched = 0;
}

void StackFrameList::InvalidateFrames(uint32_t start_idx) {
  std::lock_guard<std::recursive_mutex> guard(m_mutex);
  if (m_show_inlined_frames) {
    Clear();
  } else {
    const size_t num_frames = m_frames.size();
    while (start_idx < num_frames) {
      m_frames[start_idx].reset();
      ++start_idx;
    }
  }
}

void StackFrameList::Merge(std::unique_ptr<StackFrameList> &curr_ap,
                           lldb::StackFrameListSP &prev_sp) {
  std::unique_lock<std::recursive_mutex> current_lock, previous_lock;
  if (curr_ap)
    current_lock = std::unique_lock<std::recursive_mutex>(curr_ap->m_mutex);
  if (prev_sp)
    previous_lock = std::unique_lock<std::recursive_mutex>(prev_sp->m_mutex);

#if defined(DEBUG_STACK_FRAMES)
  StreamFile s(stdout, false);
  s.PutCString("\n\nStackFrameList::Merge():\nPrev:\n");
  if (prev_sp)
    prev_sp->Dump(&s);
  else
    s.PutCString("NULL");
  s.PutCString("\nCurr:\n");
  if (curr_ap)
    curr_ap->Dump(&s);
  else
    s.PutCString("NULL");
  s.EOL();
#endif

  if (!curr_ap || curr_ap->GetNumFrames(false) == 0) {
#if defined(DEBUG_STACK_FRAMES)
    s.PutCString("No current frames, leave previous frames alone...\n");
#endif
    curr_ap.release();
    return;
  }

  if (!prev_sp || prev_sp->GetNumFrames(false) == 0) {
#if defined(DEBUG_STACK_FRAMES)
    s.PutCString("No previous frames, so use current frames...\n");
#endif
    // We either don't have any previous frames, or since we have more than
    // one current frames it means we have all the frames and can safely
    // replace our previous frames.
    prev_sp.reset(curr_ap.release());
    return;
  }

  const uint32_t num_curr_frames = curr_ap->GetNumFrames(false);

  if (num_curr_frames > 1) {
#if defined(DEBUG_STACK_FRAMES)
    s.PutCString(
        "We have more than one current frame, so use current frames...\n");
#endif
    // We have more than one current frames it means we have all the frames
    // and can safely replace our previous frames.
    prev_sp.reset(curr_ap.release());

#if defined(DEBUG_STACK_FRAMES)
    s.PutCString("\nMerged:\n");
    prev_sp->Dump(&s);
#endif
    return;
  }

  StackFrameSP prev_frame_zero_sp(prev_sp->GetFrameAtIndex(0));
  StackFrameSP curr_frame_zero_sp(curr_ap->GetFrameAtIndex(0));
  StackID curr_stack_id(curr_frame_zero_sp->GetStackID());
  StackID prev_stack_id(prev_frame_zero_sp->GetStackID());

#if defined(DEBUG_STACK_FRAMES)
  const uint32_t num_prev_frames = prev_sp->GetNumFrames(false);
  s.Printf("\n%u previous frames with one current frame\n", num_prev_frames);
#endif

  // We have only a single current frame
  // Our previous stack frames only had a single frame as well...
  if (curr_stack_id == prev_stack_id) {
#if defined(DEBUG_STACK_FRAMES)
    s.Printf("\nPrevious frame #0 is same as current frame #0, merge the "
             "cached data\n");
#endif

    curr_frame_zero_sp->UpdateCurrentFrameFromPreviousFrame(
        *prev_frame_zero_sp);
    //        prev_frame_zero_sp->UpdatePreviousFrameFromCurrentFrame
    //        (*curr_frame_zero_sp);
    //        prev_sp->SetFrameAtIndex (0, prev_frame_zero_sp);
  } else if (curr_stack_id < prev_stack_id) {
#if defined(DEBUG_STACK_FRAMES)
    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");
#endif
    prev_sp->m_frames.insert(prev_sp->m_frames.begin(), curr_frame_zero_sp);
  }

  curr_ap.release();

#if defined(DEBUG_STACK_FRAMES)
  s.PutCString("\nMerged:\n");
  prev_sp->Dump(&s);
#endif
}

lldb::StackFrameSP
StackFrameList::GetStackFrameSPForStackFramePtr(StackFrame *stack_frame_ptr) {
  const_iterator pos;
  const_iterator begin = m_frames.begin();
  const_iterator end = m_frames.end();
  lldb::StackFrameSP ret_sp;

  for (pos = begin; pos != end; ++pos) {
    if (pos->get() == stack_frame_ptr) {
      ret_sp = (*pos);
      break;
    }
  }
  return ret_sp;
}

size_t StackFrameList::GetStatus(Stream &strm, uint32_t first_frame,
                                 uint32_t num_frames, bool show_frame_info,
                                 uint32_t num_frames_with_source,
                                 bool show_unique,
                                 const char *selected_frame_marker) {
  size_t num_frames_displayed = 0;

  if (num_frames == 0)
    return 0;

  StackFrameSP frame_sp;
  uint32_t frame_idx = 0;
  uint32_t last_frame;

  // Don't let the last frame wrap around...
  if (num_frames == UINT32_MAX)
    last_frame = UINT32_MAX;
  else
    last_frame = first_frame + num_frames;

  StackFrameSP selected_frame_sp = m_thread.GetSelectedFrame();
  const char *unselected_marker = nullptr;
  std::string buffer;
  if (selected_frame_marker) {
    size_t len = strlen(selected_frame_marker);
    buffer.insert(buffer.begin(), len, ' ');
    unselected_marker = buffer.c_str();
  }
  const char *marker = nullptr;

  for (frame_idx = first_frame; frame_idx < last_frame; ++frame_idx) {
    frame_sp = GetFrameAtIndex(frame_idx);
    if (!frame_sp)
      break;

    if (selected_frame_marker != nullptr) {
      if (frame_sp == selected_frame_sp)
        marker = selected_frame_marker;
      else
        marker = unselected_marker;
    }

    if (!frame_sp->GetStatus(strm, show_frame_info,
                             num_frames_with_source > (first_frame - frame_idx),
                             show_unique, marker))
      break;
    ++num_frames_displayed;
  }

  strm.IndentLess();
  return num_frames_displayed;
}