src/symbolize.cc

   1 // Copyright (c) 2006, Google Inc.
   2 // All rights reserved.
   3 //
   4 // Redistribution and use in source and binary forms, with or without
   5 // modification, are permitted provided that the following conditions are
   6 // met:
   7 //
   8 //     * Redistributions of source code must retain the above copyright
   9 // notice, this list of conditions and the following disclaimer.
  10 //     * Redistributions in binary form must reproduce the above
  11 // copyright notice, this list of conditions and the following disclaimer
  12 // in the documentation and/or other materials provided with the
  13 // distribution.
  14 //     * Neither the name of Google Inc. nor the names of its
  15 // contributors may be used to endorse or promote products derived from
  16 // this software without specific prior written permission.
  17 //
  18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 //
  30 // Author: Satoru Takabayashi
  31 // Stack-footprint reduction work done by Raksit Ashok
  32 //
  33 // Implementation note:
  34 //
  35 // We don't use heaps but only use stacks.  We want to reduce the
  36 // stack consumption so that the symbolizer can run on small stacks.
  37 //
  38 // Here are some numbers collected with GCC 4.1.0 on x86:
  39 // - sizeof(Elf32_Sym)  = 16
  40 // - sizeof(Elf32_Shdr) = 40
  41 // - sizeof(Elf64_Sym)  = 24
  42 // - sizeof(Elf64_Shdr) = 64
  43 //
  44 // This implementation is intended to be async-signal-safe but uses
  45 // some functions which are not guaranteed to be so, such as memchr()
  46 // and memmove().  We assume they are async-signal-safe.
  47 //
  48
  49 #include "utilities.h"
  50
  51 #if defined(HAVE_SYMBOLIZE)
  52
  53 #include <limits>
  54
  55 #include "symbolize.h"
  56 #include "demangle.h"
  57
  58 _START_GOOGLE_NAMESPACE_
  59
  60 // We don't use assert() since it's not guaranteed to be
  61 // async-signal-safe.  Instead we define a minimal assertion
  62 // macro. So far, we don't need pretty printing for __FILE__, etc.
  63
  64 // A wrapper for abort() to make it callable in ? :.
  65 static int AssertFail() {
  66   abort();
  67   return 0;  // Should not reach.
  68 }
  69
  70 #define SAFE_ASSERT(expr) ((expr) ? 0 : AssertFail())
  71
  72 static SymbolizeCallback g_symbolize_callback = NULL;
  73 void InstallSymbolizeCallback(SymbolizeCallback callback) {
  74   g_symbolize_callback = callback;
  75 }
  76
  77 // This function wraps the Demangle function to provide an interface
  78 // where the input symbol is demangled in-place.
  79 // To keep stack consumption low, we would like this function to not
  80 // get inlined.
  81 static ATTRIBUTE_NOINLINE void DemangleInplace(char *out, int out_size) {
  82   char demangled[256];  // Big enough for sane demangled symbols.
  83   if (Demangle(out, demangled, sizeof(demangled))) {
  84     // Demangling succeeded. Copy to out if the space allows.
  85     int len = strlen(demangled);
  86     if (len + 1 <= out_size) {  // +1 for '\0'.
  87       SAFE_ASSERT(len < sizeof(demangled));
  88       memmove(out, demangled, len + 1);
  89     }
  90   }
  91 }
  92
  93 _END_GOOGLE_NAMESPACE_
  94
  95 #if defined(__ELF__)
  96
  97 #include <dlfcn.h>
  98 #include <elf.h>
  99 #include <errno.h>
 100 #include <fcntl.h>
 101 #include <limits.h>
 102 #include <link.h>  // For ElfW() macro.
 103 #include <stdint.h>
 104 #include <stdio.h>
 105 #include <stdlib.h>
 106 #include <stddef.h>
 107 #include <string.h>
 108 #include <sys/stat.h>
 109 #include <sys/types.h>
 110 #include <unistd.h>
 111
 112 #include "symbolize.h"
 113 #include "config.h"
 114 #include "glog/raw_logging.h"
 115
 116 // Re-runs fn until it doesn't cause EINTR.
 117 #define NO_INTR(fn)   do {} while ((fn) < 0 && errno == EINTR)
 118
 119 _START_GOOGLE_NAMESPACE_
 120
 121 // Read up to "count" bytes from file descriptor "fd" into the buffer
 122 // starting at "buf" while handling short reads and EINTR.  On
 123 // success, return the number of bytes read.  Otherwise, return -1.
 124 static ssize_t ReadPersistent(const int fd, void *buf, const size_t count) {
 125   SAFE_ASSERT(fd >= 0);
 126   SAFE_ASSERT(count >= 0 && count <= std::numeric_limits<ssize_t>::max());
 127   char *buf0 = reinterpret_cast<char *>(buf);
 128   ssize_t num_bytes = 0;
 129   while (num_bytes < count) {
 130     ssize_t len;
 131     NO_INTR(len = read(fd, buf0 + num_bytes, count - num_bytes));
 132     if (len < 0) {  // There was an error other than EINTR.
 133       return -1;
 134     }
 135     if (len == 0) {  // Reached EOF.
 136       break;
 137     }
 138     num_bytes += len;
 139   }
 140   SAFE_ASSERT(num_bytes <= count);
 141   return num_bytes;
 142 }
 143
 144 // Read up to "count" bytes from "offset" in the file pointed by file
 145 // descriptor "fd" into the buffer starting at "buf".  On success,
 146 // return the number of bytes read.  Otherwise, return -1.
 147 static ssize_t ReadFromOffset(const int fd, void *buf,
 148                               const size_t count, const off_t offset) {
 149   off_t off = lseek(fd, offset, SEEK_SET);
 150   if (off == (off_t)-1) {
 151     return -1;
 152   }
 153   return ReadPersistent(fd, buf, count);
 154 }
 155
 156 // Try reading exactly "count" bytes from "offset" bytes in a file
 157 // pointed by "fd" into the buffer starting at "buf" while handling
 158 // short reads and EINTR.  On success, return true. Otherwise, return
 159 // false.
 160 static bool ReadFromOffsetExact(const int fd, void *buf,
 161                                 const size_t count, const off_t offset) {
 162   ssize_t len = ReadFromOffset(fd, buf, count, offset);
 163   return len == count;
 164 }
 165
 166 // Returns elf_header.e_type if the file pointed by fd is an ELF binary.
 167 static int FileGetElfType(const int fd) {
 168   ElfW(Ehdr) elf_header;
 169   if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) {
 170     return -1;
 171   }
 172   if (memcmp(elf_header.e_ident, ELFMAG, SELFMAG) != 0) {
 173     return -1;
 174   }
 175   return elf_header.e_type;
 176 }
 177
 178 // Read the section headers in the given ELF binary, and if a section
 179 // of the specified type is found, set the output to this section header
 180 // and return true.  Otherwise, return false.
 181 // To keep stack consumption low, we would like this function to not get
 182 // inlined.
 183 static ATTRIBUTE_NOINLINE bool
 184 GetSectionHeaderByType(const int fd, ElfW(Half) sh_num, const off_t sh_offset,
 185                        ElfW(Word) type, ElfW(Shdr) *out) {
 186   // Read at most 16 section headers at a time to save read calls.
 187   ElfW(Shdr) buf[16];
 188   for (int i = 0; i < sh_num;) {
 189     const ssize_t num_bytes_left = (sh_num - i) * sizeof(buf[0]);
 190     const ssize_t num_bytes_to_read =
 191         (sizeof(buf) > num_bytes_left) ? num_bytes_left : sizeof(buf);
 192     const ssize_t len = ReadFromOffset(fd, buf, num_bytes_to_read,
 193                                        sh_offset + i * sizeof(buf[0]));
 194     SAFE_ASSERT(len % sizeof(buf[0]) == 0);
 195     const ssize_t num_headers_in_buf = len / sizeof(buf[0]);
 196     SAFE_ASSERT(num_headers_in_buf <= sizeof(buf) / sizeof(buf[0]));
 197     for (int j = 0; j < num_headers_in_buf; ++j) {
 198       if (buf[j].sh_type == type) {
 199         *out = buf[j];
 200         return true;
 201       }
 202     }
 203     i += num_headers_in_buf;
 204   }
 205   return false;
 206 }
 207
 208 // There is no particular reason to limit section name to 63 characters,
 209 // but there has (as yet) been no need for anything longer either.
 210 const int kMaxSectionNameLen = 64;
 211
 212 // name_len should include terminating '\0'.
 213 bool GetSectionHeaderByName(int fd, const char *name, size_t name_len,
 214                             ElfW(Shdr) *out) {
 215   ElfW(Ehdr) elf_header;
 216   if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) {
 217     return false;
 218   }
 219
 220   ElfW(Shdr) shstrtab;
 221   off_t shstrtab_offset = (elf_header.e_shoff +
 222                            elf_header.e_shentsize * elf_header.e_shstrndx);
 223   if (!ReadFromOffsetExact(fd, &shstrtab, sizeof(shstrtab), shstrtab_offset)) {
 224     return false;
 225   }
 226
 227   for (int i = 0; i < elf_header.e_shnum; ++i) {
 228     off_t section_header_offset = (elf_header.e_shoff +
 229                                    elf_header.e_shentsize * i);
 230     if (!ReadFromOffsetExact(fd, out, sizeof(*out), section_header_offset)) {
 231       return false;
 232     }
 233     char header_name[kMaxSectionNameLen];
 234     if (sizeof(header_name) < name_len) {
 235       RAW_LOG(WARNING, "Section name '%s' is too long (%"PRIuS"); "
 236               "section will not be found (even if present).", name, name_len);
 237       // No point in even trying.
 238       return false;
 239     }
 240     off_t name_offset = shstrtab.sh_offset + out->sh_name;
 241     ssize_t n_read = ReadFromOffset(fd, &header_name, name_len, name_offset);
 242     if (n_read == -1) {
 243       return false;
 244     } else if (n_read != name_len) {
 245       // Short read -- name could be at end of file.
 246       continue;
 247     }
 248     if (memcmp(header_name, name, name_len) == 0) {
 249       return true;
 250     }
 251   }
 252   return false;
 253 }
 254
 255 // Read a symbol table and look for the symbol containing the
 256 // pc. Iterate over symbols in a symbol table and look for the symbol
 257 // containing "pc".  On success, return true and write the symbol name
 258 // to out.  Otherwise, return false.
 259 // To keep stack consumption low, we would like this function to not get
 260 // inlined.
 261 static ATTRIBUTE_NOINLINE bool
 262 FindSymbol(uint64_t pc, const int fd, char *out, int out_size,
 263            uint64_t symbol_offset, const ElfW(Shdr) *strtab,
 264            const ElfW(Shdr) *symtab) {
 265   if (symtab == NULL) {
 266     return false;
 267   }
 268   const int num_symbols = symtab->sh_size / symtab->sh_entsize;
 269   for (int i = 0; i < num_symbols;) {
 270     off_t offset = symtab->sh_offset + i * symtab->sh_entsize;
 271
 272     // If we are reading Elf64_Sym's, we want to limit this array to
 273     // 32 elements (to keep stack consumption low), otherwise we can
 274     // have a 64 element Elf32_Sym array.
 275 #if __WORDSIZE == 64
 276 #define NUM_SYMBOLS 32
 277 #else
 278 #define NUM_SYMBOLS 64
 279 #endif
 280
 281     // Read at most NUM_SYMBOLS symbols at once to save read() calls.
 282     ElfW(Sym) buf[NUM_SYMBOLS];
 283     const ssize_t len = ReadFromOffset(fd, &buf, sizeof(buf), offset);
 284     SAFE_ASSERT(len % sizeof(buf[0]) == 0);
 285     const ssize_t num_symbols_in_buf = len / sizeof(buf[0]);
 286     SAFE_ASSERT(num_symbols_in_buf <= sizeof(buf)/sizeof(buf[0]));
 287     for (int j = 0; j < num_symbols_in_buf; ++j) {
 288       const ElfW(Sym)& symbol = buf[j];
 289       uint64_t start_address = symbol.st_value;
 290       start_address += symbol_offset;
 291       uint64_t end_address = start_address + symbol.st_size;
 292       if (symbol.st_value != 0 &&  // Skip null value symbols.
 293           symbol.st_shndx != 0 &&  // Skip undefined symbols.
 294           start_address <= pc && pc < end_address) {
 295         ssize_t len1 = ReadFromOffset(fd, out, out_size,
 296                                       strtab->sh_offset + symbol.st_name);
 297         if (len1 <= 0 || memchr(out, '\0', out_size) == NULL) {
 298           return false;
 299         }
 300         return true;  // Obtained the symbol name.
 301       }
 302     }
 303     i += num_symbols_in_buf;
 304   }
 305   return false;
 306 }
 307
 308 // Get the symbol name of "pc" from the file pointed by "fd".  Process
 309 // both regular and dynamic symbol tables if necessary.  On success,
 310 // write the symbol name to "out" and return true.  Otherwise, return
 311 // false.
 312 static bool GetSymbolFromObjectFile(const int fd, uint64_t pc,
 313                                     char *out, int out_size,
 314                                     uint64_t map_start_address) {
 315   // Read the ELF header.
 316   ElfW(Ehdr) elf_header;
 317   if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) {
 318     return false;
 319   }
 320
 321   uint64_t symbol_offset = 0;
 322   if (elf_header.e_type == ET_DYN) {  // DSO needs offset adjustment.
 323     symbol_offset = map_start_address;
 324   }
 325
 326   ElfW(Shdr) symtab, strtab;
 327
 328   // Consult a regular symbol table first.
 329   if (!GetSectionHeaderByType(fd, elf_header.e_shnum, elf_header.e_shoff,
 330                               SHT_SYMTAB, &symtab)) {
 331     return false;
 332   }
 333   if (!ReadFromOffsetExact(fd, &strtab, sizeof(strtab), elf_header.e_shoff +
 334                            symtab.sh_link * sizeof(symtab))) {
 335     return false;
 336   }
 337   if (FindSymbol(pc, fd, out, out_size, symbol_offset,
 338                  &strtab, &symtab)) {
 339     return true;  // Found the symbol in a regular symbol table.
 340   }
 341
 342   // If the symbol is not found, then consult a dynamic symbol table.
 343   if (!GetSectionHeaderByType(fd, elf_header.e_shnum, elf_header.e_shoff,
 344                               SHT_DYNSYM, &symtab)) {
 345     return false;
 346   }
 347   if (!ReadFromOffsetExact(fd, &strtab, sizeof(strtab), elf_header.e_shoff +
 348                            symtab.sh_link * sizeof(symtab))) {
 349     return false;
 350   }
 351   if (FindSymbol(pc, fd, out, out_size, symbol_offset,
 352                  &strtab, &symtab)) {
 353     return true;  // Found the symbol in a dynamic symbol table.
 354   }
 355
 356   return false;
 357 }
 358
 359 namespace {
 360 // Thin wrapper around a file descriptor so that the file descriptor
 361 // gets closed for sure.
 362 struct FileDescriptor {
 363   const int fd_;
 364   explicit FileDescriptor(int fd) : fd_(fd) {}
 365   ~FileDescriptor() {
 366     if (fd_ >= 0) {
 367       NO_INTR(close(fd_));
 368     }
 369   }
 370   int get() { return fd_; }
 371
 372  private:
 373   explicit FileDescriptor(const FileDescriptor&);
 374   void operator=(const FileDescriptor&);
 375 };
 376
 377 // Helper class for reading lines from file.
 378 //
 379 // Note: we don't use ProcMapsIterator since the object is big (it has
 380 // a 5k array member) and uses async-unsafe functions such as sscanf()
 381 // and snprintf().
 382 class LineReader {
 383  public:
 384   explicit LineReader(int fd, char *buf, int buf_len) : fd_(fd),
 385     buf_(buf), buf_len_(buf_len), bol_(buf), eol_(buf), eod_(buf) {
 386   }
 387
 388   // Read '\n'-terminated line from file.  On success, modify "bol"
 389   // and "eol", then return true.  Otherwise, return false.
 390   //
 391   // Note: if the last line doesn't end with '\n', the line will be
 392   // dropped.  It's an intentional behavior to make the code simple.
 393   bool ReadLine(const char **bol, const char **eol) {
 394     if (BufferIsEmpty()) {  // First time.
 395       const ssize_t num_bytes = ReadPersistent(fd_, buf_, buf_len_);
 396       if (num_bytes <= 0) {  // EOF or error.
 397         return false;
 398       }
 399       eod_ = buf_ + num_bytes;
 400       bol_ = buf_;
 401     } else {
 402       bol_ = eol_ + 1;  // Advance to the next line in the buffer.
 403       SAFE_ASSERT(bol_ <= eod_);  // "bol_" can point to "eod_".
 404       if (!HasCompleteLine()) {
 405         const int incomplete_line_length = eod_ - bol_;
 406         // Move the trailing incomplete line to the beginning.
 407         memmove(buf_, bol_, incomplete_line_length);
 408         // Read text from file and append it.
 409         char * const append_pos = buf_ + incomplete_line_length;
 410         const int capacity_left = buf_len_ - incomplete_line_length;
 411         const ssize_t num_bytes = ReadPersistent(fd_, append_pos,
 412                                                  capacity_left);
 413         if (num_bytes <= 0) {  // EOF or error.
 414           return false;
 415         }
 416         eod_ = append_pos + num_bytes;
 417         bol_ = buf_;
 418       }
 419     }
 420     eol_ = FindLineFeed();
 421     if (eol_ == NULL) {  // '\n' not found.  Malformed line.
 422       return false;
 423     }
 424     *eol_ = '\0';  // Replace '\n' with '\0'.
 425
 426     *bol = bol_;
 427     *eol = eol_;
 428     return true;
 429   }
 430
 431   // Beginning of line.
 432   const char *bol() {
 433     return bol_;
 434   }
 435
 436   // End of line.
 437   const char *eol() {
 438     return eol_;
 439   }
 440
 441  private:
 442   explicit LineReader(const LineReader&);
 443   void operator=(const LineReader&);
 444
 445   char *FindLineFeed() {
 446     return reinterpret_cast<char *>(memchr(bol_, '\n', eod_ - bol_));
 447   }
 448
 449   bool BufferIsEmpty() {
 450     return buf_ == eod_;
 451   }
 452
 453   bool HasCompleteLine() {
 454     return !BufferIsEmpty() && FindLineFeed() != NULL;
 455   }
 456
 457   const int fd_;
 458   char * const buf_;
 459   const int buf_len_;
 460   char *bol_;
 461   char *eol_;
 462   const char *eod_;  // End of data in "buf_".
 463 };
 464 }  // namespace
 465
 466 // Place the hex number read from "start" into "*hex".  The pointer to
 467 // the first non-hex character or "end" is returned.
 468 static char *GetHex(const char *start, const char *end, uint64_t *hex) {
 469   *hex = 0;
 470   const char *p;
 471   for (p = start; p < end; ++p) {
 472     int ch = *p;
 473     if ((ch >= '0' && ch <= '9') ||
 474         (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f')) {
 475       *hex = (*hex << 4) | (ch < 'A' ? ch - '0' : (ch & 0xF) + 9);
 476     } else {  // Encountered the first non-hex character.
 477       break;
 478     }
 479   }
 480   SAFE_ASSERT(p <= end);
 481   return const_cast<char *>(p);
 482 }
 483
 484 // Search for the object file (from /proc/self/maps) that contains
 485 // the specified pc. If found, open this file and return the file handle,
 486 // and also set start_address to the start address of where this object
 487 // file is mapped to in memory. Otherwise, return -1.
 488 static ATTRIBUTE_NOINLINE int
 489 OpenObjectFileContainingPcAndGetStartAddress(uint64_t pc,
 490                                              uint64_t &start_address) {
 491   int object_fd;
 492
 493   // Open /proc/self/maps.
 494   int maps_fd;
 495   NO_INTR(maps_fd = open("/proc/self/maps", O_RDONLY));
 496   FileDescriptor wrapped_maps_fd(maps_fd);
 497   if (wrapped_maps_fd.get() < 0) {
 498     return -1;
 499   }
 500
 501   // Iterate over maps and look for the map containing the pc.  Then
 502   // look into the symbol tables inside.
 503   char buf[1024];  // Big enough for line of sane /proc/self/maps
 504   LineReader reader(wrapped_maps_fd.get(), buf, sizeof(buf));
 505   while (true) {
 506     const char *cursor;
 507     const char *eol;
 508     if (!reader.ReadLine(&cursor, &eol)) {  // EOF or malformed line.
 509       return -1;
 510     }
 511
 512     // Start parsing line in /proc/self/maps.  Here is an example:
 513     //
 514     // 08048000-0804c000 r-xp 00000000 08:01 2142121    /bin/cat
 515     //
 516     // We want start address (08048000), end address (0804c000), flags
 517     // (r-xp) and file name (/bin/cat).
 518
 519     // Read start address.
 520     cursor = GetHex(cursor, eol, &start_address);
 521     if (cursor == eol || *cursor != '-') {
 522       return -1;  // Malformed line.
 523     }
 524     ++cursor;  // Skip '-'.
 525
 526     // Read end address.
 527     uint64_t end_address;
 528     cursor = GetHex(cursor, eol, &end_address);
 529     if (cursor == eol || *cursor != ' ') {
 530       return -1;  // Malformed line.
 531     }
 532     ++cursor;  // Skip ' '.
 533
 534     // Check start and end addresses.
 535     if (!(start_address <= pc && pc < end_address)) {
 536       continue;  // We skip this map.  PC isn't in this map.
 537     }
 538
 539     // Read flags.  Skip flags until we encounter a space or eol.
 540     const char * const flags_start = cursor;
 541     while (cursor < eol && *cursor != ' ') {
 542       ++cursor;
 543     }
 544     // We expect at least four letters for flags (ex. "r-xp").
 545     if (cursor == eol || cursor < flags_start + 4) {
 546       return -1;  // Malformed line.
 547     }
 548
 549     // Check flags.  We are only interested in "r-x" maps.
 550     if (memcmp(flags_start, "r-x", 3) != 0) {  // Not a "r-x" map.
 551       continue;  // We skip this map.
 552     }
 553     ++cursor;  // Skip ' '.
 554
 555     // Skip to file name.  "cursor" now points to file offset.  We need to
 556     // skip at least three spaces for file offset, dev, and inode.
 557     int num_spaces = 0;
 558     while (cursor < eol) {
 559       if (*cursor == ' ') {
 560         ++num_spaces;
 561       } else if (num_spaces >= 3) {
 562         // The first non-space character after  skipping three spaces
 563         // is the beginning of the file name.
 564         break;
 565       }
 566       ++cursor;
 567     }
 568     if (cursor == eol) {
 569       return -1;  // Malformed line.
 570     }
 571
 572     // Finally, "cursor" now points to file name of our interest.
 573     NO_INTR(object_fd = open(cursor, O_RDONLY));
 574     if (object_fd < 0) {
 575       return -1;
 576     }
 577     return object_fd;
 578   }
 579 }
 580
 581 // The implementation of our symbolization routine.  If it
 582 // successfully finds the symbol containing "pc" and obtains the
 583 // symbol name, returns true and write the symbol name to "out".
 584 // Otherwise, returns false. If Callback function is installed via
 585 // InstallSymbolizeCallback(), the function is also called in this function,
 586 // and "out" is used as its output.
 587 // To keep stack consumption low, we would like this function to not
 588 // get inlined.
 589 static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void *pc, char *out,
 590                                                     int out_size) {
 591   uint64_t pc0 = reinterpret_cast<uintptr_t>(pc);
 592   uint64_t start_address = 0;
 593
 594   int object_fd = OpenObjectFileContainingPcAndGetStartAddress(pc0,
 595                                                                start_address);
 596   if (object_fd == -1) {
 597     return false;
 598   }
 599   FileDescriptor wrapped_object_fd(object_fd);
 600   int elf_type = FileGetElfType(wrapped_object_fd.get());
 601   if (elf_type == -1) {
 602     return false;
 603   }
 604   if (g_symbolize_callback) {
 605     // Run the call back if it's installed.
 606     // Note: relocation (and much of the rest of this code) will be
 607     // wrong for prelinked shared libraries and PIE executables.
 608     uint64 relocation = (elf_type == ET_DYN) ? start_address : 0;
 609     int num_bytes_written = g_symbolize_callback(wrapped_object_fd.get(),
 610                                                  pc, out, out_size,
 611                                                  relocation);
 612     if (num_bytes_written > 0) {
 613       out += num_bytes_written;
 614       out_size -= num_bytes_written;
 615     }
 616   }
 617   if (!GetSymbolFromObjectFile(wrapped_object_fd.get(), pc0,
 618                                out, out_size, start_address)) {
 619     return false;
 620   }
 621
 622   // Symbolization succeeded.  Now we try to demangle the symbol.
 623   DemangleInplace(out, out_size);
 624   return true;
 625 }
 626
 627 _END_GOOGLE_NAMESPACE_
 628
 629 #elif defined(OS_MACOSX) && defined(HAVE_DLADDR)
 630
 631 #include <dlfcn.h>
 632 #include <string.h>
 633
 634 _START_GOOGLE_NAMESPACE_
 635
 636 static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void *pc, char *out,
 637                                                     int out_size) {
 638   Dl_info info;
 639   if (dladdr(pc, &info)) {
 640     if (strlen(info.dli_sname) < out_size) {
 641       strcpy(out, info.dli_sname);
 642       // Symbolization succeeded.  Now we try to demangle the symbol.
 643       DemangleInplace(out, out_size);
 644       return true;
 645     }
 646   }
 647   return false;
 648 }
 649
 650 _END_GOOGLE_NAMESPACE_
 651
 652 #else
 653 # error BUG: HAVE_SYMBOLIZE was wrongly set
 654 #endif
 655
 656 _START_GOOGLE_NAMESPACE_
 657
 658 bool Symbolize(void *pc, char *out, int out_size) {
 659   SAFE_ASSERT(out_size >= 0);
 660   return SymbolizeAndDemangle(pc, out, out_size);
 661 }
 662
 663 _END_GOOGLE_NAMESPACE_
 664
 665 #else  /* HAVE_SYMBOLIZE */
 666
 667 #include <assert.h>
 668
 669 #include "config.h"
 670
 671 _START_GOOGLE_NAMESPACE_
 672
 673 // TODO: Support other environments.
 674 bool Symbolize(void *pc, char *out, int out_size) {
 675   assert(0);
 676   return false;
 677 }
 678
 679 _END_GOOGLE_NAMESPACE_
 680
 681 #endif