forked from OSchip/llvm-project
136 lines
3.3 KiB
C++
136 lines
3.3 KiB
C++
//===-- 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/Target/StackFrame.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
//----------------------------------------------------------------------
|
|
// StackFrameList constructor
|
|
//----------------------------------------------------------------------
|
|
StackFrameList::StackFrameList() :
|
|
m_mutex (Mutex::eMutexTypeRecursive),
|
|
m_frames (),
|
|
m_current_frame_idx (0)
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Destructor
|
|
//----------------------------------------------------------------------
|
|
StackFrameList::~StackFrameList()
|
|
{
|
|
}
|
|
|
|
|
|
uint32_t
|
|
StackFrameList::GetNumFrames() const
|
|
{
|
|
Mutex::Locker locker (m_mutex);
|
|
return m_frames.size();
|
|
}
|
|
|
|
// After we have determined the number of frames, we can set the count here
|
|
// and have the frame info be generated on demand.
|
|
void
|
|
StackFrameList::SetNumFrames(uint32_t count)
|
|
{
|
|
Mutex::Locker locker (m_mutex);
|
|
return m_frames.resize(count);
|
|
}
|
|
|
|
StackFrameSP
|
|
StackFrameList::GetFrameAtIndex (uint32_t idx) const
|
|
{
|
|
StackFrameSP frame_sp;
|
|
{
|
|
Mutex::Locker locker (m_mutex);
|
|
if (idx < m_frames.size())
|
|
frame_sp = m_frames[idx];
|
|
}
|
|
return frame_sp;
|
|
}
|
|
|
|
bool
|
|
StackFrameList::SetFrameAtIndex (uint32_t idx, StackFrameSP &frame_sp)
|
|
{
|
|
Mutex::Locker locker (m_mutex);
|
|
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::GetCurrentFrameIndex () const
|
|
{
|
|
Mutex::Locker locker (m_mutex);
|
|
return m_current_frame_idx;
|
|
}
|
|
|
|
|
|
uint32_t
|
|
StackFrameList::SetCurrentFrame (lldb_private::StackFrame *frame)
|
|
{
|
|
Mutex::Locker locker (m_mutex);
|
|
const_iterator pos,
|
|
begin = m_frames.begin(),
|
|
end = m_frames.end();
|
|
for (pos = begin; pos != end; ++pos)
|
|
{
|
|
if (pos->get() == frame)
|
|
{
|
|
m_current_frame_idx = std::distance (begin, pos);
|
|
return m_current_frame_idx;
|
|
}
|
|
}
|
|
m_current_frame_idx = 0;
|
|
return m_current_frame_idx;
|
|
}
|
|
|
|
// Mark a stack frame as the current frame using the frame index
|
|
void
|
|
StackFrameList::SetCurrentFrameByIndex (uint32_t idx)
|
|
{
|
|
Mutex::Locker locker (m_mutex);
|
|
m_current_frame_idx = idx;
|
|
}
|
|
|
|
// 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 ()
|
|
{
|
|
Mutex::Locker locker (m_mutex);
|
|
m_frames.clear();
|
|
}
|
|
|
|
void
|
|
StackFrameList::InvalidateFrames (uint32_t start_idx)
|
|
{
|
|
Mutex::Locker locker (m_mutex);
|
|
size_t num_frames = m_frames.size();
|
|
while (start_idx < num_frames)
|
|
{
|
|
m_frames[start_idx].reset();
|
|
++start_idx;
|
|
}
|
|
}
|