void csdbg::__cyg_profile_func_exit	(	void *	this_fn,
		void *	call_site
	)

In code compiled with -finstrument-functions, g++ injects code to call this function at the end of instrumented functions. By implementing this function (and __cyg_profile_func_enter), libcsdbg simulates the call stack of each thread.

Parameters

[in]	this_fn	the address of the returning function
[in]	call_site	the address that the program counter will return to

Note

If an exception occurs, the process exits

Definition at line 147 of file tracer.cpp.

References __D_ASSERT, csdbg::filter::apply(), csdbg::process::current_thread(), csdbg::plugin::end(), csdbg::tracer::filter_count(), csdbg::tracer::get_filter(), csdbg::tracer::get_plugin(), csdbg::util::header(), csdbg::process::ilookup(), csdbg::tracer::interface(), likely, csdbg::util::lock(), csdbg::process::lookup(), csdbg::filter::mode(), csdbg::tracer::plugin_count(), csdbg::tracer::proc(), csdbg::thread::returned(), unlikely, and csdbg::util::unlock().

{
  __D_ASSERT(this_fn != NULL);
  __D_ASSERT(call_site != NULL);

  util::lock();
  tracer *iface = tracer::interface();

  __D_ASSERT(iface != NULL);
  if ( unlikely(iface == NULL) ) {
    util::unlock();
    return;
  }

#ifdef CSDBG_WITH_PLUGIN
  /* Call all plugin exit functions in the reverse order they were registered */
  for (i32 i = iface->plugin_count() - 1; likely(i >= 0); i--)
    try {
      iface->get_plugin(i)->end(this_fn, call_site);
    }

    catch (exception &x) {
      std::cerr << x;
    }

    catch (std::exception &x) {
      std::cerr << x;
    }

    catch (...) {
      util::header(std::cerr, "x");
      std::cerr << "plugin " << std::dec << i << ": unidentified exception\r\n";
    }
#endif

  try {
    mem_addr_t addr = reinterpret_cast<mem_addr_t> (this_fn);
    process *proc = iface->proc();

#ifdef CSDBG_WITH_FILTER
    mem_addr_t base = 0;
    const i8 *path = proc->ilookup(addr, base);

    /* Call all the module filters in the order they were registered */
    if ( likely(path != NULL) )
      for (u32 i = 0, sz = iface->filter_count(); likely(i < sz); i++) {
        filter *filt = iface->get_filter(i);
        if ( likely(filt->mode()) )
          continue;

        if ( unlikely(filt->apply(path)) ) {
          util::unlock();
          return;
        }
      }
#endif

    /*
     * Lookup the process namespace to resolve the returning function symbol. If
     * it gets resolved update the simulated call stack of the current thread
     */
    const i8 *nm = proc->lookup(addr);
    if ( likely(nm != NULL) ) {
#ifdef CSDBG_WITH_FILTER
      /* Call all the symbol filters in the order they were registered */
      for (u32 i = 0, sz = iface->filter_count(); likely(i < sz); i++) {
        filter *filt = iface->get_filter(i);
        if ( likely(!filt->mode()) )
          continue;

        if ( unlikely(filt->apply(nm)) ) {
          util::unlock();
          return;
        }
      }
#endif

      proc->current_thread()->returned();
    }

    util::unlock();
    return;
  }

  catch (exception x) {
    std::cerr << x;
  }

  catch (std::exception x) {
    std::cerr << x;
  }

  util::unlock();
  exit(EXIT_FAILURE);
}

Here is the call graph for this function: