folly::symbolizer::Symbolizer Class Reference

#include <Symbolizer.h>

Public Member Functions
	Symbolizer (Dwarf::LocationInfoMode mode=kDefaultLocationInfoMode)
	Symbolizer (ElfCacheBase *cache, Dwarf::LocationInfoMode mode=kDefaultLocationInfoMode, size_t symbolCacheSize=0)
void	symbolize (const uintptr_t *addresses, SymbolizedFrame *frames, size_t frameCount)
template<size_t N>
void	symbolize (FrameArray< N > &fa)
bool	symbolize (uintptr_t address, SymbolizedFrame &frame)

Static Public Attributes
static constexpr Dwarf::LocationInfoMode	kDefaultLocationInfoMode

Private Types
using	SymbolCache = EvictingCacheMap< uintptr_t, SymbolizedFrame >

Private Attributes
ElfCacheBase *const	cache_
const Dwarf::LocationInfoMode	mode_
folly::Optional< Synchronized< SymbolCache > >	symbolCache_

Detailed Description

Definition at line 118 of file Symbolizer.h.

Member Typedef Documentation

using folly::symbolizer::Symbolizer::SymbolCache = EvictingCacheMap<uintptr_t, SymbolizedFrame>

private

Definition at line 155 of file Symbolizer.h.

Constructor & Destructor Documentation

folly::symbolizer::Symbolizer::Symbolizer ( Dwarf::LocationInfoMode  mode = kDefaultLocationInfoMode )

inlineexplicit

Definition at line 123 of file Symbolizer.h.

References mode.

      : Symbolizer(nullptr, mode) {}

folly::symbolizer::Symbolizer::Symbolizer ( ElfCacheBase *  cache, Dwarf::LocationInfoMode  mode = kDefaultLocationInfoMode, size_t  symbolCacheSize = 0  )

explicit

Definition at line 84 of file Symbolizer.cpp.

References folly::in_place(), and symbolCache_.

    : cache_(cache ? cache : defaultElfCache()), mode_(mode) {
  if (symbolCacheSize > 0) {
    symbolCache_.emplace(folly::in_place, symbolCacheSize);
  }
}

Member Function Documentation

void folly::symbolizer::Symbolizer::symbolize	(	const uintptr_t *	addresses,
		SymbolizedFrame *	frames,
		size_t	frameCount
	)

Symbolize given addresses.

Definition at line 94 of file Symbolizer.cpp.

References _r_debug, addr, folly::symbolizer::AddressFormatter::bufTemplate, cache_, folly::symbolizer::SymbolizedFrame::clear(), folly::symbolizer::ElfCacheBase::getFile(), i, folly::symbolizer::SymbolizePrinter::kColorMap, mode_, and symbolCache_.

Referenced by folly::symbolizer::FastStackTracePrinter::printStackTrace(), folly::symbolizer::SafeStackTracePrinter::printSymbolizedStackTrace(), folly::symbolizer::test::runElfCacheTest(), folly::SingletonVault::scheduleDestroyInstances(), folly::symbolizer::test::ElfCacheTest::SetUp(), folly::symbolizer::test::TEST(), and verifyStackTraces().

                      {
  size_t remaining = 0;
  for (size_t i = 0; i < addrCount; ++i) {
    auto& frame = frames[i];
    if (!frame.found) {
      ++remaining;
      frame.clear();
    }
  }

  if (remaining == 0) { // we're done
    return;
  }

  if (_r_debug.r_version != 1) {
    return;
  }

  char selfPath[PATH_MAX + 8];
  ssize_t selfSize;
  if ((selfSize = readlink("/proc/self/exe", selfPath, PATH_MAX + 1)) == -1) {
    // Something has gone terribly wrong.
    return;
  }
  selfPath[selfSize] = '\0';

  for (auto lmap = _r_debug.r_map; lmap != nullptr && remaining != 0;
       lmap = lmap->l_next) {
    // The empty string is used in place of the filename for the link_map
    // corresponding to the running executable.  Additionally, the `l_addr' is
    // 0 and the link_map appears to be first in the list---but none of this
    // behavior appears to be documented, so checking for the empty string is
    // as good as anything.
    auto const objPath = lmap->l_name[0] != '\0' ? lmap->l_name : selfPath;

    auto const elfFile = cache_->getFile(objPath);
    if (!elfFile) {
      continue;
    }

    // Get the address at which the object is loaded.  We have to use the ELF
    // header for the running executable, since its `l_addr' is zero, but we
    // should use `l_addr' for everything else---in particular, if the object
    // is position-independent, getBaseAddress() (which is p_vaddr) will be 0.
    auto const base =
        lmap->l_addr != 0 ? lmap->l_addr : elfFile->getBaseAddress();

    for (size_t i = 0; i < addrCount && remaining != 0; ++i) {
      auto& frame = frames[i];
      if (frame.found) {
        continue;
      }

      auto const addr = addresses[i];
      if (symbolCache_) {
        // Need a write lock, because EvictingCacheMap brings found item to
        // front of eviction list.
        auto lockedSymbolCache = symbolCache_->wlock();

        auto const iter = lockedSymbolCache->find(addr);
        if (iter != lockedSymbolCache->end()) {
          frame = iter->second;
          continue;
        }
      }

      // Get the unrelocated, ELF-relative address.
      auto const adjusted = addr - base;

      if (elfFile->getSectionContainingAddress(adjusted)) {
        frame.set(elfFile, adjusted, mode_);
        --remaining;
        if (symbolCache_) {
          // frame may already have been set here.  That's ok, we'll just
          // overwrite, which doesn't cause a correctness problem.
          symbolCache_->wlock()->set(addr, frame);
        }
      }
    }
  }
}

template<size_t N>

void folly::symbolizer::Symbolizer::symbolize ( FrameArray< N > &  fa )

inline

Definition at line 139 of file Symbolizer.h.

References folly::symbolizer::FrameArray< N >::addresses, folly::symbolizer::FrameArray< N >::frameCount, and folly::symbolizer::FrameArray< N >::frames.

                                    {
    symbolize(fa.addresses, fa.frames, fa.frameCount);
  }

bool folly::symbolizer::Symbolizer::symbolize ( uintptr_t  address, SymbolizedFrame &  frame  )

inline

Shortcut to symbolize one address.

Definition at line 146 of file Symbolizer.h.

References folly::symbolizer::SymbolizedFrame::found.

                                                            {
    symbolize(&address, &frame, 1);
    return frame.found;
  }

Member Data Documentation

ElfCacheBase* const folly::symbolizer::Symbolizer::cache_

private

Definition at line 152 of file Symbolizer.h.

Referenced by symbolize().

constexpr Dwarf::LocationInfoMode folly::symbolizer::Symbolizer::kDefaultLocationInfoMode

static

Initial value:

=
      Dwarf::LocationInfoMode::FAST

Definition at line 120 of file Symbolizer.h.

const Dwarf::LocationInfoMode folly::symbolizer::Symbolizer::mode_

private

Definition at line 153 of file Symbolizer.h.

Referenced by symbolize().

folly::Optional<Synchronized<SymbolCache> > folly::symbolizer::Symbolizer::symbolCache_

private

Definition at line 156 of file Symbolizer.h.

Referenced by symbolize(), and Symbolizer().

---

The documentation for this class was generated from the following files:

• proxygen/folly/folly/experimental/symbolizer/Symbolizer.h
• proxygen/folly/folly/experimental/symbolizer/Symbolizer.cpp