folly::symbolizer::SymbolizePrinter Class Reference

#include <Symbolizer.h>

Inheritance diagram for folly::symbolizer::SymbolizePrinter:

Public Types
enum	Options {   NO_FILE_AND_LINE = 1 << 0, TERSE = 1 << 1, COLOR = 1 << 2, COLOR_IF_TTY = 1 << 3,   NO_FRAME_ADDRESS = 1 << 4 }
enum	Color {   DEFAULT, RED, GREEN, YELLOW,   BLUE, CYAN, WHITE, PURPLE,   NUM }

Public Member Functions
void	print (uintptr_t address, const SymbolizedFrame &frame)
void	println (uintptr_t address, const SymbolizedFrame &frame)
void	println (const uintptr_t *addresses, const SymbolizedFrame *frames, size_t frameCount)
void	print (StringPiece sp)
template<size_t N>
void	println (const FrameArray< N > &fa, size_t skip=0)
virtual void	flush ()
virtual	~SymbolizePrinter ()
void	color (Color c)

Protected Member Functions
	SymbolizePrinter (int options, bool isTty=false)

Protected Attributes
const int	options_
const bool	isTty_

Private Member Functions
void	printTerse (uintptr_t address, const SymbolizedFrame &frame)
virtual void	doPrint (StringPiece sp)=0

Static Private Attributes
static constexpr std::array< const char *, Color::NUM >	kColorMap

Detailed Description

Print a list of symbolized addresses. Base class.

Definition at line 180 of file Symbolizer.h.

Member Enumeration Documentation

enum folly::symbolizer::SymbolizePrinter::Color

Enumerator
DEFAULT
RED
GREEN
YELLOW
BLUE
CYAN
WHITE
PURPLE
NUM

Definition at line 244 of file Symbolizer.h.

{ DEFAULT, RED, GREEN, YELLOW, BLUE, CYAN, WHITE, PURPLE, NUM };

enum folly::symbolizer::SymbolizePrinter::Options

Enumerator
NO_FILE_AND_LINE
TERSE
COLOR
COLOR_IF_TTY
NO_FRAME_ADDRESS

Definition at line 226 of file Symbolizer.h.

               {
    // Skip file and line information
    NO_FILE_AND_LINE = 1 << 0,

    // As terse as it gets: function name if found, address otherwise
    TERSE = 1 << 1,

    // Always colorize output (ANSI escape code)
    COLOR = 1 << 2,

    // Colorize output only if output is printed to a TTY (ANSI escape code)
    COLOR_IF_TTY = 1 << 3,

    // Skip frame address information
    NO_FRAME_ADDRESS = 1 << 4,
  };

Constructor & Destructor Documentation

virtual folly::symbolizer::SymbolizePrinter::~SymbolizePrinter ( )

inlinevirtual

Definition at line 224 of file Symbolizer.h.

{}

folly::symbolizer::SymbolizePrinter::SymbolizePrinter ( int  options, bool  isTty = false  )

inlineexplicitprotected

Definition at line 248 of file Symbolizer.h.

      : options_(options), isTty_(isTty) {}

Member Function Documentation

void folly::symbolizer::SymbolizePrinter::color

(

SymbolizePrinter::Color

color

)

Definition at line 274 of file Symbolizer.cpp.

                                                        {
  if ((options_ & COLOR) == 0 && ((options_ & COLOR_IF_TTY) == 0 || !isTty_)) {
    return;
  }
  if (static_cast<size_t>(color) >= kColorMap.size()) { // catches underflow too
    return;
  }
  doPrint(kColorMap[color]);
}

virtual void folly::symbolizer::SymbolizePrinter::doPrint ( StringPiece  sp )

privatepure virtual

Implemented in folly::symbolizer::StringSymbolizePrinter, folly::symbolizer::FILESymbolizePrinter, folly::symbolizer::FDSymbolizePrinter, and folly::symbolizer::OStreamSymbolizePrinter.

virtual void folly::symbolizer::SymbolizePrinter::flush ( )

inlinevirtual

If output buffered inside this class, send it to the output stream, so that any output done in other ways appears after this.

Reimplemented in folly::symbolizer::FDSymbolizePrinter.

Definition at line 222 of file Symbolizer.h.

{}

void folly::symbolizer::SymbolizePrinter::print	(	uintptr_t	address,
		const SymbolizedFrame &	frame
	)

Print one address, no ending newline.

Definition at line 208 of file Symbolizer.cpp.

References folly::demangle(), folly::symbolizer::Dwarf::LocationInfo::file, folly::symbolizer::AddressFormatter::format(), folly::symbolizer::SymbolizedFrame::found, folly::symbolizer::Dwarf::LocationInfo::hasFileAndLine, folly::symbolizer::Dwarf::LocationInfo::hasMainFile, folly::symbolizer::Dwarf::LocationInfo::line, folly::symbolizer::SymbolizedFrame::location, folly::symbolizer::Dwarf::LocationInfo::mainFile, folly::symbolizer::SymbolizedFrame::name, SCOPE_EXIT, folly::symbolizer::Dwarf::Path::toBuffer(), uint32_t, and folly::uint64ToBufferUnsafe().

                                                                            {
  if (options_ & TERSE) {
    printTerse(address, frame);
    return;
  }

  SCOPE_EXIT {
    color(Color::DEFAULT);
  };

  if (!(options_ & NO_FRAME_ADDRESS)) {
    color(kAddressColor);

    AddressFormatter formatter;
    doPrint(formatter.format(address));
  }

  const char padBuf[] = "                       ";
  folly::StringPiece pad(
      padBuf, sizeof(padBuf) - 1 - (16 - 2 * sizeof(uintptr_t)));

  color(kFunctionColor);
  if (!frame.found) {
    doPrint(" (not found)");
    return;
  }

  if (!frame.name || frame.name[0] == '\0') {
    doPrint(" (unknown)");
  } else {
    char demangledBuf[2048];
    demangle(frame.name, demangledBuf, sizeof(demangledBuf));
    doPrint(" ");
    doPrint(demangledBuf[0] == '\0' ? frame.name : demangledBuf);
  }

  if (!(options_ & NO_FILE_AND_LINE)) {
    color(kFileColor);
    char fileBuf[PATH_MAX];
    fileBuf[0] = '\0';
    if (frame.location.hasFileAndLine) {
      frame.location.file.toBuffer(fileBuf, sizeof(fileBuf));
      doPrint("\n");
      doPrint(pad);
      doPrint(fileBuf);

      char buf[22];
      uint32_t n = uint64ToBufferUnsafe(frame.location.line, buf);
      doPrint(":");
      doPrint(StringPiece(buf, n));
    }

    if (frame.location.hasMainFile) {
      char mainFileBuf[PATH_MAX];
      mainFileBuf[0] = '\0';
      frame.location.mainFile.toBuffer(mainFileBuf, sizeof(mainFileBuf));
      if (!frame.location.hasFileAndLine || strcmp(fileBuf, mainFileBuf)) {
        doPrint("\n");
        doPrint(pad);
        doPrint("-> ");
        doPrint(mainFileBuf);
      }
    }
  }
}

void folly::symbolizer::SymbolizePrinter::print ( StringPiece  sp )

inline

Print a string, no endling newline.

Definition at line 203 of file Symbolizer.h.

                             {
    doPrint(sp);
  }

void folly::symbolizer::SymbolizePrinter::println	(	uintptr_t	address,
		const SymbolizedFrame &	frame
	)

Print one address with ending newline.

Definition at line 284 of file Symbolizer.cpp.

Referenced by folly::symbolizer::SafeStackTracePrinter::printSymbolizedStackTrace(), folly::SingletonVault::scheduleDestroyInstances(), and verifyStackTraces().

                                  {
  print(address, frame);
  doPrint("\n");
}

void folly::symbolizer::SymbolizePrinter::println	(	const uintptr_t *	addresses,
		const SymbolizedFrame *	frames,
		size_t	frameCount
	)

Print multiple addresses on separate lines.

Definition at line 313 of file Symbolizer.cpp.

References COLOR_IF_TTY, i, println, and TERSE.

                       {
  for (size_t i = 0; i < frameCount; ++i) {
    println(addresses[i], frames[i]);
  }
}

template<size_t N>

void folly::symbolizer::SymbolizePrinter::println ( const FrameArray< N > &  fa, size_t  skip = 0  )

inline

Print multiple addresses on separate lines, skipping the first skip addresses.

Definition at line 212 of file Symbolizer.h.

References folly::symbolizer::FrameArray< N >::addresses, folly::symbolizer::FrameArray< N >::frameCount, folly::symbolizer::FrameArray< N >::frames, println, and folly::gen::skip().

                                                         {
    if (skip < fa.frameCount) {
      println(fa.addresses + skip, fa.frames + skip, fa.frameCount - skip);
    }
  }

void folly::symbolizer::SymbolizePrinter::printTerse ( uintptr_t  address, const SymbolizedFrame &  frame  )

private

Definition at line 291 of file Symbolizer.cpp.

References folly::demangle(), folly::test::end(), folly::symbolizer::SymbolizedFrame::found, and folly::symbolizer::SymbolizedFrame::name.

                                  {
  if (frame.found && frame.name && frame.name[0] != '\0') {
    char demangledBuf[2048] = {0};
    demangle(frame.name, demangledBuf, sizeof(demangledBuf));
    doPrint(demangledBuf[0] == '\0' ? frame.name : demangledBuf);
  } else {
    // Can't use sprintf, not async-signal-safe
    static_assert(sizeof(uintptr_t) <= 8, "huge uintptr_t?");
    char buf[] = "0x0000000000000000";
    char* end = buf + sizeof(buf) - 1 - (16 - 2 * sizeof(uintptr_t));
    char* p = end;
    *p-- = '\0';
    while (address != 0) {
      *p-- = kHexChars[address & 0xf];
      address >>= 4;
    }
    doPrint(StringPiece(buf, end));
  }
}

Member Data Documentation

const bool folly::symbolizer::SymbolizePrinter::isTty_

protected

Definition at line 252 of file Symbolizer.h.

constexpr std::array< const char *, SymbolizePrinter::Color::NUM > folly::symbolizer::SymbolizePrinter::kColorMap

staticprivate

Initial value:

= {{
      "\x1B[0m",
      "\x1B[31m",
      "\x1B[32m",
      "\x1B[33m",
      "\x1B[34m",
      "\x1B[36m",
      "\x1B[37m",
      "\x1B[35m",
  }}

Definition at line 258 of file Symbolizer.h.

Referenced by folly::symbolizer::Symbolizer::symbolize().

const int folly::symbolizer::SymbolizePrinter::options_

protected

Definition at line 251 of file Symbolizer.h.

---

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