Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(9)

Side by Side Diff: base/third_party/symbolize/symbolize.cc

Issue 545148: Import google-glog's Symbolize() and use it in debug_util_posix.cc. (Closed)
Patch Set: Fix checkdeps.py error Created 10 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698