tracer & csdbg::tracer::trace ( string &  dst )

virtual

Create an exception stack trace using the simulated call stack of the current thread. The trace is appended to a string and the simulated stack is unwinded.

Parameters

[in]

dst

the destination string

Returns

*this

Exceptions

std::bad_alloc
csdbg::exception

Attention

The simulated call stack is unwinded even if the method fails, in any way to produce a trace

Definition at line 658 of file tracer.cpp.

References csdbg::symbol::addr(), addr2line(), csdbg::string::append(), csdbg::thread::backtrace(), csdbg::process::current_thread(), csdbg::thread::handle(), csdbg::process::ilookup(), csdbg::thread::lag(), likely, csdbg::util::lock(), m_proc, csdbg::symbol::name(), csdbg::thread::name(), csdbg::call::site(), csdbg::util::unlock(), csdbg::thread::unwind(), and unwind().

Referenced by dump(), and csdbg::operator<<().

{
  /* If an exception occurs, unwind, unlock and rethrow it */
  try {
    util::lock();
    thread *thr = m_proc->current_thread();

    const i8 *nm = thr->name();
    if ( likely(nm == NULL) )
      nm = "anonymous";
    dst.append("at %s thread (0x%lx) {\r\n", nm, thr->handle());

    /* For each function call */
    for (i32 i = thr->lag(); likely(i >= 0); i--) {
      const call *cur = thr->backtrace(i);
      dst.append("  at %s", cur->name());

      /* Append addr2line debug information */
      u32 prev = i + 1;
      if ( likely (prev < thr->call_depth()) ) {
        const call *caller = thr->backtrace(prev);
        mem_addr_t base = 0;

        const i8 *path = m_proc->ilookup(caller->addr(), base);
        addr2line(dst, path, cur->site() - base);
      }

      dst.append("\r\n");
    }

    dst.append("}\r\n");
    thr->unwind();
    util::unlock();
    return *this;
  }

  catch (...) {
    unwind();
    util::unlock();
    throw;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function: