thread.cpp

Go to the documentation of this file.

#include "../include/thread.hpp"

namespace csdbg {

thread::thread(const i8 *nm)
try:
m_name(NULL),
m_handle(pthread_self()),
m_stack(NULL),
m_lag(0)
{
  if ( unlikely(nm != NULL) ) {
    m_name = new i8[strlen(nm) + 1];
    strcpy(m_name, nm);
  }

  m_stack = new stack<call>;
}

catch (...) {
  delete[] m_name;
  m_name = NULL;
}


thread::thread(const thread &src)
try:
m_name(NULL),
m_handle(src.m_handle),
m_stack(NULL),
m_lag(src.m_lag)
{
  const i8 *nm = src.m_name;
  if ( unlikely(nm != NULL) ) {
    m_name = new i8[strlen(nm) + 1];
    strcpy(m_name, nm);
  }

  m_stack = src.m_stack->clone();
}

catch (...) {
  delete[] m_name;
  m_name = NULL;
}


thread::~thread()
{
  delete[] m_name;
  delete m_stack;
  m_name = NULL;
  m_stack = NULL;
}


inline thread* thread::clone() const
{
  return new thread(*this);
}


inline const i8* thread::name() const
{
  return m_name;
}


inline pthread_t thread::handle() const
{
  return m_handle;
}


inline i32 thread::lag() const
{
  return m_lag;
}


thread& thread::set_name(const i8 *nm)
{
  if ( unlikely(nm == NULL) ) {
    delete[] m_name;
    m_name = NULL;
    return *this;
  }

  u32 len = strlen(nm);
  if ( likely(m_name == NULL || len > strlen(m_name)) ) {
    delete[] m_name;
    m_name = NULL;
    m_name = new i8[len + 1];
  }

  strcpy(m_name, nm);
  return *this;
}


thread& thread::operator=(const thread &rval)
{
  if ( unlikely(this == &rval) )
    return *this;

  *m_stack = *rval.m_stack;
  m_handle = rval.m_handle;
  m_lag = rval.m_lag;

  return set_name(rval.m_name);
}


inline bool thread::is_current() const
{
  return pthread_equal(m_handle, pthread_self()) != 0;
}


inline u32 thread::call_depth() const
{
  return m_stack->size();
}


inline const call* thread::backtrace(u32 i) const
{
  return m_stack->peek(i);
}


thread& thread::called(mem_addr_t addr, mem_addr_t site, const i8 *nm)
{
  /*
   * If the function is called while an exception is unwinding the stack, keep
   * track of the call depth difference between the simulated and the real call
   * stack (the 'lag')
   */
  if ( unlikely(std::uncaught_exception()) ) {
    m_lag--;
    return *this;
  }

  call *c = NULL;
  try {
    __D_ASSERT(nm != NULL);
    c = new call(addr, site, nm);
    m_stack->push(c);
    return *this;
  }

  catch (...) {
    delete c;
    throw;
  }
}


thread& thread::returned()
{
  /*
   * If the function returned because an exception is propagating, unwinding the
   * stack, keep track of the call depth difference between the simulated and
   * the real call stack (the 'lag')
   */
  if ( unlikely(std::uncaught_exception()) )
    m_lag++;
  else
    m_stack->pop();

  return *this;
}


thread& thread::unwind()
{
  while ( likely(m_lag > 0) ) {
    m_stack->pop();
    m_lag--;
  }

  return *this;
}


inline thread& thread::foreach(void (*pfunc)(u32, call*)) const
{
  m_stack->foreach(pfunc);
  return const_cast<thread&> (*this);
}

}