SYMBOL INDEX (506 symbols across 53 files)

FILE: bazel/example/main.cc
  function main (line 5) | int main(int argc, char* argv[]) {

FILE: examples/custom_sink.cc
  type MyLogSink (line 42) | struct MyLogSink : google::LogSink {  // (1)!
    method send (line 43) | void send(google::LogSeverity severity, const char* /*full_filename*/,
  function main (line 57) | int main(int /*argc*/, char** argv) {

FILE: src/base/googleinit.h
  function class (line 36) | class GoogleInitializer {

FILE: src/cleanup_immediately_unittest.cc
  function TEST (line 57) | TEST(CleanImmediately, logging) {
  function main (line 69) | int main(int argc, char** argv) {

FILE: src/cleanup_with_absolute_prefix_unittest.cc
  function TEST (line 57) | TEST(CleanImmediatelyWithAbsolutePrefix, logging) {
  function main (line 74) | int main(int argc, char** argv) {

FILE: src/cleanup_with_relative_prefix_unittest.cc
  function TEST (line 57) | TEST(CleanImmediatelyWithRelativePrefix, logging) {
  function main (line 70) | int main(int argc, char** argv) {

FILE: src/dcheck_unittest/glog_dcheck.cc
  function main (line 34) | int main(int /*argc*/, char** argv) {

FILE: src/demangle.cc
  type google (line 53) | namespace google {
    type glog_internal_namespace_ (line 54) | inline namespace glog_internal_namespace_ {
      type AbbrevPair (line 58) | struct AbbrevPair {
      type State (line 111) | struct State {
      function StrLen (line 128) | size_t StrLen(const char* str) {
      function AtLeastNumCharsRemaining (line 138) | bool AtLeastNumCharsRemaining(const char* str, ssize_t n) {
      function StrPrefix (line 148) | bool StrPrefix(const char* str, const char* prefix) {
      function InitState (line 156) | void InitState(State* state, const char* mangled, char* out, size_t ...
      function ParseOneCharToken (line 174) | bool ParseOneCharToken(State* state, const char one_char_token) {
      function ParseTwoCharToken (line 185) | bool ParseTwoCharToken(State* state, const char* two_char_token) {
      function ParseCharClass (line 196) | bool ParseCharClass(State* state, const char* char_class) {
      function Optional (line 208) | bool Optional(bool) { return true; }
      function OneOrMore (line 212) | bool OneOrMore(ParseFunc parse_func, State* state) {
      function ZeroOrMore (line 225) | bool ZeroOrMore(ParseFunc parse_func, State* state) {
      function Append (line 234) | void Append(State* state, const char* const str, ssize_t length) {
      function IsLower (line 254) | bool IsLower(char c) { return c >= 'a' && c <= 'z'; }
      function IsAlpha (line 256) | bool IsAlpha(char c) {
      function IsDigit (line 260) | bool IsDigit(char c) { return c >= '0' && c <= '9'; }
      function IsFunctionCloneSuffix (line 266) | bool IsFunctionCloneSuffix(const char* str) {
      function MaybeAppendWithLength (line 290) | void MaybeAppendWithLength(State* state, const char* const str,
      function MaybeAppend (line 309) | bool MaybeAppend(State* state, const char* const str) {
      function EnterNestedName (line 318) | bool EnterNestedName(State* state) {
      function LeaveNestedName (line 324) | bool LeaveNestedName(State* state, short prev_value) {
      function DisableAppend (line 330) | bool DisableAppend(State* state) {
      function RestoreAppend (line 336) | bool RestoreAppend(State* state, bool prev_value) {
      function MaybeIncreaseNestLevel (line 342) | void MaybeIncreaseNestLevel(State* state) {
      function MaybeAppendSeparator (line 349) | void MaybeAppendSeparator(State* state) {
      function MaybeCancelLastSeparator (line 356) | void MaybeCancelLastSeparator(State* state) {
      function IdentifierIsAnonymousNamespace (line 366) | bool IdentifierIsAnonymousNamespace(State* state, ssize_t length) {
      function ParseMangledName (line 445) | bool ParseMangledName(State* state) {
      function ParseEncoding (line 452) | bool ParseEncoding(State* state) {
      function ParseName (line 469) | bool ParseName(State* state) {
      function ParseUnscopedName (line 489) | bool ParseUnscopedName(State* state) {
      function ParseUnscopedTemplateName (line 505) | bool ParseUnscopedTemplateName(State* state) {
      function ParseNestedName (line 511) | bool ParseNestedName(State* state) {
      function ParsePrefix (line 534) | bool ParsePrefix(State* state) {
      function ParseUnqualifiedName (line 558) | bool ParseUnqualifiedName(State* state) {
      function ParseSourceName (line 565) | bool ParseSourceName(State* state) {
      function ParseLocalSourceName (line 580) | bool ParseLocalSourceName(State* state) {
      function ParseNumber (line 593) | bool ParseNumber(State* state, int* number_out) {
      function ParseFloatNumber (line 633) | bool ParseFloatNumber(State* state) {
      function ParseSeqId (line 649) | bool ParseSeqId(State* state) {
      function ParseIdentifier (line 664) | bool ParseIdentifier(State* state, ssize_t length) {
      function ParseAbiTags (line 682) | bool ParseAbiTags(State* state) {
      function ParseAbiTag (line 694) | bool ParseAbiTag(State* state) {
      function ParseOperatorName (line 701) | bool ParseOperatorName(State* state) {
      function ParseSpecialName (line 761) | bool ParseSpecialName(State* state) {
      function ParseCallOffset (line 821) | bool ParseCallOffset(State* state) {
      function ParseNVOffset (line 839) | bool ParseNVOffset(State* state) { return ParseNumber(state, nullptr...
      function ParseVOffset (line 842) | bool ParseVOffset(State* state) {
      function ParseCtorDtorName (line 854) | bool ParseCtorDtorName(State* state) {
      function ParseType (line 895) | bool ParseType(State* state) {
      function ParseCVQualifiers (line 947) | bool ParseCVQualifiers(State* state) {
      function ParseBuiltinType (line 957) | bool ParseBuiltinType(State* state) {
      function ParseFunctionType (line 976) | bool ParseFunctionType(State* state) {
      function ParseBareFunctionType (line 988) | bool ParseBareFunctionType(State* state) {
      function ParseClassEnumType (line 1001) | bool ParseClassEnumType(State* state) { return ParseName(state); }
      function ParseArrayType (line 1005) | bool ParseArrayType(State* state) {
      function ParsePointerToMemberType (line 1022) | bool ParsePointerToMemberType(State* state) {
      function ParseTemplateParam (line 1033) | bool ParseTemplateParam(State* state) {
      function ParseTemplateTemplateParam (line 1051) | bool ParseTemplateTemplateParam(State* state) {
      function ParseTemplateArgs (line 1056) | bool ParseTemplateArgs(State* state) {
      function ParseTemplateArg (line 1074) | bool ParseTemplateArg(State* state) {
      function ParseExpression (line 1115) | bool ParseExpression(State* state) {
      function ParseExprPrimary (line 1184) | bool ParseExprPrimary(State* state) {
      function ParseLocalName (line 1216) | bool ParseLocalName(State* state) {
      function ParseDiscriminator (line 1243) | bool ParseDiscriminator(State* state) {
      function ParseSubstitution (line 1255) | bool ParseSubstitution(State* state) {
      function ParseTopLevelMangledName (line 1290) | bool ParseTopLevelMangledName(State* state) {
      function Demangle (line 1313) | bool Demangle(const char* mangled, char* out, size_t out_size) {

FILE: src/demangle.h
  function namespace (line 83) | namespace google {

FILE: src/demangle_unittest.cc
  function TEST (line 69) | TEST(Demangle, Windows) {
  function TEST (line 82) | TEST(Demangle, CornerCases) {
  function TEST (line 102) | TEST(Demangle, Clones) {
  function TEST (line 124) | TEST(Demangle, FromFile) {
  function main (line 147) | int main(int argc, char** argv) {

FILE: src/flags.cc
  function BoolFromEnv (line 53) | bool BoolFromEnv(const char* varname, bool defval) {

FILE: src/fuzz_demangle.cc
  function LLVMFuzzerTestOneInput (line 21) | int LLVMFuzzerTestOneInput(const unsigned char* Data,

FILE: src/glog/log_severity.h
  function namespace (line 41) | namespace google {

FILE: src/glog/logging.h
  function namespace (line 80) | namespace google {
  function namespace (line 453) | namespace google {
  function namespace (line 879) | namespace google {
  function class (line 1459) | class GLOG_EXPORT LogSink {
  function namespace (line 1567) | namespace base {

FILE: src/glog/raw_logging.h
  function namespace (line 50) | namespace google {

FILE: src/glog/stl_logging.h
  function namespace (line 58) | namespace google {
  function namespace (line 124) | namespace google {
  function namespace (line 164) | namespace std {

FILE: src/glog/types.h
  function namespace (line 38) | namespace google {

FILE: src/glog/vlog_is_on.h
  function namespace (line 101) | namespace google {

FILE: src/googletest.h
  function namespace (line 75) | namespace google {
  function string (line 85) | static inline string GetTempDir() {
  function namespace (line 127) | namespace google {
  function namespace (line 238) | namespace google {
  function class (line 315) | class CapturedStream {
  function Capture (line 323) | void Capture() {
  function CaptureTestOutput (line 361) | static inline void CaptureTestOutput(int fd, const string& filename) {
  function CaptureTestStdout (line 366) | static inline void CaptureTestStdout() {
  function CaptureTestStderr (line 369) | static inline void CaptureTestStderr() {
  function GetFileSize (line 373) | static inline size_t GetFileSize(FILE* file) {
  function string (line 378) | static inline string ReadEntireFile(FILE* file) {
  function string (line 398) | static inline string GetCapturedTestOutput(int fd) {
  function throw (line 603) | throw std::bad_alloc{}
  function delete (line 612) | void operator delete(void* p) noexcept { free(p); }
  function delete (line 614) | void operator delete(void* p, size_t) noexcept { ::operator delete(p); }
  function noexcept (line 616) | void operator delete[](void* p) noexcept { ::operator delete(p); }
  function noexcept (line 618) | void operator delete[](void* p, size_t) noexcept { ::operator delete(p); }

FILE: src/includes_unittest/glog_includes_logging.cc
  function main (line 34) | int main() {

FILE: src/includes_unittest/glog_includes_raw_logging.cc
  function main (line 34) | int main() {

FILE: src/includes_unittest/glog_includes_stl_logging.cc
  function main (line 34) | int main() {}

FILE: src/includes_unittest/glog_includes_vlog_is_on.cc
  function main (line 34) | int main() { VLOG_IS_ON(0); }

FILE: src/log_severity_unittest/glog_log_severity_constants.cc
  function main (line 34) | int main() {

FILE: src/log_severity_unittest/glog_log_severity_conversion.cc
  function main (line 34) | int main() {

FILE: src/logging.cc
  function pread (line 129) | static ssize_t pread(int fd, void* buf, size_t count, off_t offset) {
  function pwrite (line 141) | static ssize_t pwrite(int fd, void* buf, size_t count, off_t offset) {
  function GetHostName (line 152) | static void GetHostName(string* hostname) {
  function TerminalSupportsColor (line 175) | static bool TerminalSupportsColor() {
  type GLogColor (line 221) | enum GLogColor { COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW }
  function GLogColor (line 223) | static GLogColor SeverityToColor(LogSeverity severity) {
  function WORD (line 241) | static WORD GetColorAttribute(GLogColor color) {
  function uint32 (line 275) | static uint32 MaxLogSize() {
  type logging (line 285) | namespace logging {
    type internal (line 286) | namespace internal {
      type LogMessageData (line 287) | struct LogMessageData {
        method LogMessageData (line 312) | LogMessageData(const LogMessageData&) = delete;
        method LogMessageData (line 313) | LogMessageData& operator=(const LogMessageData&) = delete;
      function ostream (line 2573) | ostream* CheckOpMessageBuilder::ForVar2() {
      function MakeCheckOpValueString (line 2584) | void MakeCheckOpValueString(std::ostream* os, const char& v) {
      function MakeCheckOpValueString (line 2593) | void MakeCheckOpValueString(std::ostream* os, const signed char& v) {
      function MakeCheckOpValueString (line 2602) | void MakeCheckOpValueString(std::ostream* os, const unsigned char& v) {
      function MakeCheckOpValueString (line 2611) | void MakeCheckOpValueString(std::ostream* os, const std::nullptr_t& ...
    type internal (line 2453) | namespace internal {
      type LogMessageData (line 287) | struct LogMessageData {
        method LogMessageData (line 312) | LogMessageData(const LogMessageData&) = delete;
        method LogMessageData (line 313) | LogMessageData& operator=(const LogMessageData&) = delete;
      function ostream (line 2573) | ostream* CheckOpMessageBuilder::ForVar2() {
      function MakeCheckOpValueString (line 2584) | void MakeCheckOpValueString(std::ostream* os, const char& v) {
      function MakeCheckOpValueString (line 2593) | void MakeCheckOpValueString(std::ostream* os, const signed char& v) {
      function MakeCheckOpValueString (line 2602) | void MakeCheckOpValueString(std::ostream* os, const unsigned char& v) {
      function MakeCheckOpValueString (line 2611) | void MakeCheckOpValueString(std::ostream* os, const std::nullptr_t& ...
    type internal (line 2564) | namespace internal {
      type LogMessageData (line 287) | struct LogMessageData {
        method LogMessageData (line 312) | LogMessageData(const LogMessageData&) = delete;
        method LogMessageData (line 313) | LogMessageData& operator=(const LogMessageData&) = delete;
      function ostream (line 2573) | ostream* CheckOpMessageBuilder::ForVar2() {
      function MakeCheckOpValueString (line 2584) | void MakeCheckOpValueString(std::ostream* os, const char& v) {
      function MakeCheckOpValueString (line 2593) | void MakeCheckOpValueString(std::ostream* os, const signed char& v) {
      function MakeCheckOpValueString (line 2602) | void MakeCheckOpValueString(std::ostream* os, const unsigned char& v) {
      function MakeCheckOpValueString (line 2611) | void MakeCheckOpValueString(std::ostream* os, const std::nullptr_t& ...
  class PrefixFormatter (line 351) | class PrefixFormatter {
    method PrefixFormatter (line 353) | PrefixFormatter(PrefixFormatterCallback callback, void* data) noexcept
    method PrefixFormatter (line 364) | PrefixFormatter(const PrefixFormatter& other) = delete;
    method PrefixFormatter (line 365) | PrefixFormatter& operator=(const PrefixFormatter& other) = delete;
    type Version (line 368) | enum Version { V2 }
  class LogFileObject (line 379) | class LogFileObject : public base::Logger {
    method uint32 (line 399) | uint32 LogSize() override {
  class LogCleaner (line 434) | class LogCleaner {
    method enabled (line 446) | bool enabled() const { return enabled_; }
  class LogDestination (line 473) | class LogDestination {
    method ResetLoggerImpl (line 559) | void ResetLoggerImpl() { SetLoggerImpl(&fileobject_); }
    method LogDestination (line 578) | LogDestination(const LogDestination&) = delete;
    method LogDestination (line 579) | LogDestination& operator=(const LogDestination&) = delete;
  function string (line 594) | const string& LogDestination::hostname() {
  function ColoredWriteToStderrOrStdout (line 720) | static void ColoredWriteToStderrOrStdout(FILE* output, LogSeverity sever...
  function ColoredWriteToStdout (line 761) | static void ColoredWriteToStdout(LogSeverity severity, const char* message,
  function ColoredWriteToStderr (line 772) | static void ColoredWriteToStderr(LogSeverity severity, const char* message,
  function WriteToStderr (line 777) | static void WriteToStderr(const char* message, size_t len) {
  function LogDestination (line 879) | inline LogDestination* LogDestination::log_destination(LogSeverity sever...
    method ResetLoggerImpl (line 559) | void ResetLoggerImpl() { SetLoggerImpl(&fileobject_); }
    method LogDestination (line 578) | LogDestination(const LogDestination&) = delete;
    method LogDestination (line 579) | LogDestination& operator=(const LogDestination&) = delete;
  function SetApplicationFingerprint (line 901) | void SetApplicationFingerprint(const std::string& fingerprint) {
  function string (line 914) | string PrettyDuration(const std::chrono::duration<int>& secs) {
  type stat (line 1002) | struct stat
  type flock (line 1031) | struct flock
  type ::tm (line 1139) | struct ::tm
  type dirent (line 1362) | struct dirent
  type stat (line 1483) | struct stat
  function LogSeverity (line 1662) | LogSeverity LogMessage::severity() const noexcept { return data_->severi...
  function LogMessageTime (line 1670) | const LogMessageTime& LogMessage::time() const noexcept { return time_; }
  function ostream (line 1709) | ostream& LogMessage::stream() { return data_->stream_; }
  function ReprintFatalMessage (line 1773) | void ReprintFatalMessage() {
  function EXCLUSIVE_LOCKS_REQUIRED (line 1785) | EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
  function NullStream (line 1888) | NullStream& NullStream::stream() { return *this; }
  function logging_fail_func_t (line 1896) | logging_fail_func_t InstallFailureFunction(logging_fail_func_t fail_func) {
  function EXCLUSIVE_LOCKS_REQUIRED (line 1903) | EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
  function EXCLUSIVE_LOCKS_REQUIRED (line 1916) | EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
  function EXCLUSIVE_LOCKS_REQUIRED (line 1922) | EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
  function EXCLUSIVE_LOCKS_REQUIRED (line 1936) | EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
  function int64 (line 1982) | int64 LogMessage::num_messages(int severity) {
  function ostream (line 1989) | ostream& operator<<(ostream& os, const Counter_t&) {
  function FlushLogFiles (line 2013) | void FlushLogFiles(LogSeverity min_severity) {
  function FlushLogFilesUnsafe (line 2017) | void FlushLogFilesUnsafe(LogSeverity min_severity) {
  function SetLogDestination (line 2021) | void SetLogDestination(LogSeverity severity, const char* base_filename) {
  function SetLogSymlink (line 2025) | void SetLogSymlink(LogSeverity severity, const char* symlink_basename) {
  function string (line 2035) | string LogSink::ToString(LogSeverity severity, const char* file, int line,
  function AddLogSink (line 2057) | void AddLogSink(LogSink* destination) {
  function RemoveLogSink (line 2061) | void RemoveLogSink(LogSink* destination) {
  function SetLogFilenameExtension (line 2065) | void SetLogFilenameExtension(const char* ext) {
  function SetStderrLogging (line 2069) | void SetStderrLogging(LogSeverity min_severity) {
  function SetEmailLogging (line 2073) | void SetEmailLogging(LogSeverity min_severity, const char* addresses) {
  function LogToStderr (line 2077) | void LogToStderr() { LogDestination::LogToStderr(); }
  type base (line 2079) | namespace base {
    type internal (line 2080) | namespace internal {
      function GetExitOnDFatal (line 2083) | bool GetExitOnDFatal() {
      function SetExitOnDFatal (line 2099) | void SetExitOnDFatal(bool value) {
  function string (line 2114) | static string ShellEscape(const string& src) {
  function trim (line 2144) | static inline void trim(std::string& s) {
  function SendEmailInternal (line 2154) | static bool SendEmailInternal(const char* dest, const char* subject,
  function SendEmail (line 2257) | bool SendEmail(const char* dest, const char* subject, const char* body) {
  function GetTempDirectories (line 2261) | static void GetTempDirectories(vector<string>& list) {
  function GLOG_NO_EXPORT (line 2340) | GLOG_NO_EXPORT
  type stat (line 2357) | struct stat
  function TruncateStdoutStderr (line 2441) | void TruncateStdoutStderr() {
  type logging (line 2452) | namespace logging {
    type internal (line 286) | namespace internal {
      type LogMessageData (line 287) | struct LogMessageData {
        method LogMessageData (line 312) | LogMessageData(const LogMessageData&) = delete;
        method LogMessageData (line 313) | LogMessageData& operator=(const LogMessageData&) = delete;
      function ostream (line 2573) | ostream* CheckOpMessageBuilder::ForVar2() {
      function MakeCheckOpValueString (line 2584) | void MakeCheckOpValueString(std::ostream* os, const char& v) {
      function MakeCheckOpValueString (line 2593) | void MakeCheckOpValueString(std::ostream* os, const signed char& v) {
      function MakeCheckOpValueString (line 2602) | void MakeCheckOpValueString(std::ostream* os, const unsigned char& v) {
      function MakeCheckOpValueString (line 2611) | void MakeCheckOpValueString(std::ostream* os, const std::nullptr_t& ...
    type internal (line 2453) | namespace internal {
      type LogMessageData (line 287) | struct LogMessageData {
        method LogMessageData (line 312) | LogMessageData(const LogMessageData&) = delete;
        method LogMessageData (line 313) | LogMessageData& operator=(const LogMessageData&) = delete;
      function ostream (line 2573) | ostream* CheckOpMessageBuilder::ForVar2() {
      function MakeCheckOpValueString (line 2584) | void MakeCheckOpValueString(std::ostream* os, const char& v) {
      function MakeCheckOpValueString (line 2593) | void MakeCheckOpValueString(std::ostream* os, const signed char& v) {
      function MakeCheckOpValueString (line 2602) | void MakeCheckOpValueString(std::ostream* os, const unsigned char& v) {
      function MakeCheckOpValueString (line 2611) | void MakeCheckOpValueString(std::ostream* os, const std::nullptr_t& ...
    type internal (line 2564) | namespace internal {
      type LogMessageData (line 287) | struct LogMessageData {
        method LogMessageData (line 312) | LogMessageData(const LogMessageData&) = delete;
        method LogMessageData (line 313) | LogMessageData& operator=(const LogMessageData&) = delete;
      function ostream (line 2573) | ostream* CheckOpMessageBuilder::ForVar2() {
      function MakeCheckOpValueString (line 2584) | void MakeCheckOpValueString(std::ostream* os, const char& v) {
      function MakeCheckOpValueString (line 2593) | void MakeCheckOpValueString(std::ostream* os, const signed char& v) {
      function MakeCheckOpValueString (line 2602) | void MakeCheckOpValueString(std::ostream* os, const unsigned char& v) {
      function MakeCheckOpValueString (line 2611) | void MakeCheckOpValueString(std::ostream* os, const std::nullptr_t& ...
  function GLOG_NO_EXPORT (line 2488) | GLOG_NO_EXPORT
  function string (line 2542) | string StrError(int err) {
  type logging (line 2563) | namespace logging {
    type internal (line 286) | namespace internal {
      type LogMessageData (line 287) | struct LogMessageData {
        method LogMessageData (line 312) | LogMessageData(const LogMessageData&) = delete;
        method LogMessageData (line 313) | LogMessageData& operator=(const LogMessageData&) = delete;
      function ostream (line 2573) | ostream* CheckOpMessageBuilder::ForVar2() {
      function MakeCheckOpValueString (line 2584) | void MakeCheckOpValueString(std::ostream* os, const char& v) {
      function MakeCheckOpValueString (line 2593) | void MakeCheckOpValueString(std::ostream* os, const signed char& v) {
      function MakeCheckOpValueString (line 2602) | void MakeCheckOpValueString(std::ostream* os, const unsigned char& v) {
      function MakeCheckOpValueString (line 2611) | void MakeCheckOpValueString(std::ostream* os, const std::nullptr_t& ...
    type internal (line 2453) | namespace internal {
      type LogMessageData (line 287) | struct LogMessageData {
        method LogMessageData (line 312) | LogMessageData(const LogMessageData&) = delete;
        method LogMessageData (line 313) | LogMessageData& operator=(const LogMessageData&) = delete;
      function ostream (line 2573) | ostream* CheckOpMessageBuilder::ForVar2() {
      function MakeCheckOpValueString (line 2584) | void MakeCheckOpValueString(std::ostream* os, const char& v) {
      function MakeCheckOpValueString (line 2593) | void MakeCheckOpValueString(std::ostream* os, const signed char& v) {
      function MakeCheckOpValueString (line 2602) | void MakeCheckOpValueString(std::ostream* os, const unsigned char& v) {
      function MakeCheckOpValueString (line 2611) | void MakeCheckOpValueString(std::ostream* os, const std::nullptr_t& ...
    type internal (line 2564) | namespace internal {
      type LogMessageData (line 287) | struct LogMessageData {
        method LogMessageData (line 312) | LogMessageData(const LogMessageData&) = delete;
        method LogMessageData (line 313) | LogMessageData& operator=(const LogMessageData&) = delete;
      function ostream (line 2573) | ostream* CheckOpMessageBuilder::ForVar2() {
      function MakeCheckOpValueString (line 2584) | void MakeCheckOpValueString(std::ostream* os, const char& v) {
      function MakeCheckOpValueString (line 2593) | void MakeCheckOpValueString(std::ostream* os, const signed char& v) {
      function MakeCheckOpValueString (line 2602) | void MakeCheckOpValueString(std::ostream* os, const unsigned char& v) {
      function MakeCheckOpValueString (line 2611) | void MakeCheckOpValueString(std::ostream* os, const std::nullptr_t& ...
  function InitGoogleLogging (line 2618) | void InitGoogleLogging(const char* argv0) { InitGoogleLoggingUtilities(a...
  function InstallPrefixFormatter (line 2620) | void InstallPrefixFormatter(PrefixFormatterCallback callback, void* data) {
  function ShutdownGoogleLogging (line 2628) | void ShutdownGoogleLogging() {
  function EnableLogCleaner (line 2635) | void EnableLogCleaner(unsigned int overdue_days) {
  function EnableLogCleaner (line 2641) | void EnableLogCleaner(const std::chrono::minutes& overdue) {
  function DisableLogCleaner (line 2645) | void DisableLogCleaner() { log_cleaner.Disable(); }
  type void_impl (line 2652) | struct void_impl {
  type has_member_tm_gmtoff (line 2660) | struct has_member_tm_gmtoff : std::false_type {}
  type has_member_tm_gmtoff<T, void_t<decltype(&T::tm_gmtoff)>> (line 2663) | struct has_member_tm_gmtoff<T, void_t<decltype(&T::tm_gmtoff)>>
  function Breakdown (line 2667) | auto Breakdown(const std::chrono::system_clock::time_point& now)
  function Breakdown (line 2699) | auto Breakdown(const std::chrono::system_clock::time_point& now)

FILE: src/logging_unittest.cc
  type google (line 92) | namespace google {
    type base (line 93) | namespace base {
      type internal (line 94) | namespace internal {
    type glog_internal_namespace_ (line 1202) | inline namespace glog_internal_namespace_ {
  function BM_Check1 (line 126) | static void BM_Check1(int n) {
  function BM_Check3 (line 142) | static void BM_Check3(int n) {
  function BM_Check2 (line 156) | static void BM_Check2(int n) {
  function CheckFailure (line 173) | static void CheckFailure(int, int, const char* /* file */, int /* line */,
  function BM_logspeed (line 176) | static void BM_logspeed(int n) {
  function BM_vlog (line 183) | static void BM_vlog(int n) {
  function PrefixAttacher (line 194) | void PrefixAttacher(std::ostream& s, const LogMessage& m, void* data) {
  function main (line 211) | int main(int argc, char** argv) {
  function TestLogging (line 308) | void TestLogging(bool check_counts) {
  function NoAllocNewHook (line 359) | static void NoAllocNewHook() { LOG(FATAL) << "unexpected new"; }
  type NewHook (line 361) | struct NewHook {
    method NewHook (line 362) | NewHook() { g_new_hook = &NoAllocNewHook; }
  function TEST (line 370) | TEST(DeathNoAllocNewHook, logging) {
  function TestRawLogging (line 381) | void TestRawLogging() {
  function LogWithLevels (line 435) | void LogWithLevels(int v, int severity, bool err, bool alsoerr) {
  function TestLoggingLevels (line 520) | void TestLoggingLevels() {
  function TestVlogHelper (line 533) | int TestVlogHelper() {
  function TestVLogModule (line 540) | void TestVLogModule() {
  function TEST (line 551) | TEST(DeathRawCHECK, logging) {
  function TestLogString (line 558) | void TestLogString() {
  function TestLogToString (line 581) | void TestLogToString() {
  class TestLogSinkImpl (line 603) | class TestLogSinkImpl : public LogSink {
    method send (line 606) | void send(LogSeverity severity, const char* /* full_filename */,
  function TestLogSink (line 615) | void TestLogSink() {
  function TestCHECK (line 662) | void TestCHECK() {
  function TestDCHECK (line 688) | void TestDCHECK() {
  function TestSTREQ (line 708) | void TestSTREQ() {
  function TEST (line 721) | TEST(DeathSTREQ, logging) {
  function TEST (line 731) | TEST(CheckNOTNULL, Simple) {
  function TEST (line 742) | TEST(DeathCheckNN, Simple) {
  function GetFiles (line 747) | static void GetFiles(const string& pattern, vector<string>* files) {
  function DeleteFiles (line 781) | static void DeleteFiles(const string& pattern) {
  function CheckFile (line 790) | static void CheckFile(const string& name, const string& expected_string,
  function TestMaxLogSizeWhenNoTimestamp (line 811) | static void TestMaxLogSizeWhenNoTimestamp() {
  function TestBasename (line 852) | static void TestBasename() {
  function TestBasenameAppendWhenNoTimestamp (line 868) | static void TestBasenameAppendWhenNoTimestamp() {
  function TestTwoProcessesWrite (line 897) | static void TestTwoProcessesWrite() {
  function TestSymlink (line 938) | static void TestSymlink() {
  function TestExtension (line 957) | static void TestExtension() {
  type MyLogger (line 979) | struct MyLogger : public base::Logger {
    method MyLogger (line 982) | explicit MyLogger(bool* set_on_destruction)
    method Write (line 987) | void Write(bool /* should_flush */,
    method Flush (line 993) | void Flush() override {}
    method uint32 (line 995) | uint32 LogSize() override { return static_cast<uint32>(data.length()); }
  function TestWrapper (line 1001) | static void TestWrapper() {
  function TestErrno (line 1017) | static void TestErrno() {
  function TestOneTruncate (line 1025) | static void TestOneTruncate(const char* path, uint64 limit, uint64 keep,
  function TestTruncate (line 1069) | static void TestTruncate() {
  type RecordDeletionLogger (line 1111) | struct RecordDeletionLogger : public base::Logger {
    method RecordDeletionLogger (line 1112) | RecordDeletionLogger(bool* set_on_destruction, base::Logger* wrapped_l...
    method Write (line 1118) | void Write(bool force_flush,
    method Flush (line 1123) | void Flush() override { wrapped_logger_->Flush(); }
    method uint32 (line 1124) | uint32 LogSize() override { return wrapped_logger_->LogSize(); }
  function TestCustomLoggerDeletionOnShutdown (line 1131) | static void TestCustomLoggerDeletionOnShutdown() {
  type LogTimes (line 1142) | namespace LogTimes {
  type LogTimeRecorder (line 1157) | struct LogTimeRecorder {
    method LogTimeRecorder (line 1158) | LogTimeRecorder() = default;
  function int64 (line 1170) | int64 elapsedTime_ns(const std::chrono::steady_clock::time_point& begin,
  function TestLogPeriodically (line 1176) | static void TestLogPeriodically() {
  type google (line 1201) | namespace google {
    type base (line 93) | namespace base {
      type internal (line 94) | namespace internal {
    type glog_internal_namespace_ (line 1202) | inline namespace glog_internal_namespace_ {
  function WrapSafeFNMatch (line 1209) | static bool WrapSafeFNMatch(string pattern, string str) {
  function TEST (line 1216) | TEST(SafeFNMatch, logging) {
  class TestLogSinkWriter (line 1244) | class TestLogSinkWriter {
    method TestLogSinkWriter (line 1246) | TestLogSinkWriter() : t_{&TestLogSinkWriter::Run, this} {}
    method Buffer (line 1249) | void Buffer(const string& message) {
    method Wait (line 1258) | void Wait() {
    method Stop (line 1272) | void Stop() {
    method Join (line 1277) | void Join() { t_.join(); }
    method NoWork (line 1283) | bool NoWork() { return messages_.empty(); }
    method HaveWork (line 1284) | bool HaveWork() { return !messages_.empty() || should_exit_; }
    method Run (line 1287) | void Run() {
  class TestWaitingLogSink (line 1334) | class TestWaitingLogSink : public LogSink {
    method TestWaitingLogSink (line 1336) | TestWaitingLogSink() {
    method send (line 1348) | void send(LogSeverity severity, const char* /* full_filename */,
    method WaitTillSent (line 1361) | void WaitTillSent() override {
  function TestLogSinkWaitTillSent (line 1373) | static void TestLogSinkWaitTillSent() {
  function TEST (line 1395) | TEST(Strerror, logging) {
  function TEST (line 1431) | TEST(DVLog, Basic) {
  function TEST (line 1445) | TEST(DVLog, V0) {
  function TEST (line 1455) | TEST(LogAtLevel, Basic) {
  function TEST (line 1470) | TEST(TestExitOnDFatal, ToBeOrNotToBe) {
  function BacktraceAtHelper (line 1507) | static void BacktraceAtHelper() {
  function TEST (line 1515) | TEST(LogBacktraceAt, DoesNotBacktraceWhenDisabled) {
  function TEST (line 1526) | TEST(LogBacktraceAt, DoesBacktraceAtRightLineWhenEnabled) {
  type UserDefinedClass (line 1552) | struct UserDefinedClass {
  function ostream (line 1556) | inline ostream& operator<<(ostream& out, const UserDefinedClass&) {
  function TEST (line 1561) | TEST(UserDefinedClass, logging) {
  function TEST (line 1572) | TEST(LogMsgTime, gmtoff) {
  function TEST (line 1588) | TEST(EmailLogging, ValidAddress) {
  function TEST (line 1596) | TEST(EmailLogging, MultipleAddresses) {
  function TEST (line 1604) | TEST(EmailLogging, InvalidAddress) {
  function TEST (line 1611) | TEST(EmailLogging, MaliciousAddress) {
  function TEST (line 1619) | TEST(Logging, FatalThrow) {

FILE: src/mock-log.h
  function namespace (line 46) | namespace google {

FILE: src/mock-log_unittest.cc
  function TEST (line 54) | TEST(ScopedMockLogTest, InterceptsLog) {
  function LogBranch (line 69) | void LogBranch() { LOG(INFO) << "Logging a branch..."; }
  function LogTree (line 71) | void LogTree() { LOG(INFO) << "Logging the whole tree..."; }
  function LogForest (line 73) | void LogForest() {
  function TEST (line 82) | TEST(ScopedMockLogTest, LogDuringIntercept) {
  function main (line 97) | int main(int argc, char** argv) {

FILE: src/package_config_unittest/working_config/glog_package_config.cc
  function main (line 3) | int main(int /*argc*/, char** argv) { google::InitGoogleLogging(argv[0]); }

FILE: src/raw_logging.cc
  type google (line 72) | namespace google {
    function DoRawLog (line 93) | static bool DoRawLog(char** buf, size_t* size, const char* format, ...) {
    function VADoRawLog (line 105) | inline static bool VADoRawLog(char** buf, size_t* size, const char* fo...
    class StaticStringBuf (line 128) | class StaticStringBuf : public std::streambuf {
      method StaticStringBuf (line 130) | StaticStringBuf() {
    function RawLog__ (line 147) | void RawLog__(LogSeverity severity, const char* file, int line,

FILE: src/signalhandler.cc
  type google (line 63) | namespace google {
    class MinimalFormatter (line 104) | class MinimalFormatter {
      method MinimalFormatter (line 106) | MinimalFormatter(char* buffer, size_t size)
      method num_bytes_written (line 110) | std::size_t num_bytes_written() const {
      method AppendString (line 115) | void AppendString(const char* str) {
      method AppendUint64 (line 126) | void AppendUint64(uint64 number, unsigned radix) {
      method AppendHexWithPadding (line 144) | void AppendHexWithPadding(uint64 number, int width) {
    function WriteToStderr (line 164) | void WriteToStderr(const char* data, size_t size) {
    function DumpTimeInfo (line 175) | void DumpTimeInfo() {
    function DumpSignalInfo (line 192) | void DumpSignalInfo(int signal_number, siginfo_t* siginfo) {
    function DumpStackFrameInfo (line 244) | void DumpStackFrameInfo(const char* prefix, void* pc) {
    function InvokeDefaultSignalHandler (line 274) | void InvokeDefaultSignalHandler(int signal_number) {
    function FailureSignalHandler (line 355) | void FailureSignalHandler(int signal_number, siginfo_t* signal_info,
    function IsFailureSignalHandlerInstalled (line 369) | bool IsFailureSignalHandlerInstalled() {
    function InstallFailureSignalHandler (line 385) | void InstallFailureSignalHandler() {
    function InstallFailureWriter (line 406) | void InstallFailureWriter(void (*writer)(const char* data, size_t size...

FILE: src/signalhandler_unittest.cc
  function DieInThread (line 60) | static void DieInThread(int* a) {
  function WriteToStdout (line 69) | static void WriteToStdout(const char* data, size_t size) {
  function main (line 75) | int main(int argc, char** argv) {

FILE: src/stacktrace.h
  function namespace (line 69) | namespace google {

FILE: src/stacktrace_generic-inl.h
  function namespace (line 40) | namespace google {

FILE: src/stacktrace_libunwind-inl.h
  function namespace (line 43) | namespace google {

FILE: src/stacktrace_powerpc-inl.h
  function namespace (line 43) | namespace google {

FILE: src/stacktrace_unittest.cc
  type AddressRange (line 53) | struct AddressRange {
  function CheckRetAddrIsInFunction (line 111) | static void CheckRetAddrIsInFunction(void* ret_addr,
  function main (line 230) | int main(int, char** argv) {
  function main (line 241) | int main() {

FILE: src/stacktrace_unwind-inl.h
  function namespace (line 38) | namespace google {

FILE: src/stacktrace_windows-inl.h
  function namespace (line 39) | namespace google {

FILE: src/stacktrace_x86-inl.h
  function namespace (line 45) | namespace google {

FILE: src/stl_logging_unittest.cc
  type user_hash (line 45) | struct user_hash {
  function TestSTLLogging (line 49) | static void TestSTLLogging() {
  function main (line 110) | int main(int, char**) {

FILE: src/striplog_unittest.cc
  function CheckNoReturn (line 49) | int CheckNoReturn(bool b) {
  type A (line 59) | struct A {}
  function handle_abort (line 63) | void handle_abort(int /*code*/) { std::exit(EXIT_FAILURE); }
  function main (line 66) | int main(int, char* argv[]) {

FILE: src/symbolize.cc
  type google (line 73) | namespace google {
    type glog_internal_namespace_ (line 74) | inline namespace glog_internal_namespace_ {
      function ATTRIBUTE_NOINLINE (line 85) | ATTRIBUTE_NOINLINE
      function InstallSymbolizeCallback (line 100) | void InstallSymbolizeCallback(SymbolizeCallback callback) {
      function InstallSymbolizeOpenObjectFileCallback (line 104) | void InstallSymbolizeOpenObjectFileCallback(
      function ATTRIBUTE_NOINLINE (line 830) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
      class SymInitializer (line 859) | class SymInitializer final {
        method SymInitializer (line 863) | SymInitializer() : process(GetCurrentProcess()), ready(false) {
        method SymInitializer (line 879) | SymInitializer(const SymInitializer&) = delete;
        method SymInitializer (line 880) | SymInitializer& operator=(const SymInitializer&) = delete;
        method SymInitializer (line 881) | SymInitializer(SymInitializer&&) = delete;
        method SymInitializer (line 882) | SymInitializer& operator=(SymInitializer&&) = delete;
      function ATTRIBUTE_NOINLINE (line 887) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* ...
      function Symbolize (line 956) | bool Symbolize(void* pc, char* out, size_t out_size, SymbolizeOption...
    type glog_internal_namespace_ (line 828) | inline namespace glog_internal_namespace_ {
      function ATTRIBUTE_NOINLINE (line 85) | ATTRIBUTE_NOINLINE
      function InstallSymbolizeCallback (line 100) | void InstallSymbolizeCallback(SymbolizeCallback callback) {
      function InstallSymbolizeOpenObjectFileCallback (line 104) | void InstallSymbolizeOpenObjectFileCallback(
      function ATTRIBUTE_NOINLINE (line 830) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
      class SymInitializer (line 859) | class SymInitializer final {
        method SymInitializer (line 863) | SymInitializer() : process(GetCurrentProcess()), ready(false) {
        method SymInitializer (line 879) | SymInitializer(const SymInitializer&) = delete;
        method SymInitializer (line 880) | SymInitializer& operator=(const SymInitializer&) = delete;
        method SymInitializer (line 881) | SymInitializer(SymInitializer&&) = delete;
        method SymInitializer (line 882) | SymInitializer& operator=(SymInitializer&&) = delete;
      function ATTRIBUTE_NOINLINE (line 887) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* ...
      function Symbolize (line 956) | bool Symbolize(void* pc, char* out, size_t out_size, SymbolizeOption...
    type glog_internal_namespace_ (line 855) | inline namespace glog_internal_namespace_ {
      function ATTRIBUTE_NOINLINE (line 85) | ATTRIBUTE_NOINLINE
      function InstallSymbolizeCallback (line 100) | void InstallSymbolizeCallback(SymbolizeCallback callback) {
      function InstallSymbolizeOpenObjectFileCallback (line 104) | void InstallSymbolizeOpenObjectFileCallback(
      function ATTRIBUTE_NOINLINE (line 830) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
      class SymInitializer (line 859) | class SymInitializer final {
        method SymInitializer (line 863) | SymInitializer() : process(GetCurrentProcess()), ready(false) {
        method SymInitializer (line 879) | SymInitializer(const SymInitializer&) = delete;
        method SymInitializer (line 880) | SymInitializer& operator=(const SymInitializer&) = delete;
        method SymInitializer (line 881) | SymInitializer(SymInitializer&&) = delete;
        method SymInitializer (line 882) | SymInitializer& operator=(SymInitializer&&) = delete;
      function ATTRIBUTE_NOINLINE (line 887) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* ...
      function Symbolize (line 956) | bool Symbolize(void* pc, char* out, size_t out_size, SymbolizeOption...
    type glog_internal_namespace_ (line 954) | inline namespace glog_internal_namespace_ {
      function ATTRIBUTE_NOINLINE (line 85) | ATTRIBUTE_NOINLINE
      function InstallSymbolizeCallback (line 100) | void InstallSymbolizeCallback(SymbolizeCallback callback) {
      function InstallSymbolizeOpenObjectFileCallback (line 104) | void InstallSymbolizeOpenObjectFileCallback(
      function ATTRIBUTE_NOINLINE (line 830) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
      class SymInitializer (line 859) | class SymInitializer final {
        method SymInitializer (line 863) | SymInitializer() : process(GetCurrentProcess()), ready(false) {
        method SymInitializer (line 879) | SymInitializer(const SymInitializer&) = delete;
        method SymInitializer (line 880) | SymInitializer& operator=(const SymInitializer&) = delete;
        method SymInitializer (line 881) | SymInitializer(SymInitializer&&) = delete;
        method SymInitializer (line 882) | SymInitializer& operator=(SymInitializer&&) = delete;
      function ATTRIBUTE_NOINLINE (line 887) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* ...
      function Symbolize (line 956) | bool Symbolize(void* pc, char* out, size_t out_size, SymbolizeOption...
  type glog_internal_namespace_ (line 135) | inline namespace glog_internal_namespace_ {
    function FailureRetry (line 142) | auto FailureRetry(Functor run, int error = EINTR) noexcept(noexcept(ru...
    function ReadFromOffset (line 157) | static ssize_t ReadFromOffset(const int fd, void* buf, const size_t co...
    function ReadFromOffsetExact (line 185) | static bool ReadFromOffsetExact(const int fd, void* buf, const size_t ...
    function FileGetElfType (line 192) | static int FileGetElfType(const int fd) {
    function ATTRIBUTE_NOINLINE (line 208) | static ATTRIBUTE_NOINLINE bool GetSectionHeaderByType(const int fd,
    function GetSectionHeaderByName (line 243) | bool GetSectionHeaderByName(int fd, const char* name, size_t name_len,
    function ATTRIBUTE_NOINLINE (line 294) | static ATTRIBUTE_NOINLINE bool FindSymbol(uint64_t pc, const int fd, c...
    function GetSymbolFromObjectFile (line 349) | static bool GetSymbolFromObjectFile(const int fd, uint64_t pc, char* out,
    class LineReader (line 395) | class LineReader {
      method LineReader (line 397) | explicit LineReader(int fd, char* buf, size_t buf_len, size_t offset)
      method ReadLine (line 411) | bool ReadLine(const char** bol, const char** eol) {
      method LineReader (line 458) | LineReader(const LineReader&) = delete;
      method BufferIsEmpty (line 466) | bool BufferIsEmpty() { return buf_ == eod_; }
      method HasCompleteLine (line 468) | bool HasCompleteLine() {
    function ATTRIBUTE_NOINLINE (line 509) | static ATTRIBUTE_NOINLINE FileDescriptor
    function SafeAppendString (line 713) | static void SafeAppendString(const char* source, char* dest, size_t de...
    function SafeAppendHexNumber (line 726) | static void SafeAppendHexNumber(uint64_t value, char* dest, size_t des...
    function ATTRIBUTE_NOINLINE (line 740) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
  type google (line 827) | namespace google {
    type glog_internal_namespace_ (line 74) | inline namespace glog_internal_namespace_ {
      function ATTRIBUTE_NOINLINE (line 85) | ATTRIBUTE_NOINLINE
      function InstallSymbolizeCallback (line 100) | void InstallSymbolizeCallback(SymbolizeCallback callback) {
      function InstallSymbolizeOpenObjectFileCallback (line 104) | void InstallSymbolizeOpenObjectFileCallback(
      function ATTRIBUTE_NOINLINE (line 830) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
      class SymInitializer (line 859) | class SymInitializer final {
        method SymInitializer (line 863) | SymInitializer() : process(GetCurrentProcess()), ready(false) {
        method SymInitializer (line 879) | SymInitializer(const SymInitializer&) = delete;
        method SymInitializer (line 880) | SymInitializer& operator=(const SymInitializer&) = delete;
        method SymInitializer (line 881) | SymInitializer(SymInitializer&&) = delete;
        method SymInitializer (line 882) | SymInitializer& operator=(SymInitializer&&) = delete;
      function ATTRIBUTE_NOINLINE (line 887) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* ...
      function Symbolize (line 956) | bool Symbolize(void* pc, char* out, size_t out_size, SymbolizeOption...
    type glog_internal_namespace_ (line 828) | inline namespace glog_internal_namespace_ {
      function ATTRIBUTE_NOINLINE (line 85) | ATTRIBUTE_NOINLINE
      function InstallSymbolizeCallback (line 100) | void InstallSymbolizeCallback(SymbolizeCallback callback) {
      function InstallSymbolizeOpenObjectFileCallback (line 104) | void InstallSymbolizeOpenObjectFileCallback(
      function ATTRIBUTE_NOINLINE (line 830) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
      class SymInitializer (line 859) | class SymInitializer final {
        method SymInitializer (line 863) | SymInitializer() : process(GetCurrentProcess()), ready(false) {
        method SymInitializer (line 879) | SymInitializer(const SymInitializer&) = delete;
        method SymInitializer (line 880) | SymInitializer& operator=(const SymInitializer&) = delete;
        method SymInitializer (line 881) | SymInitializer(SymInitializer&&) = delete;
        method SymInitializer (line 882) | SymInitializer& operator=(SymInitializer&&) = delete;
      function ATTRIBUTE_NOINLINE (line 887) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* ...
      function Symbolize (line 956) | bool Symbolize(void* pc, char* out, size_t out_size, SymbolizeOption...
    type glog_internal_namespace_ (line 855) | inline namespace glog_internal_namespace_ {
      function ATTRIBUTE_NOINLINE (line 85) | ATTRIBUTE_NOINLINE
      function InstallSymbolizeCallback (line 100) | void InstallSymbolizeCallback(SymbolizeCallback callback) {
      function InstallSymbolizeOpenObjectFileCallback (line 104) | void InstallSymbolizeOpenObjectFileCallback(
      function ATTRIBUTE_NOINLINE (line 830) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
      class SymInitializer (line 859) | class SymInitializer final {
        method SymInitializer (line 863) | SymInitializer() : process(GetCurrentProcess()), ready(false) {
        method SymInitializer (line 879) | SymInitializer(const SymInitializer&) = delete;
        method SymInitializer (line 880) | SymInitializer& operator=(const SymInitializer&) = delete;
        method SymInitializer (line 881) | SymInitializer(SymInitializer&&) = delete;
        method SymInitializer (line 882) | SymInitializer& operator=(SymInitializer&&) = delete;
      function ATTRIBUTE_NOINLINE (line 887) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* ...
      function Symbolize (line 956) | bool Symbolize(void* pc, char* out, size_t out_size, SymbolizeOption...
    type glog_internal_namespace_ (line 954) | inline namespace glog_internal_namespace_ {
      function ATTRIBUTE_NOINLINE (line 85) | ATTRIBUTE_NOINLINE
      function InstallSymbolizeCallback (line 100) | void InstallSymbolizeCallback(SymbolizeCallback callback) {
      function InstallSymbolizeOpenObjectFileCallback (line 104) | void InstallSymbolizeOpenObjectFileCallback(
      function ATTRIBUTE_NOINLINE (line 830) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
      class SymInitializer (line 859) | class SymInitializer final {
        method SymInitializer (line 863) | SymInitializer() : process(GetCurrentProcess()), ready(false) {
        method SymInitializer (line 879) | SymInitializer(const SymInitializer&) = delete;
        method SymInitializer (line 880) | SymInitializer& operator=(const SymInitializer&) = delete;
        method SymInitializer (line 881) | SymInitializer(SymInitializer&&) = delete;
        method SymInitializer (line 882) | SymInitializer& operator=(SymInitializer&&) = delete;
      function ATTRIBUTE_NOINLINE (line 887) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* ...
      function Symbolize (line 956) | bool Symbolize(void* pc, char* out, size_t out_size, SymbolizeOption...
  type google (line 854) | namespace google {
    type glog_internal_namespace_ (line 74) | inline namespace glog_internal_namespace_ {
      function ATTRIBUTE_NOINLINE (line 85) | ATTRIBUTE_NOINLINE
      function InstallSymbolizeCallback (line 100) | void InstallSymbolizeCallback(SymbolizeCallback callback) {
      function InstallSymbolizeOpenObjectFileCallback (line 104) | void InstallSymbolizeOpenObjectFileCallback(
      function ATTRIBUTE_NOINLINE (line 830) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
      class SymInitializer (line 859) | class SymInitializer final {
        method SymInitializer (line 863) | SymInitializer() : process(GetCurrentProcess()), ready(false) {
        method SymInitializer (line 879) | SymInitializer(const SymInitializer&) = delete;
        method SymInitializer (line 880) | SymInitializer& operator=(const SymInitializer&) = delete;
        method SymInitializer (line 881) | SymInitializer(SymInitializer&&) = delete;
        method SymInitializer (line 882) | SymInitializer& operator=(SymInitializer&&) = delete;
      function ATTRIBUTE_NOINLINE (line 887) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* ...
      function Symbolize (line 956) | bool Symbolize(void* pc, char* out, size_t out_size, SymbolizeOption...
    type glog_internal_namespace_ (line 828) | inline namespace glog_internal_namespace_ {
      function ATTRIBUTE_NOINLINE (line 85) | ATTRIBUTE_NOINLINE
      function InstallSymbolizeCallback (line 100) | void InstallSymbolizeCallback(SymbolizeCallback callback) {
      function InstallSymbolizeOpenObjectFileCallback (line 104) | void InstallSymbolizeOpenObjectFileCallback(
      function ATTRIBUTE_NOINLINE (line 830) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
      class SymInitializer (line 859) | class SymInitializer final {
        method SymInitializer (line 863) | SymInitializer() : process(GetCurrentProcess()), ready(false) {
        method SymInitializer (line 879) | SymInitializer(const SymInitializer&) = delete;
        method SymInitializer (line 880) | SymInitializer& operator=(const SymInitializer&) = delete;
        method SymInitializer (line 881) | SymInitializer(SymInitializer&&) = delete;
        method SymInitializer (line 882) | SymInitializer& operator=(SymInitializer&&) = delete;
      function ATTRIBUTE_NOINLINE (line 887) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* ...
      function Symbolize (line 956) | bool Symbolize(void* pc, char* out, size_t out_size, SymbolizeOption...
    type glog_internal_namespace_ (line 855) | inline namespace glog_internal_namespace_ {
      function ATTRIBUTE_NOINLINE (line 85) | ATTRIBUTE_NOINLINE
      function InstallSymbolizeCallback (line 100) | void InstallSymbolizeCallback(SymbolizeCallback callback) {
      function InstallSymbolizeOpenObjectFileCallback (line 104) | void InstallSymbolizeOpenObjectFileCallback(
      function ATTRIBUTE_NOINLINE (line 830) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
      class SymInitializer (line 859) | class SymInitializer final {
        method SymInitializer (line 863) | SymInitializer() : process(GetCurrentProcess()), ready(false) {
        method SymInitializer (line 879) | SymInitializer(const SymInitializer&) = delete;
        method SymInitializer (line 880) | SymInitializer& operator=(const SymInitializer&) = delete;
        method SymInitializer (line 881) | SymInitializer(SymInitializer&&) = delete;
        method SymInitializer (line 882) | SymInitializer& operator=(SymInitializer&&) = delete;
      function ATTRIBUTE_NOINLINE (line 887) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* ...
      function Symbolize (line 956) | bool Symbolize(void* pc, char* out, size_t out_size, SymbolizeOption...
    type glog_internal_namespace_ (line 954) | inline namespace glog_internal_namespace_ {
      function ATTRIBUTE_NOINLINE (line 85) | ATTRIBUTE_NOINLINE
      function InstallSymbolizeCallback (line 100) | void InstallSymbolizeCallback(SymbolizeCallback callback) {
      function InstallSymbolizeOpenObjectFileCallback (line 104) | void InstallSymbolizeOpenObjectFileCallback(
      function ATTRIBUTE_NOINLINE (line 830) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
      class SymInitializer (line 859) | class SymInitializer final {
        method SymInitializer (line 863) | SymInitializer() : process(GetCurrentProcess()), ready(false) {
        method SymInitializer (line 879) | SymInitializer(const SymInitializer&) = delete;
        method SymInitializer (line 880) | SymInitializer& operator=(const SymInitializer&) = delete;
        method SymInitializer (line 881) | SymInitializer(SymInitializer&&) = delete;
        method SymInitializer (line 882) | SymInitializer& operator=(SymInitializer&&) = delete;
      function ATTRIBUTE_NOINLINE (line 887) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* ...
      function Symbolize (line 956) | bool Symbolize(void* pc, char* out, size_t out_size, SymbolizeOption...
  type google (line 953) | namespace google {
    type glog_internal_namespace_ (line 74) | inline namespace glog_internal_namespace_ {
      function ATTRIBUTE_NOINLINE (line 85) | ATTRIBUTE_NOINLINE
      function InstallSymbolizeCallback (line 100) | void InstallSymbolizeCallback(SymbolizeCallback callback) {
      function InstallSymbolizeOpenObjectFileCallback (line 104) | void InstallSymbolizeOpenObjectFileCallback(
      function ATTRIBUTE_NOINLINE (line 830) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
      class SymInitializer (line 859) | class SymInitializer final {
        method SymInitializer (line 863) | SymInitializer() : process(GetCurrentProcess()), ready(false) {
        method SymInitializer (line 879) | SymInitializer(const SymInitializer&) = delete;
        method SymInitializer (line 880) | SymInitializer& operator=(const SymInitializer&) = delete;
        method SymInitializer (line 881) | SymInitializer(SymInitializer&&) = delete;
        method SymInitializer (line 882) | SymInitializer& operator=(SymInitializer&&) = delete;
      function ATTRIBUTE_NOINLINE (line 887) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* ...
      function Symbolize (line 956) | bool Symbolize(void* pc, char* out, size_t out_size, SymbolizeOption...
    type glog_internal_namespace_ (line 828) | inline namespace glog_internal_namespace_ {
      function ATTRIBUTE_NOINLINE (line 85) | ATTRIBUTE_NOINLINE
      function InstallSymbolizeCallback (line 100) | void InstallSymbolizeCallback(SymbolizeCallback callback) {
      function InstallSymbolizeOpenObjectFileCallback (line 104) | void InstallSymbolizeOpenObjectFileCallback(
      function ATTRIBUTE_NOINLINE (line 830) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
      class SymInitializer (line 859) | class SymInitializer final {
        method SymInitializer (line 863) | SymInitializer() : process(GetCurrentProcess()), ready(false) {
        method SymInitializer (line 879) | SymInitializer(const SymInitializer&) = delete;
        method SymInitializer (line 880) | SymInitializer& operator=(const SymInitializer&) = delete;
        method SymInitializer (line 881) | SymInitializer(SymInitializer&&) = delete;
        method SymInitializer (line 882) | SymInitializer& operator=(SymInitializer&&) = delete;
      function ATTRIBUTE_NOINLINE (line 887) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* ...
      function Symbolize (line 956) | bool Symbolize(void* pc, char* out, size_t out_size, SymbolizeOption...
    type glog_internal_namespace_ (line 855) | inline namespace glog_internal_namespace_ {
      function ATTRIBUTE_NOINLINE (line 85) | ATTRIBUTE_NOINLINE
      function InstallSymbolizeCallback (line 100) | void InstallSymbolizeCallback(SymbolizeCallback callback) {
      function InstallSymbolizeOpenObjectFileCallback (line 104) | void InstallSymbolizeOpenObjectFileCallback(
      function ATTRIBUTE_NOINLINE (line 830) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
      class SymInitializer (line 859) | class SymInitializer final {
        method SymInitializer (line 863) | SymInitializer() : process(GetCurrentProcess()), ready(false) {
        method SymInitializer (line 879) | SymInitializer(const SymInitializer&) = delete;
        method SymInitializer (line 880) | SymInitializer& operator=(const SymInitializer&) = delete;
        method SymInitializer (line 881) | SymInitializer(SymInitializer&&) = delete;
        method SymInitializer (line 882) | SymInitializer& operator=(SymInitializer&&) = delete;
      function ATTRIBUTE_NOINLINE (line 887) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* ...
      function Symbolize (line 956) | bool Symbolize(void* pc, char* out, size_t out_size, SymbolizeOption...
    type glog_internal_namespace_ (line 954) | inline namespace glog_internal_namespace_ {
      function ATTRIBUTE_NOINLINE (line 85) | ATTRIBUTE_NOINLINE
      function InstallSymbolizeCallback (line 100) | void InstallSymbolizeCallback(SymbolizeCallback callback) {
      function InstallSymbolizeOpenObjectFileCallback (line 104) | void InstallSymbolizeOpenObjectFileCallback(
      function ATTRIBUTE_NOINLINE (line 830) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(
      class SymInitializer (line 859) | class SymInitializer final {
        method SymInitializer (line 863) | SymInitializer() : process(GetCurrentProcess()), ready(false) {
        method SymInitializer (line 879) | SymInitializer(const SymInitializer&) = delete;
        method SymInitializer (line 880) | SymInitializer& operator=(const SymInitializer&) = delete;
        method SymInitializer (line 881) | SymInitializer(SymInitializer&&) = delete;
        method SymInitializer (line 882) | SymInitializer& operator=(SymInitializer&&) = delete;
      function ATTRIBUTE_NOINLINE (line 887) | static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void* pc, char* ...
      function Symbolize (line 956) | bool Symbolize(void* pc, char* out, size_t out_size, SymbolizeOption...

FILE: src/symbolize.h
  function namespace (line 118) | namespace google {
  function namespace (line 132) | namespace google {
  function namespace (line 171) | namespace google {

FILE: src/symbolize_unittest.cc
  function nonstatic_func (line 98) | void nonstatic_func() {
  function static_func (line 105) | static void static_func() {
  function TEST (line 113) | TEST(Symbolize, Symbolize) {
  type Foo (line 134) | struct Foo {
  function TEST (line 148) | TEST(Symbolize, SymbolizeWithDemangling) {
  function EmptySignalHandler (line 181) | static void EmptySignalHandler(int /*signo*/) {}
  function SymbolizeSignalHandler (line 183) | static void SymbolizeSignalHandler(int /*signo*/) {
  function ATTRIBUTE_NOINLINE (line 198) | static ATTRIBUTE_NOINLINE bool StackGrowsDown(int* x) {
  function GetStackConsumption (line 202) | static int GetStackConsumption(const char* alt_stack) {
  type sigaction (line 244) | struct sigaction
  type sigaction (line 245) | struct sigaction
  type sigaction (line 246) | struct sigaction
  function TEST (line 301) | TEST(Symbolize, SymbolizeStackConsumption) {
  function TEST (line 327) | TEST(Symbolize, SymbolizeWithDemanglingStackConsumption) {
  type Foo (line 417) | struct Foo {
  function TEST (line 428) | TEST(Symbolize, SymbolizeWithDemangling) {
  function TestWithReturnAddress (line 437) | __declspec(noinline) void TestWithReturnAddress() {
  function main (line 456) | int main(int argc, char** argv) {

FILE: src/utilities.cc
  type google (line 76) | namespace google {
    function IsGoogleLoggingInitialized (line 80) | bool IsGoogleLoggingInitialized() {
    type glog_internal_namespace_ (line 84) | inline namespace glog_internal_namespace_ {
      function AlsoErrorWrite (line 88) | void AlsoErrorWrite(LogSeverity severity, const char* tag,
      function int32 (line 247) | int32 GetMainThreadPid() { return g_main_thread_pid; }
      function PidHasChanged (line 249) | bool PidHasChanged() {
      function string (line 259) | const string& MyUserName() { return g_my_user_name; }
      function MyUserNameInitializer (line 260) | static void MyUserNameInitializer() {
      function SetCrashReason (line 294) | void SetCrashReason(const logging::internal::CrashReason* r) {
      function InitGoogleLoggingUtilities (line 299) | void InitGoogleLoggingUtilities(const char* argv0) {
      function ShutdownGoogleLoggingUtilities (line 309) | void ShutdownGoogleLoggingUtilities() {
    type glog_internal_namespace_ (line 219) | inline namespace glog_internal_namespace_ {
      function AlsoErrorWrite (line 88) | void AlsoErrorWrite(LogSeverity severity, const char* tag,
      function int32 (line 247) | int32 GetMainThreadPid() { return g_main_thread_pid; }
      function PidHasChanged (line 249) | bool PidHasChanged() {
      function string (line 259) | const string& MyUserName() { return g_my_user_name; }
      function MyUserNameInitializer (line 260) | static void MyUserNameInitializer() {
      function SetCrashReason (line 294) | void SetCrashReason(const logging::internal::CrashReason* r) {
      function InitGoogleLoggingUtilities (line 299) | void InitGoogleLoggingUtilities(const char* argv0) {
      function ShutdownGoogleLoggingUtilities (line 309) | void ShutdownGoogleLoggingUtilities() {
    function GetStackTrace (line 322) | std::string GetStackTrace() {
  function DebugWriteToStderr (line 130) | static void DebugWriteToStderr(const char* data, void*) {
  function DebugWriteToString (line 139) | static void DebugWriteToString(const char* data, void* arg) {
  function DumpPCAndSymbol (line 145) | static void DumpPCAndSymbol(DebugWriter* writerfn, void* arg, void* pc,
  function DumpPC (line 162) | static void DumpPC(DebugWriter* writerfn, void* arg, void* pc,
  function DumpStackTrace (line 171) | static void DumpStackTrace(int skip_count, DebugWriter* writerfn, void* ...
  function DumpStackTraceAndExit (line 189) | __attribute__((noreturn))
  type google (line 217) | namespace google {
    function IsGoogleLoggingInitialized (line 80) | bool IsGoogleLoggingInitialized() {
    type glog_internal_namespace_ (line 84) | inline namespace glog_internal_namespace_ {
      function AlsoErrorWrite (line 88) | void AlsoErrorWrite(LogSeverity severity, const char* tag,
      function int32 (line 247) | int32 GetMainThreadPid() { return g_main_thread_pid; }
      function PidHasChanged (line 249) | bool PidHasChanged() {
      function string (line 259) | const string& MyUserName() { return g_my_user_name; }
      function MyUserNameInitializer (line 260) | static void MyUserNameInitializer() {
      function SetCrashReason (line 294) | void SetCrashReason(const logging::internal::CrashReason* r) {
      function InitGoogleLoggingUtilities (line 299) | void InitGoogleLoggingUtilities(const char* argv0) {
      function ShutdownGoogleLoggingUtilities (line 309) | void ShutdownGoogleLoggingUtilities() {
    type glog_internal_namespace_ (line 219) | inline namespace glog_internal_namespace_ {
      function AlsoErrorWrite (line 88) | void AlsoErrorWrite(LogSeverity severity, const char* tag,
      function int32 (line 247) | int32 GetMainThreadPid() { return g_main_thread_pid; }
      function PidHasChanged (line 249) | bool PidHasChanged() {
      function string (line 259) | const string& MyUserName() { return g_my_user_name; }
      function MyUserNameInitializer (line 260) | static void MyUserNameInitializer() {
      function SetCrashReason (line 294) | void SetCrashReason(const logging::internal::CrashReason* r) {
      function InitGoogleLoggingUtilities (line 299) | void InitGoogleLoggingUtilities(const char* argv0) {
      function ShutdownGoogleLoggingUtilities (line 309) | void ShutdownGoogleLoggingUtilities() {
    function GetStackTrace (line 322) | std::string GetStackTrace() {

FILE: src/utilities.h
  function namespace (line 110) | namespace google {
  function noexcept (line 258) | nullptr_t) noexcept {
  function noexcept (line 266) | nullptr_t) noexcept {
  function FILE (line 279) | struct std::default_delete<std::FILE> {

FILE: src/utilities_unittest.cc
  function TEST (line 43) | TEST(utilities, InitGoogleLoggingDeathTest) {
  function main (line 47) | int main(int argc, char** argv) {

FILE: src/vlog_is_on.cc
  type google (line 49) | namespace google {
    type glog_internal_namespace_ (line 51) | inline namespace glog_internal_namespace_ {
      function GLOG_NO_EXPORT (line 57) | GLOG_NO_EXPORT bool SafeFNMatch_(const char* pattern, size_t patt_len,
    type VModuleInfo (line 96) | struct VModuleInfo {
    function VLOG2Initializer (line 115) | static void VLOG2Initializer() {
    function SetVLOGLevel (line 150) | int SetVLOGLevel(const char* module_pattern, int log_level) {
    function InitVLOG3__ (line 203) | bool InitVLOG3__(SiteFlag* site_flag, int32* level_default, const char...

FILE: src/windows/dirent.h
  type _wdirent (line 220) | struct _wdirent {
  type _WDIR (line 240) | struct _WDIR {
  type dirent (line 258) | struct dirent {
  type DIR (line 278) | struct DIR {
  type dirent (line 287) | struct dirent
  type _wdirent (line 288) | struct _wdirent
  type dirent (line 290) | struct dirent
  type dirent (line 290) | struct dirent
  type _wdirent (line 291) | struct _wdirent
  type _wdirent (line 292) | struct _wdirent
  type dirent (line 300) | struct dirent
  type dirent (line 301) | struct dirent
  type dirent (line 302) | struct dirent
  type dirent (line 303) | struct dirent
  type dirent (line 305) | struct dirent
  type dirent (line 305) | struct dirent
  type dirent (line 307) | struct dirent
  type dirent (line 307) | struct dirent
  function _WDIR (line 336) | static _WDIR* _wopendir(const wchar_t* dirname) {
  type _wdirent (line 434) | struct _wdirent
  type _wdirent (line 435) | struct _wdirent
  function _wreaddir_r (line 453) | static int _wreaddir_r(_WDIR* dirp, struct _wdirent* entry,
  function _wclosedir (line 509) | static int _wclosedir(_WDIR* dirp) {
  function _wrewinddir (line 536) | static void _wrewinddir(_WDIR* dirp) {
  function WIN32_FIND_DATAW (line 549) | static WIN32_FIND_DATAW* dirent_first(_WDIR* dirp) {
  function WIN32_FIND_DATAW (line 593) | static WIN32_FIND_DATAW* dirent_next(_WDIR* dirp) {
  type DIR (line 634) | struct DIR
  type dirent (line 670) | struct dirent
  type dirent (line 671) | struct dirent
  function readdir_r (line 689) | static int readdir_r(DIR* dirp, struct dirent* entry, struct dirent** re...
  function closedir (line 768) | static int closedir(DIR* dirp) {
  function rewinddir (line 789) | static void rewinddir(DIR* dirp) {
  function scandir (line 797) | static int scandir(const char* dirname, struct dirent*** namelist,
  function alphasort (line 924) | static int alphasort(const struct dirent** a, const struct dirent** b) {
  function versionsort (line 929) | static int versionsort(const struct dirent** a, const struct dirent** b) {
  function dirent_mbstowcs_s (line 935) | static int dirent_mbstowcs_s(size_t* pReturnValue, wchar_t* wcstr,
  function dirent_wcstombs_s (line 979) | static int dirent_wcstombs_s(size_t* pReturnValue, char* mbstr,
  function dirent_set_errno (line 1023) | static void dirent_set_errno(int error) {

FILE: src/windows/port.cc
  type google (line 45) | namespace google {
    type glog_internal_namespace_ (line 46) | inline namespace glog_internal_namespace_ {
      type tm (line 49) | struct tm
      type tm (line 55) | struct tm

FILE: src/windows/port.h
  function namespace (line 122) | namespace google {