1 /* elf.c -- Get debug data from an ELF file for backtraces.
2 Copyright (C) 2012-2018 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
,
1001 ddescriptor
= elf_find_debugfile_by_debuglink (state
, filename
,
1003 error_callback
, data
);
1004 if (ddescriptor
< 0)
1007 if (debuglink_crc
!= 0)
1011 got_crc
= elf_crc32_file (state
, ddescriptor
, error_callback
, data
);
1012 if (got_crc
!= debuglink_crc
)
1014 backtrace_close (ddescriptor
, error_callback
, data
);
1022 /* A function useful for setting a breakpoint for an inflation failure
1023 when this code is compiled with -g. */
1026 elf_zlib_failed(void)
1030 /* *PVAL is the current value being read from the stream, and *PBITS
1031 is the number of valid bits. Ensure that *PVAL holds at least 15
1032 bits by reading additional bits from *PPIN, up to PINEND, as
1033 needed. Updates *PPIN, *PVAL and *PBITS. Returns 1 on success, 0
1037 elf_zlib_fetch (const unsigned char **ppin
, const unsigned char *pinend
,
1038 uint64_t *pval
, unsigned int *pbits
)
1041 const unsigned char *pin
;
1051 if (unlikely (pinend
- pin
< 4))
1057 /* We've ensured that PIN is aligned. */
1058 next
= *(const uint32_t *)pin
;
1060 #if __BYTE_ORDER == __ORDER_BIG_ENDIAN
1061 next
= __builtin_bswap32 (next
);
1064 val
|= (uint64_t)next
<< bits
;
1068 /* We will need the next four bytes soon. */
1069 __builtin_prefetch (pin
, 0, 0);
1077 /* Huffman code tables, like the rest of the zlib format, are defined
1078 by RFC 1951. We store a Huffman code table as a series of tables
1079 stored sequentially in memory. Each entry in a table is 16 bits.
1080 The first, main, table has 256 entries. It is followed by a set of
1081 secondary tables of length 2 to 128 entries. The maximum length of
1082 a code sequence in the deflate format is 15 bits, so that is all we
1083 need. Each secondary table has an index, which is the offset of
1084 the table in the overall memory storage.
1086 The deflate format says that all codes of a given bit length are
1087 lexicographically consecutive. Perhaps we could have 130 values
1088 that require a 15-bit code, perhaps requiring three secondary
1089 tables of size 128. I don't know if this is actually possible, but
1090 it suggests that the maximum size required for secondary tables is
1091 3 * 128 + 3 * 64 ... == 768. The zlib enough program reports 660
1092 as the maximum. We permit 768, since in addition to the 256 for
1093 the primary table, with two bytes per entry, and with the two
1094 tables we need, that gives us a page.
1096 A single table entry needs to store a value or (for the main table
1097 only) the index and size of a secondary table. Values range from 0
1098 to 285, inclusive. Secondary table indexes, per above, range from
1099 0 to 510. For a value we need to store the number of bits we need
1100 to determine that value (one value may appear multiple times in the
1101 table), which is 1 to 8. For a secondary table we need to store
1102 the number of bits used to index into the table, which is 1 to 7.
1103 And of course we need 1 bit to decide whether we have a value or a
1104 secondary table index. So each entry needs 9 bits for value/table
1105 index, 3 bits for size, 1 bit what it is. For simplicity we use 16
1108 /* Number of entries we allocate to for one code table. We get a page
1109 for the two code tables we need. */
1111 #define HUFFMAN_TABLE_SIZE (1024)
1113 /* Bit masks and shifts for the values in the table. */
1115 #define HUFFMAN_VALUE_MASK 0x01ff
1116 #define HUFFMAN_BITS_SHIFT 9
1117 #define HUFFMAN_BITS_MASK 0x7
1118 #define HUFFMAN_SECONDARY_SHIFT 12
1120 /* For working memory while inflating we need two code tables, we need
1121 an array of code lengths (max value 15, so we use unsigned char),
1122 and an array of unsigned shorts used while building a table. The
1123 latter two arrays must be large enough to hold the maximum number
1124 of code lengths, which RFC 1951 defines as 286 + 30. */
1126 #define ZDEBUG_TABLE_SIZE \
1127 (2 * HUFFMAN_TABLE_SIZE * sizeof (uint16_t) \
1128 + (286 + 30) * sizeof (uint16_t) \
1129 + (286 + 30) * sizeof (unsigned char))
1131 #define ZDEBUG_TABLE_CODELEN_OFFSET \
1132 (2 * HUFFMAN_TABLE_SIZE * sizeof (uint16_t) \
1133 + (286 + 30) * sizeof (uint16_t))
1135 #define ZDEBUG_TABLE_WORK_OFFSET \
1136 (2 * HUFFMAN_TABLE_SIZE * sizeof (uint16_t))
1138 #ifdef BACKTRACE_GENERATE_FIXED_HUFFMAN_TABLE
1140 /* Used by the main function that generates the fixed table to learn
1142 static size_t final_next_secondary
;
1146 /* Build a Huffman code table from an array of lengths in CODES of
1147 length CODES_LEN. The table is stored into *TABLE. ZDEBUG_TABLE
1148 is the same as for elf_zlib_inflate, used to find some work space.
1149 Returns 1 on success, 0 on error. */
1152 elf_zlib_inflate_table (unsigned char *codes
, size_t codes_len
,
1153 uint16_t *zdebug_table
, uint16_t *table
)
1158 uint16_t firstcode
[7];
1163 size_t next_secondary
;
1165 /* Count the number of code of each length. Set NEXT[val] to be the
1166 next value after VAL with the same bit length. */
1168 next
= (uint16_t *) (((unsigned char *) zdebug_table
)
1169 + ZDEBUG_TABLE_WORK_OFFSET
);
1171 memset (&count
[0], 0, 16 * sizeof (uint16_t));
1172 for (i
= 0; i
< codes_len
; ++i
)
1174 if (unlikely (codes
[i
] >= 16))
1180 if (count
[codes
[i
]] == 0)
1182 start
[codes
[i
]] = i
;
1187 next
[prev
[codes
[i
]]] = i
;
1194 /* For each length, fill in the table for the codes of that
1197 memset (table
, 0, HUFFMAN_TABLE_SIZE
* sizeof (uint16_t));
1199 /* Handle the values that do not require a secondary table. */
1202 for (j
= 1; j
<= 8; ++j
)
1211 if (unlikely (jcnt
> (1U << j
)))
1217 /* There are JCNT values that have this length, the values
1218 starting from START[j] continuing through NEXT[VAL]. Those
1219 values are assigned consecutive values starting at CODE. */
1222 for (i
= 0; i
< jcnt
; ++i
)
1228 /* In the compressed bit stream, the value VAL is encoded as
1229 J bits with the value C. */
1231 if (unlikely ((val
& ~HUFFMAN_VALUE_MASK
) != 0))
1237 tval
= val
| ((j
- 1) << HUFFMAN_BITS_SHIFT
);
1239 /* The table lookup uses 8 bits. If J is less than 8, we
1240 don't know what the other bits will be. We need to fill
1241 in all possibilities in the table. Since the Huffman
1242 code is unambiguous, those entries can't be used for any
1245 for (ind
= code
; ind
< 0x100; ind
+= 1 << j
)
1247 if (unlikely (table
[ind
] != 0))
1255 /* Advance to the next value with this length. */
1259 /* The Huffman codes are stored in the bitstream with the
1260 most significant bit first, as is required to make them
1261 unambiguous. The effect is that when we read them from
1262 the bitstream we see the bit sequence in reverse order:
1263 the most significant bit of the Huffman code is the least
1264 significant bit of the value we read from the bitstream.
1265 That means that to make our table lookups work, we need
1266 to reverse the bits of CODE. Since reversing bits is
1267 tedious and in general requires using a table, we instead
1268 increment CODE in reverse order. That is, if the number
1269 of bits we are currently using, here named J, is 3, we
1270 count as 000, 100, 010, 110, 001, 101, 011, 111, which is
1271 to say the numbers from 0 to 7 but with the bits
1272 reversed. Going to more bits, aka incrementing J,
1273 effectively just adds more zero bits as the beginning,
1274 and as such does not change the numeric value of CODE.
1276 To increment CODE of length J in reverse order, find the
1277 most significant zero bit and set it to one while
1278 clearing all higher bits. In other words, add 1 modulo
1279 2^J, only reversed. */
1281 incr
= 1U << (j
- 1);
1282 while ((code
& incr
) != 0)
1294 /* Handle the values that require a secondary table. */
1296 /* Set FIRSTCODE, the number at which the codes start, for each
1299 for (j
= 9; j
< 16; j
++)
1308 /* There are JCNT values that have this length, the values
1309 starting from START[j]. Those values are assigned
1310 consecutive values starting at CODE. */
1312 firstcode
[j
- 9] = code
;
1314 /* Reverse add JCNT to CODE modulo 2^J. */
1315 for (k
= 0; k
< j
; ++k
)
1317 if ((jcnt
& (1U << k
)) != 0)
1322 bit
= 1U << (j
- k
- 1);
1323 for (m
= 0; m
< j
- k
; ++m
, bit
>>= 1)
1325 if ((code
& bit
) == 0)
1335 if (unlikely (jcnt
!= 0))
1342 /* For J from 9 to 15, inclusive, we store COUNT[J] consecutive
1343 values starting at START[J] with consecutive codes starting at
1344 FIRSTCODE[J - 9]. In the primary table we need to point to the
1345 secondary table, and the secondary table will be indexed by J - 9
1346 bits. We count down from 15 so that we install the larger
1347 secondary tables first, as the smaller ones may be embedded in
1350 next_secondary
= 0; /* Index of next secondary table (after primary). */
1351 for (j
= 15; j
>= 9; j
--)
1355 size_t primary
; /* Current primary index. */
1356 size_t secondary
; /* Offset to current secondary table. */
1357 size_t secondary_bits
; /* Bit size of current secondary table. */
1364 code
= firstcode
[j
- 9];
1368 for (i
= 0; i
< jcnt
; ++i
)
1374 if ((code
& 0xff) != primary
)
1378 /* Fill in a new primary table entry. */
1380 primary
= code
& 0xff;
1382 tprimary
= table
[primary
];
1385 /* Start a new secondary table. */
1387 if (unlikely ((next_secondary
& HUFFMAN_VALUE_MASK
)
1394 secondary
= next_secondary
;
1395 secondary_bits
= j
- 8;
1396 next_secondary
+= 1 << secondary_bits
;
1397 table
[primary
] = (secondary
1398 + ((j
- 8) << HUFFMAN_BITS_SHIFT
)
1399 + (1U << HUFFMAN_SECONDARY_SHIFT
));
1403 /* There is an existing entry. It had better be a
1404 secondary table with enough bits. */
1405 if (unlikely ((tprimary
& (1U << HUFFMAN_SECONDARY_SHIFT
))
1411 secondary
= tprimary
& HUFFMAN_VALUE_MASK
;
1412 secondary_bits
= ((tprimary
>> HUFFMAN_BITS_SHIFT
)
1413 & HUFFMAN_BITS_MASK
);
1414 if (unlikely (secondary_bits
< j
- 8))
1422 /* Fill in secondary table entries. */
1424 tval
= val
| ((j
- 8) << HUFFMAN_BITS_SHIFT
);
1426 for (ind
= code
>> 8;
1427 ind
< (1U << secondary_bits
);
1428 ind
+= 1U << (j
- 8))
1430 if (unlikely (table
[secondary
+ 0x100 + ind
] != 0))
1435 table
[secondary
+ 0x100 + ind
] = tval
;
1441 incr
= 1U << (j
- 1);
1442 while ((code
& incr
) != 0)
1454 #ifdef BACKTRACE_GENERATE_FIXED_HUFFMAN_TABLE
1455 final_next_secondary
= next_secondary
;
1461 #ifdef BACKTRACE_GENERATE_FIXED_HUFFMAN_TABLE
1463 /* Used to generate the fixed Huffman table for block type 1. */
1467 static uint16_t table
[ZDEBUG_TABLE_SIZE
];
1468 static unsigned char codes
[288];
1475 for (i
= 0; i
<= 143; ++i
)
1477 for (i
= 144; i
<= 255; ++i
)
1479 for (i
= 256; i
<= 279; ++i
)
1481 for (i
= 280; i
<= 287; ++i
)
1483 if (!elf_zlib_inflate_table (&codes
[0], 288, &table
[0], &table
[0]))
1485 fprintf (stderr
, "elf_zlib_inflate_table failed\n");
1486 exit (EXIT_FAILURE
);
1489 printf ("static const uint16_t elf_zlib_default_table[%#zx] =\n",
1490 final_next_secondary
+ 0x100);
1492 for (i
= 0; i
< final_next_secondary
+ 0x100; i
+= 8)
1497 for (j
= i
; j
< final_next_secondary
+ 0x100 && j
< i
+ 8; ++j
)
1498 printf (" %#x,", table
[j
]);
1504 for (i
= 0; i
< 32; ++i
)
1506 if (!elf_zlib_inflate_table (&codes
[0], 32, &table
[0], &table
[0]))
1508 fprintf (stderr
, "elf_zlib_inflate_table failed\n");
1509 exit (EXIT_FAILURE
);
1512 printf ("static const uint16_t elf_zlib_default_dist_table[%#zx] =\n",
1513 final_next_secondary
+ 0x100);
1515 for (i
= 0; i
< final_next_secondary
+ 0x100; i
+= 8)
1520 for (j
= i
; j
< final_next_secondary
+ 0x100 && j
< i
+ 8; ++j
)
1521 printf (" %#x,", table
[j
]);
1531 /* The fixed tables generated by the #ifdef'ed out main function
1534 static const uint16_t elf_zlib_default_table
[0x170] =
1536 0xd00, 0xe50, 0xe10, 0xf18, 0xd10, 0xe70, 0xe30, 0x1230,
1537 0xd08, 0xe60, 0xe20, 0x1210, 0xe00, 0xe80, 0xe40, 0x1250,
1538 0xd04, 0xe58, 0xe18, 0x1200, 0xd14, 0xe78, 0xe38, 0x1240,
1539 0xd0c, 0xe68, 0xe28, 0x1220, 0xe08, 0xe88, 0xe48, 0x1260,
1540 0xd02, 0xe54, 0xe14, 0xf1c, 0xd12, 0xe74, 0xe34, 0x1238,
1541 0xd0a, 0xe64, 0xe24, 0x1218, 0xe04, 0xe84, 0xe44, 0x1258,
1542 0xd06, 0xe5c, 0xe1c, 0x1208, 0xd16, 0xe7c, 0xe3c, 0x1248,
1543 0xd0e, 0xe6c, 0xe2c, 0x1228, 0xe0c, 0xe8c, 0xe4c, 0x1268,
1544 0xd01, 0xe52, 0xe12, 0xf1a, 0xd11, 0xe72, 0xe32, 0x1234,
1545 0xd09, 0xe62, 0xe22, 0x1214, 0xe02, 0xe82, 0xe42, 0x1254,
1546 0xd05, 0xe5a, 0xe1a, 0x1204, 0xd15, 0xe7a, 0xe3a, 0x1244,
1547 0xd0d, 0xe6a, 0xe2a, 0x1224, 0xe0a, 0xe8a, 0xe4a, 0x1264,
1548 0xd03, 0xe56, 0xe16, 0xf1e, 0xd13, 0xe76, 0xe36, 0x123c,
1549 0xd0b, 0xe66, 0xe26, 0x121c, 0xe06, 0xe86, 0xe46, 0x125c,
1550 0xd07, 0xe5e, 0xe1e, 0x120c, 0xd17, 0xe7e, 0xe3e, 0x124c,
1551 0xd0f, 0xe6e, 0xe2e, 0x122c, 0xe0e, 0xe8e, 0xe4e, 0x126c,
1552 0xd00, 0xe51, 0xe11, 0xf19, 0xd10, 0xe71, 0xe31, 0x1232,
1553 0xd08, 0xe61, 0xe21, 0x1212, 0xe01, 0xe81, 0xe41, 0x1252,
1554 0xd04, 0xe59, 0xe19, 0x1202, 0xd14, 0xe79, 0xe39, 0x1242,
1555 0xd0c, 0xe69, 0xe29, 0x1222, 0xe09, 0xe89, 0xe49, 0x1262,
1556 0xd02, 0xe55, 0xe15, 0xf1d, 0xd12, 0xe75, 0xe35, 0x123a,
1557 0xd0a, 0xe65, 0xe25, 0x121a, 0xe05, 0xe85, 0xe45, 0x125a,
1558 0xd06, 0xe5d, 0xe1d, 0x120a, 0xd16, 0xe7d, 0xe3d, 0x124a,
1559 0xd0e, 0xe6d, 0xe2d, 0x122a, 0xe0d, 0xe8d, 0xe4d, 0x126a,
1560 0xd01, 0xe53, 0xe13, 0xf1b, 0xd11, 0xe73, 0xe33, 0x1236,
1561 0xd09, 0xe63, 0xe23, 0x1216, 0xe03, 0xe83, 0xe43, 0x1256,
1562 0xd05, 0xe5b, 0xe1b, 0x1206, 0xd15, 0xe7b, 0xe3b, 0x1246,
1563 0xd0d, 0xe6b, 0xe2b, 0x1226, 0xe0b, 0xe8b, 0xe4b, 0x1266,
1564 0xd03, 0xe57, 0xe17, 0xf1f, 0xd13, 0xe77, 0xe37, 0x123e,
1565 0xd0b, 0xe67, 0xe27, 0x121e, 0xe07, 0xe87, 0xe47, 0x125e,
1566 0xd07, 0xe5f, 0xe1f, 0x120e, 0xd17, 0xe7f, 0xe3f, 0x124e,
1567 0xd0f, 0xe6f, 0xe2f, 0x122e, 0xe0f, 0xe8f, 0xe4f, 0x126e,
1568 0x290, 0x291, 0x292, 0x293, 0x294, 0x295, 0x296, 0x297,
1569 0x298, 0x299, 0x29a, 0x29b, 0x29c, 0x29d, 0x29e, 0x29f,
1570 0x2a0, 0x2a1, 0x2a2, 0x2a3, 0x2a4, 0x2a5, 0x2a6, 0x2a7,
1571 0x2a8, 0x2a9, 0x2aa, 0x2ab, 0x2ac, 0x2ad, 0x2ae, 0x2af,
1572 0x2b0, 0x2b1, 0x2b2, 0x2b3, 0x2b4, 0x2b5, 0x2b6, 0x2b7,
1573 0x2b8, 0x2b9, 0x2ba, 0x2bb, 0x2bc, 0x2bd, 0x2be, 0x2bf,
1574 0x2c0, 0x2c1, 0x2c2, 0x2c3, 0x2c4, 0x2c5, 0x2c6, 0x2c7,
1575 0x2c8, 0x2c9, 0x2ca, 0x2cb, 0x2cc, 0x2cd, 0x2ce, 0x2cf,
1576 0x2d0, 0x2d1, 0x2d2, 0x2d3, 0x2d4, 0x2d5, 0x2d6, 0x2d7,
1577 0x2d8, 0x2d9, 0x2da, 0x2db, 0x2dc, 0x2dd, 0x2de, 0x2df,
1578 0x2e0, 0x2e1, 0x2e2, 0x2e3, 0x2e4, 0x2e5, 0x2e6, 0x2e7,
1579 0x2e8, 0x2e9, 0x2ea, 0x2eb, 0x2ec, 0x2ed, 0x2ee, 0x2ef,
1580 0x2f0, 0x2f1, 0x2f2, 0x2f3, 0x2f4, 0x2f5, 0x2f6, 0x2f7,
1581 0x2f8, 0x2f9, 0x2fa, 0x2fb, 0x2fc, 0x2fd, 0x2fe, 0x2ff,
1584 static const uint16_t elf_zlib_default_dist_table
[0x100] =
1586 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1587 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1588 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1589 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1590 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1591 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1592 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1593 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1594 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1595 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1596 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1597 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1598 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1599 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1600 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1601 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1602 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1603 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1604 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1605 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1606 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1607 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1608 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1609 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1610 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1611 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1612 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1613 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1614 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1615 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1616 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1617 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1620 /* Inflate a zlib stream from PIN/SIN to POUT/SOUT. Return 1 on
1621 success, 0 on some error parsing the stream. */
1624 elf_zlib_inflate (const unsigned char *pin
, size_t sin
, uint16_t *zdebug_table
,
1625 unsigned char *pout
, size_t sout
)
1627 unsigned char *porigout
;
1628 const unsigned char *pinend
;
1629 unsigned char *poutend
;
1631 /* We can apparently see multiple zlib streams concatenated
1632 together, so keep going as long as there is something to read.
1633 The last 4 bytes are the checksum. */
1636 poutend
= pout
+ sout
;
1637 while ((pinend
- pin
) > 4)
1643 /* Read the two byte zlib header. */
1645 if (unlikely ((pin
[0] & 0xf) != 8)) /* 8 is zlib encoding. */
1647 /* Unknown compression method. */
1651 if (unlikely ((pin
[0] >> 4) > 7))
1653 /* Window size too large. Other than this check, we don't
1654 care about the window size. */
1658 if (unlikely ((pin
[1] & 0x20) != 0))
1660 /* Stream expects a predefined dictionary, but we have no
1665 val
= (pin
[0] << 8) | pin
[1];
1666 if (unlikely (val
% 31 != 0))
1668 /* Header check failure. */
1674 /* Align PIN to a 32-bit boundary. */
1678 while ((((uintptr_t) pin
) & 3) != 0)
1680 val
|= (uint64_t)*pin
<< bits
;
1685 /* Read blocks until one is marked last. */
1692 const uint16_t *tlit
;
1693 const uint16_t *tdist
;
1695 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1699 type
= (val
>> 1) & 3;
1703 if (unlikely (type
== 3))
1705 /* Invalid block type. */
1715 /* An uncompressed block. */
1717 /* If we've read ahead more than a byte, back up. */
1726 if (unlikely ((pinend
- pin
) < 4))
1728 /* Missing length. */
1732 len
= pin
[0] | (pin
[1] << 8);
1733 lenc
= pin
[2] | (pin
[3] << 8);
1736 if (unlikely (len
!= lenc
))
1742 if (unlikely (len
> (unsigned int) (pinend
- pin
)
1743 || len
> (unsigned int) (poutend
- pout
)))
1745 /* Not enough space in buffers. */
1749 memcpy (pout
, pin
, len
);
1754 while ((((uintptr_t) pin
) & 3) != 0)
1756 val
|= (uint64_t)*pin
<< bits
;
1761 /* Go around to read the next block. */
1767 tlit
= elf_zlib_default_table
;
1768 tdist
= elf_zlib_default_dist_table
;
1775 unsigned char codebits
[19];
1776 unsigned char *plenbase
;
1777 unsigned char *plen
;
1778 unsigned char *plenend
;
1780 /* Read a Huffman encoding table. The various magic
1781 numbers here are from RFC 1951. */
1783 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1786 nlit
= (val
& 0x1f) + 257;
1788 ndist
= (val
& 0x1f) + 1;
1790 nclen
= (val
& 0xf) + 4;
1793 if (unlikely (nlit
> 286 || ndist
> 30))
1795 /* Values out of range. */
1800 /* Read and build the table used to compress the
1801 literal, length, and distance codes. */
1803 memset(&codebits
[0], 0, 19);
1805 /* There are always at least 4 elements in the
1808 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1811 codebits
[16] = val
& 7;
1812 codebits
[17] = (val
>> 3) & 7;
1813 codebits
[18] = (val
>> 6) & 7;
1814 codebits
[0] = (val
>> 9) & 7;
1821 codebits
[8] = val
& 7;
1828 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1831 codebits
[7] = val
& 7;
1838 codebits
[9] = val
& 7;
1845 codebits
[6] = val
& 7;
1852 codebits
[10] = val
& 7;
1859 codebits
[5] = val
& 7;
1866 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1869 codebits
[11] = val
& 7;
1876 codebits
[4] = val
& 7;
1883 codebits
[12] = val
& 7;
1890 codebits
[3] = val
& 7;
1897 codebits
[13] = val
& 7;
1904 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1907 codebits
[2] = val
& 7;
1914 codebits
[14] = val
& 7;
1921 codebits
[1] = val
& 7;
1928 codebits
[15] = val
& 7;
1934 if (!elf_zlib_inflate_table (codebits
, 19, zdebug_table
,
1938 /* Read the compressed bit lengths of the literal,
1939 length, and distance codes. We have allocated space
1940 at the end of zdebug_table to hold them. */
1942 plenbase
= (((unsigned char *) zdebug_table
)
1943 + ZDEBUG_TABLE_CODELEN_OFFSET
);
1945 plenend
= plen
+ nlit
+ ndist
;
1946 while (plen
< plenend
)
1952 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1955 t
= zdebug_table
[val
& 0xff];
1957 /* The compression here uses bit lengths up to 7, so
1958 a secondary table is never necessary. */
1959 if (unlikely ((t
& (1U << HUFFMAN_SECONDARY_SHIFT
)) != 0))
1965 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
1969 v
= t
& HUFFMAN_VALUE_MASK
;
1977 /* Copy previous entry 3 to 6 times. */
1979 if (unlikely (plen
== plenbase
))
1985 /* We used up to 7 bits since the last
1986 elf_zlib_fetch, so we have at least 8 bits
1989 c
= 3 + (val
& 0x3);
1992 if (unlikely ((unsigned int) (plenend
- plen
) < c
))
2018 /* Store zero 3 to 10 times. */
2020 /* We used up to 7 bits since the last
2021 elf_zlib_fetch, so we have at least 8 bits
2024 c
= 3 + (val
& 0x7);
2027 if (unlikely ((unsigned int) (plenend
- plen
) < c
))
2064 /* Store zero 11 to 138 times. */
2066 /* We used up to 7 bits since the last
2067 elf_zlib_fetch, so we have at least 8 bits
2070 c
= 11 + (val
& 0x7f);
2073 if (unlikely ((unsigned int) (plenend
- plen
) < c
))
2079 memset (plen
, 0, c
);
2089 /* Make sure that the stop code can appear. */
2092 if (unlikely (plen
[256] == 0))
2098 /* Build the decompression tables. */
2100 if (!elf_zlib_inflate_table (plen
, nlit
, zdebug_table
,
2103 if (!elf_zlib_inflate_table (plen
+ nlit
, ndist
, zdebug_table
,
2104 zdebug_table
+ HUFFMAN_TABLE_SIZE
))
2106 tlit
= zdebug_table
;
2107 tdist
= zdebug_table
+ HUFFMAN_TABLE_SIZE
;
2110 /* Inflate values until the end of the block. This is the
2111 main loop of the inflation code. */
2120 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
2123 t
= tlit
[val
& 0xff];
2124 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
2125 v
= t
& HUFFMAN_VALUE_MASK
;
2127 if ((t
& (1U << HUFFMAN_SECONDARY_SHIFT
)) == 0)
2135 t
= tlit
[v
+ 0x100 + ((val
>> 8) & ((1U << b
) - 1))];
2136 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
2137 lit
= t
& HUFFMAN_VALUE_MASK
;
2144 if (unlikely (pout
== poutend
))
2152 /* We will need to write the next byte soon. We ask
2153 for high temporal locality because we will write
2154 to the whole cache line soon. */
2155 __builtin_prefetch (pout
, 1, 3);
2157 else if (lit
== 256)
2159 /* The end of the block. */
2167 /* Convert lit into a length. */
2170 len
= lit
- 257 + 3;
2171 else if (lit
== 285)
2173 else if (unlikely (lit
> 285))
2182 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
2185 /* This is an expression for the table of length
2186 codes in RFC 1951 3.2.5. */
2188 extra
= (lit
>> 2) + 1;
2189 len
= (lit
& 3) << extra
;
2191 len
+= ((1U << (extra
- 1)) - 1) << 3;
2192 len
+= val
& ((1U << extra
) - 1);
2197 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
2200 t
= tdist
[val
& 0xff];
2201 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
2202 v
= t
& HUFFMAN_VALUE_MASK
;
2204 if ((t
& (1U << HUFFMAN_SECONDARY_SHIFT
)) == 0)
2212 t
= tdist
[v
+ 0x100 + ((val
>> 8) & ((1U << b
) - 1))];
2213 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
2214 dist
= t
& HUFFMAN_VALUE_MASK
;
2219 /* Convert dist to a distance. */
2223 /* A distance of 1. A common case, meaning
2224 repeat the last character LEN times. */
2226 if (unlikely (pout
== porigout
))
2232 if (unlikely ((unsigned int) (poutend
- pout
) < len
))
2238 memset (pout
, pout
[-1], len
);
2241 else if (unlikely (dist
> 29))
2254 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
2257 /* This is an expression for the table of
2258 distance codes in RFC 1951 3.2.5. */
2260 extra
= (dist
>> 1) + 1;
2261 dist
= (dist
& 1) << extra
;
2263 dist
+= ((1U << (extra
- 1)) - 1) << 2;
2264 dist
+= val
& ((1U << extra
) - 1);
2269 /* Go back dist bytes, and copy len bytes from
2272 if (unlikely ((unsigned int) (pout
- porigout
) < dist
))
2278 if (unlikely ((unsigned int) (poutend
- pout
) < len
))
2286 memcpy (pout
, pout
- dist
, len
);
2295 copy
= len
< dist
? len
: dist
;
2296 memcpy (pout
, pout
- dist
, copy
);
2307 /* We should have filled the output buffer. */
2308 if (unlikely (pout
!= poutend
))
2317 /* Verify the zlib checksum. The checksum is in the 4 bytes at
2318 CHECKBYTES, and the uncompressed data is at UNCOMPRESSED /
2319 UNCOMPRESSED_SIZE. Returns 1 on success, 0 on failure. */
2322 elf_zlib_verify_checksum (const unsigned char *checkbytes
,
2323 const unsigned char *uncompressed
,
2324 size_t uncompressed_size
)
2328 const unsigned char *p
;
2334 for (i
= 0; i
< 4; i
++)
2335 cksum
= (cksum
<< 8) | checkbytes
[i
];
2340 /* Minimize modulo operations. */
2343 hsz
= uncompressed_size
;
2346 for (i
= 0; i
< 5552; i
+= 16)
2348 /* Manually unroll loop 16 times. */
2389 /* Manually unroll loop 16 times. */
2426 for (i
= 0; i
< hsz
; ++i
)
2435 if (unlikely ((s2
<< 16) + s1
!= cksum
))
2444 /* Inflate a zlib stream from PIN/SIN to POUT/SOUT, and verify the
2445 checksum. Return 1 on success, 0 on error. */
2448 elf_zlib_inflate_and_verify (const unsigned char *pin
, size_t sin
,
2449 uint16_t *zdebug_table
, unsigned char *pout
,
2452 if (!elf_zlib_inflate (pin
, sin
, zdebug_table
, pout
, sout
))
2454 if (!elf_zlib_verify_checksum (pin
+ sin
- 4, pout
, sout
))
2459 /* Uncompress the old compressed debug format, the one emitted by
2460 --compress-debug-sections=zlib-gnu. The compressed data is in
2461 COMPRESSED / COMPRESSED_SIZE, and the function writes to
2462 *UNCOMPRESSED / *UNCOMPRESSED_SIZE. ZDEBUG_TABLE is work space to
2463 hold Huffman tables. Returns 0 on error, 1 on successful
2464 decompression or if something goes wrong. In general we try to
2465 carry on, by returning 1, even if we can't decompress. */
2468 elf_uncompress_zdebug (struct backtrace_state
*state
,
2469 const unsigned char *compressed
, size_t compressed_size
,
2470 uint16_t *zdebug_table
,
2471 backtrace_error_callback error_callback
, void *data
,
2472 unsigned char **uncompressed
, size_t *uncompressed_size
)
2478 *uncompressed
= NULL
;
2479 *uncompressed_size
= 0;
2481 /* The format starts with the four bytes ZLIB, followed by the 8
2482 byte length of the uncompressed data in big-endian order,
2483 followed by a zlib stream. */
2485 if (compressed_size
< 12 || memcmp (compressed
, "ZLIB", 4) != 0)
2489 for (i
= 0; i
< 8; i
++)
2490 sz
= (sz
<< 8) | compressed
[i
+ 4];
2492 if (*uncompressed
!= NULL
&& *uncompressed_size
>= sz
)
2496 po
= (unsigned char *) backtrace_alloc (state
, sz
, error_callback
, data
);
2501 if (!elf_zlib_inflate_and_verify (compressed
+ 12, compressed_size
- 12,
2502 zdebug_table
, po
, sz
))
2506 *uncompressed_size
= sz
;
2511 /* Uncompress the new compressed debug format, the official standard
2512 ELF approach emitted by --compress-debug-sections=zlib-gabi. The
2513 compressed data is in COMPRESSED / COMPRESSED_SIZE, and the
2514 function writes to *UNCOMPRESSED / *UNCOMPRESSED_SIZE.
2515 ZDEBUG_TABLE is work space as for elf_uncompress_zdebug. Returns 0
2516 on error, 1 on successful decompression or if something goes wrong.
2517 In general we try to carry on, by returning 1, even if we can't
2521 elf_uncompress_chdr (struct backtrace_state
*state
,
2522 const unsigned char *compressed
, size_t compressed_size
,
2523 uint16_t *zdebug_table
,
2524 backtrace_error_callback error_callback
, void *data
,
2525 unsigned char **uncompressed
, size_t *uncompressed_size
)
2527 const b_elf_chdr
*chdr
;
2530 *uncompressed
= NULL
;
2531 *uncompressed_size
= 0;
2533 /* The format starts with an ELF compression header. */
2534 if (compressed_size
< sizeof (b_elf_chdr
))
2537 chdr
= (const b_elf_chdr
*) compressed
;
2539 if (chdr
->ch_type
!= ELFCOMPRESS_ZLIB
)
2541 /* Unsupported compression algorithm. */
2545 if (*uncompressed
!= NULL
&& *uncompressed_size
>= chdr
->ch_size
)
2549 po
= (unsigned char *) backtrace_alloc (state
, chdr
->ch_size
,
2550 error_callback
, data
);
2555 if (!elf_zlib_inflate_and_verify (compressed
+ sizeof (b_elf_chdr
),
2556 compressed_size
- sizeof (b_elf_chdr
),
2557 zdebug_table
, po
, chdr
->ch_size
))
2561 *uncompressed_size
= chdr
->ch_size
;
2566 /* This function is a hook for testing the zlib support. It is only
2570 backtrace_uncompress_zdebug (struct backtrace_state
*state
,
2571 const unsigned char *compressed
,
2572 size_t compressed_size
,
2573 backtrace_error_callback error_callback
,
2574 void *data
, unsigned char **uncompressed
,
2575 size_t *uncompressed_size
)
2577 uint16_t *zdebug_table
;
2580 zdebug_table
= ((uint16_t *) backtrace_alloc (state
, ZDEBUG_TABLE_SIZE
,
2581 error_callback
, data
));
2582 if (zdebug_table
== NULL
)
2584 ret
= elf_uncompress_zdebug (state
, compressed
, compressed_size
,
2585 zdebug_table
, error_callback
, data
,
2586 uncompressed
, uncompressed_size
);
2587 backtrace_free (state
, zdebug_table
, ZDEBUG_TABLE_SIZE
,
2588 error_callback
, data
);
2592 /* Add the backtrace data for one ELF file. Returns 1 on success,
2593 0 on failure (in both cases descriptor is closed) or -1 if exe
2594 is non-zero and the ELF file is ET_DYN, which tells the caller that
2595 elf_add will need to be called on the descriptor again after
2596 base_address is determined. */
2599 elf_add (struct backtrace_state
*state
, const char *filename
, int descriptor
,
2600 uintptr_t base_address
, backtrace_error_callback error_callback
,
2601 void *data
, fileline
*fileline_fn
, int *found_sym
, int *found_dwarf
,
2602 int exe
, int debuginfo
)
2604 struct backtrace_view ehdr_view
;
2608 unsigned int shstrndx
;
2609 struct backtrace_view shdrs_view
;
2610 int shdrs_view_valid
;
2611 const b_elf_shdr
*shdrs
;
2612 const b_elf_shdr
*shstrhdr
;
2615 struct backtrace_view names_view
;
2616 int names_view_valid
;
2618 unsigned int symtab_shndx
;
2619 unsigned int dynsym_shndx
;
2621 struct debug_section_info sections
[DEBUG_MAX
];
2622 struct backtrace_view symtab_view
;
2623 int symtab_view_valid
;
2624 struct backtrace_view strtab_view
;
2625 int strtab_view_valid
;
2626 struct backtrace_view buildid_view
;
2627 int buildid_view_valid
;
2628 const char *buildid_data
;
2629 uint32_t buildid_size
;
2630 struct backtrace_view debuglink_view
;
2631 int debuglink_view_valid
;
2632 const char *debuglink_name
;
2633 uint32_t debuglink_crc
;
2636 struct backtrace_view debug_view
;
2637 int debug_view_valid
;
2638 unsigned int using_debug_view
;
2639 uint16_t *zdebug_table
;
2647 shdrs_view_valid
= 0;
2648 names_view_valid
= 0;
2649 symtab_view_valid
= 0;
2650 strtab_view_valid
= 0;
2651 buildid_view_valid
= 0;
2652 buildid_data
= NULL
;
2654 debuglink_view_valid
= 0;
2655 debuglink_name
= NULL
;
2657 debug_view_valid
= 0;
2659 if (!backtrace_get_view (state
, descriptor
, 0, sizeof ehdr
, error_callback
,
2663 memcpy (&ehdr
, ehdr_view
.data
, sizeof ehdr
);
2665 backtrace_release_view (state
, &ehdr_view
, error_callback
, data
);
2667 if (ehdr
.e_ident
[EI_MAG0
] != ELFMAG0
2668 || ehdr
.e_ident
[EI_MAG1
] != ELFMAG1
2669 || ehdr
.e_ident
[EI_MAG2
] != ELFMAG2
2670 || ehdr
.e_ident
[EI_MAG3
] != ELFMAG3
)
2672 error_callback (data
, "executable file is not ELF", 0);
2675 if (ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
)
2677 error_callback (data
, "executable file is unrecognized ELF version", 0);
2681 #if BACKTRACE_ELF_SIZE == 32
2682 #define BACKTRACE_ELFCLASS ELFCLASS32
2684 #define BACKTRACE_ELFCLASS ELFCLASS64
2687 if (ehdr
.e_ident
[EI_CLASS
] != BACKTRACE_ELFCLASS
)
2689 error_callback (data
, "executable file is unexpected ELF class", 0);
2693 if (ehdr
.e_ident
[EI_DATA
] != ELFDATA2LSB
2694 && ehdr
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
2696 error_callback (data
, "executable file has unknown endianness", 0);
2700 /* If the executable is ET_DYN, it is either a PIE, or we are running
2701 directly a shared library with .interp. We need to wait for
2702 dl_iterate_phdr in that case to determine the actual base_address. */
2703 if (exe
&& ehdr
.e_type
== ET_DYN
)
2706 shoff
= ehdr
.e_shoff
;
2707 shnum
= ehdr
.e_shnum
;
2708 shstrndx
= ehdr
.e_shstrndx
;
2710 if ((shnum
== 0 || shstrndx
== SHN_XINDEX
)
2713 struct backtrace_view shdr_view
;
2714 const b_elf_shdr
*shdr
;
2716 if (!backtrace_get_view (state
, descriptor
, shoff
, sizeof shdr
,
2717 error_callback
, data
, &shdr_view
))
2720 shdr
= (const b_elf_shdr
*) shdr_view
.data
;
2723 shnum
= shdr
->sh_size
;
2725 if (shstrndx
== SHN_XINDEX
)
2727 shstrndx
= shdr
->sh_link
;
2729 /* Versions of the GNU binutils between 2.12 and 2.18 did
2730 not handle objects with more than SHN_LORESERVE sections
2731 correctly. All large section indexes were offset by
2732 0x100. There is more information at
2733 http://sourceware.org/bugzilla/show_bug.cgi?id-5900 .
2734 Fortunately these object files are easy to detect, as the
2735 GNU binutils always put the section header string table
2736 near the end of the list of sections. Thus if the
2737 section header string table index is larger than the
2738 number of sections, then we know we have to subtract
2739 0x100 to get the real section index. */
2740 if (shstrndx
>= shnum
&& shstrndx
>= SHN_LORESERVE
+ 0x100)
2744 backtrace_release_view (state
, &shdr_view
, error_callback
, data
);
2747 /* To translate PC to file/line when using DWARF, we need to find
2748 the .debug_info and .debug_line sections. */
2750 /* Read the section headers, skipping the first one. */
2752 if (!backtrace_get_view (state
, descriptor
, shoff
+ sizeof (b_elf_shdr
),
2753 (shnum
- 1) * sizeof (b_elf_shdr
),
2754 error_callback
, data
, &shdrs_view
))
2756 shdrs_view_valid
= 1;
2757 shdrs
= (const b_elf_shdr
*) shdrs_view
.data
;
2759 /* Read the section names. */
2761 shstrhdr
= &shdrs
[shstrndx
- 1];
2762 shstr_size
= shstrhdr
->sh_size
;
2763 shstr_off
= shstrhdr
->sh_offset
;
2765 if (!backtrace_get_view (state
, descriptor
, shstr_off
, shstr_size
,
2766 error_callback
, data
, &names_view
))
2768 names_view_valid
= 1;
2769 names
= (const char *) names_view
.data
;
2774 memset (sections
, 0, sizeof sections
);
2776 /* Look for the symbol table. */
2777 for (i
= 1; i
< shnum
; ++i
)
2779 const b_elf_shdr
*shdr
;
2780 unsigned int sh_name
;
2784 shdr
= &shdrs
[i
- 1];
2786 if (shdr
->sh_type
== SHT_SYMTAB
)
2788 else if (shdr
->sh_type
== SHT_DYNSYM
)
2791 sh_name
= shdr
->sh_name
;
2792 if (sh_name
>= shstr_size
)
2794 error_callback (data
, "ELF section name out of range", 0);
2798 name
= names
+ sh_name
;
2800 for (j
= 0; j
< (int) DEBUG_MAX
; ++j
)
2802 if (strcmp (name
, debug_section_names
[j
]) == 0)
2804 sections
[j
].offset
= shdr
->sh_offset
;
2805 sections
[j
].size
= shdr
->sh_size
;
2806 sections
[j
].compressed
= (shdr
->sh_flags
& SHF_COMPRESSED
) != 0;
2811 /* Read the build ID if present. This could check for any
2812 SHT_NOTE section with the right note name and type, but gdb
2813 looks for a specific section name. */
2815 && !buildid_view_valid
2816 && strcmp (name
, ".note.gnu.build-id") == 0)
2818 const b_elf_note
*note
;
2820 if (!backtrace_get_view (state
, descriptor
, shdr
->sh_offset
,
2821 shdr
->sh_size
, error_callback
, data
,
2825 buildid_view_valid
= 1;
2826 note
= (const b_elf_note
*) buildid_view
.data
;
2827 if (note
->type
== NT_GNU_BUILD_ID
2828 && note
->namesz
== 4
2829 && strncmp (note
->name
, "GNU", 4) == 0
2830 && shdr
->sh_size
< 12 + ((note
->namesz
+ 3) & ~ 3) + note
->descsz
)
2832 buildid_data
= ¬e
->name
[0] + ((note
->namesz
+ 3) & ~ 3);
2833 buildid_size
= note
->descsz
;
2837 /* Read the debuglink file if present. */
2839 && !debuglink_view_valid
2840 && strcmp (name
, ".gnu_debuglink") == 0)
2842 const char *debuglink_data
;
2845 if (!backtrace_get_view (state
, descriptor
, shdr
->sh_offset
,
2846 shdr
->sh_size
, error_callback
, data
,
2850 debuglink_view_valid
= 1;
2851 debuglink_data
= (const char *) debuglink_view
.data
;
2852 crc_offset
= strnlen (debuglink_data
, shdr
->sh_size
);
2853 crc_offset
= (crc_offset
+ 3) & ~3;
2854 if (crc_offset
+ 4 <= shdr
->sh_size
)
2856 debuglink_name
= debuglink_data
;
2857 debuglink_crc
= *(const uint32_t*)(debuglink_data
+ crc_offset
);
2862 if (symtab_shndx
== 0)
2863 symtab_shndx
= dynsym_shndx
;
2864 if (symtab_shndx
!= 0 && !debuginfo
)
2866 const b_elf_shdr
*symtab_shdr
;
2867 unsigned int strtab_shndx
;
2868 const b_elf_shdr
*strtab_shdr
;
2869 struct elf_syminfo_data
*sdata
;
2871 symtab_shdr
= &shdrs
[symtab_shndx
- 1];
2872 strtab_shndx
= symtab_shdr
->sh_link
;
2873 if (strtab_shndx
>= shnum
)
2875 error_callback (data
,
2876 "ELF symbol table strtab link out of range", 0);
2879 strtab_shdr
= &shdrs
[strtab_shndx
- 1];
2881 if (!backtrace_get_view (state
, descriptor
, symtab_shdr
->sh_offset
,
2882 symtab_shdr
->sh_size
, error_callback
, data
,
2885 symtab_view_valid
= 1;
2887 if (!backtrace_get_view (state
, descriptor
, strtab_shdr
->sh_offset
,
2888 strtab_shdr
->sh_size
, error_callback
, data
,
2891 strtab_view_valid
= 1;
2893 sdata
= ((struct elf_syminfo_data
*)
2894 backtrace_alloc (state
, sizeof *sdata
, error_callback
, data
));
2898 if (!elf_initialize_syminfo (state
, base_address
,
2899 symtab_view
.data
, symtab_shdr
->sh_size
,
2900 strtab_view
.data
, strtab_shdr
->sh_size
,
2901 error_callback
, data
, sdata
))
2903 backtrace_free (state
, sdata
, sizeof *sdata
, error_callback
, data
);
2907 /* We no longer need the symbol table, but we hold on to the
2908 string table permanently. */
2909 backtrace_release_view (state
, &symtab_view
, error_callback
, data
);
2910 symtab_view_valid
= 0;
2914 elf_add_syminfo_data (state
, sdata
);
2917 backtrace_release_view (state
, &shdrs_view
, error_callback
, data
);
2918 shdrs_view_valid
= 0;
2919 backtrace_release_view (state
, &names_view
, error_callback
, data
);
2920 names_view_valid
= 0;
2922 /* If the debug info is in a separate file, read that one instead. */
2924 if (buildid_data
!= NULL
)
2928 d
= elf_open_debugfile_by_buildid (state
, buildid_data
, buildid_size
,
2929 error_callback
, data
);
2934 backtrace_release_view (state
, &buildid_view
, error_callback
, data
);
2935 if (debuglink_view_valid
)
2936 backtrace_release_view (state
, &debuglink_view
, error_callback
,
2938 ret
= elf_add (state
, NULL
, d
, base_address
, error_callback
, data
,
2939 fileline_fn
, found_sym
, found_dwarf
, 0, 1);
2941 backtrace_close (d
, error_callback
, data
);
2943 backtrace_close (descriptor
, error_callback
, data
);
2948 if (buildid_view_valid
)
2950 backtrace_release_view (state
, &buildid_view
, error_callback
, data
);
2951 buildid_view_valid
= 0;
2954 if (debuglink_name
!= NULL
)
2958 d
= elf_open_debugfile_by_debuglink (state
, filename
, debuglink_name
,
2959 debuglink_crc
, error_callback
,
2965 backtrace_release_view (state
, &debuglink_view
, error_callback
,
2967 ret
= elf_add (state
, NULL
, d
, base_address
, error_callback
, data
,
2968 fileline_fn
, found_sym
, found_dwarf
, 0, 1);
2970 backtrace_close (d
, error_callback
, data
);
2972 backtrace_close(descriptor
, error_callback
, data
);
2977 if (debuglink_view_valid
)
2979 backtrace_release_view (state
, &debuglink_view
, error_callback
, data
);
2980 debuglink_view_valid
= 0;
2983 /* Read all the debug sections in a single view, since they are
2984 probably adjacent in the file. We never release this view. */
2988 for (i
= 0; i
< (int) DEBUG_MAX
; ++i
)
2992 if (sections
[i
].size
== 0)
2994 if (min_offset
== 0 || sections
[i
].offset
< min_offset
)
2995 min_offset
= sections
[i
].offset
;
2996 end
= sections
[i
].offset
+ sections
[i
].size
;
2997 if (end
> max_offset
)
3000 if (min_offset
== 0 || max_offset
== 0)
3002 if (!backtrace_close (descriptor
, error_callback
, data
))
3007 if (!backtrace_get_view (state
, descriptor
, min_offset
,
3008 max_offset
- min_offset
,
3009 error_callback
, data
, &debug_view
))
3011 debug_view_valid
= 1;
3013 /* We've read all we need from the executable. */
3014 if (!backtrace_close (descriptor
, error_callback
, data
))
3018 using_debug_view
= 0;
3019 for (i
= 0; i
< (int) DEBUG_MAX
; ++i
)
3021 if (sections
[i
].size
== 0)
3022 sections
[i
].data
= NULL
;
3025 sections
[i
].data
= ((const unsigned char *) debug_view
.data
3026 + (sections
[i
].offset
- min_offset
));
3027 if (i
< ZDEBUG_INFO
)
3032 /* Uncompress the old format (--compress-debug-sections=zlib-gnu). */
3034 zdebug_table
= NULL
;
3035 for (i
= 0; i
< ZDEBUG_INFO
; ++i
)
3037 struct debug_section_info
*pz
;
3039 pz
= §ions
[i
+ ZDEBUG_INFO
- DEBUG_INFO
];
3040 if (sections
[i
].size
== 0 && pz
->size
> 0)
3042 unsigned char *uncompressed_data
;
3043 size_t uncompressed_size
;
3045 if (zdebug_table
== NULL
)
3047 zdebug_table
= ((uint16_t *)
3048 backtrace_alloc (state
, ZDEBUG_TABLE_SIZE
,
3049 error_callback
, data
));
3050 if (zdebug_table
== NULL
)
3054 uncompressed_data
= NULL
;
3055 uncompressed_size
= 0;
3056 if (!elf_uncompress_zdebug (state
, pz
->data
, pz
->size
, zdebug_table
,
3057 error_callback
, data
,
3058 &uncompressed_data
, &uncompressed_size
))
3060 sections
[i
].data
= uncompressed_data
;
3061 sections
[i
].size
= uncompressed_size
;
3062 sections
[i
].compressed
= 0;
3066 /* Uncompress the official ELF format
3067 (--compress-debug-sections=zlib-gabi). */
3068 for (i
= 0; i
< ZDEBUG_INFO
; ++i
)
3070 unsigned char *uncompressed_data
;
3071 size_t uncompressed_size
;
3073 if (sections
[i
].size
== 0 || !sections
[i
].compressed
)
3076 if (zdebug_table
== NULL
)
3078 zdebug_table
= ((uint16_t *)
3079 backtrace_alloc (state
, ZDEBUG_TABLE_SIZE
,
3080 error_callback
, data
));
3081 if (zdebug_table
== NULL
)
3085 uncompressed_data
= NULL
;
3086 uncompressed_size
= 0;
3087 if (!elf_uncompress_chdr (state
, sections
[i
].data
, sections
[i
].size
,
3088 zdebug_table
, error_callback
, data
,
3089 &uncompressed_data
, &uncompressed_size
))
3091 sections
[i
].data
= uncompressed_data
;
3092 sections
[i
].size
= uncompressed_size
;
3093 sections
[i
].compressed
= 0;
3098 if (zdebug_table
!= NULL
)
3099 backtrace_free (state
, zdebug_table
, ZDEBUG_TABLE_SIZE
,
3100 error_callback
, data
);
3102 if (debug_view_valid
&& using_debug_view
== 0)
3104 backtrace_release_view (state
, &debug_view
, error_callback
, data
);
3105 debug_view_valid
= 0;
3108 if (!backtrace_dwarf_add (state
, base_address
,
3109 sections
[DEBUG_INFO
].data
,
3110 sections
[DEBUG_INFO
].size
,
3111 sections
[DEBUG_LINE
].data
,
3112 sections
[DEBUG_LINE
].size
,
3113 sections
[DEBUG_ABBREV
].data
,
3114 sections
[DEBUG_ABBREV
].size
,
3115 sections
[DEBUG_RANGES
].data
,
3116 sections
[DEBUG_RANGES
].size
,
3117 sections
[DEBUG_STR
].data
,
3118 sections
[DEBUG_STR
].size
,
3119 ehdr
.e_ident
[EI_DATA
] == ELFDATA2MSB
,
3120 error_callback
, data
, fileline_fn
))
3128 if (shdrs_view_valid
)
3129 backtrace_release_view (state
, &shdrs_view
, error_callback
, data
);
3130 if (names_view_valid
)
3131 backtrace_release_view (state
, &names_view
, error_callback
, data
);
3132 if (symtab_view_valid
)
3133 backtrace_release_view (state
, &symtab_view
, error_callback
, data
);
3134 if (strtab_view_valid
)
3135 backtrace_release_view (state
, &strtab_view
, error_callback
, data
);
3136 if (debuglink_view_valid
)
3137 backtrace_release_view (state
, &debuglink_view
, error_callback
, data
);
3138 if (buildid_view_valid
)
3139 backtrace_release_view (state
, &buildid_view
, error_callback
, data
);
3140 if (debug_view_valid
)
3141 backtrace_release_view (state
, &debug_view
, error_callback
, data
);
3142 if (descriptor
!= -1)
3143 backtrace_close (descriptor
, error_callback
, data
);
3147 /* Data passed to phdr_callback. */
3151 struct backtrace_state
*state
;
3152 backtrace_error_callback error_callback
;
3154 fileline
*fileline_fn
;
3157 const char *exe_filename
;
3161 /* Callback passed to dl_iterate_phdr. Load debug info from shared
3166 __attribute__ ((__force_align_arg_pointer__
))
3168 phdr_callback (struct dl_phdr_info
*info
, size_t size ATTRIBUTE_UNUSED
,
3171 struct phdr_data
*pd
= (struct phdr_data
*) pdata
;
3172 const char *filename
;
3175 fileline elf_fileline_fn
;
3178 /* There is not much we can do if we don't have the module name,
3179 unless executable is ET_DYN, where we expect the very first
3180 phdr_callback to be for the PIE. */
3181 if (info
->dlpi_name
== NULL
|| info
->dlpi_name
[0] == '\0')
3183 if (pd
->exe_descriptor
== -1)
3185 filename
= pd
->exe_filename
;
3186 descriptor
= pd
->exe_descriptor
;
3187 pd
->exe_descriptor
= -1;
3191 if (pd
->exe_descriptor
!= -1)
3193 backtrace_close (pd
->exe_descriptor
, pd
->error_callback
, pd
->data
);
3194 pd
->exe_descriptor
= -1;
3197 filename
= info
->dlpi_name
;
3198 descriptor
= backtrace_open (info
->dlpi_name
, pd
->error_callback
,
3199 pd
->data
, &does_not_exist
);
3204 if (elf_add (pd
->state
, filename
, descriptor
, info
->dlpi_addr
,
3205 pd
->error_callback
, pd
->data
, &elf_fileline_fn
, pd
->found_sym
,
3206 &found_dwarf
, 0, 0))
3210 *pd
->found_dwarf
= 1;
3211 *pd
->fileline_fn
= elf_fileline_fn
;
3218 /* Initialize the backtrace data we need from an ELF executable. At
3219 the ELF level, all we need to do is find the debug info
3223 backtrace_initialize (struct backtrace_state
*state
, const char *filename
,
3224 int descriptor
, backtrace_error_callback error_callback
,
3225 void *data
, fileline
*fileline_fn
)
3230 fileline elf_fileline_fn
= elf_nodebug
;
3231 struct phdr_data pd
;
3233 ret
= elf_add (state
, filename
, descriptor
, 0, error_callback
, data
,
3234 &elf_fileline_fn
, &found_sym
, &found_dwarf
, 1, 0);
3239 pd
.error_callback
= error_callback
;
3241 pd
.fileline_fn
= &elf_fileline_fn
;
3242 pd
.found_sym
= &found_sym
;
3243 pd
.found_dwarf
= &found_dwarf
;
3244 pd
.exe_filename
= filename
;
3245 pd
.exe_descriptor
= ret
< 0 ? descriptor
: -1;
3247 dl_iterate_phdr (phdr_callback
, (void *) &pd
);
3249 if (!state
->threaded
)
3252 state
->syminfo_fn
= elf_syminfo
;
3253 else if (state
->syminfo_fn
== NULL
)
3254 state
->syminfo_fn
= elf_nosyms
;
3259 backtrace_atomic_store_pointer (&state
->syminfo_fn
, elf_syminfo
);
3261 (void) __sync_bool_compare_and_swap (&state
->syminfo_fn
, NULL
,
3265 if (!state
->threaded
)
3266 *fileline_fn
= state
->fileline_fn
;
3268 *fileline_fn
= backtrace_atomic_load_pointer (&state
->fileline_fn
);
3270 if (*fileline_fn
== NULL
|| *fileline_fn
== elf_nodebug
)
3271 *fileline_fn
= elf_fileline_fn
;