/thirdparty/breakpad/third_party/glog/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 ? :.
 65static int AssertFail() {
 66  abort();
 67  return 0;  // Should not reach.
 68}
 69
 70#define SAFE_ASSERT(expr) ((expr) ? 0 : AssertFail())
 71
 72static SymbolizeCallback g_symbolize_callback = NULL;
 73void 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.
 81static 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.
124static 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.
147static 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.
160static 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.
167static 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.
183static ATTRIBUTE_NOINLINE bool
184GetSectionHeaderByType(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.
210const int kMaxSectionNameLen = 64;
211
212// name_len should include terminating '\0'.
213bool 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.
261static ATTRIBUTE_NOINLINE bool
262FindSymbol(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.
312static 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
359namespace {
360// Thin wrapper around a file descriptor so that the file descriptor
361// gets closed for sure.
362struct 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().
382class 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.
468static 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.
488static ATTRIBUTE_NOINLINE int
489OpenObjectFileContainingPcAndGetStartAddress(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.
589static 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
636static 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
658bool 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.
674bool Symbolize(void *pc, char *out, int out_size) {
675  assert(0);
676  return false;
677}
678
679_END_GOOGLE_NAMESPACE_
680
681#endif