1 /* elf.c -- Get debug data from an ELF file for backtraces.
2 Copyright (C) 2012-2017 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Google.
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are
9 (1) Redistributions of source code must retain the above copyright
10 notice, this list of conditions and the following disclaimer.
12 (2) Redistributions in binary form must reproduce the above copyright
13 notice, this list of conditions and the following disclaimer in
14 the documentation and/or other materials provided with the
17 (3) The name of the author may not be used to
18 endorse or promote products derived from this software without
19 specific prior written permission.
21 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24 DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
25 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
27 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
29 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
30 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 POSSIBILITY OF SUCH DAMAGE. */
38 #include <sys/types.h>
42 #ifdef HAVE_DL_ITERATE_PHDR
46 #include "backtrace.h"
51 #define S_IFLNK 0120000
54 #define S_IFMT 0170000
56 #define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
60 #define __builtin_prefetch(p, r, l)
61 #define unlikely(x) (x)
63 #define unlikely(x) __builtin_expect(!!(x), 0)
66 #if !defined(HAVE_DECL_STRNLEN) || !HAVE_DECL_STRNLEN
68 /* If strnlen is not declared, provide our own version. */
71 xstrnlen (const char *s
, size_t maxlen
)
75 for (i
= 0; i
< maxlen
; ++i
)
81 #define strnlen xstrnlen
87 /* Dummy version of lstat for systems that don't have it. */
90 xlstat (const char *path ATTRIBUTE_UNUSED
, struct stat
*st ATTRIBUTE_UNUSED
)
101 /* Dummy version of readlink for systems that don't have it. */
104 xreadlink (const char *path ATTRIBUTE_UNUSED
, char *buf ATTRIBUTE_UNUSED
,
105 size_t bufsz ATTRIBUTE_UNUSED
)
110 #define readlink xreadlink
114 #ifndef HAVE_DL_ITERATE_PHDR
116 /* Dummy version of dl_iterate_phdr for systems that don't have it. */
118 #define dl_phdr_info x_dl_phdr_info
119 #define dl_iterate_phdr x_dl_iterate_phdr
124 const char *dlpi_name
;
128 dl_iterate_phdr (int (*callback
) (struct dl_phdr_info
*,
129 size_t, void *) ATTRIBUTE_UNUSED
,
130 void *data ATTRIBUTE_UNUSED
)
135 #endif /* ! defined (HAVE_DL_ITERATE_PHDR) */
137 /* The configure script must tell us whether we are 32-bit or 64-bit
138 ELF. We could make this code test and support either possibility,
139 but there is no point. This code only works for the currently
140 running executable, which means that we know the ELF mode at
143 #if BACKTRACE_ELF_SIZE != 32 && BACKTRACE_ELF_SIZE != 64
144 #error "Unknown BACKTRACE_ELF_SIZE"
147 /* <link.h> might #include <elf.h> which might define our constants
148 with slightly different values. Undefine them to be safe. */
174 #undef SHF_COMPRESSED
177 #undef NT_GNU_BUILD_ID
178 #undef ELFCOMPRESS_ZLIB
182 typedef uint16_t b_elf_half
; /* Elf_Half. */
183 typedef uint32_t b_elf_word
; /* Elf_Word. */
184 typedef int32_t b_elf_sword
; /* Elf_Sword. */
186 #if BACKTRACE_ELF_SIZE == 32
188 typedef uint32_t b_elf_addr
; /* Elf_Addr. */
189 typedef uint32_t b_elf_off
; /* Elf_Off. */
191 typedef uint32_t b_elf_wxword
; /* 32-bit Elf_Word, 64-bit ELF_Xword. */
195 typedef uint64_t b_elf_addr
; /* Elf_Addr. */
196 typedef uint64_t b_elf_off
; /* Elf_Off. */
197 typedef uint64_t b_elf_xword
; /* Elf_Xword. */
198 typedef int64_t b_elf_sxword
; /* Elf_Sxword. */
200 typedef uint64_t b_elf_wxword
; /* 32-bit Elf_Word, 64-bit ELF_Xword. */
204 /* Data structures and associated constants. */
209 unsigned char e_ident
[EI_NIDENT
]; /* ELF "magic number" */
210 b_elf_half e_type
; /* Identifies object file type */
211 b_elf_half e_machine
; /* Specifies required architecture */
212 b_elf_word e_version
; /* Identifies object file version */
213 b_elf_addr e_entry
; /* Entry point virtual address */
214 b_elf_off e_phoff
; /* Program header table file offset */
215 b_elf_off e_shoff
; /* Section header table file offset */
216 b_elf_word e_flags
; /* Processor-specific flags */
217 b_elf_half e_ehsize
; /* ELF header size in bytes */
218 b_elf_half e_phentsize
; /* Program header table entry size */
219 b_elf_half e_phnum
; /* Program header table entry count */
220 b_elf_half e_shentsize
; /* Section header table entry size */
221 b_elf_half e_shnum
; /* Section header table entry count */
222 b_elf_half e_shstrndx
; /* Section header string table index */
223 } b_elf_ehdr
; /* Elf_Ehdr. */
241 #define ELFDATA2LSB 1
242 #define ELFDATA2MSB 2
249 b_elf_word sh_name
; /* Section name, index in string tbl */
250 b_elf_word sh_type
; /* Type of section */
251 b_elf_wxword sh_flags
; /* Miscellaneous section attributes */
252 b_elf_addr sh_addr
; /* Section virtual addr at execution */
253 b_elf_off sh_offset
; /* Section file offset */
254 b_elf_wxword sh_size
; /* Size of section in bytes */
255 b_elf_word sh_link
; /* Index of another section */
256 b_elf_word sh_info
; /* Additional section information */
257 b_elf_wxword sh_addralign
; /* Section alignment */
258 b_elf_wxword sh_entsize
; /* Entry size if section holds table */
259 } b_elf_shdr
; /* Elf_Shdr. */
261 #define SHN_UNDEF 0x0000 /* Undefined section */
262 #define SHN_LORESERVE 0xFF00 /* Begin range of reserved indices */
263 #define SHN_XINDEX 0xFFFF /* Section index is held elsewhere */
267 #define SHT_DYNSYM 11
269 #define SHF_COMPRESSED 0x800
271 #if BACKTRACE_ELF_SIZE == 32
275 b_elf_word st_name
; /* Symbol name, index in string tbl */
276 b_elf_addr st_value
; /* Symbol value */
277 b_elf_word st_size
; /* Symbol size */
278 unsigned char st_info
; /* Symbol binding and type */
279 unsigned char st_other
; /* Visibility and other data */
280 b_elf_half st_shndx
; /* Symbol section index */
281 } b_elf_sym
; /* Elf_Sym. */
283 #else /* BACKTRACE_ELF_SIZE != 32 */
287 b_elf_word st_name
; /* Symbol name, index in string tbl */
288 unsigned char st_info
; /* Symbol binding and type */
289 unsigned char st_other
; /* Visibility and other data */
290 b_elf_half st_shndx
; /* Symbol section index */
291 b_elf_addr st_value
; /* Symbol value */
292 b_elf_xword st_size
; /* Symbol size */
293 } b_elf_sym
; /* Elf_Sym. */
295 #endif /* BACKTRACE_ELF_SIZE != 32 */
308 #define NT_GNU_BUILD_ID 3
310 #if BACKTRACE_ELF_SIZE == 32
314 b_elf_word ch_type
; /* Compresstion algorithm */
315 b_elf_word ch_size
; /* Uncompressed size */
316 b_elf_word ch_addralign
; /* Alignment for uncompressed data */
317 } b_elf_chdr
; /* Elf_Chdr */
319 #else /* BACKTRACE_ELF_SIZE != 32 */
323 b_elf_word ch_type
; /* Compression algorithm */
324 b_elf_word ch_reserved
; /* Reserved */
325 b_elf_xword ch_size
; /* Uncompressed size */
326 b_elf_xword ch_addralign
; /* Alignment for uncompressed data */
327 } b_elf_chdr
; /* Elf_Chdr */
329 #endif /* BACKTRACE_ELF_SIZE != 32 */
331 #define ELFCOMPRESS_ZLIB 1
333 /* An index of ELF sections we care about. */
343 /* The old style compressed sections. This list must correspond to
344 the list of normal debug sections. */
354 /* Names of sections, indexed by enum elf_section. */
356 static const char * const debug_section_names
[DEBUG_MAX
] =
370 /* Information we gather for the sections we care about. */
372 struct debug_section_info
374 /* Section file offset. */
378 /* Section contents, after read from file. */
379 const unsigned char *data
;
380 /* Whether the SHF_COMPRESSED flag is set for the section. */
384 /* Information we keep for an ELF symbol. */
388 /* The name of the symbol. */
390 /* The address of the symbol. */
392 /* The size of the symbol. */
396 /* Information to pass to elf_syminfo. */
398 struct elf_syminfo_data
400 /* Symbols for the next module. */
401 struct elf_syminfo_data
*next
;
402 /* The ELF symbols, sorted by address. */
403 struct elf_symbol
*symbols
;
404 /* The number of symbols. */
408 /* Compute the CRC-32 of BUF/LEN. This uses the CRC used for
409 .gnu_debuglink files. */
412 elf_crc32 (uint32_t crc
, const unsigned char *buf
, size_t len
)
414 static const uint32_t crc32_table
[256] =
416 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
417 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
418 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
419 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
420 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
421 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
422 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
423 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
424 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
425 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
426 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
427 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
428 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
429 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
430 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
431 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
432 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
433 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
434 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
435 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
436 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
437 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
438 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
439 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
440 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
441 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
442 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
443 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
444 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
445 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
446 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
447 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
448 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
449 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
450 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
451 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
452 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
453 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
454 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
455 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
456 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
457 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
458 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
459 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
460 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
461 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
462 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
463 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
464 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
465 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
466 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
469 const unsigned char *end
;
472 for (end
= buf
+ len
; buf
< end
; ++ buf
)
473 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
477 /* Return the CRC-32 of the entire file open at DESCRIPTOR. */
480 elf_crc32_file (struct backtrace_state
*state
, int descriptor
,
481 backtrace_error_callback error_callback
, void *data
)
484 struct backtrace_view file_view
;
487 if (fstat (descriptor
, &st
) < 0)
489 error_callback (data
, "fstat", errno
);
493 if (!backtrace_get_view (state
, descriptor
, 0, st
.st_size
, error_callback
,
497 ret
= elf_crc32 (0, (const unsigned char *) file_view
.data
, st
.st_size
);
499 backtrace_release_view (state
, &file_view
, error_callback
, data
);
504 /* A dummy callback function used when we can't find any debug info. */
507 elf_nodebug (struct backtrace_state
*state ATTRIBUTE_UNUSED
,
508 uintptr_t pc ATTRIBUTE_UNUSED
,
509 backtrace_full_callback callback ATTRIBUTE_UNUSED
,
510 backtrace_error_callback error_callback
, void *data
)
512 error_callback (data
, "no debug info in ELF executable", -1);
516 /* A dummy callback function used when we can't find a symbol
520 elf_nosyms (struct backtrace_state
*state ATTRIBUTE_UNUSED
,
521 uintptr_t addr ATTRIBUTE_UNUSED
,
522 backtrace_syminfo_callback callback ATTRIBUTE_UNUSED
,
523 backtrace_error_callback error_callback
, void *data
)
525 error_callback (data
, "no symbol table in ELF executable", -1);
528 /* Compare struct elf_symbol for qsort. */
531 elf_symbol_compare (const void *v1
, const void *v2
)
533 const struct elf_symbol
*e1
= (const struct elf_symbol
*) v1
;
534 const struct elf_symbol
*e2
= (const struct elf_symbol
*) v2
;
536 if (e1
->address
< e2
->address
)
538 else if (e1
->address
> e2
->address
)
544 /* Compare an ADDR against an elf_symbol for bsearch. We allocate one
545 extra entry in the array so that this can look safely at the next
549 elf_symbol_search (const void *vkey
, const void *ventry
)
551 const uintptr_t *key
= (const uintptr_t *) vkey
;
552 const struct elf_symbol
*entry
= (const struct elf_symbol
*) ventry
;
556 if (addr
< entry
->address
)
558 else if (addr
>= entry
->address
+ entry
->size
)
564 /* Initialize the symbol table info for elf_syminfo. */
567 elf_initialize_syminfo (struct backtrace_state
*state
,
568 uintptr_t base_address
,
569 const unsigned char *symtab_data
, size_t symtab_size
,
570 const unsigned char *strtab
, size_t strtab_size
,
571 backtrace_error_callback error_callback
,
572 void *data
, struct elf_syminfo_data
*sdata
)
575 const b_elf_sym
*sym
;
576 size_t elf_symbol_count
;
577 size_t elf_symbol_size
;
578 struct elf_symbol
*elf_symbols
;
582 sym_count
= symtab_size
/ sizeof (b_elf_sym
);
584 /* We only care about function symbols. Count them. */
585 sym
= (const b_elf_sym
*) symtab_data
;
586 elf_symbol_count
= 0;
587 for (i
= 0; i
< sym_count
; ++i
, ++sym
)
591 info
= sym
->st_info
& 0xf;
592 if ((info
== STT_FUNC
|| info
== STT_OBJECT
)
593 && sym
->st_shndx
!= SHN_UNDEF
)
597 elf_symbol_size
= elf_symbol_count
* sizeof (struct elf_symbol
);
598 elf_symbols
= ((struct elf_symbol
*)
599 backtrace_alloc (state
, elf_symbol_size
, error_callback
,
601 if (elf_symbols
== NULL
)
604 sym
= (const b_elf_sym
*) symtab_data
;
606 for (i
= 0; i
< sym_count
; ++i
, ++sym
)
610 info
= sym
->st_info
& 0xf;
611 if (info
!= STT_FUNC
&& info
!= STT_OBJECT
)
613 if (sym
->st_shndx
== SHN_UNDEF
)
615 if (sym
->st_name
>= strtab_size
)
617 error_callback (data
, "symbol string index out of range", 0);
618 backtrace_free (state
, elf_symbols
, elf_symbol_size
, error_callback
,
622 elf_symbols
[j
].name
= (const char *) strtab
+ sym
->st_name
;
623 elf_symbols
[j
].address
= sym
->st_value
+ base_address
;
624 elf_symbols
[j
].size
= sym
->st_size
;
628 backtrace_qsort (elf_symbols
, elf_symbol_count
, sizeof (struct elf_symbol
),
632 sdata
->symbols
= elf_symbols
;
633 sdata
->count
= elf_symbol_count
;
638 /* Add EDATA to the list in STATE. */
641 elf_add_syminfo_data (struct backtrace_state
*state
,
642 struct elf_syminfo_data
*edata
)
644 if (!state
->threaded
)
646 struct elf_syminfo_data
**pp
;
648 for (pp
= (struct elf_syminfo_data
**) (void *) &state
->syminfo_data
;
658 struct elf_syminfo_data
**pp
;
660 pp
= (struct elf_syminfo_data
**) (void *) &state
->syminfo_data
;
664 struct elf_syminfo_data
*p
;
666 p
= backtrace_atomic_load_pointer (pp
);
674 if (__sync_bool_compare_and_swap (pp
, NULL
, edata
))
680 /* Return the symbol name and value for an ADDR. */
683 elf_syminfo (struct backtrace_state
*state
, uintptr_t addr
,
684 backtrace_syminfo_callback callback
,
685 backtrace_error_callback error_callback ATTRIBUTE_UNUSED
,
688 struct elf_syminfo_data
*edata
;
689 struct elf_symbol
*sym
= NULL
;
691 if (!state
->threaded
)
693 for (edata
= (struct elf_syminfo_data
*) state
->syminfo_data
;
697 sym
= ((struct elf_symbol
*)
698 bsearch (&addr
, edata
->symbols
, edata
->count
,
699 sizeof (struct elf_symbol
), elf_symbol_search
));
706 struct elf_syminfo_data
**pp
;
708 pp
= (struct elf_syminfo_data
**) (void *) &state
->syminfo_data
;
711 edata
= backtrace_atomic_load_pointer (pp
);
715 sym
= ((struct elf_symbol
*)
716 bsearch (&addr
, edata
->symbols
, edata
->count
,
717 sizeof (struct elf_symbol
), elf_symbol_search
));
726 callback (data
, addr
, NULL
, 0, 0);
728 callback (data
, addr
, sym
->name
, sym
->address
, sym
->size
);
731 /* Return whether FILENAME is a symlink. */
734 elf_is_symlink (const char *filename
)
738 if (lstat (filename
, &st
) < 0)
740 return S_ISLNK (st
.st_mode
);
743 /* Return the results of reading the symlink FILENAME in a buffer
744 allocated by backtrace_alloc. Return the length of the buffer in
748 elf_readlink (struct backtrace_state
*state
, const char *filename
,
749 backtrace_error_callback error_callback
, void *data
,
760 buf
= backtrace_alloc (state
, len
, error_callback
, data
);
763 rl
= readlink (filename
, buf
, len
);
766 backtrace_free (state
, buf
, len
, error_callback
, data
);
769 if ((size_t) rl
< len
- 1)
775 backtrace_free (state
, buf
, len
, error_callback
, data
);
780 /* Open a separate debug info file, using the build ID to find it.
781 Returns an open file descriptor, or -1.
783 The GDB manual says that the only place gdb looks for a debug file
784 when the build ID is known is in /usr/lib/debug/.build-id. */
787 elf_open_debugfile_by_buildid (struct backtrace_state
*state
,
788 const char *buildid_data
, size_t buildid_size
,
789 backtrace_error_callback error_callback
,
792 const char * const prefix
= "/usr/lib/debug/.build-id/";
793 const size_t prefix_len
= strlen (prefix
);
794 const char * const suffix
= ".debug";
795 const size_t suffix_len
= strlen (suffix
);
803 len
= prefix_len
+ buildid_size
* 2 + suffix_len
+ 2;
804 bd_filename
= backtrace_alloc (state
, len
, error_callback
, data
);
805 if (bd_filename
== NULL
)
809 memcpy (t
, prefix
, prefix_len
);
811 for (i
= 0; i
< buildid_size
; i
++)
816 b
= (unsigned char) buildid_data
[i
];
817 nib
= (b
& 0xf0) >> 4;
818 *t
++ = nib
< 10 ? '0' + nib
: 'a' + nib
- 10;
820 *t
++ = nib
< 10 ? '0' + nib
: 'a' + nib
- 10;
824 memcpy (t
, suffix
, suffix_len
);
825 t
[suffix_len
] = '\0';
827 ret
= backtrace_open (bd_filename
, error_callback
, data
, &does_not_exist
);
829 backtrace_free (state
, bd_filename
, len
, error_callback
, data
);
831 /* gdb checks that the debuginfo file has the same build ID note.
832 That seems kind of pointless to me--why would it have the right
833 name but not the right build ID?--so skipping the check. */
838 /* Try to open a file whose name is PREFIX (length PREFIX_LEN)
839 concatenated with PREFIX2 (length PREFIX2_LEN) concatenated with
840 DEBUGLINK_NAME. Returns an open file descriptor, or -1. */
843 elf_try_debugfile (struct backtrace_state
*state
, const char *prefix
,
844 size_t prefix_len
, const char *prefix2
, size_t prefix2_len
,
845 const char *debuglink_name
,
846 backtrace_error_callback error_callback
, void *data
)
848 size_t debuglink_len
;
854 debuglink_len
= strlen (debuglink_name
);
855 try_len
= prefix_len
+ prefix2_len
+ debuglink_len
+ 1;
856 try = backtrace_alloc (state
, try_len
, error_callback
, data
);
860 memcpy (try, prefix
, prefix_len
);
861 memcpy (try + prefix_len
, prefix2
, prefix2_len
);
862 memcpy (try + prefix_len
+ prefix2_len
, debuglink_name
, debuglink_len
);
863 try[prefix_len
+ prefix2_len
+ debuglink_len
] = '\0';
865 ret
= backtrace_open (try, error_callback
, data
, &does_not_exist
);
867 backtrace_free (state
, try, try_len
, error_callback
, data
);
872 /* Find a separate debug info file, using the debuglink section data
873 to find it. Returns an open file descriptor, or -1. */
876 elf_find_debugfile_by_debuglink (struct backtrace_state
*state
,
877 const char *filename
,
878 const char *debuglink_name
,
879 backtrace_error_callback error_callback
,
890 /* Resolve symlinks in FILENAME. Since FILENAME is fairly likely to
891 be /proc/self/exe, symlinks are common. We don't try to resolve
892 the whole path name, just the base name. */
896 while (elf_is_symlink (filename
))
901 new_buf
= elf_readlink (state
, filename
, error_callback
, data
, &new_len
);
905 if (new_buf
[0] == '/')
909 slash
= strrchr (filename
, '/');
918 clen
= slash
- filename
+ strlen (new_buf
) + 1;
919 c
= backtrace_alloc (state
, clen
, error_callback
, data
);
923 memcpy (c
, filename
, slash
- filename
);
924 memcpy (c
+ (slash
- filename
), new_buf
, strlen (new_buf
));
925 c
[slash
- filename
+ strlen (new_buf
)] = '\0';
926 backtrace_free (state
, new_buf
, new_len
, error_callback
, data
);
934 backtrace_free (state
, alc
, alc_len
, error_callback
, data
);
939 /* Look for DEBUGLINK_NAME in the same directory as FILENAME. */
941 slash
= strrchr (filename
, '/');
951 prefix_len
= slash
- filename
;
954 ddescriptor
= elf_try_debugfile (state
, prefix
, prefix_len
, "", 0,
955 debuglink_name
, error_callback
, data
);
956 if (ddescriptor
>= 0)
962 /* Look for DEBUGLINK_NAME in a .debug subdirectory of FILENAME. */
964 ddescriptor
= elf_try_debugfile (state
, prefix
, prefix_len
, ".debug/",
965 strlen (".debug/"), debuglink_name
,
966 error_callback
, data
);
967 if (ddescriptor
>= 0)
973 /* Look for DEBUGLINK_NAME in /usr/lib/debug. */
975 ddescriptor
= elf_try_debugfile (state
, "/usr/lib/debug/",
976 strlen ("/usr/lib/debug/"), prefix
,
977 prefix_len
, debuglink_name
,
978 error_callback
, data
);
979 if (ddescriptor
>= 0)
983 if (alc
!= NULL
&& alc_len
> 0)
984 backtrace_free (state
, alc
, alc_len
, error_callback
, data
);
988 /* Open a separate debug info file, using the debuglink section data
989 to find it. Returns an open file descriptor, or -1. */
992 elf_open_debugfile_by_debuglink (struct backtrace_state
*state
,
993 const char *filename
,
994 const char *debuglink_name
,
995 uint32_t debuglink_crc
,
996 backtrace_error_callback error_callback
,
1002 ddescriptor
= elf_find_debugfile_by_debuglink (state
, filename
,
1004 error_callback
, data
);
1005 if (ddescriptor
< 0)
1008 got_crc
= elf_crc32_file (state
, ddescriptor
, error_callback
, data
);
1009 if (got_crc
!= debuglink_crc
)
1011 backtrace_close (ddescriptor
, error_callback
, data
);
1018 /* A function useful for setting a breakpoint for an inflation failure
1019 when this code is compiled with -g. */
1022 elf_zlib_failed(void)
1026 /* *PVAL is the current value being read from the stream, and *PBITS
1027 is the number of valid bits. Ensure that *PVAL holds at least 15
1028 bits by reading additional bits from *PPIN, up to PINEND, as
1029 needed. Updates *PPIN, *PVAL and *PBITS. Returns 1 on success, 0
1033 elf_zlib_fetch (const unsigned char **ppin
, const unsigned char *pinend
,
1034 uint32_t *pval
, unsigned int *pbits
)
1037 const unsigned char *pin
;
1046 if (unlikely (pinend
- pin
< 2))
1051 val
|= pin
[0] << bits
;
1052 val
|= pin
[1] << (bits
+ 8);
1056 /* We will need the next two bytes soon. We ask for high temporal
1057 locality because we will need the whole cache line soon. */
1058 __builtin_prefetch (pin
, 0, 3);
1059 __builtin_prefetch (pin
+ 1, 0, 3);
1067 /* Huffman code tables, like the rest of the zlib format, are defined
1068 by RFC 1951. We store a Huffman code table as a series of tables
1069 stored sequentially in memory. Each entry in a table is 16 bits.
1070 The first, main, table has 256 entries. It is followed by a set of
1071 secondary tables of length 2 to 128 entries. The maximum length of
1072 a code sequence in the deflate format is 15 bits, so that is all we
1073 need. Each secondary table has an index, which is the offset of
1074 the table in the overall memory storage.
1076 The deflate format says that all codes of a given bit length are
1077 lexicographically consecutive. Perhaps we could have 130 values
1078 that require a 15-bit code, perhaps requiring three secondary
1079 tables of size 128. I don't know if this is actually possible, but
1080 it suggests that the maximum size required for secondary tables is
1081 3 * 128 + 3 * 64 ... == 768. The zlib enough program reports 660
1082 as the maximum. We permit 768, since in addition to the 256 for
1083 the primary table, with two bytes per entry, and with the two
1084 tables we need, that gives us a page.
1086 A single table entry needs to store a value or (for the main table
1087 only) the index and size of a secondary table. Values range from 0
1088 to 285, inclusive. Secondary table indexes, per above, range from
1089 0 to 510. For a value we need to store the number of bits we need
1090 to determine that value (one value may appear multiple times in the
1091 table), which is 1 to 8. For a secondary table we need to store
1092 the number of bits used to index into the table, which is 1 to 7.
1093 And of course we need 1 bit to decide whether we have a value or a
1094 secondary table index. So each entry needs 9 bits for value/table
1095 index, 3 bits for size, 1 bit what it is. For simplicity we use 16
1098 /* Number of entries we allocate to for one code table. We get a page
1099 for the two code tables we need. */
1101 #define HUFFMAN_TABLE_SIZE (1024)
1103 /* Bit masks and shifts for the values in the table. */
1105 #define HUFFMAN_VALUE_MASK 0x01ff
1106 #define HUFFMAN_BITS_SHIFT 9
1107 #define HUFFMAN_BITS_MASK 0x7
1108 #define HUFFMAN_SECONDARY_SHIFT 12
1110 /* For working memory while inflating we need two code tables, we need
1111 an array of code lengths (max value 15, so we use unsigned char),
1112 and an array of unsigned shorts used while building a table. The
1113 latter two arrays must be large enough to hold the maximum number
1114 of code lengths, which RFC 1951 defines as 286 + 30. */
1116 #define ZDEBUG_TABLE_SIZE \
1117 (2 * HUFFMAN_TABLE_SIZE * sizeof (uint16_t) \
1118 + (286 + 30) * sizeof (uint16_t) \
1119 + (286 + 30) * sizeof (unsigned char))
1121 #define ZDEBUG_TABLE_CODELEN_OFFSET \
1122 (2 * HUFFMAN_TABLE_SIZE * sizeof (uint16_t) \
1123 + (286 + 30) * sizeof (uint16_t))
1125 #define ZDEBUG_TABLE_WORK_OFFSET \
1126 (2 * HUFFMAN_TABLE_SIZE * sizeof (uint16_t))
1128 #ifdef BACKTRACE_GENERATE_FIXED_HUFFMAN_TABLE
1130 /* Used by the main function that generates the fixed table to learn
1132 static size_t final_next_secondary
;
1136 /* Build a Huffman code table from an array of lengths in CODES of
1137 length CODES_LEN. The table is stored into *TABLE. ZDEBUG_TABLE
1138 is the same as for elf_zlib_inflate, used to find some work space.
1139 Returns 1 on success, 0 on error. */
1142 elf_zlib_inflate_table (unsigned char *codes
, size_t codes_len
,
1143 uint16_t *zdebug_table
, uint16_t *table
)
1148 uint16_t firstcode
[7];
1153 size_t next_secondary
;
1155 /* Count the number of code of each length. Set NEXT[val] to be the
1156 next value after VAL with the same bit length. */
1158 next
= (uint16_t *) (((unsigned char *) zdebug_table
)
1159 + ZDEBUG_TABLE_WORK_OFFSET
);
1161 memset (&count
[0], 0, 16 * sizeof (uint16_t));
1162 for (i
= 0; i
< codes_len
; ++i
)
1164 if (unlikely (codes
[i
] >= 16))
1170 if (count
[codes
[i
]] == 0)
1172 start
[codes
[i
]] = i
;
1177 next
[prev
[codes
[i
]]] = i
;
1184 /* For each length, fill in the table for the codes of that
1187 memset (table
, 0, HUFFMAN_TABLE_SIZE
* sizeof (uint16_t));
1189 /* Handle the values that do not require a secondary table. */
1192 for (j
= 1; j
<= 8; ++j
)
1201 if (unlikely (jcnt
> (1U << j
)))
1207 /* There are JCNT values that have this length, the values
1208 starting from START[j] continuing through NEXT[VAL]. Those
1209 values are assigned consecutive values starting at CODE. */
1212 for (i
= 0; i
< jcnt
; ++i
)
1218 /* In the compressed bit stream, the value VAL is encoded as
1219 J bits with the value C. */
1221 if (unlikely ((val
& ~HUFFMAN_VALUE_MASK
) != 0))
1227 tval
= val
| ((j
- 1) << HUFFMAN_BITS_SHIFT
);
1229 /* The table lookup uses 8 bits. If J is less than 8, we
1230 don't know what the other bits will be. We need to fill
1231 in all possibilities in the table. Since the Huffman
1232 code is unambiguous, those entries can't be used for any
1235 for (ind
= code
; ind
< 0x100; ind
+= 1 << j
)
1237 if (unlikely (table
[ind
] != 0))
1245 /* Advance to the next value with this length. */
1249 /* The Huffman codes are stored in the bitstream with the
1250 most significant bit first, as is required to make them
1251 unambiguous. The effect is that when we read them from
1252 the bitstream we see the bit sequence in reverse order:
1253 the most significant bit of the Huffman code is the least
1254 significant bit of the value we read from the bitstream.
1255 That means that to make our table lookups work, we need
1256 to reverse the bits of CODE. Since reversing bits is
1257 tedious and in general requires using a table, we instead
1258 increment CODE in reverse order. That is, if the number
1259 of bits we are currently using, here named J, is 3, we
1260 count as 000, 100, 010, 110, 001, 101, 011, 111, which is
1261 to say the numbers from 0 to 7 but with the bits
1262 reversed. Going to more bits, aka incrementing J,
1263 effectively just adds more zero bits as the beginning,
1264 and as such does not change the numeric value of CODE.
1266 To increment CODE of length J in reverse order, find the
1267 most significant zero bit and set it to one while
1268 clearing all higher bits. In other words, add 1 modulo
1269 2^J, only reversed. */
1271 incr
= 1U << (j
- 1);
1272 while ((code
& incr
) != 0)
1284 /* Handle the values that require a secondary table. */
1286 /* Set FIRSTCODE, the number at which the codes start, for each
1289 for (j
= 9; j
< 16; j
++)
1298 /* There are JCNT values that have this length, the values
1299 starting from START[j]. Those values are assigned
1300 consecutive values starting at CODE. */
1302 firstcode
[j
- 9] = code
;
1304 /* Reverse add JCNT to CODE modulo 2^J. */
1305 for (k
= 0; k
< j
; ++k
)
1307 if ((jcnt
& (1U << k
)) != 0)
1312 bit
= 1U << (j
- k
- 1);
1313 for (m
= 0; m
< j
- k
; ++m
, bit
>>= 1)
1315 if ((code
& bit
) == 0)
1325 if (unlikely (jcnt
!= 0))
1332 /* For J from 9 to 15, inclusive, we store COUNT[J] consecutive
1333 values starting at START[J] with consecutive codes starting at
1334 FIRSTCODE[J - 9]. In the primary table we need to point to the
1335 secondary table, and the secondary table will be indexed by J - 9
1336 bits. We count down from 15 so that we install the larger
1337 secondary tables first, as the smaller ones may be embedded in
1340 next_secondary
= 0; /* Index of next secondary table (after primary). */
1341 for (j
= 15; j
>= 9; j
--)
1345 size_t primary
; /* Current primary index. */
1346 size_t secondary
; /* Offset to current secondary table. */
1347 size_t secondary_bits
; /* Bit size of current secondary table. */
1354 code
= firstcode
[j
- 9];
1358 for (i
= 0; i
< jcnt
; ++i
)
1364 if ((code
& 0xff) != primary
)
1368 /* Fill in a new primary table entry. */
1370 primary
= code
& 0xff;
1372 tprimary
= table
[primary
];
1375 /* Start a new secondary table. */
1377 if (unlikely ((next_secondary
& HUFFMAN_VALUE_MASK
)
1384 secondary
= next_secondary
;
1385 secondary_bits
= j
- 8;
1386 next_secondary
+= 1 << secondary_bits
;
1387 table
[primary
] = (secondary
1388 + ((j
- 8) << HUFFMAN_BITS_SHIFT
)
1389 + (1U << HUFFMAN_SECONDARY_SHIFT
));
1393 /* There is an existing entry. It had better be a
1394 secondary table with enough bits. */
1395 if (unlikely ((tprimary
& (1U << HUFFMAN_SECONDARY_SHIFT
))
1401 secondary
= tprimary
& HUFFMAN_VALUE_MASK
;
1402 secondary_bits
= ((tprimary
>> HUFFMAN_BITS_SHIFT
)
1403 & HUFFMAN_BITS_MASK
);
1404 if (unlikely (secondary_bits
< j
- 8))
1412 /* Fill in secondary table entries. */
1414 tval
= val
| ((j
- 8) << HUFFMAN_BITS_SHIFT
);
1416 for (ind
= code
>> 8;
1417 ind
< (1U << secondary_bits
);
1418 ind
+= 1U << (j
- 8))
1420 if (unlikely (table
[secondary
+ 0x100 + ind
] != 0))
1425 table
[secondary
+ 0x100 + ind
] = tval
;
1431 incr
= 1U << (j
- 1);
1432 while ((code
& incr
) != 0)
1444 #ifdef BACKTRACE_GENERATE_FIXED_HUFFMAN_TABLE
1445 final_next_secondary
= next_secondary
;
1451 #ifdef BACKTRACE_GENERATE_FIXED_HUFFMAN_TABLE
1453 /* Used to generate the fixed Huffman table for block type 1. */
1457 static uint16_t table
[ZDEBUG_TABLE_SIZE
];
1458 static unsigned char codes
[287];
1465 for (i
= 0; i
<= 143; ++i
)
1467 for (i
= 144; i
<= 255; ++i
)
1469 for (i
= 256; i
<= 279; ++i
)
1471 for (i
= 280; i
<= 287; ++i
)
1473 if (!elf_zlib_inflate_table (&codes
[0], 287, &table
[0], &table
[0]))
1475 fprintf (stderr
, "elf_zlib_inflate_table failed\n");
1476 exit (EXIT_FAILURE
);
1479 printf ("static const uint16_t elf_zlib_default_table[%#zx] =\n",
1480 final_next_secondary
+ 0x100);
1482 for (i
= 0; i
< final_next_secondary
+ 0x100; i
+= 8)
1487 for (j
= i
; j
< final_next_secondary
+ 0x100 && j
< i
+ 8; ++j
)
1488 printf (" %#x,", table
[j
]);
1497 /* The fixed table generated by the #ifdef'ed out main function
1500 static const uint16_t elf_zlib_default_table
[0x170] =
1502 0xd00, 0xe50, 0xe10, 0xf18, 0xd10, 0xe70, 0xe30, 0x1232,
1503 0xd08, 0xe60, 0xe20, 0x1212, 0xe00, 0xe80, 0xe40, 0x1252,
1504 0xd04, 0xe58, 0xe18, 0x1202, 0xd14, 0xe78, 0xe38, 0x1242,
1505 0xd0c, 0xe68, 0xe28, 0x1222, 0xe08, 0xe88, 0xe48, 0x1262,
1506 0xd02, 0xe54, 0xe14, 0xf1c, 0xd12, 0xe74, 0xe34, 0x123a,
1507 0xd0a, 0xe64, 0xe24, 0x121a, 0xe04, 0xe84, 0xe44, 0x125a,
1508 0xd06, 0xe5c, 0xe1c, 0x120a, 0xd16, 0xe7c, 0xe3c, 0x124a,
1509 0xd0e, 0xe6c, 0xe2c, 0x122a, 0xe0c, 0xe8c, 0xe4c, 0x126a,
1510 0xd01, 0xe52, 0xe12, 0xf1a, 0xd11, 0xe72, 0xe32, 0x1236,
1511 0xd09, 0xe62, 0xe22, 0x1216, 0xe02, 0xe82, 0xe42, 0x1256,
1512 0xd05, 0xe5a, 0xe1a, 0x1206, 0xd15, 0xe7a, 0xe3a, 0x1246,
1513 0xd0d, 0xe6a, 0xe2a, 0x1226, 0xe0a, 0xe8a, 0xe4a, 0x1266,
1514 0xd03, 0xe56, 0xe16, 0xf1e, 0xd13, 0xe76, 0xe36, 0x123e,
1515 0xd0b, 0xe66, 0xe26, 0x121e, 0xe06, 0xe86, 0xe46, 0x125e,
1516 0xd07, 0xe5e, 0xe1e, 0x120e, 0xd17, 0xe7e, 0xe3e, 0x124e,
1517 0xd0f, 0xe6e, 0xe2e, 0x122e, 0xe0e, 0xe8e, 0xe4e, 0x126e,
1518 0xd00, 0xe51, 0xe11, 0xf19, 0xd10, 0xe71, 0xe31, 0x1234,
1519 0xd08, 0xe61, 0xe21, 0x1214, 0xe01, 0xe81, 0xe41, 0x1254,
1520 0xd04, 0xe59, 0xe19, 0x1204, 0xd14, 0xe79, 0xe39, 0x1244,
1521 0xd0c, 0xe69, 0xe29, 0x1224, 0xe09, 0xe89, 0xe49, 0x1264,
1522 0xd02, 0xe55, 0xe15, 0xf1d, 0xd12, 0xe75, 0xe35, 0x123c,
1523 0xd0a, 0xe65, 0xe25, 0x121c, 0xe05, 0xe85, 0xe45, 0x125c,
1524 0xd06, 0xe5d, 0xe1d, 0x120c, 0xd16, 0xe7d, 0xe3d, 0x124c,
1525 0xd0e, 0xe6d, 0xe2d, 0x122c, 0xe0d, 0xe8d, 0xe4d, 0x126c,
1526 0xd01, 0xe53, 0xe13, 0xf1b, 0xd11, 0xe73, 0xe33, 0x1238,
1527 0xd09, 0xe63, 0xe23, 0x1218, 0xe03, 0xe83, 0xe43, 0x1258,
1528 0xd05, 0xe5b, 0xe1b, 0x1208, 0xd15, 0xe7b, 0xe3b, 0x1248,
1529 0xd0d, 0xe6b, 0xe2b, 0x1228, 0xe0b, 0xe8b, 0xe4b, 0x1268,
1530 0xd03, 0xe57, 0xe17, 0x1200, 0xd13, 0xe77, 0xe37, 0x1240,
1531 0xd0b, 0xe67, 0xe27, 0x1220, 0xe07, 0xe87, 0xe47, 0x1260,
1532 0xd07, 0xe5f, 0xe1f, 0x1210, 0xd17, 0xe7f, 0xe3f, 0x1250,
1533 0xd0f, 0xe6f, 0xe2f, 0x1230, 0xe0f, 0xe8f, 0xe4f, 0,
1534 0x290, 0x291, 0x292, 0x293, 0x294, 0x295, 0x296, 0x297,
1535 0x298, 0x299, 0x29a, 0x29b, 0x29c, 0x29d, 0x29e, 0x29f,
1536 0x2a0, 0x2a1, 0x2a2, 0x2a3, 0x2a4, 0x2a5, 0x2a6, 0x2a7,
1537 0x2a8, 0x2a9, 0x2aa, 0x2ab, 0x2ac, 0x2ad, 0x2ae, 0x2af,
1538 0x2b0, 0x2b1, 0x2b2, 0x2b3, 0x2b4, 0x2b5, 0x2b6, 0x2b7,
1539 0x2b8, 0x2b9, 0x2ba, 0x2bb, 0x2bc, 0x2bd, 0x2be, 0x2bf,
1540 0x2c0, 0x2c1, 0x2c2, 0x2c3, 0x2c4, 0x2c5, 0x2c6, 0x2c7,
1541 0x2c8, 0x2c9, 0x2ca, 0x2cb, 0x2cc, 0x2cd, 0x2ce, 0x2cf,
1542 0x2d0, 0x2d1, 0x2d2, 0x2d3, 0x2d4, 0x2d5, 0x2d6, 0x2d7,
1543 0x2d8, 0x2d9, 0x2da, 0x2db, 0x2dc, 0x2dd, 0x2de, 0x2df,
1544 0x2e0, 0x2e1, 0x2e2, 0x2e3, 0x2e4, 0x2e5, 0x2e6, 0x2e7,
1545 0x2e8, 0x2e9, 0x2ea, 0x2eb, 0x2ec, 0x2ed, 0x2ee, 0x2ef,
1546 0x2f0, 0x2f1, 0x2f2, 0x2f3, 0x2f4, 0x2f5, 0x2f6, 0x2f7,
1547 0x2f8, 0x2f9, 0x2fa, 0x2fb, 0x2fc, 0x2fd, 0x2fe, 0x2ff,
1550 /* Inflate a zlib stream from PIN/SIN to POUT/SOUT. Return 1 on
1551 success, 0 on some error parsing the stream. */
1554 elf_zlib_inflate (const unsigned char *pin
, size_t sin
, uint16_t *zdebug_table
,
1555 unsigned char *pout
, size_t sout
)
1557 unsigned char *porigout
;
1558 const unsigned char *pinend
;
1559 unsigned char *poutend
;
1561 /* We can apparently see multiple zlib streams concatenated
1562 together, so keep going as long as there is something to read.
1563 The last 4 bytes are the checksum. */
1566 poutend
= pout
+ sout
;
1567 while ((pinend
- pin
) > 4)
1573 /* Read the two byte zlib header. */
1575 if (unlikely ((pin
[0] & 0xf) != 8)) /* 8 is zlib encoding. */
1577 /* Unknown compression method. */
1581 if (unlikely ((pin
[0] >> 4) > 7))
1583 /* Window size too large. Other than this check, we don't
1584 care about the window size. */
1588 if (unlikely ((pin
[1] & 0x20) != 0))
1590 /* Stream expects a predefined dictionary, but we have no
1595 val
= (pin
[0] << 8) | pin
[1];
1596 if (unlikely (val
% 31 != 0))
1598 /* Header check failure. */
1604 /* Read blocks until one is marked last. */
1613 const uint16_t *tlit
;
1614 const uint16_t *tdist
;
1616 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1620 type
= (val
>> 1) & 3;
1624 if (unlikely (type
== 3))
1626 /* Invalid block type. */
1636 /* An uncompressed block. */
1638 /* If we've read ahead more than a byte, back up. */
1647 if (unlikely ((pinend
- pin
) < 4))
1649 /* Missing length. */
1653 len
= pin
[0] | (pin
[1] << 8);
1654 lenc
= pin
[2] | (pin
[3] << 8);
1657 if (unlikely (len
!= lenc
))
1663 if (unlikely (len
> (unsigned int) (pinend
- pin
)
1664 || len
> (unsigned int) (poutend
- pout
)))
1666 /* Not enough space in buffers. */
1670 memcpy (pout
, pin
, len
);
1674 /* Go around to read the next block. */
1680 tlit
= elf_zlib_default_table
;
1681 tdist
= elf_zlib_default_table
;
1688 unsigned char codebits
[19];
1689 unsigned char *plenbase
;
1690 unsigned char *plen
;
1691 unsigned char *plenend
;
1693 /* Read a Huffman encoding table. The various magic
1694 numbers here are from RFC 1951. */
1696 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1699 nlit
= (val
& 0x1f) + 257;
1701 ndist
= (val
& 0x1f) + 1;
1703 nclen
= (val
& 0xf) + 4;
1706 if (unlikely (nlit
> 286 || ndist
> 30))
1708 /* Values out of range. */
1713 /* Read and build the table used to compress the
1714 literal, length, and distance codes. */
1716 memset(&codebits
[0], 0, 19);
1718 /* There are always at least 4 elements in the
1721 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1724 codebits
[16] = val
& 7;
1725 codebits
[17] = (val
>> 3) & 7;
1726 codebits
[18] = (val
>> 6) & 7;
1727 codebits
[0] = (val
>> 9) & 7;
1734 codebits
[8] = val
& 7;
1741 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1744 codebits
[7] = val
& 7;
1751 codebits
[9] = val
& 7;
1758 codebits
[6] = val
& 7;
1765 codebits
[10] = val
& 7;
1772 codebits
[5] = val
& 7;
1779 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1782 codebits
[11] = val
& 7;
1789 codebits
[4] = val
& 7;
1796 codebits
[12] = val
& 7;
1803 codebits
[3] = val
& 7;
1810 codebits
[13] = val
& 7;
1817 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1820 codebits
[2] = val
& 7;
1827 codebits
[14] = val
& 7;
1834 codebits
[1] = val
& 7;
1841 codebits
[15] = val
& 7;
1847 if (!elf_zlib_inflate_table (codebits
, 19, zdebug_table
,
1851 /* Read the compressed bit lengths of the literal,
1852 length, and distance codes. We have allocated space
1853 at the end of zdebug_table to hold them. */
1855 plenbase
= (((unsigned char *) zdebug_table
)
1856 + ZDEBUG_TABLE_CODELEN_OFFSET
);
1858 plenend
= plen
+ nlit
+ ndist
;
1859 while (plen
< plenend
)
1865 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1868 t
= zdebug_table
[val
& 0xff];
1870 /* The compression here uses bit lengths up to 7, so
1871 a secondary table is never necessary. */
1872 if (unlikely ((t
& (1U << HUFFMAN_SECONDARY_SHIFT
)) != 0))
1878 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
1882 v
= t
& HUFFMAN_VALUE_MASK
;
1890 /* Copy previous entry 3 to 6 times. */
1892 if (unlikely (plen
== plenbase
))
1898 /* We used up to 7 bits since the last
1899 elf_zlib_fetch, so we have at least 8 bits
1902 c
= 3 + (val
& 0x3);
1905 if (unlikely ((unsigned int) (plenend
- plen
) < c
))
1931 /* Store zero 3 to 10 times. */
1933 /* We used up to 7 bits since the last
1934 elf_zlib_fetch, so we have at least 8 bits
1937 c
= 3 + (val
& 0x7);
1940 if (unlikely ((unsigned int) (plenend
- plen
) < c
))
1977 /* Store zero 11 to 138 times. */
1979 /* We used up to 7 bits since the last
1980 elf_zlib_fetch, so we have at least 8 bits
1983 c
= 11 + (val
& 0x7f);
1986 if (unlikely ((unsigned int) (plenend
- plen
) < c
))
1992 memset (plen
, 0, c
);
2002 /* Make sure that the stop code can appear. */
2005 if (unlikely (plen
[256] == 0))
2011 /* Build the decompression tables. */
2013 if (!elf_zlib_inflate_table (plen
, nlit
, zdebug_table
,
2016 if (!elf_zlib_inflate_table (plen
+ nlit
, ndist
, zdebug_table
,
2017 zdebug_table
+ HUFFMAN_TABLE_SIZE
))
2019 tlit
= zdebug_table
;
2020 tdist
= zdebug_table
+ HUFFMAN_TABLE_SIZE
;
2023 /* Inflate values until the end of the block. This is the
2024 main loop of the inflation code. */
2033 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
2036 t
= tlit
[val
& 0xff];
2037 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
2038 v
= t
& HUFFMAN_VALUE_MASK
;
2040 if ((t
& (1U << HUFFMAN_SECONDARY_SHIFT
)) == 0)
2048 t
= tlit
[v
+ 0x100 + ((val
>> 8) & ((1U << b
) - 1))];
2049 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
2050 lit
= t
& HUFFMAN_VALUE_MASK
;
2057 if (unlikely (pout
== poutend
))
2065 /* We will need to write the next byte soon. We ask
2066 for high temporal locality because we will write
2067 to the whole cache line soon. */
2068 __builtin_prefetch (pout
, 1, 3);
2070 else if (lit
== 256)
2072 /* The end of the block. */
2080 /* Convert lit into a length. */
2083 len
= lit
- 257 + 3;
2084 else if (lit
== 285)
2086 else if (unlikely (lit
> 285))
2095 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
2098 /* This is an expression for the table of length
2099 codes in RFC 1951 3.2.5. */
2101 extra
= (lit
>> 2) + 1;
2102 len
= (lit
& 3) << extra
;
2104 len
+= ((1U << (extra
- 1)) - 1) << 3;
2105 len
+= val
& ((1U << extra
) - 1);
2110 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
2113 t
= tdist
[val
& 0xff];
2114 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
2115 v
= t
& HUFFMAN_VALUE_MASK
;
2117 if ((t
& (1U << HUFFMAN_SECONDARY_SHIFT
)) == 0)
2125 t
= tdist
[v
+ 0x100 + ((val
>> 8) & ((1U << b
) - 1))];
2126 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
2127 dist
= t
& HUFFMAN_VALUE_MASK
;
2132 /* Convert dist to a distance. */
2136 /* A distance of 1. A common case, meaning
2137 repeat the last character LEN times. */
2139 if (unlikely (pout
== porigout
))
2145 if (unlikely ((unsigned int) (poutend
- pout
) < len
))
2151 memset (pout
, pout
[-1], len
);
2154 else if (unlikely (dist
> 29))
2167 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
2170 /* This is an expression for the table of
2171 distance codes in RFC 1951 3.2.5. */
2173 extra
= (dist
>> 1) + 1;
2174 dist
= (dist
& 1) << extra
;
2176 dist
+= ((1U << (extra
- 1)) - 1) << 2;
2177 dist
+= val
& ((1U << extra
) - 1);
2182 /* Go back dist bytes, and copy len bytes from
2185 if (unlikely ((unsigned int) (pout
- porigout
) < dist
))
2191 if (unlikely ((unsigned int) (poutend
- pout
) < len
))
2199 memcpy (pout
, pout
- dist
, len
);
2208 copy
= len
< dist
? len
: dist
;
2209 memcpy (pout
, pout
- dist
, copy
);
2220 /* We should have filled the output buffer. */
2221 if (unlikely (pout
!= poutend
))
2230 /* Verify the zlib checksum. The checksum is in the 4 bytes at
2231 CHECKBYTES, and the uncompressed data is at UNCOMPRESSED /
2232 UNCOMPRESSED_SIZE. Returns 1 on success, 0 on failure. */
2235 elf_zlib_verify_checksum (const unsigned char *checkbytes
,
2236 const unsigned char *uncompressed
,
2237 size_t uncompressed_size
)
2241 const unsigned char *p
;
2247 for (i
= 0; i
< 4; i
++)
2248 cksum
= (cksum
<< 8) | checkbytes
[i
];
2253 /* Minimize modulo operations. */
2256 hsz
= uncompressed_size
;
2259 for (i
= 0; i
< 5552; i
+= 16)
2261 /* Manually unroll loop 16 times. */
2302 /* Manually unroll loop 16 times. */
2339 for (i
= 0; i
< hsz
; ++i
)
2348 if (unlikely ((s2
<< 16) + s1
!= cksum
))
2357 /* Inflate a zlib stream from PIN/SIN to POUT/SOUT, and verify the
2358 checksum. Return 1 on success, 0 on error. */
2361 elf_zlib_inflate_and_verify (const unsigned char *pin
, size_t sin
,
2362 uint16_t *zdebug_table
, unsigned char *pout
,
2365 if (!elf_zlib_inflate (pin
, sin
, zdebug_table
, pout
, sout
))
2367 if (!elf_zlib_verify_checksum (pin
+ sin
- 4, pout
, sout
))
2372 /* Uncompress the old compressed debug format, the one emitted by
2373 --compress-debug-sections=zlib-gnu. The compressed data is in
2374 COMPRESSED / COMPRESSED_SIZE, and the function writes to
2375 *UNCOMPRESSED / *UNCOMPRESSED_SIZE. ZDEBUG_TABLE is work space to
2376 hold Huffman tables. Returns 0 on error, 1 on successful
2377 decompression or if something goes wrong. In general we try to
2378 carry on, by returning 1, even if we can't decompress. */
2381 elf_uncompress_zdebug (struct backtrace_state
*state
,
2382 const unsigned char *compressed
, size_t compressed_size
,
2383 uint16_t *zdebug_table
,
2384 backtrace_error_callback error_callback
, void *data
,
2385 unsigned char **uncompressed
, size_t *uncompressed_size
)
2391 *uncompressed
= NULL
;
2392 *uncompressed_size
= 0;
2394 /* The format starts with the four bytes ZLIB, followed by the 8
2395 byte length of the uncompressed data in big-endian order,
2396 followed by a zlib stream. */
2398 if (compressed_size
< 12 || memcmp (compressed
, "ZLIB", 4) != 0)
2402 for (i
= 0; i
< 8; i
++)
2403 sz
= (sz
<< 8) | compressed
[i
+ 4];
2405 if (*uncompressed
!= NULL
&& *uncompressed_size
>= sz
)
2409 po
= (unsigned char *) backtrace_alloc (state
, sz
, error_callback
, data
);
2414 if (!elf_zlib_inflate_and_verify (compressed
+ 12, compressed_size
- 12,
2415 zdebug_table
, po
, sz
))
2419 *uncompressed_size
= sz
;
2424 /* Uncompress the new compressed debug format, the official standard
2425 ELF approach emitted by --compress-debug-sections=zlib-gabi. The
2426 compressed data is in COMPRESSED / COMPRESSED_SIZE, and the
2427 function writes to *UNCOMPRESSED / *UNCOMPRESSED_SIZE.
2428 ZDEBUG_TABLE is work space as for elf_uncompress_zdebug. Returns 0
2429 on error, 1 on successful decompression or if something goes wrong.
2430 In general we try to carry on, by returning 1, even if we can't
2434 elf_uncompress_chdr (struct backtrace_state
*state
,
2435 const unsigned char *compressed
, size_t compressed_size
,
2436 uint16_t *zdebug_table
,
2437 backtrace_error_callback error_callback
, void *data
,
2438 unsigned char **uncompressed
, size_t *uncompressed_size
)
2440 const b_elf_chdr
*chdr
;
2443 *uncompressed
= NULL
;
2444 *uncompressed_size
= 0;
2446 /* The format starts with an ELF compression header. */
2447 if (compressed_size
< sizeof (b_elf_chdr
))
2450 chdr
= (const b_elf_chdr
*) compressed
;
2452 if (chdr
->ch_type
!= ELFCOMPRESS_ZLIB
)
2454 /* Unsupported compression algorithm. */
2458 if (*uncompressed
!= NULL
&& *uncompressed_size
>= chdr
->ch_size
)
2462 po
= (unsigned char *) backtrace_alloc (state
, chdr
->ch_size
,
2463 error_callback
, data
);
2468 if (!elf_zlib_inflate_and_verify (compressed
+ sizeof (b_elf_chdr
),
2469 compressed_size
- sizeof (b_elf_chdr
),
2470 zdebug_table
, po
, chdr
->ch_size
))
2474 *uncompressed_size
= chdr
->ch_size
;
2479 /* This function is a hook for testing the zlib support. It is only
2483 backtrace_uncompress_zdebug (struct backtrace_state
*state
,
2484 const unsigned char *compressed
,
2485 size_t compressed_size
,
2486 backtrace_error_callback error_callback
,
2487 void *data
, unsigned char **uncompressed
,
2488 size_t *uncompressed_size
)
2490 uint16_t *zdebug_table
;
2493 zdebug_table
= ((uint16_t *) backtrace_alloc (state
, ZDEBUG_TABLE_SIZE
,
2494 error_callback
, data
));
2495 if (zdebug_table
== NULL
)
2497 ret
= elf_uncompress_zdebug (state
, compressed
, compressed_size
,
2498 zdebug_table
, error_callback
, data
,
2499 uncompressed
, uncompressed_size
);
2500 backtrace_free (state
, zdebug_table
, ZDEBUG_TABLE_SIZE
,
2501 error_callback
, data
);
2505 /* Add the backtrace data for one ELF file. Returns 1 on success,
2506 0 on failure (in both cases descriptor is closed) or -1 if exe
2507 is non-zero and the ELF file is ET_DYN, which tells the caller that
2508 elf_add will need to be called on the descriptor again after
2509 base_address is determined. */
2512 elf_add (struct backtrace_state
*state
, const char *filename
, int descriptor
,
2513 uintptr_t base_address
, backtrace_error_callback error_callback
,
2514 void *data
, fileline
*fileline_fn
, int *found_sym
, int *found_dwarf
,
2515 int exe
, int debuginfo
)
2517 struct backtrace_view ehdr_view
;
2521 unsigned int shstrndx
;
2522 struct backtrace_view shdrs_view
;
2523 int shdrs_view_valid
;
2524 const b_elf_shdr
*shdrs
;
2525 const b_elf_shdr
*shstrhdr
;
2528 struct backtrace_view names_view
;
2529 int names_view_valid
;
2531 unsigned int symtab_shndx
;
2532 unsigned int dynsym_shndx
;
2534 struct debug_section_info sections
[DEBUG_MAX
];
2535 struct backtrace_view symtab_view
;
2536 int symtab_view_valid
;
2537 struct backtrace_view strtab_view
;
2538 int strtab_view_valid
;
2539 struct backtrace_view buildid_view
;
2540 int buildid_view_valid
;
2541 const char *buildid_data
;
2542 uint32_t buildid_size
;
2543 struct backtrace_view debuglink_view
;
2544 int debuglink_view_valid
;
2545 const char *debuglink_name
;
2546 uint32_t debuglink_crc
;
2549 struct backtrace_view debug_view
;
2550 int debug_view_valid
;
2551 unsigned int using_debug_view
;
2552 uint16_t *zdebug_table
;
2557 shdrs_view_valid
= 0;
2558 names_view_valid
= 0;
2559 symtab_view_valid
= 0;
2560 strtab_view_valid
= 0;
2561 buildid_view_valid
= 0;
2562 buildid_data
= NULL
;
2564 debuglink_view_valid
= 0;
2565 debuglink_name
= NULL
;
2567 debug_view_valid
= 0;
2569 if (!backtrace_get_view (state
, descriptor
, 0, sizeof ehdr
, error_callback
,
2573 memcpy (&ehdr
, ehdr_view
.data
, sizeof ehdr
);
2575 backtrace_release_view (state
, &ehdr_view
, error_callback
, data
);
2577 if (ehdr
.e_ident
[EI_MAG0
] != ELFMAG0
2578 || ehdr
.e_ident
[EI_MAG1
] != ELFMAG1
2579 || ehdr
.e_ident
[EI_MAG2
] != ELFMAG2
2580 || ehdr
.e_ident
[EI_MAG3
] != ELFMAG3
)
2582 error_callback (data
, "executable file is not ELF", 0);
2585 if (ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
)
2587 error_callback (data
, "executable file is unrecognized ELF version", 0);
2591 #if BACKTRACE_ELF_SIZE == 32
2592 #define BACKTRACE_ELFCLASS ELFCLASS32
2594 #define BACKTRACE_ELFCLASS ELFCLASS64
2597 if (ehdr
.e_ident
[EI_CLASS
] != BACKTRACE_ELFCLASS
)
2599 error_callback (data
, "executable file is unexpected ELF class", 0);
2603 if (ehdr
.e_ident
[EI_DATA
] != ELFDATA2LSB
2604 && ehdr
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
2606 error_callback (data
, "executable file has unknown endianness", 0);
2610 /* If the executable is ET_DYN, it is either a PIE, or we are running
2611 directly a shared library with .interp. We need to wait for
2612 dl_iterate_phdr in that case to determine the actual base_address. */
2613 if (exe
&& ehdr
.e_type
== ET_DYN
)
2616 shoff
= ehdr
.e_shoff
;
2617 shnum
= ehdr
.e_shnum
;
2618 shstrndx
= ehdr
.e_shstrndx
;
2620 if ((shnum
== 0 || shstrndx
== SHN_XINDEX
)
2623 struct backtrace_view shdr_view
;
2624 const b_elf_shdr
*shdr
;
2626 if (!backtrace_get_view (state
, descriptor
, shoff
, sizeof shdr
,
2627 error_callback
, data
, &shdr_view
))
2630 shdr
= (const b_elf_shdr
*) shdr_view
.data
;
2633 shnum
= shdr
->sh_size
;
2635 if (shstrndx
== SHN_XINDEX
)
2637 shstrndx
= shdr
->sh_link
;
2639 /* Versions of the GNU binutils between 2.12 and 2.18 did
2640 not handle objects with more than SHN_LORESERVE sections
2641 correctly. All large section indexes were offset by
2642 0x100. There is more information at
2643 http://sourceware.org/bugzilla/show_bug.cgi?id-5900 .
2644 Fortunately these object files are easy to detect, as the
2645 GNU binutils always put the section header string table
2646 near the end of the list of sections. Thus if the
2647 section header string table index is larger than the
2648 number of sections, then we know we have to subtract
2649 0x100 to get the real section index. */
2650 if (shstrndx
>= shnum
&& shstrndx
>= SHN_LORESERVE
+ 0x100)
2654 backtrace_release_view (state
, &shdr_view
, error_callback
, data
);
2657 /* To translate PC to file/line when using DWARF, we need to find
2658 the .debug_info and .debug_line sections. */
2660 /* Read the section headers, skipping the first one. */
2662 if (!backtrace_get_view (state
, descriptor
, shoff
+ sizeof (b_elf_shdr
),
2663 (shnum
- 1) * sizeof (b_elf_shdr
),
2664 error_callback
, data
, &shdrs_view
))
2666 shdrs_view_valid
= 1;
2667 shdrs
= (const b_elf_shdr
*) shdrs_view
.data
;
2669 /* Read the section names. */
2671 shstrhdr
= &shdrs
[shstrndx
- 1];
2672 shstr_size
= shstrhdr
->sh_size
;
2673 shstr_off
= shstrhdr
->sh_offset
;
2675 if (!backtrace_get_view (state
, descriptor
, shstr_off
, shstr_size
,
2676 error_callback
, data
, &names_view
))
2678 names_view_valid
= 1;
2679 names
= (const char *) names_view
.data
;
2684 memset (sections
, 0, sizeof sections
);
2686 /* Look for the symbol table. */
2687 for (i
= 1; i
< shnum
; ++i
)
2689 const b_elf_shdr
*shdr
;
2690 unsigned int sh_name
;
2694 shdr
= &shdrs
[i
- 1];
2696 if (shdr
->sh_type
== SHT_SYMTAB
)
2698 else if (shdr
->sh_type
== SHT_DYNSYM
)
2701 sh_name
= shdr
->sh_name
;
2702 if (sh_name
>= shstr_size
)
2704 error_callback (data
, "ELF section name out of range", 0);
2708 name
= names
+ sh_name
;
2710 for (j
= 0; j
< (int) DEBUG_MAX
; ++j
)
2712 if (strcmp (name
, debug_section_names
[j
]) == 0)
2714 sections
[j
].offset
= shdr
->sh_offset
;
2715 sections
[j
].size
= shdr
->sh_size
;
2716 sections
[j
].compressed
= (shdr
->sh_flags
& SHF_COMPRESSED
) != 0;
2721 /* Read the build ID if present. This could check for any
2722 SHT_NOTE section with the right note name and type, but gdb
2723 looks for a specific section name. */
2725 && !buildid_view_valid
2726 && strcmp (name
, ".note.gnu.build-id") == 0)
2728 const b_elf_note
*note
;
2730 if (!backtrace_get_view (state
, descriptor
, shdr
->sh_offset
,
2731 shdr
->sh_size
, error_callback
, data
,
2735 buildid_view_valid
= 1;
2736 note
= (const b_elf_note
*) buildid_view
.data
;
2737 if (note
->type
== NT_GNU_BUILD_ID
2738 && note
->namesz
== 4
2739 && strncmp (note
->name
, "GNU", 4) == 0
2740 && shdr
->sh_size
< 12 + ((note
->namesz
+ 3) & ~ 3) + note
->descsz
)
2742 buildid_data
= ¬e
->name
[0] + ((note
->namesz
+ 3) & ~ 3);
2743 buildid_size
= note
->descsz
;
2747 /* Read the debuglink file if present. */
2749 && !debuglink_view_valid
2750 && strcmp (name
, ".gnu_debuglink") == 0)
2752 const char *debuglink_data
;
2755 if (!backtrace_get_view (state
, descriptor
, shdr
->sh_offset
,
2756 shdr
->sh_size
, error_callback
, data
,
2760 debuglink_view_valid
= 1;
2761 debuglink_data
= (const char *) debuglink_view
.data
;
2762 crc_offset
= strnlen (debuglink_data
, shdr
->sh_size
);
2763 crc_offset
= (crc_offset
+ 3) & ~3;
2764 if (crc_offset
+ 4 <= shdr
->sh_size
)
2766 debuglink_name
= debuglink_data
;
2767 debuglink_crc
= *(const uint32_t*)(debuglink_data
+ crc_offset
);
2772 if (symtab_shndx
== 0)
2773 symtab_shndx
= dynsym_shndx
;
2774 if (symtab_shndx
!= 0 && !debuginfo
)
2776 const b_elf_shdr
*symtab_shdr
;
2777 unsigned int strtab_shndx
;
2778 const b_elf_shdr
*strtab_shdr
;
2779 struct elf_syminfo_data
*sdata
;
2781 symtab_shdr
= &shdrs
[symtab_shndx
- 1];
2782 strtab_shndx
= symtab_shdr
->sh_link
;
2783 if (strtab_shndx
>= shnum
)
2785 error_callback (data
,
2786 "ELF symbol table strtab link out of range", 0);
2789 strtab_shdr
= &shdrs
[strtab_shndx
- 1];
2791 if (!backtrace_get_view (state
, descriptor
, symtab_shdr
->sh_offset
,
2792 symtab_shdr
->sh_size
, error_callback
, data
,
2795 symtab_view_valid
= 1;
2797 if (!backtrace_get_view (state
, descriptor
, strtab_shdr
->sh_offset
,
2798 strtab_shdr
->sh_size
, error_callback
, data
,
2801 strtab_view_valid
= 1;
2803 sdata
= ((struct elf_syminfo_data
*)
2804 backtrace_alloc (state
, sizeof *sdata
, error_callback
, data
));
2808 if (!elf_initialize_syminfo (state
, base_address
,
2809 symtab_view
.data
, symtab_shdr
->sh_size
,
2810 strtab_view
.data
, strtab_shdr
->sh_size
,
2811 error_callback
, data
, sdata
))
2813 backtrace_free (state
, sdata
, sizeof *sdata
, error_callback
, data
);
2817 /* We no longer need the symbol table, but we hold on to the
2818 string table permanently. */
2819 backtrace_release_view (state
, &symtab_view
, error_callback
, data
);
2820 symtab_view_valid
= 0;
2824 elf_add_syminfo_data (state
, sdata
);
2827 backtrace_release_view (state
, &shdrs_view
, error_callback
, data
);
2828 shdrs_view_valid
= 0;
2829 backtrace_release_view (state
, &names_view
, error_callback
, data
);
2830 names_view_valid
= 0;
2832 /* If the debug info is in a separate file, read that one instead. */
2834 if (buildid_data
!= NULL
)
2838 d
= elf_open_debugfile_by_buildid (state
, buildid_data
, buildid_size
,
2839 error_callback
, data
);
2842 backtrace_release_view (state
, &buildid_view
, error_callback
, data
);
2843 if (debuglink_view_valid
)
2844 backtrace_release_view (state
, &debuglink_view
, error_callback
,
2846 return elf_add (state
, NULL
, d
, base_address
, error_callback
, data
,
2847 fileline_fn
, found_sym
, found_dwarf
, 0, 1);
2851 if (buildid_view_valid
)
2853 backtrace_release_view (state
, &buildid_view
, error_callback
, data
);
2854 buildid_view_valid
= 0;
2857 if (debuglink_name
!= NULL
)
2861 d
= elf_open_debugfile_by_debuglink (state
, filename
, debuglink_name
,
2862 debuglink_crc
, error_callback
,
2866 backtrace_release_view (state
, &debuglink_view
, error_callback
,
2868 return elf_add (state
, NULL
, d
, base_address
, error_callback
, data
,
2869 fileline_fn
, found_sym
, found_dwarf
, 0, 1);
2873 if (debuglink_view_valid
)
2875 backtrace_release_view (state
, &debuglink_view
, error_callback
, data
);
2876 debuglink_view_valid
= 0;
2879 /* Read all the debug sections in a single view, since they are
2880 probably adjacent in the file. We never release this view. */
2884 for (i
= 0; i
< (int) DEBUG_MAX
; ++i
)
2888 if (sections
[i
].size
== 0)
2890 if (min_offset
== 0 || sections
[i
].offset
< min_offset
)
2891 min_offset
= sections
[i
].offset
;
2892 end
= sections
[i
].offset
+ sections
[i
].size
;
2893 if (end
> max_offset
)
2896 if (min_offset
== 0 || max_offset
== 0)
2898 if (!backtrace_close (descriptor
, error_callback
, data
))
2903 if (!backtrace_get_view (state
, descriptor
, min_offset
,
2904 max_offset
- min_offset
,
2905 error_callback
, data
, &debug_view
))
2907 debug_view_valid
= 1;
2909 /* We've read all we need from the executable. */
2910 if (!backtrace_close (descriptor
, error_callback
, data
))
2914 using_debug_view
= 0;
2915 for (i
= 0; i
< (int) DEBUG_MAX
; ++i
)
2917 if (sections
[i
].size
== 0)
2918 sections
[i
].data
= NULL
;
2921 sections
[i
].data
= ((const unsigned char *) debug_view
.data
2922 + (sections
[i
].offset
- min_offset
));
2923 if (i
< ZDEBUG_INFO
)
2928 /* Uncompress the old format (--compress-debug-sections=zlib-gnu). */
2930 zdebug_table
= NULL
;
2931 for (i
= 0; i
< ZDEBUG_INFO
; ++i
)
2933 struct debug_section_info
*pz
;
2935 pz
= §ions
[i
+ ZDEBUG_INFO
- DEBUG_INFO
];
2936 if (sections
[i
].size
== 0 && pz
->size
> 0)
2938 unsigned char *uncompressed_data
;
2939 size_t uncompressed_size
;
2941 if (zdebug_table
== NULL
)
2943 zdebug_table
= ((uint16_t *)
2944 backtrace_alloc (state
, ZDEBUG_TABLE_SIZE
,
2945 error_callback
, data
));
2946 if (zdebug_table
== NULL
)
2950 uncompressed_data
= NULL
;
2951 uncompressed_size
= 0;
2952 if (!elf_uncompress_zdebug (state
, pz
->data
, pz
->size
, zdebug_table
,
2953 error_callback
, data
,
2954 &uncompressed_data
, &uncompressed_size
))
2956 sections
[i
].data
= uncompressed_data
;
2957 sections
[i
].size
= uncompressed_size
;
2958 sections
[i
].compressed
= 0;
2962 /* Uncompress the official ELF format
2963 (--compress-debug-sections=zlib-gabi). */
2964 for (i
= 0; i
< ZDEBUG_INFO
; ++i
)
2966 unsigned char *uncompressed_data
;
2967 size_t uncompressed_size
;
2969 if (sections
[i
].size
== 0 || !sections
[i
].compressed
)
2972 if (zdebug_table
== NULL
)
2974 zdebug_table
= ((uint16_t *)
2975 backtrace_alloc (state
, ZDEBUG_TABLE_SIZE
,
2976 error_callback
, data
));
2977 if (zdebug_table
== NULL
)
2981 uncompressed_data
= NULL
;
2982 uncompressed_size
= 0;
2983 if (!elf_uncompress_chdr (state
, sections
[i
].data
, sections
[i
].size
,
2984 zdebug_table
, error_callback
, data
,
2985 &uncompressed_data
, &uncompressed_size
))
2987 sections
[i
].data
= uncompressed_data
;
2988 sections
[i
].size
= uncompressed_size
;
2989 sections
[i
].compressed
= 0;
2994 if (zdebug_table
!= NULL
)
2995 backtrace_free (state
, zdebug_table
, ZDEBUG_TABLE_SIZE
,
2996 error_callback
, data
);
2998 if (debug_view_valid
&& using_debug_view
== 0)
3000 backtrace_release_view (state
, &debug_view
, error_callback
, data
);
3001 debug_view_valid
= 0;
3004 if (!backtrace_dwarf_add (state
, base_address
,
3005 sections
[DEBUG_INFO
].data
,
3006 sections
[DEBUG_INFO
].size
,
3007 sections
[DEBUG_LINE
].data
,
3008 sections
[DEBUG_LINE
].size
,
3009 sections
[DEBUG_ABBREV
].data
,
3010 sections
[DEBUG_ABBREV
].size
,
3011 sections
[DEBUG_RANGES
].data
,
3012 sections
[DEBUG_RANGES
].size
,
3013 sections
[DEBUG_STR
].data
,
3014 sections
[DEBUG_STR
].size
,
3015 ehdr
.e_ident
[EI_DATA
] == ELFDATA2MSB
,
3016 error_callback
, data
, fileline_fn
))
3024 if (shdrs_view_valid
)
3025 backtrace_release_view (state
, &shdrs_view
, error_callback
, data
);
3026 if (names_view_valid
)
3027 backtrace_release_view (state
, &names_view
, error_callback
, data
);
3028 if (symtab_view_valid
)
3029 backtrace_release_view (state
, &symtab_view
, error_callback
, data
);
3030 if (strtab_view_valid
)
3031 backtrace_release_view (state
, &strtab_view
, error_callback
, data
);
3032 if (debuglink_view_valid
)
3033 backtrace_release_view (state
, &debuglink_view
, error_callback
, data
);
3034 if (buildid_view_valid
)
3035 backtrace_release_view (state
, &buildid_view
, error_callback
, data
);
3036 if (debug_view_valid
)
3037 backtrace_release_view (state
, &debug_view
, error_callback
, data
);
3038 if (descriptor
!= -1)
3039 backtrace_close (descriptor
, error_callback
, data
);
3043 /* Data passed to phdr_callback. */
3047 struct backtrace_state
*state
;
3048 backtrace_error_callback error_callback
;
3050 fileline
*fileline_fn
;
3053 const char *exe_filename
;
3057 /* Callback passed to dl_iterate_phdr. Load debug info from shared
3062 __attribute__ ((__force_align_arg_pointer__
))
3064 phdr_callback (struct dl_phdr_info
*info
, size_t size ATTRIBUTE_UNUSED
,
3067 struct phdr_data
*pd
= (struct phdr_data
*) pdata
;
3068 const char *filename
;
3071 fileline elf_fileline_fn
;
3074 /* There is not much we can do if we don't have the module name,
3075 unless executable is ET_DYN, where we expect the very first
3076 phdr_callback to be for the PIE. */
3077 if (info
->dlpi_name
== NULL
|| info
->dlpi_name
[0] == '\0')
3079 if (pd
->exe_descriptor
== -1)
3081 filename
= pd
->exe_filename
;
3082 descriptor
= pd
->exe_descriptor
;
3083 pd
->exe_descriptor
= -1;
3087 if (pd
->exe_descriptor
!= -1)
3089 backtrace_close (pd
->exe_descriptor
, pd
->error_callback
, pd
->data
);
3090 pd
->exe_descriptor
= -1;
3093 filename
= info
->dlpi_name
;
3094 descriptor
= backtrace_open (info
->dlpi_name
, pd
->error_callback
,
3095 pd
->data
, &does_not_exist
);
3100 if (elf_add (pd
->state
, filename
, descriptor
, info
->dlpi_addr
,
3101 pd
->error_callback
, pd
->data
, &elf_fileline_fn
, pd
->found_sym
,
3102 &found_dwarf
, 0, 0))
3106 *pd
->found_dwarf
= 1;
3107 *pd
->fileline_fn
= elf_fileline_fn
;
3114 /* Initialize the backtrace data we need from an ELF executable. At
3115 the ELF level, all we need to do is find the debug info
3119 backtrace_initialize (struct backtrace_state
*state
, const char *filename
,
3120 int descriptor
, backtrace_error_callback error_callback
,
3121 void *data
, fileline
*fileline_fn
)
3126 fileline elf_fileline_fn
= elf_nodebug
;
3127 struct phdr_data pd
;
3129 ret
= elf_add (state
, filename
, descriptor
, 0, error_callback
, data
,
3130 &elf_fileline_fn
, &found_sym
, &found_dwarf
, 1, 0);
3135 pd
.error_callback
= error_callback
;
3137 pd
.fileline_fn
= &elf_fileline_fn
;
3138 pd
.found_sym
= &found_sym
;
3139 pd
.found_dwarf
= &found_dwarf
;
3140 pd
.exe_filename
= filename
;
3141 pd
.exe_descriptor
= ret
< 0 ? descriptor
: -1;
3143 dl_iterate_phdr (phdr_callback
, (void *) &pd
);
3145 if (!state
->threaded
)
3148 state
->syminfo_fn
= elf_syminfo
;
3149 else if (state
->syminfo_fn
== NULL
)
3150 state
->syminfo_fn
= elf_nosyms
;
3155 backtrace_atomic_store_pointer (&state
->syminfo_fn
, elf_syminfo
);
3157 (void) __sync_bool_compare_and_swap (&state
->syminfo_fn
, NULL
,
3161 if (!state
->threaded
)
3162 *fileline_fn
= state
->fileline_fn
;
3164 *fileline_fn
= backtrace_atomic_load_pointer (&state
->fileline_fn
);
3166 if (*fileline_fn
== NULL
|| *fileline_fn
== elf_nodebug
)
3167 *fileline_fn
= elf_fileline_fn
;