1 /* elf.c -- Get debug data from an ELF file for backtraces.
2 Copyright (C) 2012-2019 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. */
177 #undef SHF_COMPRESSED
180 #undef NT_GNU_BUILD_ID
181 #undef ELFCOMPRESS_ZLIB
185 typedef uint16_t b_elf_half
; /* Elf_Half. */
186 typedef uint32_t b_elf_word
; /* Elf_Word. */
187 typedef int32_t b_elf_sword
; /* Elf_Sword. */
189 #if BACKTRACE_ELF_SIZE == 32
191 typedef uint32_t b_elf_addr
; /* Elf_Addr. */
192 typedef uint32_t b_elf_off
; /* Elf_Off. */
194 typedef uint32_t b_elf_wxword
; /* 32-bit Elf_Word, 64-bit ELF_Xword. */
198 typedef uint64_t b_elf_addr
; /* Elf_Addr. */
199 typedef uint64_t b_elf_off
; /* Elf_Off. */
200 typedef uint64_t b_elf_xword
; /* Elf_Xword. */
201 typedef int64_t b_elf_sxword
; /* Elf_Sxword. */
203 typedef uint64_t b_elf_wxword
; /* 32-bit Elf_Word, 64-bit ELF_Xword. */
207 /* Data structures and associated constants. */
212 unsigned char e_ident
[EI_NIDENT
]; /* ELF "magic number" */
213 b_elf_half e_type
; /* Identifies object file type */
214 b_elf_half e_machine
; /* Specifies required architecture */
215 b_elf_word e_version
; /* Identifies object file version */
216 b_elf_addr e_entry
; /* Entry point virtual address */
217 b_elf_off e_phoff
; /* Program header table file offset */
218 b_elf_off e_shoff
; /* Section header table file offset */
219 b_elf_word e_flags
; /* Processor-specific flags */
220 b_elf_half e_ehsize
; /* ELF header size in bytes */
221 b_elf_half e_phentsize
; /* Program header table entry size */
222 b_elf_half e_phnum
; /* Program header table entry count */
223 b_elf_half e_shentsize
; /* Section header table entry size */
224 b_elf_half e_shnum
; /* Section header table entry count */
225 b_elf_half e_shstrndx
; /* Section header string table index */
226 } b_elf_ehdr
; /* Elf_Ehdr. */
244 #define ELFDATA2LSB 1
245 #define ELFDATA2MSB 2
252 #define EF_PPC64_ABI 3
255 b_elf_word sh_name
; /* Section name, index in string tbl */
256 b_elf_word sh_type
; /* Type of section */
257 b_elf_wxword sh_flags
; /* Miscellaneous section attributes */
258 b_elf_addr sh_addr
; /* Section virtual addr at execution */
259 b_elf_off sh_offset
; /* Section file offset */
260 b_elf_wxword sh_size
; /* Size of section in bytes */
261 b_elf_word sh_link
; /* Index of another section */
262 b_elf_word sh_info
; /* Additional section information */
263 b_elf_wxword sh_addralign
; /* Section alignment */
264 b_elf_wxword sh_entsize
; /* Entry size if section holds table */
265 } b_elf_shdr
; /* Elf_Shdr. */
267 #define SHN_UNDEF 0x0000 /* Undefined section */
268 #define SHN_LORESERVE 0xFF00 /* Begin range of reserved indices */
269 #define SHN_XINDEX 0xFFFF /* Section index is held elsewhere */
271 #define SHT_PROGBITS 1
274 #define SHT_DYNSYM 11
276 #define SHF_COMPRESSED 0x800
278 #if BACKTRACE_ELF_SIZE == 32
282 b_elf_word st_name
; /* Symbol name, index in string tbl */
283 b_elf_addr st_value
; /* Symbol value */
284 b_elf_word st_size
; /* Symbol size */
285 unsigned char st_info
; /* Symbol binding and type */
286 unsigned char st_other
; /* Visibility and other data */
287 b_elf_half st_shndx
; /* Symbol section index */
288 } b_elf_sym
; /* Elf_Sym. */
290 #else /* BACKTRACE_ELF_SIZE != 32 */
294 b_elf_word st_name
; /* Symbol name, index in string tbl */
295 unsigned char st_info
; /* Symbol binding and type */
296 unsigned char st_other
; /* Visibility and other data */
297 b_elf_half st_shndx
; /* Symbol section index */
298 b_elf_addr st_value
; /* Symbol value */
299 b_elf_xword st_size
; /* Symbol size */
300 } b_elf_sym
; /* Elf_Sym. */
302 #endif /* BACKTRACE_ELF_SIZE != 32 */
315 #define NT_GNU_BUILD_ID 3
317 #if BACKTRACE_ELF_SIZE == 32
321 b_elf_word ch_type
; /* Compresstion algorithm */
322 b_elf_word ch_size
; /* Uncompressed size */
323 b_elf_word ch_addralign
; /* Alignment for uncompressed data */
324 } b_elf_chdr
; /* Elf_Chdr */
326 #else /* BACKTRACE_ELF_SIZE != 32 */
330 b_elf_word ch_type
; /* Compression algorithm */
331 b_elf_word ch_reserved
; /* Reserved */
332 b_elf_xword ch_size
; /* Uncompressed size */
333 b_elf_xword ch_addralign
; /* Alignment for uncompressed data */
334 } b_elf_chdr
; /* Elf_Chdr */
336 #endif /* BACKTRACE_ELF_SIZE != 32 */
338 #define ELFCOMPRESS_ZLIB 1
340 /* An index of ELF sections we care about. */
350 /* The old style compressed sections. This list must correspond to
351 the list of normal debug sections. */
361 /* Names of sections, indexed by enum elf_section. */
363 static const char * const debug_section_names
[DEBUG_MAX
] =
377 /* Information we gather for the sections we care about. */
379 struct debug_section_info
381 /* Section file offset. */
385 /* Section contents, after read from file. */
386 const unsigned char *data
;
387 /* Whether the SHF_COMPRESSED flag is set for the section. */
391 /* Information we keep for an ELF symbol. */
395 /* The name of the symbol. */
397 /* The address of the symbol. */
399 /* The size of the symbol. */
403 /* Information to pass to elf_syminfo. */
405 struct elf_syminfo_data
407 /* Symbols for the next module. */
408 struct elf_syminfo_data
*next
;
409 /* The ELF symbols, sorted by address. */
410 struct elf_symbol
*symbols
;
411 /* The number of symbols. */
415 /* Information about PowerPC64 ELFv1 .opd section. */
417 struct elf_ppc64_opd_data
419 /* Address of the .opd section. */
423 /* Size of the .opd section. */
425 /* Corresponding section view. */
426 struct backtrace_view view
;
429 /* Compute the CRC-32 of BUF/LEN. This uses the CRC used for
430 .gnu_debuglink files. */
433 elf_crc32 (uint32_t crc
, const unsigned char *buf
, size_t len
)
435 static const uint32_t crc32_table
[256] =
437 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
438 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
439 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
440 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
441 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
442 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
443 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
444 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
445 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
446 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
447 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
448 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
449 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
450 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
451 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
452 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
453 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
454 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
455 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
456 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
457 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
458 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
459 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
460 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
461 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
462 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
463 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
464 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
465 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
466 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
467 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
468 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
469 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
470 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
471 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
472 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
473 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
474 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
475 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
476 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
477 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
478 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
479 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
480 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
481 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
482 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
483 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
484 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
485 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
486 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
487 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
490 const unsigned char *end
;
493 for (end
= buf
+ len
; buf
< end
; ++ buf
)
494 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
498 /* Return the CRC-32 of the entire file open at DESCRIPTOR. */
501 elf_crc32_file (struct backtrace_state
*state
, int descriptor
,
502 backtrace_error_callback error_callback
, void *data
)
505 struct backtrace_view file_view
;
508 if (fstat (descriptor
, &st
) < 0)
510 error_callback (data
, "fstat", errno
);
514 if (!backtrace_get_view (state
, descriptor
, 0, st
.st_size
, error_callback
,
518 ret
= elf_crc32 (0, (const unsigned char *) file_view
.data
, st
.st_size
);
520 backtrace_release_view (state
, &file_view
, error_callback
, data
);
525 /* A dummy callback function used when we can't find any debug info. */
528 elf_nodebug (struct backtrace_state
*state ATTRIBUTE_UNUSED
,
529 uintptr_t pc ATTRIBUTE_UNUSED
,
530 backtrace_full_callback callback ATTRIBUTE_UNUSED
,
531 backtrace_error_callback error_callback
, void *data
)
533 error_callback (data
, "no debug info in ELF executable", -1);
537 /* A dummy callback function used when we can't find a symbol
541 elf_nosyms (struct backtrace_state
*state ATTRIBUTE_UNUSED
,
542 uintptr_t addr ATTRIBUTE_UNUSED
,
543 backtrace_syminfo_callback callback ATTRIBUTE_UNUSED
,
544 backtrace_error_callback error_callback
, void *data
)
546 error_callback (data
, "no symbol table in ELF executable", -1);
549 /* Compare struct elf_symbol for qsort. */
552 elf_symbol_compare (const void *v1
, const void *v2
)
554 const struct elf_symbol
*e1
= (const struct elf_symbol
*) v1
;
555 const struct elf_symbol
*e2
= (const struct elf_symbol
*) v2
;
557 if (e1
->address
< e2
->address
)
559 else if (e1
->address
> e2
->address
)
565 /* Compare an ADDR against an elf_symbol for bsearch. We allocate one
566 extra entry in the array so that this can look safely at the next
570 elf_symbol_search (const void *vkey
, const void *ventry
)
572 const uintptr_t *key
= (const uintptr_t *) vkey
;
573 const struct elf_symbol
*entry
= (const struct elf_symbol
*) ventry
;
577 if (addr
< entry
->address
)
579 else if (addr
>= entry
->address
+ entry
->size
)
585 /* Initialize the symbol table info for elf_syminfo. */
588 elf_initialize_syminfo (struct backtrace_state
*state
,
589 uintptr_t base_address
,
590 const unsigned char *symtab_data
, size_t symtab_size
,
591 const unsigned char *strtab
, size_t strtab_size
,
592 backtrace_error_callback error_callback
,
593 void *data
, struct elf_syminfo_data
*sdata
,
594 struct elf_ppc64_opd_data
*opd
)
597 const b_elf_sym
*sym
;
598 size_t elf_symbol_count
;
599 size_t elf_symbol_size
;
600 struct elf_symbol
*elf_symbols
;
604 sym_count
= symtab_size
/ sizeof (b_elf_sym
);
606 /* We only care about function symbols. Count them. */
607 sym
= (const b_elf_sym
*) symtab_data
;
608 elf_symbol_count
= 0;
609 for (i
= 0; i
< sym_count
; ++i
, ++sym
)
613 info
= sym
->st_info
& 0xf;
614 if ((info
== STT_FUNC
|| info
== STT_OBJECT
)
615 && sym
->st_shndx
!= SHN_UNDEF
)
619 elf_symbol_size
= elf_symbol_count
* sizeof (struct elf_symbol
);
620 elf_symbols
= ((struct elf_symbol
*)
621 backtrace_alloc (state
, elf_symbol_size
, error_callback
,
623 if (elf_symbols
== NULL
)
626 sym
= (const b_elf_sym
*) symtab_data
;
628 for (i
= 0; i
< sym_count
; ++i
, ++sym
)
632 info
= sym
->st_info
& 0xf;
633 if (info
!= STT_FUNC
&& info
!= STT_OBJECT
)
635 if (sym
->st_shndx
== SHN_UNDEF
)
637 if (sym
->st_name
>= strtab_size
)
639 error_callback (data
, "symbol string index out of range", 0);
640 backtrace_free (state
, elf_symbols
, elf_symbol_size
, error_callback
,
644 elf_symbols
[j
].name
= (const char *) strtab
+ sym
->st_name
;
645 /* Special case PowerPC64 ELFv1 symbols in .opd section, if the symbol
646 is a function descriptor, read the actual code address from the
649 && sym
->st_value
>= opd
->addr
650 && sym
->st_value
< opd
->addr
+ opd
->size
)
651 elf_symbols
[j
].address
652 = *(const b_elf_addr
*) (opd
->data
+ (sym
->st_value
- opd
->addr
));
654 elf_symbols
[j
].address
= sym
->st_value
;
655 elf_symbols
[j
].address
+= base_address
;
656 elf_symbols
[j
].size
= sym
->st_size
;
660 backtrace_qsort (elf_symbols
, elf_symbol_count
, sizeof (struct elf_symbol
),
664 sdata
->symbols
= elf_symbols
;
665 sdata
->count
= elf_symbol_count
;
670 /* Add EDATA to the list in STATE. */
673 elf_add_syminfo_data (struct backtrace_state
*state
,
674 struct elf_syminfo_data
*edata
)
676 if (!state
->threaded
)
678 struct elf_syminfo_data
**pp
;
680 for (pp
= (struct elf_syminfo_data
**) (void *) &state
->syminfo_data
;
690 struct elf_syminfo_data
**pp
;
692 pp
= (struct elf_syminfo_data
**) (void *) &state
->syminfo_data
;
696 struct elf_syminfo_data
*p
;
698 p
= backtrace_atomic_load_pointer (pp
);
706 if (__sync_bool_compare_and_swap (pp
, NULL
, edata
))
712 /* Return the symbol name and value for an ADDR. */
715 elf_syminfo (struct backtrace_state
*state
, uintptr_t addr
,
716 backtrace_syminfo_callback callback
,
717 backtrace_error_callback error_callback ATTRIBUTE_UNUSED
,
720 struct elf_syminfo_data
*edata
;
721 struct elf_symbol
*sym
= NULL
;
723 if (!state
->threaded
)
725 for (edata
= (struct elf_syminfo_data
*) state
->syminfo_data
;
729 sym
= ((struct elf_symbol
*)
730 bsearch (&addr
, edata
->symbols
, edata
->count
,
731 sizeof (struct elf_symbol
), elf_symbol_search
));
738 struct elf_syminfo_data
**pp
;
740 pp
= (struct elf_syminfo_data
**) (void *) &state
->syminfo_data
;
743 edata
= backtrace_atomic_load_pointer (pp
);
747 sym
= ((struct elf_symbol
*)
748 bsearch (&addr
, edata
->symbols
, edata
->count
,
749 sizeof (struct elf_symbol
), elf_symbol_search
));
758 callback (data
, addr
, NULL
, 0, 0);
760 callback (data
, addr
, sym
->name
, sym
->address
, sym
->size
);
763 /* Return whether FILENAME is a symlink. */
766 elf_is_symlink (const char *filename
)
770 if (lstat (filename
, &st
) < 0)
772 return S_ISLNK (st
.st_mode
);
775 /* Return the results of reading the symlink FILENAME in a buffer
776 allocated by backtrace_alloc. Return the length of the buffer in
780 elf_readlink (struct backtrace_state
*state
, const char *filename
,
781 backtrace_error_callback error_callback
, void *data
,
792 buf
= backtrace_alloc (state
, len
, error_callback
, data
);
795 rl
= readlink (filename
, buf
, len
);
798 backtrace_free (state
, buf
, len
, error_callback
, data
);
801 if ((size_t) rl
< len
- 1)
807 backtrace_free (state
, buf
, len
, error_callback
, data
);
812 /* Open a separate debug info file, using the build ID to find it.
813 Returns an open file descriptor, or -1.
815 The GDB manual says that the only place gdb looks for a debug file
816 when the build ID is known is in /usr/lib/debug/.build-id. */
819 elf_open_debugfile_by_buildid (struct backtrace_state
*state
,
820 const char *buildid_data
, size_t buildid_size
,
821 backtrace_error_callback error_callback
,
824 const char * const prefix
= "/usr/lib/debug/.build-id/";
825 const size_t prefix_len
= strlen (prefix
);
826 const char * const suffix
= ".debug";
827 const size_t suffix_len
= strlen (suffix
);
835 len
= prefix_len
+ buildid_size
* 2 + suffix_len
+ 2;
836 bd_filename
= backtrace_alloc (state
, len
, error_callback
, data
);
837 if (bd_filename
== NULL
)
841 memcpy (t
, prefix
, prefix_len
);
843 for (i
= 0; i
< buildid_size
; i
++)
848 b
= (unsigned char) buildid_data
[i
];
849 nib
= (b
& 0xf0) >> 4;
850 *t
++ = nib
< 10 ? '0' + nib
: 'a' + nib
- 10;
852 *t
++ = nib
< 10 ? '0' + nib
: 'a' + nib
- 10;
856 memcpy (t
, suffix
, suffix_len
);
857 t
[suffix_len
] = '\0';
859 ret
= backtrace_open (bd_filename
, error_callback
, data
, &does_not_exist
);
861 backtrace_free (state
, bd_filename
, len
, error_callback
, data
);
863 /* gdb checks that the debuginfo file has the same build ID note.
864 That seems kind of pointless to me--why would it have the right
865 name but not the right build ID?--so skipping the check. */
870 /* Try to open a file whose name is PREFIX (length PREFIX_LEN)
871 concatenated with PREFIX2 (length PREFIX2_LEN) concatenated with
872 DEBUGLINK_NAME. Returns an open file descriptor, or -1. */
875 elf_try_debugfile (struct backtrace_state
*state
, const char *prefix
,
876 size_t prefix_len
, const char *prefix2
, size_t prefix2_len
,
877 const char *debuglink_name
,
878 backtrace_error_callback error_callback
, void *data
)
880 size_t debuglink_len
;
886 debuglink_len
= strlen (debuglink_name
);
887 try_len
= prefix_len
+ prefix2_len
+ debuglink_len
+ 1;
888 try = backtrace_alloc (state
, try_len
, error_callback
, data
);
892 memcpy (try, prefix
, prefix_len
);
893 memcpy (try + prefix_len
, prefix2
, prefix2_len
);
894 memcpy (try + prefix_len
+ prefix2_len
, debuglink_name
, debuglink_len
);
895 try[prefix_len
+ prefix2_len
+ debuglink_len
] = '\0';
897 ret
= backtrace_open (try, error_callback
, data
, &does_not_exist
);
899 backtrace_free (state
, try, try_len
, error_callback
, data
);
904 /* Find a separate debug info file, using the debuglink section data
905 to find it. Returns an open file descriptor, or -1. */
908 elf_find_debugfile_by_debuglink (struct backtrace_state
*state
,
909 const char *filename
,
910 const char *debuglink_name
,
911 backtrace_error_callback error_callback
,
922 /* Resolve symlinks in FILENAME. Since FILENAME is fairly likely to
923 be /proc/self/exe, symlinks are common. We don't try to resolve
924 the whole path name, just the base name. */
928 while (elf_is_symlink (filename
))
933 new_buf
= elf_readlink (state
, filename
, error_callback
, data
, &new_len
);
937 if (new_buf
[0] == '/')
941 slash
= strrchr (filename
, '/');
950 clen
= slash
- filename
+ strlen (new_buf
) + 1;
951 c
= backtrace_alloc (state
, clen
, error_callback
, data
);
955 memcpy (c
, filename
, slash
- filename
);
956 memcpy (c
+ (slash
- filename
), new_buf
, strlen (new_buf
));
957 c
[slash
- filename
+ strlen (new_buf
)] = '\0';
958 backtrace_free (state
, new_buf
, new_len
, error_callback
, data
);
966 backtrace_free (state
, alc
, alc_len
, error_callback
, data
);
971 /* Look for DEBUGLINK_NAME in the same directory as FILENAME. */
973 slash
= strrchr (filename
, '/');
983 prefix_len
= slash
- filename
;
986 ddescriptor
= elf_try_debugfile (state
, prefix
, prefix_len
, "", 0,
987 debuglink_name
, error_callback
, data
);
988 if (ddescriptor
>= 0)
994 /* Look for DEBUGLINK_NAME in a .debug subdirectory of FILENAME. */
996 ddescriptor
= elf_try_debugfile (state
, prefix
, prefix_len
, ".debug/",
997 strlen (".debug/"), debuglink_name
,
998 error_callback
, data
);
999 if (ddescriptor
>= 0)
1005 /* Look for DEBUGLINK_NAME in /usr/lib/debug. */
1007 ddescriptor
= elf_try_debugfile (state
, "/usr/lib/debug/",
1008 strlen ("/usr/lib/debug/"), prefix
,
1009 prefix_len
, debuglink_name
,
1010 error_callback
, data
);
1011 if (ddescriptor
>= 0)
1015 if (alc
!= NULL
&& alc_len
> 0)
1016 backtrace_free (state
, alc
, alc_len
, error_callback
, data
);
1020 /* Open a separate debug info file, using the debuglink section data
1021 to find it. Returns an open file descriptor, or -1. */
1024 elf_open_debugfile_by_debuglink (struct backtrace_state
*state
,
1025 const char *filename
,
1026 const char *debuglink_name
,
1027 uint32_t debuglink_crc
,
1028 backtrace_error_callback error_callback
,
1033 ddescriptor
= elf_find_debugfile_by_debuglink (state
, filename
,
1035 error_callback
, data
);
1036 if (ddescriptor
< 0)
1039 if (debuglink_crc
!= 0)
1043 got_crc
= elf_crc32_file (state
, ddescriptor
, error_callback
, data
);
1044 if (got_crc
!= debuglink_crc
)
1046 backtrace_close (ddescriptor
, error_callback
, data
);
1054 /* A function useful for setting a breakpoint for an inflation failure
1055 when this code is compiled with -g. */
1058 elf_zlib_failed(void)
1062 /* *PVAL is the current value being read from the stream, and *PBITS
1063 is the number of valid bits. Ensure that *PVAL holds at least 15
1064 bits by reading additional bits from *PPIN, up to PINEND, as
1065 needed. Updates *PPIN, *PVAL and *PBITS. Returns 1 on success, 0
1069 elf_zlib_fetch (const unsigned char **ppin
, const unsigned char *pinend
,
1070 uint64_t *pval
, unsigned int *pbits
)
1073 const unsigned char *pin
;
1083 if (unlikely (pinend
- pin
< 4))
1089 #if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) \
1090 && defined(__ORDER_BIG_ENDIAN__) \
1091 && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ \
1092 || __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
1093 /* We've ensured that PIN is aligned. */
1094 next
= *(const uint32_t *)pin
;
1096 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
1097 next
= __builtin_bswap32 (next
);
1100 next
= pin
[0] | (pin
[1] << 8) | (pin
[2] << 16) | (pin
[3] << 24);
1103 val
|= (uint64_t)next
<< bits
;
1107 /* We will need the next four bytes soon. */
1108 __builtin_prefetch (pin
, 0, 0);
1116 /* Huffman code tables, like the rest of the zlib format, are defined
1117 by RFC 1951. We store a Huffman code table as a series of tables
1118 stored sequentially in memory. Each entry in a table is 16 bits.
1119 The first, main, table has 256 entries. It is followed by a set of
1120 secondary tables of length 2 to 128 entries. The maximum length of
1121 a code sequence in the deflate format is 15 bits, so that is all we
1122 need. Each secondary table has an index, which is the offset of
1123 the table in the overall memory storage.
1125 The deflate format says that all codes of a given bit length are
1126 lexicographically consecutive. Perhaps we could have 130 values
1127 that require a 15-bit code, perhaps requiring three secondary
1128 tables of size 128. I don't know if this is actually possible, but
1129 it suggests that the maximum size required for secondary tables is
1130 3 * 128 + 3 * 64 ... == 768. The zlib enough program reports 660
1131 as the maximum. We permit 768, since in addition to the 256 for
1132 the primary table, with two bytes per entry, and with the two
1133 tables we need, that gives us a page.
1135 A single table entry needs to store a value or (for the main table
1136 only) the index and size of a secondary table. Values range from 0
1137 to 285, inclusive. Secondary table indexes, per above, range from
1138 0 to 510. For a value we need to store the number of bits we need
1139 to determine that value (one value may appear multiple times in the
1140 table), which is 1 to 8. For a secondary table we need to store
1141 the number of bits used to index into the table, which is 1 to 7.
1142 And of course we need 1 bit to decide whether we have a value or a
1143 secondary table index. So each entry needs 9 bits for value/table
1144 index, 3 bits for size, 1 bit what it is. For simplicity we use 16
1147 /* Number of entries we allocate to for one code table. We get a page
1148 for the two code tables we need. */
1150 #define HUFFMAN_TABLE_SIZE (1024)
1152 /* Bit masks and shifts for the values in the table. */
1154 #define HUFFMAN_VALUE_MASK 0x01ff
1155 #define HUFFMAN_BITS_SHIFT 9
1156 #define HUFFMAN_BITS_MASK 0x7
1157 #define HUFFMAN_SECONDARY_SHIFT 12
1159 /* For working memory while inflating we need two code tables, we need
1160 an array of code lengths (max value 15, so we use unsigned char),
1161 and an array of unsigned shorts used while building a table. The
1162 latter two arrays must be large enough to hold the maximum number
1163 of code lengths, which RFC 1951 defines as 286 + 30. */
1165 #define ZDEBUG_TABLE_SIZE \
1166 (2 * HUFFMAN_TABLE_SIZE * sizeof (uint16_t) \
1167 + (286 + 30) * sizeof (uint16_t) \
1168 + (286 + 30) * sizeof (unsigned char))
1170 #define ZDEBUG_TABLE_CODELEN_OFFSET \
1171 (2 * HUFFMAN_TABLE_SIZE * sizeof (uint16_t) \
1172 + (286 + 30) * sizeof (uint16_t))
1174 #define ZDEBUG_TABLE_WORK_OFFSET \
1175 (2 * HUFFMAN_TABLE_SIZE * sizeof (uint16_t))
1177 #ifdef BACKTRACE_GENERATE_FIXED_HUFFMAN_TABLE
1179 /* Used by the main function that generates the fixed table to learn
1181 static size_t final_next_secondary
;
1185 /* Build a Huffman code table from an array of lengths in CODES of
1186 length CODES_LEN. The table is stored into *TABLE. ZDEBUG_TABLE
1187 is the same as for elf_zlib_inflate, used to find some work space.
1188 Returns 1 on success, 0 on error. */
1191 elf_zlib_inflate_table (unsigned char *codes
, size_t codes_len
,
1192 uint16_t *zdebug_table
, uint16_t *table
)
1197 uint16_t firstcode
[7];
1202 size_t next_secondary
;
1204 /* Count the number of code of each length. Set NEXT[val] to be the
1205 next value after VAL with the same bit length. */
1207 next
= (uint16_t *) (((unsigned char *) zdebug_table
)
1208 + ZDEBUG_TABLE_WORK_OFFSET
);
1210 memset (&count
[0], 0, 16 * sizeof (uint16_t));
1211 for (i
= 0; i
< codes_len
; ++i
)
1213 if (unlikely (codes
[i
] >= 16))
1219 if (count
[codes
[i
]] == 0)
1221 start
[codes
[i
]] = i
;
1226 next
[prev
[codes
[i
]]] = i
;
1233 /* For each length, fill in the table for the codes of that
1236 memset (table
, 0, HUFFMAN_TABLE_SIZE
* sizeof (uint16_t));
1238 /* Handle the values that do not require a secondary table. */
1241 for (j
= 1; j
<= 8; ++j
)
1250 if (unlikely (jcnt
> (1U << j
)))
1256 /* There are JCNT values that have this length, the values
1257 starting from START[j] continuing through NEXT[VAL]. Those
1258 values are assigned consecutive values starting at CODE. */
1261 for (i
= 0; i
< jcnt
; ++i
)
1267 /* In the compressed bit stream, the value VAL is encoded as
1268 J bits with the value C. */
1270 if (unlikely ((val
& ~HUFFMAN_VALUE_MASK
) != 0))
1276 tval
= val
| ((j
- 1) << HUFFMAN_BITS_SHIFT
);
1278 /* The table lookup uses 8 bits. If J is less than 8, we
1279 don't know what the other bits will be. We need to fill
1280 in all possibilities in the table. Since the Huffman
1281 code is unambiguous, those entries can't be used for any
1284 for (ind
= code
; ind
< 0x100; ind
+= 1 << j
)
1286 if (unlikely (table
[ind
] != 0))
1294 /* Advance to the next value with this length. */
1298 /* The Huffman codes are stored in the bitstream with the
1299 most significant bit first, as is required to make them
1300 unambiguous. The effect is that when we read them from
1301 the bitstream we see the bit sequence in reverse order:
1302 the most significant bit of the Huffman code is the least
1303 significant bit of the value we read from the bitstream.
1304 That means that to make our table lookups work, we need
1305 to reverse the bits of CODE. Since reversing bits is
1306 tedious and in general requires using a table, we instead
1307 increment CODE in reverse order. That is, if the number
1308 of bits we are currently using, here named J, is 3, we
1309 count as 000, 100, 010, 110, 001, 101, 011, 111, which is
1310 to say the numbers from 0 to 7 but with the bits
1311 reversed. Going to more bits, aka incrementing J,
1312 effectively just adds more zero bits as the beginning,
1313 and as such does not change the numeric value of CODE.
1315 To increment CODE of length J in reverse order, find the
1316 most significant zero bit and set it to one while
1317 clearing all higher bits. In other words, add 1 modulo
1318 2^J, only reversed. */
1320 incr
= 1U << (j
- 1);
1321 while ((code
& incr
) != 0)
1333 /* Handle the values that require a secondary table. */
1335 /* Set FIRSTCODE, the number at which the codes start, for each
1338 for (j
= 9; j
< 16; j
++)
1347 /* There are JCNT values that have this length, the values
1348 starting from START[j]. Those values are assigned
1349 consecutive values starting at CODE. */
1351 firstcode
[j
- 9] = code
;
1353 /* Reverse add JCNT to CODE modulo 2^J. */
1354 for (k
= 0; k
< j
; ++k
)
1356 if ((jcnt
& (1U << k
)) != 0)
1361 bit
= 1U << (j
- k
- 1);
1362 for (m
= 0; m
< j
- k
; ++m
, bit
>>= 1)
1364 if ((code
& bit
) == 0)
1374 if (unlikely (jcnt
!= 0))
1381 /* For J from 9 to 15, inclusive, we store COUNT[J] consecutive
1382 values starting at START[J] with consecutive codes starting at
1383 FIRSTCODE[J - 9]. In the primary table we need to point to the
1384 secondary table, and the secondary table will be indexed by J - 9
1385 bits. We count down from 15 so that we install the larger
1386 secondary tables first, as the smaller ones may be embedded in
1389 next_secondary
= 0; /* Index of next secondary table (after primary). */
1390 for (j
= 15; j
>= 9; j
--)
1394 size_t primary
; /* Current primary index. */
1395 size_t secondary
; /* Offset to current secondary table. */
1396 size_t secondary_bits
; /* Bit size of current secondary table. */
1403 code
= firstcode
[j
- 9];
1407 for (i
= 0; i
< jcnt
; ++i
)
1413 if ((code
& 0xff) != primary
)
1417 /* Fill in a new primary table entry. */
1419 primary
= code
& 0xff;
1421 tprimary
= table
[primary
];
1424 /* Start a new secondary table. */
1426 if (unlikely ((next_secondary
& HUFFMAN_VALUE_MASK
)
1433 secondary
= next_secondary
;
1434 secondary_bits
= j
- 8;
1435 next_secondary
+= 1 << secondary_bits
;
1436 table
[primary
] = (secondary
1437 + ((j
- 8) << HUFFMAN_BITS_SHIFT
)
1438 + (1U << HUFFMAN_SECONDARY_SHIFT
));
1442 /* There is an existing entry. It had better be a
1443 secondary table with enough bits. */
1444 if (unlikely ((tprimary
& (1U << HUFFMAN_SECONDARY_SHIFT
))
1450 secondary
= tprimary
& HUFFMAN_VALUE_MASK
;
1451 secondary_bits
= ((tprimary
>> HUFFMAN_BITS_SHIFT
)
1452 & HUFFMAN_BITS_MASK
);
1453 if (unlikely (secondary_bits
< j
- 8))
1461 /* Fill in secondary table entries. */
1463 tval
= val
| ((j
- 8) << HUFFMAN_BITS_SHIFT
);
1465 for (ind
= code
>> 8;
1466 ind
< (1U << secondary_bits
);
1467 ind
+= 1U << (j
- 8))
1469 if (unlikely (table
[secondary
+ 0x100 + ind
] != 0))
1474 table
[secondary
+ 0x100 + ind
] = tval
;
1480 incr
= 1U << (j
- 1);
1481 while ((code
& incr
) != 0)
1493 #ifdef BACKTRACE_GENERATE_FIXED_HUFFMAN_TABLE
1494 final_next_secondary
= next_secondary
;
1500 #ifdef BACKTRACE_GENERATE_FIXED_HUFFMAN_TABLE
1502 /* Used to generate the fixed Huffman table for block type 1. */
1506 static uint16_t table
[ZDEBUG_TABLE_SIZE
];
1507 static unsigned char codes
[288];
1514 for (i
= 0; i
<= 143; ++i
)
1516 for (i
= 144; i
<= 255; ++i
)
1518 for (i
= 256; i
<= 279; ++i
)
1520 for (i
= 280; i
<= 287; ++i
)
1522 if (!elf_zlib_inflate_table (&codes
[0], 288, &table
[0], &table
[0]))
1524 fprintf (stderr
, "elf_zlib_inflate_table failed\n");
1525 exit (EXIT_FAILURE
);
1528 printf ("static const uint16_t elf_zlib_default_table[%#zx] =\n",
1529 final_next_secondary
+ 0x100);
1531 for (i
= 0; i
< final_next_secondary
+ 0x100; i
+= 8)
1536 for (j
= i
; j
< final_next_secondary
+ 0x100 && j
< i
+ 8; ++j
)
1537 printf (" %#x,", table
[j
]);
1543 for (i
= 0; i
< 32; ++i
)
1545 if (!elf_zlib_inflate_table (&codes
[0], 32, &table
[0], &table
[0]))
1547 fprintf (stderr
, "elf_zlib_inflate_table failed\n");
1548 exit (EXIT_FAILURE
);
1551 printf ("static const uint16_t elf_zlib_default_dist_table[%#zx] =\n",
1552 final_next_secondary
+ 0x100);
1554 for (i
= 0; i
< final_next_secondary
+ 0x100; i
+= 8)
1559 for (j
= i
; j
< final_next_secondary
+ 0x100 && j
< i
+ 8; ++j
)
1560 printf (" %#x,", table
[j
]);
1570 /* The fixed tables generated by the #ifdef'ed out main function
1573 static const uint16_t elf_zlib_default_table
[0x170] =
1575 0xd00, 0xe50, 0xe10, 0xf18, 0xd10, 0xe70, 0xe30, 0x1230,
1576 0xd08, 0xe60, 0xe20, 0x1210, 0xe00, 0xe80, 0xe40, 0x1250,
1577 0xd04, 0xe58, 0xe18, 0x1200, 0xd14, 0xe78, 0xe38, 0x1240,
1578 0xd0c, 0xe68, 0xe28, 0x1220, 0xe08, 0xe88, 0xe48, 0x1260,
1579 0xd02, 0xe54, 0xe14, 0xf1c, 0xd12, 0xe74, 0xe34, 0x1238,
1580 0xd0a, 0xe64, 0xe24, 0x1218, 0xe04, 0xe84, 0xe44, 0x1258,
1581 0xd06, 0xe5c, 0xe1c, 0x1208, 0xd16, 0xe7c, 0xe3c, 0x1248,
1582 0xd0e, 0xe6c, 0xe2c, 0x1228, 0xe0c, 0xe8c, 0xe4c, 0x1268,
1583 0xd01, 0xe52, 0xe12, 0xf1a, 0xd11, 0xe72, 0xe32, 0x1234,
1584 0xd09, 0xe62, 0xe22, 0x1214, 0xe02, 0xe82, 0xe42, 0x1254,
1585 0xd05, 0xe5a, 0xe1a, 0x1204, 0xd15, 0xe7a, 0xe3a, 0x1244,
1586 0xd0d, 0xe6a, 0xe2a, 0x1224, 0xe0a, 0xe8a, 0xe4a, 0x1264,
1587 0xd03, 0xe56, 0xe16, 0xf1e, 0xd13, 0xe76, 0xe36, 0x123c,
1588 0xd0b, 0xe66, 0xe26, 0x121c, 0xe06, 0xe86, 0xe46, 0x125c,
1589 0xd07, 0xe5e, 0xe1e, 0x120c, 0xd17, 0xe7e, 0xe3e, 0x124c,
1590 0xd0f, 0xe6e, 0xe2e, 0x122c, 0xe0e, 0xe8e, 0xe4e, 0x126c,
1591 0xd00, 0xe51, 0xe11, 0xf19, 0xd10, 0xe71, 0xe31, 0x1232,
1592 0xd08, 0xe61, 0xe21, 0x1212, 0xe01, 0xe81, 0xe41, 0x1252,
1593 0xd04, 0xe59, 0xe19, 0x1202, 0xd14, 0xe79, 0xe39, 0x1242,
1594 0xd0c, 0xe69, 0xe29, 0x1222, 0xe09, 0xe89, 0xe49, 0x1262,
1595 0xd02, 0xe55, 0xe15, 0xf1d, 0xd12, 0xe75, 0xe35, 0x123a,
1596 0xd0a, 0xe65, 0xe25, 0x121a, 0xe05, 0xe85, 0xe45, 0x125a,
1597 0xd06, 0xe5d, 0xe1d, 0x120a, 0xd16, 0xe7d, 0xe3d, 0x124a,
1598 0xd0e, 0xe6d, 0xe2d, 0x122a, 0xe0d, 0xe8d, 0xe4d, 0x126a,
1599 0xd01, 0xe53, 0xe13, 0xf1b, 0xd11, 0xe73, 0xe33, 0x1236,
1600 0xd09, 0xe63, 0xe23, 0x1216, 0xe03, 0xe83, 0xe43, 0x1256,
1601 0xd05, 0xe5b, 0xe1b, 0x1206, 0xd15, 0xe7b, 0xe3b, 0x1246,
1602 0xd0d, 0xe6b, 0xe2b, 0x1226, 0xe0b, 0xe8b, 0xe4b, 0x1266,
1603 0xd03, 0xe57, 0xe17, 0xf1f, 0xd13, 0xe77, 0xe37, 0x123e,
1604 0xd0b, 0xe67, 0xe27, 0x121e, 0xe07, 0xe87, 0xe47, 0x125e,
1605 0xd07, 0xe5f, 0xe1f, 0x120e, 0xd17, 0xe7f, 0xe3f, 0x124e,
1606 0xd0f, 0xe6f, 0xe2f, 0x122e, 0xe0f, 0xe8f, 0xe4f, 0x126e,
1607 0x290, 0x291, 0x292, 0x293, 0x294, 0x295, 0x296, 0x297,
1608 0x298, 0x299, 0x29a, 0x29b, 0x29c, 0x29d, 0x29e, 0x29f,
1609 0x2a0, 0x2a1, 0x2a2, 0x2a3, 0x2a4, 0x2a5, 0x2a6, 0x2a7,
1610 0x2a8, 0x2a9, 0x2aa, 0x2ab, 0x2ac, 0x2ad, 0x2ae, 0x2af,
1611 0x2b0, 0x2b1, 0x2b2, 0x2b3, 0x2b4, 0x2b5, 0x2b6, 0x2b7,
1612 0x2b8, 0x2b9, 0x2ba, 0x2bb, 0x2bc, 0x2bd, 0x2be, 0x2bf,
1613 0x2c0, 0x2c1, 0x2c2, 0x2c3, 0x2c4, 0x2c5, 0x2c6, 0x2c7,
1614 0x2c8, 0x2c9, 0x2ca, 0x2cb, 0x2cc, 0x2cd, 0x2ce, 0x2cf,
1615 0x2d0, 0x2d1, 0x2d2, 0x2d3, 0x2d4, 0x2d5, 0x2d6, 0x2d7,
1616 0x2d8, 0x2d9, 0x2da, 0x2db, 0x2dc, 0x2dd, 0x2de, 0x2df,
1617 0x2e0, 0x2e1, 0x2e2, 0x2e3, 0x2e4, 0x2e5, 0x2e6, 0x2e7,
1618 0x2e8, 0x2e9, 0x2ea, 0x2eb, 0x2ec, 0x2ed, 0x2ee, 0x2ef,
1619 0x2f0, 0x2f1, 0x2f2, 0x2f3, 0x2f4, 0x2f5, 0x2f6, 0x2f7,
1620 0x2f8, 0x2f9, 0x2fa, 0x2fb, 0x2fc, 0x2fd, 0x2fe, 0x2ff,
1623 static const uint16_t elf_zlib_default_dist_table
[0x100] =
1625 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1626 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1627 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1628 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1629 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1630 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1631 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1632 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1633 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1634 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1635 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1636 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1637 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1638 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1639 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1640 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1641 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1642 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1643 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1644 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1645 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1646 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1647 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1648 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1649 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1650 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1651 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1652 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1653 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1654 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1655 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1656 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1659 /* Inflate a zlib stream from PIN/SIN to POUT/SOUT. Return 1 on
1660 success, 0 on some error parsing the stream. */
1663 elf_zlib_inflate (const unsigned char *pin
, size_t sin
, uint16_t *zdebug_table
,
1664 unsigned char *pout
, size_t sout
)
1666 unsigned char *porigout
;
1667 const unsigned char *pinend
;
1668 unsigned char *poutend
;
1670 /* We can apparently see multiple zlib streams concatenated
1671 together, so keep going as long as there is something to read.
1672 The last 4 bytes are the checksum. */
1675 poutend
= pout
+ sout
;
1676 while ((pinend
- pin
) > 4)
1682 /* Read the two byte zlib header. */
1684 if (unlikely ((pin
[0] & 0xf) != 8)) /* 8 is zlib encoding. */
1686 /* Unknown compression method. */
1690 if (unlikely ((pin
[0] >> 4) > 7))
1692 /* Window size too large. Other than this check, we don't
1693 care about the window size. */
1697 if (unlikely ((pin
[1] & 0x20) != 0))
1699 /* Stream expects a predefined dictionary, but we have no
1704 val
= (pin
[0] << 8) | pin
[1];
1705 if (unlikely (val
% 31 != 0))
1707 /* Header check failure. */
1713 /* Align PIN to a 32-bit boundary. */
1717 while ((((uintptr_t) pin
) & 3) != 0)
1719 val
|= (uint64_t)*pin
<< bits
;
1724 /* Read blocks until one is marked last. */
1731 const uint16_t *tlit
;
1732 const uint16_t *tdist
;
1734 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1738 type
= (val
>> 1) & 3;
1742 if (unlikely (type
== 3))
1744 /* Invalid block type. */
1754 /* An uncompressed block. */
1756 /* If we've read ahead more than a byte, back up. */
1765 if (unlikely ((pinend
- pin
) < 4))
1767 /* Missing length. */
1771 len
= pin
[0] | (pin
[1] << 8);
1772 lenc
= pin
[2] | (pin
[3] << 8);
1775 if (unlikely (len
!= lenc
))
1781 if (unlikely (len
> (unsigned int) (pinend
- pin
)
1782 || len
> (unsigned int) (poutend
- pout
)))
1784 /* Not enough space in buffers. */
1788 memcpy (pout
, pin
, len
);
1793 while ((((uintptr_t) pin
) & 3) != 0)
1795 val
|= (uint64_t)*pin
<< bits
;
1800 /* Go around to read the next block. */
1806 tlit
= elf_zlib_default_table
;
1807 tdist
= elf_zlib_default_dist_table
;
1814 unsigned char codebits
[19];
1815 unsigned char *plenbase
;
1816 unsigned char *plen
;
1817 unsigned char *plenend
;
1819 /* Read a Huffman encoding table. The various magic
1820 numbers here are from RFC 1951. */
1822 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1825 nlit
= (val
& 0x1f) + 257;
1827 ndist
= (val
& 0x1f) + 1;
1829 nclen
= (val
& 0xf) + 4;
1832 if (unlikely (nlit
> 286 || ndist
> 30))
1834 /* Values out of range. */
1839 /* Read and build the table used to compress the
1840 literal, length, and distance codes. */
1842 memset(&codebits
[0], 0, 19);
1844 /* There are always at least 4 elements in the
1847 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1850 codebits
[16] = val
& 7;
1851 codebits
[17] = (val
>> 3) & 7;
1852 codebits
[18] = (val
>> 6) & 7;
1853 codebits
[0] = (val
>> 9) & 7;
1860 codebits
[8] = val
& 7;
1867 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1870 codebits
[7] = val
& 7;
1877 codebits
[9] = val
& 7;
1884 codebits
[6] = val
& 7;
1891 codebits
[10] = val
& 7;
1898 codebits
[5] = val
& 7;
1905 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1908 codebits
[11] = val
& 7;
1915 codebits
[4] = val
& 7;
1922 codebits
[12] = val
& 7;
1929 codebits
[3] = val
& 7;
1936 codebits
[13] = val
& 7;
1943 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1946 codebits
[2] = val
& 7;
1953 codebits
[14] = val
& 7;
1960 codebits
[1] = val
& 7;
1967 codebits
[15] = val
& 7;
1973 if (!elf_zlib_inflate_table (codebits
, 19, zdebug_table
,
1977 /* Read the compressed bit lengths of the literal,
1978 length, and distance codes. We have allocated space
1979 at the end of zdebug_table to hold them. */
1981 plenbase
= (((unsigned char *) zdebug_table
)
1982 + ZDEBUG_TABLE_CODELEN_OFFSET
);
1984 plenend
= plen
+ nlit
+ ndist
;
1985 while (plen
< plenend
)
1991 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1994 t
= zdebug_table
[val
& 0xff];
1996 /* The compression here uses bit lengths up to 7, so
1997 a secondary table is never necessary. */
1998 if (unlikely ((t
& (1U << HUFFMAN_SECONDARY_SHIFT
)) != 0))
2004 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
2008 v
= t
& HUFFMAN_VALUE_MASK
;
2016 /* Copy previous entry 3 to 6 times. */
2018 if (unlikely (plen
== plenbase
))
2024 /* We used up to 7 bits since the last
2025 elf_zlib_fetch, so we have at least 8 bits
2028 c
= 3 + (val
& 0x3);
2031 if (unlikely ((unsigned int) (plenend
- plen
) < c
))
2057 /* Store zero 3 to 10 times. */
2059 /* We used up to 7 bits since the last
2060 elf_zlib_fetch, so we have at least 8 bits
2063 c
= 3 + (val
& 0x7);
2066 if (unlikely ((unsigned int) (plenend
- plen
) < c
))
2103 /* Store zero 11 to 138 times. */
2105 /* We used up to 7 bits since the last
2106 elf_zlib_fetch, so we have at least 8 bits
2109 c
= 11 + (val
& 0x7f);
2112 if (unlikely ((unsigned int) (plenend
- plen
) < c
))
2118 memset (plen
, 0, c
);
2128 /* Make sure that the stop code can appear. */
2131 if (unlikely (plen
[256] == 0))
2137 /* Build the decompression tables. */
2139 if (!elf_zlib_inflate_table (plen
, nlit
, zdebug_table
,
2142 if (!elf_zlib_inflate_table (plen
+ nlit
, ndist
, zdebug_table
,
2143 zdebug_table
+ HUFFMAN_TABLE_SIZE
))
2145 tlit
= zdebug_table
;
2146 tdist
= zdebug_table
+ HUFFMAN_TABLE_SIZE
;
2149 /* Inflate values until the end of the block. This is the
2150 main loop of the inflation code. */
2159 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
2162 t
= tlit
[val
& 0xff];
2163 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
2164 v
= t
& HUFFMAN_VALUE_MASK
;
2166 if ((t
& (1U << HUFFMAN_SECONDARY_SHIFT
)) == 0)
2174 t
= tlit
[v
+ 0x100 + ((val
>> 8) & ((1U << b
) - 1))];
2175 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
2176 lit
= t
& HUFFMAN_VALUE_MASK
;
2183 if (unlikely (pout
== poutend
))
2191 /* We will need to write the next byte soon. We ask
2192 for high temporal locality because we will write
2193 to the whole cache line soon. */
2194 __builtin_prefetch (pout
, 1, 3);
2196 else if (lit
== 256)
2198 /* The end of the block. */
2206 /* Convert lit into a length. */
2209 len
= lit
- 257 + 3;
2210 else if (lit
== 285)
2212 else if (unlikely (lit
> 285))
2221 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
2224 /* This is an expression for the table of length
2225 codes in RFC 1951 3.2.5. */
2227 extra
= (lit
>> 2) + 1;
2228 len
= (lit
& 3) << extra
;
2230 len
+= ((1U << (extra
- 1)) - 1) << 3;
2231 len
+= val
& ((1U << extra
) - 1);
2236 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
2239 t
= tdist
[val
& 0xff];
2240 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
2241 v
= t
& HUFFMAN_VALUE_MASK
;
2243 if ((t
& (1U << HUFFMAN_SECONDARY_SHIFT
)) == 0)
2251 t
= tdist
[v
+ 0x100 + ((val
>> 8) & ((1U << b
) - 1))];
2252 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
2253 dist
= t
& HUFFMAN_VALUE_MASK
;
2258 /* Convert dist to a distance. */
2262 /* A distance of 1. A common case, meaning
2263 repeat the last character LEN times. */
2265 if (unlikely (pout
== porigout
))
2271 if (unlikely ((unsigned int) (poutend
- pout
) < len
))
2277 memset (pout
, pout
[-1], len
);
2280 else if (unlikely (dist
> 29))
2293 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
2296 /* This is an expression for the table of
2297 distance codes in RFC 1951 3.2.5. */
2299 extra
= (dist
>> 1) + 1;
2300 dist
= (dist
& 1) << extra
;
2302 dist
+= ((1U << (extra
- 1)) - 1) << 2;
2303 dist
+= val
& ((1U << extra
) - 1);
2308 /* Go back dist bytes, and copy len bytes from
2311 if (unlikely ((unsigned int) (pout
- porigout
) < dist
))
2317 if (unlikely ((unsigned int) (poutend
- pout
) < len
))
2325 memcpy (pout
, pout
- dist
, len
);
2334 copy
= len
< dist
? len
: dist
;
2335 memcpy (pout
, pout
- dist
, copy
);
2346 /* We should have filled the output buffer. */
2347 if (unlikely (pout
!= poutend
))
2356 /* Verify the zlib checksum. The checksum is in the 4 bytes at
2357 CHECKBYTES, and the uncompressed data is at UNCOMPRESSED /
2358 UNCOMPRESSED_SIZE. Returns 1 on success, 0 on failure. */
2361 elf_zlib_verify_checksum (const unsigned char *checkbytes
,
2362 const unsigned char *uncompressed
,
2363 size_t uncompressed_size
)
2367 const unsigned char *p
;
2373 for (i
= 0; i
< 4; i
++)
2374 cksum
= (cksum
<< 8) | checkbytes
[i
];
2379 /* Minimize modulo operations. */
2382 hsz
= uncompressed_size
;
2385 for (i
= 0; i
< 5552; i
+= 16)
2387 /* Manually unroll loop 16 times. */
2428 /* Manually unroll loop 16 times. */
2465 for (i
= 0; i
< hsz
; ++i
)
2474 if (unlikely ((s2
<< 16) + s1
!= cksum
))
2483 /* Inflate a zlib stream from PIN/SIN to POUT/SOUT, and verify the
2484 checksum. Return 1 on success, 0 on error. */
2487 elf_zlib_inflate_and_verify (const unsigned char *pin
, size_t sin
,
2488 uint16_t *zdebug_table
, unsigned char *pout
,
2491 if (!elf_zlib_inflate (pin
, sin
, zdebug_table
, pout
, sout
))
2493 if (!elf_zlib_verify_checksum (pin
+ sin
- 4, pout
, sout
))
2498 /* Uncompress the old compressed debug format, the one emitted by
2499 --compress-debug-sections=zlib-gnu. The compressed data is in
2500 COMPRESSED / COMPRESSED_SIZE, and the function writes to
2501 *UNCOMPRESSED / *UNCOMPRESSED_SIZE. ZDEBUG_TABLE is work space to
2502 hold Huffman tables. Returns 0 on error, 1 on successful
2503 decompression or if something goes wrong. In general we try to
2504 carry on, by returning 1, even if we can't decompress. */
2507 elf_uncompress_zdebug (struct backtrace_state
*state
,
2508 const unsigned char *compressed
, size_t compressed_size
,
2509 uint16_t *zdebug_table
,
2510 backtrace_error_callback error_callback
, void *data
,
2511 unsigned char **uncompressed
, size_t *uncompressed_size
)
2517 *uncompressed
= NULL
;
2518 *uncompressed_size
= 0;
2520 /* The format starts with the four bytes ZLIB, followed by the 8
2521 byte length of the uncompressed data in big-endian order,
2522 followed by a zlib stream. */
2524 if (compressed_size
< 12 || memcmp (compressed
, "ZLIB", 4) != 0)
2528 for (i
= 0; i
< 8; i
++)
2529 sz
= (sz
<< 8) | compressed
[i
+ 4];
2531 if (*uncompressed
!= NULL
&& *uncompressed_size
>= sz
)
2535 po
= (unsigned char *) backtrace_alloc (state
, sz
, error_callback
, data
);
2540 if (!elf_zlib_inflate_and_verify (compressed
+ 12, compressed_size
- 12,
2541 zdebug_table
, po
, sz
))
2545 *uncompressed_size
= sz
;
2550 /* Uncompress the new compressed debug format, the official standard
2551 ELF approach emitted by --compress-debug-sections=zlib-gabi. The
2552 compressed data is in COMPRESSED / COMPRESSED_SIZE, and the
2553 function writes to *UNCOMPRESSED / *UNCOMPRESSED_SIZE.
2554 ZDEBUG_TABLE is work space as for elf_uncompress_zdebug. Returns 0
2555 on error, 1 on successful decompression or if something goes wrong.
2556 In general we try to carry on, by returning 1, even if we can't
2560 elf_uncompress_chdr (struct backtrace_state
*state
,
2561 const unsigned char *compressed
, size_t compressed_size
,
2562 uint16_t *zdebug_table
,
2563 backtrace_error_callback error_callback
, void *data
,
2564 unsigned char **uncompressed
, size_t *uncompressed_size
)
2566 const b_elf_chdr
*chdr
;
2569 *uncompressed
= NULL
;
2570 *uncompressed_size
= 0;
2572 /* The format starts with an ELF compression header. */
2573 if (compressed_size
< sizeof (b_elf_chdr
))
2576 chdr
= (const b_elf_chdr
*) compressed
;
2578 if (chdr
->ch_type
!= ELFCOMPRESS_ZLIB
)
2580 /* Unsupported compression algorithm. */
2584 if (*uncompressed
!= NULL
&& *uncompressed_size
>= chdr
->ch_size
)
2588 po
= (unsigned char *) backtrace_alloc (state
, chdr
->ch_size
,
2589 error_callback
, data
);
2594 if (!elf_zlib_inflate_and_verify (compressed
+ sizeof (b_elf_chdr
),
2595 compressed_size
- sizeof (b_elf_chdr
),
2596 zdebug_table
, po
, chdr
->ch_size
))
2600 *uncompressed_size
= chdr
->ch_size
;
2605 /* This function is a hook for testing the zlib support. It is only
2609 backtrace_uncompress_zdebug (struct backtrace_state
*state
,
2610 const unsigned char *compressed
,
2611 size_t compressed_size
,
2612 backtrace_error_callback error_callback
,
2613 void *data
, unsigned char **uncompressed
,
2614 size_t *uncompressed_size
)
2616 uint16_t *zdebug_table
;
2619 zdebug_table
= ((uint16_t *) backtrace_alloc (state
, ZDEBUG_TABLE_SIZE
,
2620 error_callback
, data
));
2621 if (zdebug_table
== NULL
)
2623 ret
= elf_uncompress_zdebug (state
, compressed
, compressed_size
,
2624 zdebug_table
, error_callback
, data
,
2625 uncompressed
, uncompressed_size
);
2626 backtrace_free (state
, zdebug_table
, ZDEBUG_TABLE_SIZE
,
2627 error_callback
, data
);
2631 /* Add the backtrace data for one ELF file. Returns 1 on success,
2632 0 on failure (in both cases descriptor is closed) or -1 if exe
2633 is non-zero and the ELF file is ET_DYN, which tells the caller that
2634 elf_add will need to be called on the descriptor again after
2635 base_address is determined. */
2638 elf_add (struct backtrace_state
*state
, const char *filename
, int descriptor
,
2639 uintptr_t base_address
, backtrace_error_callback error_callback
,
2640 void *data
, fileline
*fileline_fn
, int *found_sym
, int *found_dwarf
,
2641 struct dwarf_data
**fileline_entry
, int exe
, int debuginfo
,
2642 const char *with_buildid_data
, uint32_t with_buildid_size
)
2644 struct backtrace_view ehdr_view
;
2648 unsigned int shstrndx
;
2649 struct backtrace_view shdrs_view
;
2650 int shdrs_view_valid
;
2651 const b_elf_shdr
*shdrs
;
2652 const b_elf_shdr
*shstrhdr
;
2655 struct backtrace_view names_view
;
2656 int names_view_valid
;
2658 unsigned int symtab_shndx
;
2659 unsigned int dynsym_shndx
;
2661 struct debug_section_info sections
[DEBUG_MAX
];
2662 struct backtrace_view symtab_view
;
2663 int symtab_view_valid
;
2664 struct backtrace_view strtab_view
;
2665 int strtab_view_valid
;
2666 struct backtrace_view buildid_view
;
2667 int buildid_view_valid
;
2668 const char *buildid_data
;
2669 uint32_t buildid_size
;
2670 struct backtrace_view debuglink_view
;
2671 int debuglink_view_valid
;
2672 const char *debuglink_name
;
2673 uint32_t debuglink_crc
;
2674 struct backtrace_view debugaltlink_view
;
2675 int debugaltlink_view_valid
;
2676 const char *debugaltlink_name
;
2677 const char *debugaltlink_buildid_data
;
2678 uint32_t debugaltlink_buildid_size
;
2681 struct backtrace_view debug_view
;
2682 int debug_view_valid
;
2683 unsigned int using_debug_view
;
2684 uint16_t *zdebug_table
;
2685 struct elf_ppc64_opd_data opd_data
, *opd
;
2693 shdrs_view_valid
= 0;
2694 names_view_valid
= 0;
2695 symtab_view_valid
= 0;
2696 strtab_view_valid
= 0;
2697 buildid_view_valid
= 0;
2698 buildid_data
= NULL
;
2700 debuglink_view_valid
= 0;
2701 debuglink_name
= NULL
;
2703 debugaltlink_view_valid
= 0;
2704 debugaltlink_name
= NULL
;
2705 debugaltlink_buildid_data
= NULL
;
2706 debugaltlink_buildid_size
= 0;
2707 debug_view_valid
= 0;
2710 if (!backtrace_get_view (state
, descriptor
, 0, sizeof ehdr
, error_callback
,
2714 memcpy (&ehdr
, ehdr_view
.data
, sizeof ehdr
);
2716 backtrace_release_view (state
, &ehdr_view
, error_callback
, data
);
2718 if (ehdr
.e_ident
[EI_MAG0
] != ELFMAG0
2719 || ehdr
.e_ident
[EI_MAG1
] != ELFMAG1
2720 || ehdr
.e_ident
[EI_MAG2
] != ELFMAG2
2721 || ehdr
.e_ident
[EI_MAG3
] != ELFMAG3
)
2723 error_callback (data
, "executable file is not ELF", 0);
2726 if (ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
)
2728 error_callback (data
, "executable file is unrecognized ELF version", 0);
2732 #if BACKTRACE_ELF_SIZE == 32
2733 #define BACKTRACE_ELFCLASS ELFCLASS32
2735 #define BACKTRACE_ELFCLASS ELFCLASS64
2738 if (ehdr
.e_ident
[EI_CLASS
] != BACKTRACE_ELFCLASS
)
2740 error_callback (data
, "executable file is unexpected ELF class", 0);
2744 if (ehdr
.e_ident
[EI_DATA
] != ELFDATA2LSB
2745 && ehdr
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
2747 error_callback (data
, "executable file has unknown endianness", 0);
2751 /* If the executable is ET_DYN, it is either a PIE, or we are running
2752 directly a shared library with .interp. We need to wait for
2753 dl_iterate_phdr in that case to determine the actual base_address. */
2754 if (exe
&& ehdr
.e_type
== ET_DYN
)
2757 shoff
= ehdr
.e_shoff
;
2758 shnum
= ehdr
.e_shnum
;
2759 shstrndx
= ehdr
.e_shstrndx
;
2761 if ((shnum
== 0 || shstrndx
== SHN_XINDEX
)
2764 struct backtrace_view shdr_view
;
2765 const b_elf_shdr
*shdr
;
2767 if (!backtrace_get_view (state
, descriptor
, shoff
, sizeof shdr
,
2768 error_callback
, data
, &shdr_view
))
2771 shdr
= (const b_elf_shdr
*) shdr_view
.data
;
2774 shnum
= shdr
->sh_size
;
2776 if (shstrndx
== SHN_XINDEX
)
2778 shstrndx
= shdr
->sh_link
;
2780 /* Versions of the GNU binutils between 2.12 and 2.18 did
2781 not handle objects with more than SHN_LORESERVE sections
2782 correctly. All large section indexes were offset by
2783 0x100. There is more information at
2784 http://sourceware.org/bugzilla/show_bug.cgi?id-5900 .
2785 Fortunately these object files are easy to detect, as the
2786 GNU binutils always put the section header string table
2787 near the end of the list of sections. Thus if the
2788 section header string table index is larger than the
2789 number of sections, then we know we have to subtract
2790 0x100 to get the real section index. */
2791 if (shstrndx
>= shnum
&& shstrndx
>= SHN_LORESERVE
+ 0x100)
2795 backtrace_release_view (state
, &shdr_view
, error_callback
, data
);
2798 /* To translate PC to file/line when using DWARF, we need to find
2799 the .debug_info and .debug_line sections. */
2801 /* Read the section headers, skipping the first one. */
2803 if (!backtrace_get_view (state
, descriptor
, shoff
+ sizeof (b_elf_shdr
),
2804 (shnum
- 1) * sizeof (b_elf_shdr
),
2805 error_callback
, data
, &shdrs_view
))
2807 shdrs_view_valid
= 1;
2808 shdrs
= (const b_elf_shdr
*) shdrs_view
.data
;
2810 /* Read the section names. */
2812 shstrhdr
= &shdrs
[shstrndx
- 1];
2813 shstr_size
= shstrhdr
->sh_size
;
2814 shstr_off
= shstrhdr
->sh_offset
;
2816 if (!backtrace_get_view (state
, descriptor
, shstr_off
, shstrhdr
->sh_size
,
2817 error_callback
, data
, &names_view
))
2819 names_view_valid
= 1;
2820 names
= (const char *) names_view
.data
;
2825 memset (sections
, 0, sizeof sections
);
2827 /* Look for the symbol table. */
2828 for (i
= 1; i
< shnum
; ++i
)
2830 const b_elf_shdr
*shdr
;
2831 unsigned int sh_name
;
2835 shdr
= &shdrs
[i
- 1];
2837 if (shdr
->sh_type
== SHT_SYMTAB
)
2839 else if (shdr
->sh_type
== SHT_DYNSYM
)
2842 sh_name
= shdr
->sh_name
;
2843 if (sh_name
>= shstr_size
)
2845 error_callback (data
, "ELF section name out of range", 0);
2849 name
= names
+ sh_name
;
2851 for (j
= 0; j
< (int) DEBUG_MAX
; ++j
)
2853 if (strcmp (name
, debug_section_names
[j
]) == 0)
2855 sections
[j
].offset
= shdr
->sh_offset
;
2856 sections
[j
].size
= shdr
->sh_size
;
2857 sections
[j
].compressed
= (shdr
->sh_flags
& SHF_COMPRESSED
) != 0;
2862 /* Read the build ID if present. This could check for any
2863 SHT_NOTE section with the right note name and type, but gdb
2864 looks for a specific section name. */
2866 && !buildid_view_valid
2867 && strcmp (name
, ".note.gnu.build-id") == 0)
2869 const b_elf_note
*note
;
2871 if (!backtrace_get_view (state
, descriptor
, shdr
->sh_offset
,
2872 shdr
->sh_size
, error_callback
, data
,
2876 buildid_view_valid
= 1;
2877 note
= (const b_elf_note
*) buildid_view
.data
;
2878 if (note
->type
== NT_GNU_BUILD_ID
2879 && note
->namesz
== 4
2880 && strncmp (note
->name
, "GNU", 4) == 0
2881 && shdr
->sh_size
<= 12 + ((note
->namesz
+ 3) & ~ 3) + note
->descsz
)
2883 buildid_data
= ¬e
->name
[0] + ((note
->namesz
+ 3) & ~ 3);
2884 buildid_size
= note
->descsz
;
2887 if (with_buildid_size
!= 0)
2889 if (buildid_size
!= with_buildid_size
)
2892 if (memcmp (buildid_data
, with_buildid_data
, buildid_size
) != 0)
2897 /* Read the debuglink file if present. */
2899 && !debuglink_view_valid
2900 && strcmp (name
, ".gnu_debuglink") == 0)
2902 const char *debuglink_data
;
2905 if (!backtrace_get_view (state
, descriptor
, shdr
->sh_offset
,
2906 shdr
->sh_size
, error_callback
, data
,
2910 debuglink_view_valid
= 1;
2911 debuglink_data
= (const char *) debuglink_view
.data
;
2912 crc_offset
= strnlen (debuglink_data
, shdr
->sh_size
);
2913 crc_offset
= (crc_offset
+ 3) & ~3;
2914 if (crc_offset
+ 4 <= shdr
->sh_size
)
2916 debuglink_name
= debuglink_data
;
2917 debuglink_crc
= *(const uint32_t*)(debuglink_data
+ crc_offset
);
2921 if (!debugaltlink_view_valid
2922 && strcmp (name
, ".gnu_debugaltlink") == 0)
2924 const char *debugaltlink_data
;
2925 size_t debugaltlink_name_len
;
2927 if (!backtrace_get_view (state
, descriptor
, shdr
->sh_offset
,
2928 shdr
->sh_size
, error_callback
, data
,
2929 &debugaltlink_view
))
2932 debugaltlink_view_valid
= 1;
2933 debugaltlink_data
= (const char *) debugaltlink_view
.data
;
2934 debugaltlink_name
= debugaltlink_data
;
2935 debugaltlink_name_len
= strnlen (debugaltlink_data
, shdr
->sh_size
);
2936 if (debugaltlink_name_len
< shdr
->sh_size
)
2938 /* Include terminating zero. */
2939 debugaltlink_name_len
=+ 1;
2941 debugaltlink_buildid_data
2942 = debugaltlink_data
+ debugaltlink_name_len
;
2943 debugaltlink_buildid_size
= shdr
->sh_size
- debugaltlink_name_len
;
2947 /* Read the .opd section on PowerPC64 ELFv1. */
2948 if (ehdr
.e_machine
== EM_PPC64
2949 && (ehdr
.e_flags
& EF_PPC64_ABI
) < 2
2950 && shdr
->sh_type
== SHT_PROGBITS
2951 && strcmp (name
, ".opd") == 0)
2953 if (!backtrace_get_view (state
, descriptor
, shdr
->sh_offset
,
2954 shdr
->sh_size
, error_callback
, data
,
2959 opd
->addr
= shdr
->sh_addr
;
2960 opd
->data
= (const char *) opd_data
.view
.data
;
2961 opd
->size
= shdr
->sh_size
;
2965 if (symtab_shndx
== 0)
2966 symtab_shndx
= dynsym_shndx
;
2967 if (symtab_shndx
!= 0 && !debuginfo
)
2969 const b_elf_shdr
*symtab_shdr
;
2970 unsigned int strtab_shndx
;
2971 const b_elf_shdr
*strtab_shdr
;
2972 struct elf_syminfo_data
*sdata
;
2974 symtab_shdr
= &shdrs
[symtab_shndx
- 1];
2975 strtab_shndx
= symtab_shdr
->sh_link
;
2976 if (strtab_shndx
>= shnum
)
2978 error_callback (data
,
2979 "ELF symbol table strtab link out of range", 0);
2982 strtab_shdr
= &shdrs
[strtab_shndx
- 1];
2984 if (!backtrace_get_view (state
, descriptor
, symtab_shdr
->sh_offset
,
2985 symtab_shdr
->sh_size
, error_callback
, data
,
2988 symtab_view_valid
= 1;
2990 if (!backtrace_get_view (state
, descriptor
, strtab_shdr
->sh_offset
,
2991 strtab_shdr
->sh_size
, error_callback
, data
,
2994 strtab_view_valid
= 1;
2996 sdata
= ((struct elf_syminfo_data
*)
2997 backtrace_alloc (state
, sizeof *sdata
, error_callback
, data
));
3001 if (!elf_initialize_syminfo (state
, base_address
,
3002 symtab_view
.data
, symtab_shdr
->sh_size
,
3003 strtab_view
.data
, strtab_shdr
->sh_size
,
3004 error_callback
, data
, sdata
, opd
))
3006 backtrace_free (state
, sdata
, sizeof *sdata
, error_callback
, data
);
3010 /* We no longer need the symbol table, but we hold on to the
3011 string table permanently. */
3012 backtrace_release_view (state
, &symtab_view
, error_callback
, data
);
3013 symtab_view_valid
= 0;
3017 elf_add_syminfo_data (state
, sdata
);
3020 backtrace_release_view (state
, &shdrs_view
, error_callback
, data
);
3021 shdrs_view_valid
= 0;
3022 backtrace_release_view (state
, &names_view
, error_callback
, data
);
3023 names_view_valid
= 0;
3025 /* If the debug info is in a separate file, read that one instead. */
3027 if (buildid_data
!= NULL
)
3031 d
= elf_open_debugfile_by_buildid (state
, buildid_data
, buildid_size
,
3032 error_callback
, data
);
3037 backtrace_release_view (state
, &buildid_view
, error_callback
, data
);
3038 if (debuglink_view_valid
)
3039 backtrace_release_view (state
, &debuglink_view
, error_callback
,
3041 if (debugaltlink_view_valid
)
3042 backtrace_release_view (state
, &debugaltlink_view
, error_callback
,
3044 ret
= elf_add (state
, "", d
, base_address
, error_callback
, data
,
3045 fileline_fn
, found_sym
, found_dwarf
, NULL
, 0, 1, NULL
,
3048 backtrace_close (d
, error_callback
, data
);
3050 backtrace_close (descriptor
, error_callback
, data
);
3055 if (buildid_view_valid
)
3057 backtrace_release_view (state
, &buildid_view
, error_callback
, data
);
3058 buildid_view_valid
= 0;
3063 backtrace_release_view (state
, &opd
->view
, error_callback
, data
);
3067 if (debuglink_name
!= NULL
)
3071 d
= elf_open_debugfile_by_debuglink (state
, filename
, debuglink_name
,
3072 debuglink_crc
, error_callback
,
3078 backtrace_release_view (state
, &debuglink_view
, error_callback
,
3080 if (debugaltlink_view_valid
)
3081 backtrace_release_view (state
, &debugaltlink_view
, error_callback
,
3083 ret
= elf_add (state
, "", d
, base_address
, error_callback
, data
,
3084 fileline_fn
, found_sym
, found_dwarf
, NULL
, 0, 1, NULL
,
3087 backtrace_close (d
, error_callback
, data
);
3089 backtrace_close(descriptor
, error_callback
, data
);
3094 if (debuglink_view_valid
)
3096 backtrace_release_view (state
, &debuglink_view
, error_callback
, data
);
3097 debuglink_view_valid
= 0;
3100 struct dwarf_data
*fileline_altlink
= NULL
;
3101 if (debugaltlink_name
!= NULL
)
3105 d
= elf_open_debugfile_by_debuglink (state
, filename
, debugaltlink_name
,
3106 0, error_callback
, data
);
3111 ret
= elf_add (state
, filename
, d
, base_address
, error_callback
, data
,
3112 fileline_fn
, found_sym
, found_dwarf
, &fileline_altlink
,
3113 0, 1, debugaltlink_buildid_data
,
3114 debugaltlink_buildid_size
);
3115 backtrace_release_view (state
, &debugaltlink_view
, error_callback
,
3117 debugaltlink_view_valid
= 0;
3120 backtrace_close (d
, error_callback
, data
);
3126 if (debugaltlink_view_valid
)
3128 backtrace_release_view (state
, &debugaltlink_view
, error_callback
, data
);
3129 debugaltlink_view_valid
= 0;
3132 /* Read all the debug sections in a single view, since they are
3133 probably adjacent in the file. We never release this view. */
3137 for (i
= 0; i
< (int) DEBUG_MAX
; ++i
)
3141 if (sections
[i
].size
== 0)
3143 if (min_offset
== 0 || sections
[i
].offset
< min_offset
)
3144 min_offset
= sections
[i
].offset
;
3145 end
= sections
[i
].offset
+ sections
[i
].size
;
3146 if (end
> max_offset
)
3149 if (min_offset
== 0 || max_offset
== 0)
3151 if (!backtrace_close (descriptor
, error_callback
, data
))
3156 if (!backtrace_get_view (state
, descriptor
, min_offset
,
3157 max_offset
- min_offset
,
3158 error_callback
, data
, &debug_view
))
3160 debug_view_valid
= 1;
3162 /* We've read all we need from the executable. */
3163 if (!backtrace_close (descriptor
, error_callback
, data
))
3167 using_debug_view
= 0;
3168 for (i
= 0; i
< (int) DEBUG_MAX
; ++i
)
3170 if (sections
[i
].size
== 0)
3171 sections
[i
].data
= NULL
;
3174 sections
[i
].data
= ((const unsigned char *) debug_view
.data
3175 + (sections
[i
].offset
- min_offset
));
3176 if (i
< ZDEBUG_INFO
)
3181 /* Uncompress the old format (--compress-debug-sections=zlib-gnu). */
3183 zdebug_table
= NULL
;
3184 for (i
= 0; i
< ZDEBUG_INFO
; ++i
)
3186 struct debug_section_info
*pz
;
3188 pz
= §ions
[i
+ ZDEBUG_INFO
- DEBUG_INFO
];
3189 if (sections
[i
].size
== 0 && pz
->size
> 0)
3191 unsigned char *uncompressed_data
;
3192 size_t uncompressed_size
;
3194 if (zdebug_table
== NULL
)
3196 zdebug_table
= ((uint16_t *)
3197 backtrace_alloc (state
, ZDEBUG_TABLE_SIZE
,
3198 error_callback
, data
));
3199 if (zdebug_table
== NULL
)
3203 uncompressed_data
= NULL
;
3204 uncompressed_size
= 0;
3205 if (!elf_uncompress_zdebug (state
, pz
->data
, pz
->size
, zdebug_table
,
3206 error_callback
, data
,
3207 &uncompressed_data
, &uncompressed_size
))
3209 sections
[i
].data
= uncompressed_data
;
3210 sections
[i
].size
= uncompressed_size
;
3211 sections
[i
].compressed
= 0;
3215 /* Uncompress the official ELF format
3216 (--compress-debug-sections=zlib-gabi). */
3217 for (i
= 0; i
< ZDEBUG_INFO
; ++i
)
3219 unsigned char *uncompressed_data
;
3220 size_t uncompressed_size
;
3222 if (sections
[i
].size
== 0 || !sections
[i
].compressed
)
3225 if (zdebug_table
== NULL
)
3227 zdebug_table
= ((uint16_t *)
3228 backtrace_alloc (state
, ZDEBUG_TABLE_SIZE
,
3229 error_callback
, data
));
3230 if (zdebug_table
== NULL
)
3234 uncompressed_data
= NULL
;
3235 uncompressed_size
= 0;
3236 if (!elf_uncompress_chdr (state
, sections
[i
].data
, sections
[i
].size
,
3237 zdebug_table
, error_callback
, data
,
3238 &uncompressed_data
, &uncompressed_size
))
3240 sections
[i
].data
= uncompressed_data
;
3241 sections
[i
].size
= uncompressed_size
;
3242 sections
[i
].compressed
= 0;
3247 if (zdebug_table
!= NULL
)
3248 backtrace_free (state
, zdebug_table
, ZDEBUG_TABLE_SIZE
,
3249 error_callback
, data
);
3251 if (debug_view_valid
&& using_debug_view
== 0)
3253 backtrace_release_view (state
, &debug_view
, error_callback
, data
);
3254 debug_view_valid
= 0;
3257 if (!backtrace_dwarf_add (state
, base_address
,
3258 sections
[DEBUG_INFO
].data
,
3259 sections
[DEBUG_INFO
].size
,
3260 sections
[DEBUG_LINE
].data
,
3261 sections
[DEBUG_LINE
].size
,
3262 sections
[DEBUG_ABBREV
].data
,
3263 sections
[DEBUG_ABBREV
].size
,
3264 sections
[DEBUG_RANGES
].data
,
3265 sections
[DEBUG_RANGES
].size
,
3266 sections
[DEBUG_STR
].data
,
3267 sections
[DEBUG_STR
].size
,
3268 ehdr
.e_ident
[EI_DATA
] == ELFDATA2MSB
,
3270 error_callback
, data
, fileline_fn
,
3279 if (shdrs_view_valid
)
3280 backtrace_release_view (state
, &shdrs_view
, error_callback
, data
);
3281 if (names_view_valid
)
3282 backtrace_release_view (state
, &names_view
, error_callback
, data
);
3283 if (symtab_view_valid
)
3284 backtrace_release_view (state
, &symtab_view
, error_callback
, data
);
3285 if (strtab_view_valid
)
3286 backtrace_release_view (state
, &strtab_view
, error_callback
, data
);
3287 if (debuglink_view_valid
)
3288 backtrace_release_view (state
, &debuglink_view
, error_callback
, data
);
3289 if (debugaltlink_view_valid
)
3290 backtrace_release_view (state
, &debugaltlink_view
, error_callback
, data
);
3291 if (buildid_view_valid
)
3292 backtrace_release_view (state
, &buildid_view
, error_callback
, data
);
3293 if (debug_view_valid
)
3294 backtrace_release_view (state
, &debug_view
, error_callback
, data
);
3296 backtrace_release_view (state
, &opd
->view
, error_callback
, data
);
3297 if (descriptor
!= -1)
3298 backtrace_close (descriptor
, error_callback
, data
);
3302 /* Data passed to phdr_callback. */
3306 struct backtrace_state
*state
;
3307 backtrace_error_callback error_callback
;
3309 fileline
*fileline_fn
;
3312 const char *exe_filename
;
3316 /* Callback passed to dl_iterate_phdr. Load debug info from shared
3321 __attribute__ ((__force_align_arg_pointer__
))
3323 phdr_callback (struct dl_phdr_info
*info
, size_t size ATTRIBUTE_UNUSED
,
3326 struct phdr_data
*pd
= (struct phdr_data
*) pdata
;
3327 const char *filename
;
3330 fileline elf_fileline_fn
;
3333 /* There is not much we can do if we don't have the module name,
3334 unless executable is ET_DYN, where we expect the very first
3335 phdr_callback to be for the PIE. */
3336 if (info
->dlpi_name
== NULL
|| info
->dlpi_name
[0] == '\0')
3338 if (pd
->exe_descriptor
== -1)
3340 filename
= pd
->exe_filename
;
3341 descriptor
= pd
->exe_descriptor
;
3342 pd
->exe_descriptor
= -1;
3346 if (pd
->exe_descriptor
!= -1)
3348 backtrace_close (pd
->exe_descriptor
, pd
->error_callback
, pd
->data
);
3349 pd
->exe_descriptor
= -1;
3352 filename
= info
->dlpi_name
;
3353 descriptor
= backtrace_open (info
->dlpi_name
, pd
->error_callback
,
3354 pd
->data
, &does_not_exist
);
3359 if (elf_add (pd
->state
, filename
, descriptor
, info
->dlpi_addr
,
3360 pd
->error_callback
, pd
->data
, &elf_fileline_fn
, pd
->found_sym
,
3361 &found_dwarf
, NULL
, 0, 0, NULL
, 0))
3365 *pd
->found_dwarf
= 1;
3366 *pd
->fileline_fn
= elf_fileline_fn
;
3373 /* Initialize the backtrace data we need from an ELF executable. At
3374 the ELF level, all we need to do is find the debug info
3378 backtrace_initialize (struct backtrace_state
*state
, const char *filename
,
3379 int descriptor
, backtrace_error_callback error_callback
,
3380 void *data
, fileline
*fileline_fn
)
3385 fileline elf_fileline_fn
= elf_nodebug
;
3386 struct phdr_data pd
;
3388 ret
= elf_add (state
, filename
, descriptor
, 0, error_callback
, data
,
3389 &elf_fileline_fn
, &found_sym
, &found_dwarf
, NULL
, 1, 0, NULL
,
3395 pd
.error_callback
= error_callback
;
3397 pd
.fileline_fn
= &elf_fileline_fn
;
3398 pd
.found_sym
= &found_sym
;
3399 pd
.found_dwarf
= &found_dwarf
;
3400 pd
.exe_filename
= filename
;
3401 pd
.exe_descriptor
= ret
< 0 ? descriptor
: -1;
3403 dl_iterate_phdr (phdr_callback
, (void *) &pd
);
3405 if (!state
->threaded
)
3408 state
->syminfo_fn
= elf_syminfo
;
3409 else if (state
->syminfo_fn
== NULL
)
3410 state
->syminfo_fn
= elf_nosyms
;
3415 backtrace_atomic_store_pointer (&state
->syminfo_fn
, elf_syminfo
);
3417 (void) __sync_bool_compare_and_swap (&state
->syminfo_fn
, NULL
,
3421 if (!state
->threaded
)
3422 *fileline_fn
= state
->fileline_fn
;
3424 *fileline_fn
= backtrace_atomic_load_pointer (&state
->fileline_fn
);
3426 if (*fileline_fn
== NULL
|| *fileline_fn
== elf_nodebug
)
3427 *fileline_fn
= elf_fileline_fn
;