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 /* Names of sections, indexed by enum dwarf_section in internal.h. */
342 static const char * const dwarf_section_names
[DEBUG_MAX
] =
351 /* Information we gather for the sections we care about. */
353 struct debug_section_info
355 /* Section file offset. */
359 /* Section contents, after read from file. */
360 const unsigned char *data
;
361 /* Whether the SHF_COMPRESSED flag is set for the section. */
365 /* Information we keep for an ELF symbol. */
369 /* The name of the symbol. */
371 /* The address of the symbol. */
373 /* The size of the symbol. */
377 /* Information to pass to elf_syminfo. */
379 struct elf_syminfo_data
381 /* Symbols for the next module. */
382 struct elf_syminfo_data
*next
;
383 /* The ELF symbols, sorted by address. */
384 struct elf_symbol
*symbols
;
385 /* The number of symbols. */
389 /* Information about PowerPC64 ELFv1 .opd section. */
391 struct elf_ppc64_opd_data
393 /* Address of the .opd section. */
397 /* Size of the .opd section. */
399 /* Corresponding section view. */
400 struct backtrace_view view
;
403 /* Compute the CRC-32 of BUF/LEN. This uses the CRC used for
404 .gnu_debuglink files. */
407 elf_crc32 (uint32_t crc
, const unsigned char *buf
, size_t len
)
409 static const uint32_t crc32_table
[256] =
411 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
412 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
413 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
414 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
415 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
416 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
417 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
418 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
419 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
420 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
421 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
422 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
423 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
424 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
425 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
426 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
427 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
428 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
429 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
430 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
431 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
432 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
433 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
434 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
435 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
436 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
437 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
438 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
439 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
440 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
441 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
442 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
443 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
444 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
445 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
446 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
447 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
448 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
449 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
450 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
451 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
452 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
453 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
454 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
455 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
456 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
457 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
458 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
459 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
460 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
461 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
464 const unsigned char *end
;
467 for (end
= buf
+ len
; buf
< end
; ++ buf
)
468 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
472 /* Return the CRC-32 of the entire file open at DESCRIPTOR. */
475 elf_crc32_file (struct backtrace_state
*state
, int descriptor
,
476 backtrace_error_callback error_callback
, void *data
)
479 struct backtrace_view file_view
;
482 if (fstat (descriptor
, &st
) < 0)
484 error_callback (data
, "fstat", errno
);
488 if (!backtrace_get_view (state
, descriptor
, 0, st
.st_size
, error_callback
,
492 ret
= elf_crc32 (0, (const unsigned char *) file_view
.data
, st
.st_size
);
494 backtrace_release_view (state
, &file_view
, error_callback
, data
);
499 /* A dummy callback function used when we can't find any debug info. */
502 elf_nodebug (struct backtrace_state
*state ATTRIBUTE_UNUSED
,
503 uintptr_t pc ATTRIBUTE_UNUSED
,
504 backtrace_full_callback callback ATTRIBUTE_UNUSED
,
505 backtrace_error_callback error_callback
, void *data
)
507 error_callback (data
, "no debug info in ELF executable", -1);
511 /* A dummy callback function used when we can't find a symbol
515 elf_nosyms (struct backtrace_state
*state ATTRIBUTE_UNUSED
,
516 uintptr_t addr ATTRIBUTE_UNUSED
,
517 backtrace_syminfo_callback callback ATTRIBUTE_UNUSED
,
518 backtrace_error_callback error_callback
, void *data
)
520 error_callback (data
, "no symbol table in ELF executable", -1);
523 /* Compare struct elf_symbol for qsort. */
526 elf_symbol_compare (const void *v1
, const void *v2
)
528 const struct elf_symbol
*e1
= (const struct elf_symbol
*) v1
;
529 const struct elf_symbol
*e2
= (const struct elf_symbol
*) v2
;
531 if (e1
->address
< e2
->address
)
533 else if (e1
->address
> e2
->address
)
539 /* Compare an ADDR against an elf_symbol for bsearch. We allocate one
540 extra entry in the array so that this can look safely at the next
544 elf_symbol_search (const void *vkey
, const void *ventry
)
546 const uintptr_t *key
= (const uintptr_t *) vkey
;
547 const struct elf_symbol
*entry
= (const struct elf_symbol
*) ventry
;
551 if (addr
< entry
->address
)
553 else if (addr
>= entry
->address
+ entry
->size
)
559 /* Initialize the symbol table info for elf_syminfo. */
562 elf_initialize_syminfo (struct backtrace_state
*state
,
563 uintptr_t base_address
,
564 const unsigned char *symtab_data
, size_t symtab_size
,
565 const unsigned char *strtab
, size_t strtab_size
,
566 backtrace_error_callback error_callback
,
567 void *data
, struct elf_syminfo_data
*sdata
,
568 struct elf_ppc64_opd_data
*opd
)
571 const b_elf_sym
*sym
;
572 size_t elf_symbol_count
;
573 size_t elf_symbol_size
;
574 struct elf_symbol
*elf_symbols
;
578 sym_count
= symtab_size
/ sizeof (b_elf_sym
);
580 /* We only care about function symbols. Count them. */
581 sym
= (const b_elf_sym
*) symtab_data
;
582 elf_symbol_count
= 0;
583 for (i
= 0; i
< sym_count
; ++i
, ++sym
)
587 info
= sym
->st_info
& 0xf;
588 if ((info
== STT_FUNC
|| info
== STT_OBJECT
)
589 && sym
->st_shndx
!= SHN_UNDEF
)
593 elf_symbol_size
= elf_symbol_count
* sizeof (struct elf_symbol
);
594 elf_symbols
= ((struct elf_symbol
*)
595 backtrace_alloc (state
, elf_symbol_size
, error_callback
,
597 if (elf_symbols
== NULL
)
600 sym
= (const b_elf_sym
*) symtab_data
;
602 for (i
= 0; i
< sym_count
; ++i
, ++sym
)
606 info
= sym
->st_info
& 0xf;
607 if (info
!= STT_FUNC
&& info
!= STT_OBJECT
)
609 if (sym
->st_shndx
== SHN_UNDEF
)
611 if (sym
->st_name
>= strtab_size
)
613 error_callback (data
, "symbol string index out of range", 0);
614 backtrace_free (state
, elf_symbols
, elf_symbol_size
, error_callback
,
618 elf_symbols
[j
].name
= (const char *) strtab
+ sym
->st_name
;
619 /* Special case PowerPC64 ELFv1 symbols in .opd section, if the symbol
620 is a function descriptor, read the actual code address from the
623 && sym
->st_value
>= opd
->addr
624 && sym
->st_value
< opd
->addr
+ opd
->size
)
625 elf_symbols
[j
].address
626 = *(const b_elf_addr
*) (opd
->data
+ (sym
->st_value
- opd
->addr
));
628 elf_symbols
[j
].address
= sym
->st_value
;
629 elf_symbols
[j
].address
+= base_address
;
630 elf_symbols
[j
].size
= sym
->st_size
;
634 backtrace_qsort (elf_symbols
, elf_symbol_count
, sizeof (struct elf_symbol
),
638 sdata
->symbols
= elf_symbols
;
639 sdata
->count
= elf_symbol_count
;
644 /* Add EDATA to the list in STATE. */
647 elf_add_syminfo_data (struct backtrace_state
*state
,
648 struct elf_syminfo_data
*edata
)
650 if (!state
->threaded
)
652 struct elf_syminfo_data
**pp
;
654 for (pp
= (struct elf_syminfo_data
**) (void *) &state
->syminfo_data
;
664 struct elf_syminfo_data
**pp
;
666 pp
= (struct elf_syminfo_data
**) (void *) &state
->syminfo_data
;
670 struct elf_syminfo_data
*p
;
672 p
= backtrace_atomic_load_pointer (pp
);
680 if (__sync_bool_compare_and_swap (pp
, NULL
, edata
))
686 /* Return the symbol name and value for an ADDR. */
689 elf_syminfo (struct backtrace_state
*state
, uintptr_t addr
,
690 backtrace_syminfo_callback callback
,
691 backtrace_error_callback error_callback ATTRIBUTE_UNUSED
,
694 struct elf_syminfo_data
*edata
;
695 struct elf_symbol
*sym
= NULL
;
697 if (!state
->threaded
)
699 for (edata
= (struct elf_syminfo_data
*) state
->syminfo_data
;
703 sym
= ((struct elf_symbol
*)
704 bsearch (&addr
, edata
->symbols
, edata
->count
,
705 sizeof (struct elf_symbol
), elf_symbol_search
));
712 struct elf_syminfo_data
**pp
;
714 pp
= (struct elf_syminfo_data
**) (void *) &state
->syminfo_data
;
717 edata
= backtrace_atomic_load_pointer (pp
);
721 sym
= ((struct elf_symbol
*)
722 bsearch (&addr
, edata
->symbols
, edata
->count
,
723 sizeof (struct elf_symbol
), elf_symbol_search
));
732 callback (data
, addr
, NULL
, 0, 0);
734 callback (data
, addr
, sym
->name
, sym
->address
, sym
->size
);
737 /* Return whether FILENAME is a symlink. */
740 elf_is_symlink (const char *filename
)
744 if (lstat (filename
, &st
) < 0)
746 return S_ISLNK (st
.st_mode
);
749 /* Return the results of reading the symlink FILENAME in a buffer
750 allocated by backtrace_alloc. Return the length of the buffer in
754 elf_readlink (struct backtrace_state
*state
, const char *filename
,
755 backtrace_error_callback error_callback
, void *data
,
766 buf
= backtrace_alloc (state
, len
, error_callback
, data
);
769 rl
= readlink (filename
, buf
, len
);
772 backtrace_free (state
, buf
, len
, error_callback
, data
);
775 if ((size_t) rl
< len
- 1)
781 backtrace_free (state
, buf
, len
, error_callback
, data
);
786 #define SYSTEM_BUILD_ID_DIR "/usr/lib/debug/.build-id/"
788 /* Open a separate debug info file, using the build ID to find it.
789 Returns an open file descriptor, or -1.
791 The GDB manual says that the only place gdb looks for a debug file
792 when the build ID is known is in /usr/lib/debug/.build-id. */
795 elf_open_debugfile_by_buildid (struct backtrace_state
*state
,
796 const char *buildid_data
, size_t buildid_size
,
797 backtrace_error_callback error_callback
,
800 const char * const prefix
= SYSTEM_BUILD_ID_DIR
;
801 const size_t prefix_len
= strlen (prefix
);
802 const char * const suffix
= ".debug";
803 const size_t suffix_len
= strlen (suffix
);
811 len
= prefix_len
+ buildid_size
* 2 + suffix_len
+ 2;
812 bd_filename
= backtrace_alloc (state
, len
, error_callback
, data
);
813 if (bd_filename
== NULL
)
817 memcpy (t
, prefix
, prefix_len
);
819 for (i
= 0; i
< buildid_size
; i
++)
824 b
= (unsigned char) buildid_data
[i
];
825 nib
= (b
& 0xf0) >> 4;
826 *t
++ = nib
< 10 ? '0' + nib
: 'a' + nib
- 10;
828 *t
++ = nib
< 10 ? '0' + nib
: 'a' + nib
- 10;
832 memcpy (t
, suffix
, suffix_len
);
833 t
[suffix_len
] = '\0';
835 ret
= backtrace_open (bd_filename
, error_callback
, data
, &does_not_exist
);
837 backtrace_free (state
, bd_filename
, len
, error_callback
, data
);
839 /* gdb checks that the debuginfo file has the same build ID note.
840 That seems kind of pointless to me--why would it have the right
841 name but not the right build ID?--so skipping the check. */
846 /* Try to open a file whose name is PREFIX (length PREFIX_LEN)
847 concatenated with PREFIX2 (length PREFIX2_LEN) concatenated with
848 DEBUGLINK_NAME. Returns an open file descriptor, or -1. */
851 elf_try_debugfile (struct backtrace_state
*state
, const char *prefix
,
852 size_t prefix_len
, const char *prefix2
, size_t prefix2_len
,
853 const char *debuglink_name
,
854 backtrace_error_callback error_callback
, void *data
)
856 size_t debuglink_len
;
862 debuglink_len
= strlen (debuglink_name
);
863 try_len
= prefix_len
+ prefix2_len
+ debuglink_len
+ 1;
864 try = backtrace_alloc (state
, try_len
, error_callback
, data
);
868 memcpy (try, prefix
, prefix_len
);
869 memcpy (try + prefix_len
, prefix2
, prefix2_len
);
870 memcpy (try + prefix_len
+ prefix2_len
, debuglink_name
, debuglink_len
);
871 try[prefix_len
+ prefix2_len
+ debuglink_len
] = '\0';
873 ret
= backtrace_open (try, error_callback
, data
, &does_not_exist
);
875 backtrace_free (state
, try, try_len
, error_callback
, data
);
880 /* Find a separate debug info file, using the debuglink section data
881 to find it. Returns an open file descriptor, or -1. */
884 elf_find_debugfile_by_debuglink (struct backtrace_state
*state
,
885 const char *filename
,
886 const char *debuglink_name
,
887 backtrace_error_callback error_callback
,
898 /* Resolve symlinks in FILENAME. Since FILENAME is fairly likely to
899 be /proc/self/exe, symlinks are common. We don't try to resolve
900 the whole path name, just the base name. */
904 while (elf_is_symlink (filename
))
909 new_buf
= elf_readlink (state
, filename
, error_callback
, data
, &new_len
);
913 if (new_buf
[0] == '/')
917 slash
= strrchr (filename
, '/');
926 clen
= slash
- filename
+ strlen (new_buf
) + 1;
927 c
= backtrace_alloc (state
, clen
, error_callback
, data
);
931 memcpy (c
, filename
, slash
- filename
);
932 memcpy (c
+ (slash
- filename
), new_buf
, strlen (new_buf
));
933 c
[slash
- filename
+ strlen (new_buf
)] = '\0';
934 backtrace_free (state
, new_buf
, new_len
, error_callback
, data
);
942 backtrace_free (state
, alc
, alc_len
, error_callback
, data
);
947 /* Look for DEBUGLINK_NAME in the same directory as FILENAME. */
949 slash
= strrchr (filename
, '/');
959 prefix_len
= slash
- filename
;
962 ddescriptor
= elf_try_debugfile (state
, prefix
, prefix_len
, "", 0,
963 debuglink_name
, error_callback
, data
);
964 if (ddescriptor
>= 0)
970 /* Look for DEBUGLINK_NAME in a .debug subdirectory of FILENAME. */
972 ddescriptor
= elf_try_debugfile (state
, prefix
, prefix_len
, ".debug/",
973 strlen (".debug/"), debuglink_name
,
974 error_callback
, data
);
975 if (ddescriptor
>= 0)
981 /* Look for DEBUGLINK_NAME in /usr/lib/debug. */
983 ddescriptor
= elf_try_debugfile (state
, "/usr/lib/debug/",
984 strlen ("/usr/lib/debug/"), prefix
,
985 prefix_len
, debuglink_name
,
986 error_callback
, data
);
987 if (ddescriptor
>= 0)
991 if (alc
!= NULL
&& alc_len
> 0)
992 backtrace_free (state
, alc
, alc_len
, error_callback
, data
);
996 /* Open a separate debug info file, using the debuglink section data
997 to find it. Returns an open file descriptor, or -1. */
1000 elf_open_debugfile_by_debuglink (struct backtrace_state
*state
,
1001 const char *filename
,
1002 const char *debuglink_name
,
1003 uint32_t debuglink_crc
,
1004 backtrace_error_callback error_callback
,
1009 ddescriptor
= elf_find_debugfile_by_debuglink (state
, filename
,
1011 error_callback
, data
);
1012 if (ddescriptor
< 0)
1015 if (debuglink_crc
!= 0)
1019 got_crc
= elf_crc32_file (state
, ddescriptor
, error_callback
, data
);
1020 if (got_crc
!= debuglink_crc
)
1022 backtrace_close (ddescriptor
, error_callback
, data
);
1030 /* A function useful for setting a breakpoint for an inflation failure
1031 when this code is compiled with -g. */
1034 elf_zlib_failed(void)
1038 /* *PVAL is the current value being read from the stream, and *PBITS
1039 is the number of valid bits. Ensure that *PVAL holds at least 15
1040 bits by reading additional bits from *PPIN, up to PINEND, as
1041 needed. Updates *PPIN, *PVAL and *PBITS. Returns 1 on success, 0
1045 elf_zlib_fetch (const unsigned char **ppin
, const unsigned char *pinend
,
1046 uint64_t *pval
, unsigned int *pbits
)
1049 const unsigned char *pin
;
1059 if (unlikely (pinend
- pin
< 4))
1065 #if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) \
1066 && defined(__ORDER_BIG_ENDIAN__) \
1067 && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ \
1068 || __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
1069 /* We've ensured that PIN is aligned. */
1070 next
= *(const uint32_t *)pin
;
1072 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
1073 next
= __builtin_bswap32 (next
);
1076 next
= pin
[0] | (pin
[1] << 8) | (pin
[2] << 16) | (pin
[3] << 24);
1079 val
|= (uint64_t)next
<< bits
;
1083 /* We will need the next four bytes soon. */
1084 __builtin_prefetch (pin
, 0, 0);
1092 /* Huffman code tables, like the rest of the zlib format, are defined
1093 by RFC 1951. We store a Huffman code table as a series of tables
1094 stored sequentially in memory. Each entry in a table is 16 bits.
1095 The first, main, table has 256 entries. It is followed by a set of
1096 secondary tables of length 2 to 128 entries. The maximum length of
1097 a code sequence in the deflate format is 15 bits, so that is all we
1098 need. Each secondary table has an index, which is the offset of
1099 the table in the overall memory storage.
1101 The deflate format says that all codes of a given bit length are
1102 lexicographically consecutive. Perhaps we could have 130 values
1103 that require a 15-bit code, perhaps requiring three secondary
1104 tables of size 128. I don't know if this is actually possible, but
1105 it suggests that the maximum size required for secondary tables is
1106 3 * 128 + 3 * 64 ... == 768. The zlib enough program reports 660
1107 as the maximum. We permit 768, since in addition to the 256 for
1108 the primary table, with two bytes per entry, and with the two
1109 tables we need, that gives us a page.
1111 A single table entry needs to store a value or (for the main table
1112 only) the index and size of a secondary table. Values range from 0
1113 to 285, inclusive. Secondary table indexes, per above, range from
1114 0 to 510. For a value we need to store the number of bits we need
1115 to determine that value (one value may appear multiple times in the
1116 table), which is 1 to 8. For a secondary table we need to store
1117 the number of bits used to index into the table, which is 1 to 7.
1118 And of course we need 1 bit to decide whether we have a value or a
1119 secondary table index. So each entry needs 9 bits for value/table
1120 index, 3 bits for size, 1 bit what it is. For simplicity we use 16
1123 /* Number of entries we allocate to for one code table. We get a page
1124 for the two code tables we need. */
1126 #define HUFFMAN_TABLE_SIZE (1024)
1128 /* Bit masks and shifts for the values in the table. */
1130 #define HUFFMAN_VALUE_MASK 0x01ff
1131 #define HUFFMAN_BITS_SHIFT 9
1132 #define HUFFMAN_BITS_MASK 0x7
1133 #define HUFFMAN_SECONDARY_SHIFT 12
1135 /* For working memory while inflating we need two code tables, we need
1136 an array of code lengths (max value 15, so we use unsigned char),
1137 and an array of unsigned shorts used while building a table. The
1138 latter two arrays must be large enough to hold the maximum number
1139 of code lengths, which RFC 1951 defines as 286 + 30. */
1141 #define ZDEBUG_TABLE_SIZE \
1142 (2 * HUFFMAN_TABLE_SIZE * sizeof (uint16_t) \
1143 + (286 + 30) * sizeof (uint16_t) \
1144 + (286 + 30) * sizeof (unsigned char))
1146 #define ZDEBUG_TABLE_CODELEN_OFFSET \
1147 (2 * HUFFMAN_TABLE_SIZE * sizeof (uint16_t) \
1148 + (286 + 30) * sizeof (uint16_t))
1150 #define ZDEBUG_TABLE_WORK_OFFSET \
1151 (2 * HUFFMAN_TABLE_SIZE * sizeof (uint16_t))
1153 #ifdef BACKTRACE_GENERATE_FIXED_HUFFMAN_TABLE
1155 /* Used by the main function that generates the fixed table to learn
1157 static size_t final_next_secondary
;
1161 /* Build a Huffman code table from an array of lengths in CODES of
1162 length CODES_LEN. The table is stored into *TABLE. ZDEBUG_TABLE
1163 is the same as for elf_zlib_inflate, used to find some work space.
1164 Returns 1 on success, 0 on error. */
1167 elf_zlib_inflate_table (unsigned char *codes
, size_t codes_len
,
1168 uint16_t *zdebug_table
, uint16_t *table
)
1173 uint16_t firstcode
[7];
1178 size_t next_secondary
;
1180 /* Count the number of code of each length. Set NEXT[val] to be the
1181 next value after VAL with the same bit length. */
1183 next
= (uint16_t *) (((unsigned char *) zdebug_table
)
1184 + ZDEBUG_TABLE_WORK_OFFSET
);
1186 memset (&count
[0], 0, 16 * sizeof (uint16_t));
1187 for (i
= 0; i
< codes_len
; ++i
)
1189 if (unlikely (codes
[i
] >= 16))
1195 if (count
[codes
[i
]] == 0)
1197 start
[codes
[i
]] = i
;
1202 next
[prev
[codes
[i
]]] = i
;
1209 /* For each length, fill in the table for the codes of that
1212 memset (table
, 0, HUFFMAN_TABLE_SIZE
* sizeof (uint16_t));
1214 /* Handle the values that do not require a secondary table. */
1217 for (j
= 1; j
<= 8; ++j
)
1226 if (unlikely (jcnt
> (1U << j
)))
1232 /* There are JCNT values that have this length, the values
1233 starting from START[j] continuing through NEXT[VAL]. Those
1234 values are assigned consecutive values starting at CODE. */
1237 for (i
= 0; i
< jcnt
; ++i
)
1243 /* In the compressed bit stream, the value VAL is encoded as
1244 J bits with the value C. */
1246 if (unlikely ((val
& ~HUFFMAN_VALUE_MASK
) != 0))
1252 tval
= val
| ((j
- 1) << HUFFMAN_BITS_SHIFT
);
1254 /* The table lookup uses 8 bits. If J is less than 8, we
1255 don't know what the other bits will be. We need to fill
1256 in all possibilities in the table. Since the Huffman
1257 code is unambiguous, those entries can't be used for any
1260 for (ind
= code
; ind
< 0x100; ind
+= 1 << j
)
1262 if (unlikely (table
[ind
] != 0))
1270 /* Advance to the next value with this length. */
1274 /* The Huffman codes are stored in the bitstream with the
1275 most significant bit first, as is required to make them
1276 unambiguous. The effect is that when we read them from
1277 the bitstream we see the bit sequence in reverse order:
1278 the most significant bit of the Huffman code is the least
1279 significant bit of the value we read from the bitstream.
1280 That means that to make our table lookups work, we need
1281 to reverse the bits of CODE. Since reversing bits is
1282 tedious and in general requires using a table, we instead
1283 increment CODE in reverse order. That is, if the number
1284 of bits we are currently using, here named J, is 3, we
1285 count as 000, 100, 010, 110, 001, 101, 011, 111, which is
1286 to say the numbers from 0 to 7 but with the bits
1287 reversed. Going to more bits, aka incrementing J,
1288 effectively just adds more zero bits as the beginning,
1289 and as such does not change the numeric value of CODE.
1291 To increment CODE of length J in reverse order, find the
1292 most significant zero bit and set it to one while
1293 clearing all higher bits. In other words, add 1 modulo
1294 2^J, only reversed. */
1296 incr
= 1U << (j
- 1);
1297 while ((code
& incr
) != 0)
1309 /* Handle the values that require a secondary table. */
1311 /* Set FIRSTCODE, the number at which the codes start, for each
1314 for (j
= 9; j
< 16; j
++)
1323 /* There are JCNT values that have this length, the values
1324 starting from START[j]. Those values are assigned
1325 consecutive values starting at CODE. */
1327 firstcode
[j
- 9] = code
;
1329 /* Reverse add JCNT to CODE modulo 2^J. */
1330 for (k
= 0; k
< j
; ++k
)
1332 if ((jcnt
& (1U << k
)) != 0)
1337 bit
= 1U << (j
- k
- 1);
1338 for (m
= 0; m
< j
- k
; ++m
, bit
>>= 1)
1340 if ((code
& bit
) == 0)
1350 if (unlikely (jcnt
!= 0))
1357 /* For J from 9 to 15, inclusive, we store COUNT[J] consecutive
1358 values starting at START[J] with consecutive codes starting at
1359 FIRSTCODE[J - 9]. In the primary table we need to point to the
1360 secondary table, and the secondary table will be indexed by J - 9
1361 bits. We count down from 15 so that we install the larger
1362 secondary tables first, as the smaller ones may be embedded in
1365 next_secondary
= 0; /* Index of next secondary table (after primary). */
1366 for (j
= 15; j
>= 9; j
--)
1370 size_t primary
; /* Current primary index. */
1371 size_t secondary
; /* Offset to current secondary table. */
1372 size_t secondary_bits
; /* Bit size of current secondary table. */
1379 code
= firstcode
[j
- 9];
1383 for (i
= 0; i
< jcnt
; ++i
)
1389 if ((code
& 0xff) != primary
)
1393 /* Fill in a new primary table entry. */
1395 primary
= code
& 0xff;
1397 tprimary
= table
[primary
];
1400 /* Start a new secondary table. */
1402 if (unlikely ((next_secondary
& HUFFMAN_VALUE_MASK
)
1409 secondary
= next_secondary
;
1410 secondary_bits
= j
- 8;
1411 next_secondary
+= 1 << secondary_bits
;
1412 table
[primary
] = (secondary
1413 + ((j
- 8) << HUFFMAN_BITS_SHIFT
)
1414 + (1U << HUFFMAN_SECONDARY_SHIFT
));
1418 /* There is an existing entry. It had better be a
1419 secondary table with enough bits. */
1420 if (unlikely ((tprimary
& (1U << HUFFMAN_SECONDARY_SHIFT
))
1426 secondary
= tprimary
& HUFFMAN_VALUE_MASK
;
1427 secondary_bits
= ((tprimary
>> HUFFMAN_BITS_SHIFT
)
1428 & HUFFMAN_BITS_MASK
);
1429 if (unlikely (secondary_bits
< j
- 8))
1437 /* Fill in secondary table entries. */
1439 tval
= val
| ((j
- 8) << HUFFMAN_BITS_SHIFT
);
1441 for (ind
= code
>> 8;
1442 ind
< (1U << secondary_bits
);
1443 ind
+= 1U << (j
- 8))
1445 if (unlikely (table
[secondary
+ 0x100 + ind
] != 0))
1450 table
[secondary
+ 0x100 + ind
] = tval
;
1456 incr
= 1U << (j
- 1);
1457 while ((code
& incr
) != 0)
1469 #ifdef BACKTRACE_GENERATE_FIXED_HUFFMAN_TABLE
1470 final_next_secondary
= next_secondary
;
1476 #ifdef BACKTRACE_GENERATE_FIXED_HUFFMAN_TABLE
1478 /* Used to generate the fixed Huffman table for block type 1. */
1482 static uint16_t table
[ZDEBUG_TABLE_SIZE
];
1483 static unsigned char codes
[288];
1490 for (i
= 0; i
<= 143; ++i
)
1492 for (i
= 144; i
<= 255; ++i
)
1494 for (i
= 256; i
<= 279; ++i
)
1496 for (i
= 280; i
<= 287; ++i
)
1498 if (!elf_zlib_inflate_table (&codes
[0], 288, &table
[0], &table
[0]))
1500 fprintf (stderr
, "elf_zlib_inflate_table failed\n");
1501 exit (EXIT_FAILURE
);
1504 printf ("static const uint16_t elf_zlib_default_table[%#zx] =\n",
1505 final_next_secondary
+ 0x100);
1507 for (i
= 0; i
< final_next_secondary
+ 0x100; i
+= 8)
1512 for (j
= i
; j
< final_next_secondary
+ 0x100 && j
< i
+ 8; ++j
)
1513 printf (" %#x,", table
[j
]);
1519 for (i
= 0; i
< 32; ++i
)
1521 if (!elf_zlib_inflate_table (&codes
[0], 32, &table
[0], &table
[0]))
1523 fprintf (stderr
, "elf_zlib_inflate_table failed\n");
1524 exit (EXIT_FAILURE
);
1527 printf ("static const uint16_t elf_zlib_default_dist_table[%#zx] =\n",
1528 final_next_secondary
+ 0x100);
1530 for (i
= 0; i
< final_next_secondary
+ 0x100; i
+= 8)
1535 for (j
= i
; j
< final_next_secondary
+ 0x100 && j
< i
+ 8; ++j
)
1536 printf (" %#x,", table
[j
]);
1546 /* The fixed tables generated by the #ifdef'ed out main function
1549 static const uint16_t elf_zlib_default_table
[0x170] =
1551 0xd00, 0xe50, 0xe10, 0xf18, 0xd10, 0xe70, 0xe30, 0x1230,
1552 0xd08, 0xe60, 0xe20, 0x1210, 0xe00, 0xe80, 0xe40, 0x1250,
1553 0xd04, 0xe58, 0xe18, 0x1200, 0xd14, 0xe78, 0xe38, 0x1240,
1554 0xd0c, 0xe68, 0xe28, 0x1220, 0xe08, 0xe88, 0xe48, 0x1260,
1555 0xd02, 0xe54, 0xe14, 0xf1c, 0xd12, 0xe74, 0xe34, 0x1238,
1556 0xd0a, 0xe64, 0xe24, 0x1218, 0xe04, 0xe84, 0xe44, 0x1258,
1557 0xd06, 0xe5c, 0xe1c, 0x1208, 0xd16, 0xe7c, 0xe3c, 0x1248,
1558 0xd0e, 0xe6c, 0xe2c, 0x1228, 0xe0c, 0xe8c, 0xe4c, 0x1268,
1559 0xd01, 0xe52, 0xe12, 0xf1a, 0xd11, 0xe72, 0xe32, 0x1234,
1560 0xd09, 0xe62, 0xe22, 0x1214, 0xe02, 0xe82, 0xe42, 0x1254,
1561 0xd05, 0xe5a, 0xe1a, 0x1204, 0xd15, 0xe7a, 0xe3a, 0x1244,
1562 0xd0d, 0xe6a, 0xe2a, 0x1224, 0xe0a, 0xe8a, 0xe4a, 0x1264,
1563 0xd03, 0xe56, 0xe16, 0xf1e, 0xd13, 0xe76, 0xe36, 0x123c,
1564 0xd0b, 0xe66, 0xe26, 0x121c, 0xe06, 0xe86, 0xe46, 0x125c,
1565 0xd07, 0xe5e, 0xe1e, 0x120c, 0xd17, 0xe7e, 0xe3e, 0x124c,
1566 0xd0f, 0xe6e, 0xe2e, 0x122c, 0xe0e, 0xe8e, 0xe4e, 0x126c,
1567 0xd00, 0xe51, 0xe11, 0xf19, 0xd10, 0xe71, 0xe31, 0x1232,
1568 0xd08, 0xe61, 0xe21, 0x1212, 0xe01, 0xe81, 0xe41, 0x1252,
1569 0xd04, 0xe59, 0xe19, 0x1202, 0xd14, 0xe79, 0xe39, 0x1242,
1570 0xd0c, 0xe69, 0xe29, 0x1222, 0xe09, 0xe89, 0xe49, 0x1262,
1571 0xd02, 0xe55, 0xe15, 0xf1d, 0xd12, 0xe75, 0xe35, 0x123a,
1572 0xd0a, 0xe65, 0xe25, 0x121a, 0xe05, 0xe85, 0xe45, 0x125a,
1573 0xd06, 0xe5d, 0xe1d, 0x120a, 0xd16, 0xe7d, 0xe3d, 0x124a,
1574 0xd0e, 0xe6d, 0xe2d, 0x122a, 0xe0d, 0xe8d, 0xe4d, 0x126a,
1575 0xd01, 0xe53, 0xe13, 0xf1b, 0xd11, 0xe73, 0xe33, 0x1236,
1576 0xd09, 0xe63, 0xe23, 0x1216, 0xe03, 0xe83, 0xe43, 0x1256,
1577 0xd05, 0xe5b, 0xe1b, 0x1206, 0xd15, 0xe7b, 0xe3b, 0x1246,
1578 0xd0d, 0xe6b, 0xe2b, 0x1226, 0xe0b, 0xe8b, 0xe4b, 0x1266,
1579 0xd03, 0xe57, 0xe17, 0xf1f, 0xd13, 0xe77, 0xe37, 0x123e,
1580 0xd0b, 0xe67, 0xe27, 0x121e, 0xe07, 0xe87, 0xe47, 0x125e,
1581 0xd07, 0xe5f, 0xe1f, 0x120e, 0xd17, 0xe7f, 0xe3f, 0x124e,
1582 0xd0f, 0xe6f, 0xe2f, 0x122e, 0xe0f, 0xe8f, 0xe4f, 0x126e,
1583 0x290, 0x291, 0x292, 0x293, 0x294, 0x295, 0x296, 0x297,
1584 0x298, 0x299, 0x29a, 0x29b, 0x29c, 0x29d, 0x29e, 0x29f,
1585 0x2a0, 0x2a1, 0x2a2, 0x2a3, 0x2a4, 0x2a5, 0x2a6, 0x2a7,
1586 0x2a8, 0x2a9, 0x2aa, 0x2ab, 0x2ac, 0x2ad, 0x2ae, 0x2af,
1587 0x2b0, 0x2b1, 0x2b2, 0x2b3, 0x2b4, 0x2b5, 0x2b6, 0x2b7,
1588 0x2b8, 0x2b9, 0x2ba, 0x2bb, 0x2bc, 0x2bd, 0x2be, 0x2bf,
1589 0x2c0, 0x2c1, 0x2c2, 0x2c3, 0x2c4, 0x2c5, 0x2c6, 0x2c7,
1590 0x2c8, 0x2c9, 0x2ca, 0x2cb, 0x2cc, 0x2cd, 0x2ce, 0x2cf,
1591 0x2d0, 0x2d1, 0x2d2, 0x2d3, 0x2d4, 0x2d5, 0x2d6, 0x2d7,
1592 0x2d8, 0x2d9, 0x2da, 0x2db, 0x2dc, 0x2dd, 0x2de, 0x2df,
1593 0x2e0, 0x2e1, 0x2e2, 0x2e3, 0x2e4, 0x2e5, 0x2e6, 0x2e7,
1594 0x2e8, 0x2e9, 0x2ea, 0x2eb, 0x2ec, 0x2ed, 0x2ee, 0x2ef,
1595 0x2f0, 0x2f1, 0x2f2, 0x2f3, 0x2f4, 0x2f5, 0x2f6, 0x2f7,
1596 0x2f8, 0x2f9, 0x2fa, 0x2fb, 0x2fc, 0x2fd, 0x2fe, 0x2ff,
1599 static const uint16_t elf_zlib_default_dist_table
[0x100] =
1601 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1602 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1603 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1604 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1605 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1606 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1607 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1608 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1609 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1610 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1611 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1612 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1613 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1614 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1615 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1616 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1617 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1618 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1619 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1620 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
1621 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c,
1622 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
1623 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
1624 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f,
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,
1635 /* Inflate a zlib stream from PIN/SIN to POUT/SOUT. Return 1 on
1636 success, 0 on some error parsing the stream. */
1639 elf_zlib_inflate (const unsigned char *pin
, size_t sin
, uint16_t *zdebug_table
,
1640 unsigned char *pout
, size_t sout
)
1642 unsigned char *porigout
;
1643 const unsigned char *pinend
;
1644 unsigned char *poutend
;
1646 /* We can apparently see multiple zlib streams concatenated
1647 together, so keep going as long as there is something to read.
1648 The last 4 bytes are the checksum. */
1651 poutend
= pout
+ sout
;
1652 while ((pinend
- pin
) > 4)
1658 /* Read the two byte zlib header. */
1660 if (unlikely ((pin
[0] & 0xf) != 8)) /* 8 is zlib encoding. */
1662 /* Unknown compression method. */
1666 if (unlikely ((pin
[0] >> 4) > 7))
1668 /* Window size too large. Other than this check, we don't
1669 care about the window size. */
1673 if (unlikely ((pin
[1] & 0x20) != 0))
1675 /* Stream expects a predefined dictionary, but we have no
1680 val
= (pin
[0] << 8) | pin
[1];
1681 if (unlikely (val
% 31 != 0))
1683 /* Header check failure. */
1689 /* Align PIN to a 32-bit boundary. */
1693 while ((((uintptr_t) pin
) & 3) != 0)
1695 val
|= (uint64_t)*pin
<< bits
;
1700 /* Read blocks until one is marked last. */
1707 const uint16_t *tlit
;
1708 const uint16_t *tdist
;
1710 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1714 type
= (val
>> 1) & 3;
1718 if (unlikely (type
== 3))
1720 /* Invalid block type. */
1730 /* An uncompressed block. */
1732 /* If we've read ahead more than a byte, back up. */
1741 if (unlikely ((pinend
- pin
) < 4))
1743 /* Missing length. */
1747 len
= pin
[0] | (pin
[1] << 8);
1748 lenc
= pin
[2] | (pin
[3] << 8);
1751 if (unlikely (len
!= lenc
))
1757 if (unlikely (len
> (unsigned int) (pinend
- pin
)
1758 || len
> (unsigned int) (poutend
- pout
)))
1760 /* Not enough space in buffers. */
1764 memcpy (pout
, pin
, len
);
1769 while ((((uintptr_t) pin
) & 3) != 0)
1771 val
|= (uint64_t)*pin
<< bits
;
1776 /* Go around to read the next block. */
1782 tlit
= elf_zlib_default_table
;
1783 tdist
= elf_zlib_default_dist_table
;
1790 unsigned char codebits
[19];
1791 unsigned char *plenbase
;
1792 unsigned char *plen
;
1793 unsigned char *plenend
;
1795 /* Read a Huffman encoding table. The various magic
1796 numbers here are from RFC 1951. */
1798 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1801 nlit
= (val
& 0x1f) + 257;
1803 ndist
= (val
& 0x1f) + 1;
1805 nclen
= (val
& 0xf) + 4;
1808 if (unlikely (nlit
> 286 || ndist
> 30))
1810 /* Values out of range. */
1815 /* Read and build the table used to compress the
1816 literal, length, and distance codes. */
1818 memset(&codebits
[0], 0, 19);
1820 /* There are always at least 4 elements in the
1823 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1826 codebits
[16] = val
& 7;
1827 codebits
[17] = (val
>> 3) & 7;
1828 codebits
[18] = (val
>> 6) & 7;
1829 codebits
[0] = (val
>> 9) & 7;
1836 codebits
[8] = val
& 7;
1843 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1846 codebits
[7] = val
& 7;
1853 codebits
[9] = val
& 7;
1860 codebits
[6] = val
& 7;
1867 codebits
[10] = val
& 7;
1874 codebits
[5] = val
& 7;
1881 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1884 codebits
[11] = val
& 7;
1891 codebits
[4] = val
& 7;
1898 codebits
[12] = val
& 7;
1905 codebits
[3] = val
& 7;
1912 codebits
[13] = val
& 7;
1919 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1922 codebits
[2] = val
& 7;
1929 codebits
[14] = val
& 7;
1936 codebits
[1] = val
& 7;
1943 codebits
[15] = val
& 7;
1949 if (!elf_zlib_inflate_table (codebits
, 19, zdebug_table
,
1953 /* Read the compressed bit lengths of the literal,
1954 length, and distance codes. We have allocated space
1955 at the end of zdebug_table to hold them. */
1957 plenbase
= (((unsigned char *) zdebug_table
)
1958 + ZDEBUG_TABLE_CODELEN_OFFSET
);
1960 plenend
= plen
+ nlit
+ ndist
;
1961 while (plen
< plenend
)
1967 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
1970 t
= zdebug_table
[val
& 0xff];
1972 /* The compression here uses bit lengths up to 7, so
1973 a secondary table is never necessary. */
1974 if (unlikely ((t
& (1U << HUFFMAN_SECONDARY_SHIFT
)) != 0))
1980 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
1984 v
= t
& HUFFMAN_VALUE_MASK
;
1992 /* Copy previous entry 3 to 6 times. */
1994 if (unlikely (plen
== plenbase
))
2000 /* We used up to 7 bits since the last
2001 elf_zlib_fetch, so we have at least 8 bits
2004 c
= 3 + (val
& 0x3);
2007 if (unlikely ((unsigned int) (plenend
- plen
) < c
))
2033 /* Store zero 3 to 10 times. */
2035 /* We used up to 7 bits since the last
2036 elf_zlib_fetch, so we have at least 8 bits
2039 c
= 3 + (val
& 0x7);
2042 if (unlikely ((unsigned int) (plenend
- plen
) < c
))
2079 /* Store zero 11 to 138 times. */
2081 /* We used up to 7 bits since the last
2082 elf_zlib_fetch, so we have at least 8 bits
2085 c
= 11 + (val
& 0x7f);
2088 if (unlikely ((unsigned int) (plenend
- plen
) < c
))
2094 memset (plen
, 0, c
);
2104 /* Make sure that the stop code can appear. */
2107 if (unlikely (plen
[256] == 0))
2113 /* Build the decompression tables. */
2115 if (!elf_zlib_inflate_table (plen
, nlit
, zdebug_table
,
2118 if (!elf_zlib_inflate_table (plen
+ nlit
, ndist
, zdebug_table
,
2119 zdebug_table
+ HUFFMAN_TABLE_SIZE
))
2121 tlit
= zdebug_table
;
2122 tdist
= zdebug_table
+ HUFFMAN_TABLE_SIZE
;
2125 /* Inflate values until the end of the block. This is the
2126 main loop of the inflation code. */
2135 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
2138 t
= tlit
[val
& 0xff];
2139 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
2140 v
= t
& HUFFMAN_VALUE_MASK
;
2142 if ((t
& (1U << HUFFMAN_SECONDARY_SHIFT
)) == 0)
2150 t
= tlit
[v
+ 0x100 + ((val
>> 8) & ((1U << b
) - 1))];
2151 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
2152 lit
= t
& HUFFMAN_VALUE_MASK
;
2159 if (unlikely (pout
== poutend
))
2167 /* We will need to write the next byte soon. We ask
2168 for high temporal locality because we will write
2169 to the whole cache line soon. */
2170 __builtin_prefetch (pout
, 1, 3);
2172 else if (lit
== 256)
2174 /* The end of the block. */
2182 /* Convert lit into a length. */
2185 len
= lit
- 257 + 3;
2186 else if (lit
== 285)
2188 else if (unlikely (lit
> 285))
2197 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
2200 /* This is an expression for the table of length
2201 codes in RFC 1951 3.2.5. */
2203 extra
= (lit
>> 2) + 1;
2204 len
= (lit
& 3) << extra
;
2206 len
+= ((1U << (extra
- 1)) - 1) << 3;
2207 len
+= val
& ((1U << extra
) - 1);
2212 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
2215 t
= tdist
[val
& 0xff];
2216 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
2217 v
= t
& HUFFMAN_VALUE_MASK
;
2219 if ((t
& (1U << HUFFMAN_SECONDARY_SHIFT
)) == 0)
2227 t
= tdist
[v
+ 0x100 + ((val
>> 8) & ((1U << b
) - 1))];
2228 b
= (t
>> HUFFMAN_BITS_SHIFT
) & HUFFMAN_BITS_MASK
;
2229 dist
= t
& HUFFMAN_VALUE_MASK
;
2234 /* Convert dist to a distance. */
2238 /* A distance of 1. A common case, meaning
2239 repeat the last character LEN times. */
2241 if (unlikely (pout
== porigout
))
2247 if (unlikely ((unsigned int) (poutend
- pout
) < len
))
2253 memset (pout
, pout
[-1], len
);
2256 else if (unlikely (dist
> 29))
2269 if (!elf_zlib_fetch (&pin
, pinend
, &val
, &bits
))
2272 /* This is an expression for the table of
2273 distance codes in RFC 1951 3.2.5. */
2275 extra
= (dist
>> 1) + 1;
2276 dist
= (dist
& 1) << extra
;
2278 dist
+= ((1U << (extra
- 1)) - 1) << 2;
2279 dist
+= val
& ((1U << extra
) - 1);
2284 /* Go back dist bytes, and copy len bytes from
2287 if (unlikely ((unsigned int) (pout
- porigout
) < dist
))
2293 if (unlikely ((unsigned int) (poutend
- pout
) < len
))
2301 memcpy (pout
, pout
- dist
, len
);
2310 copy
= len
< dist
? len
: dist
;
2311 memcpy (pout
, pout
- dist
, copy
);
2322 /* We should have filled the output buffer. */
2323 if (unlikely (pout
!= poutend
))
2332 /* Verify the zlib checksum. The checksum is in the 4 bytes at
2333 CHECKBYTES, and the uncompressed data is at UNCOMPRESSED /
2334 UNCOMPRESSED_SIZE. Returns 1 on success, 0 on failure. */
2337 elf_zlib_verify_checksum (const unsigned char *checkbytes
,
2338 const unsigned char *uncompressed
,
2339 size_t uncompressed_size
)
2343 const unsigned char *p
;
2349 for (i
= 0; i
< 4; i
++)
2350 cksum
= (cksum
<< 8) | checkbytes
[i
];
2355 /* Minimize modulo operations. */
2358 hsz
= uncompressed_size
;
2361 for (i
= 0; i
< 5552; i
+= 16)
2363 /* Manually unroll loop 16 times. */
2404 /* Manually unroll loop 16 times. */
2441 for (i
= 0; i
< hsz
; ++i
)
2450 if (unlikely ((s2
<< 16) + s1
!= cksum
))
2459 /* Inflate a zlib stream from PIN/SIN to POUT/SOUT, and verify the
2460 checksum. Return 1 on success, 0 on error. */
2463 elf_zlib_inflate_and_verify (const unsigned char *pin
, size_t sin
,
2464 uint16_t *zdebug_table
, unsigned char *pout
,
2467 if (!elf_zlib_inflate (pin
, sin
, zdebug_table
, pout
, sout
))
2469 if (!elf_zlib_verify_checksum (pin
+ sin
- 4, pout
, sout
))
2474 /* Uncompress the old compressed debug format, the one emitted by
2475 --compress-debug-sections=zlib-gnu. The compressed data is in
2476 COMPRESSED / COMPRESSED_SIZE, and the function writes to
2477 *UNCOMPRESSED / *UNCOMPRESSED_SIZE. ZDEBUG_TABLE is work space to
2478 hold Huffman tables. Returns 0 on error, 1 on successful
2479 decompression or if something goes wrong. In general we try to
2480 carry on, by returning 1, even if we can't decompress. */
2483 elf_uncompress_zdebug (struct backtrace_state
*state
,
2484 const unsigned char *compressed
, size_t compressed_size
,
2485 uint16_t *zdebug_table
,
2486 backtrace_error_callback error_callback
, void *data
,
2487 unsigned char **uncompressed
, size_t *uncompressed_size
)
2493 *uncompressed
= NULL
;
2494 *uncompressed_size
= 0;
2496 /* The format starts with the four bytes ZLIB, followed by the 8
2497 byte length of the uncompressed data in big-endian order,
2498 followed by a zlib stream. */
2500 if (compressed_size
< 12 || memcmp (compressed
, "ZLIB", 4) != 0)
2504 for (i
= 0; i
< 8; i
++)
2505 sz
= (sz
<< 8) | compressed
[i
+ 4];
2507 if (*uncompressed
!= NULL
&& *uncompressed_size
>= sz
)
2511 po
= (unsigned char *) backtrace_alloc (state
, sz
, error_callback
, data
);
2516 if (!elf_zlib_inflate_and_verify (compressed
+ 12, compressed_size
- 12,
2517 zdebug_table
, po
, sz
))
2521 *uncompressed_size
= sz
;
2526 /* Uncompress the new compressed debug format, the official standard
2527 ELF approach emitted by --compress-debug-sections=zlib-gabi. The
2528 compressed data is in COMPRESSED / COMPRESSED_SIZE, and the
2529 function writes to *UNCOMPRESSED / *UNCOMPRESSED_SIZE.
2530 ZDEBUG_TABLE is work space as for elf_uncompress_zdebug. Returns 0
2531 on error, 1 on successful decompression or if something goes wrong.
2532 In general we try to carry on, by returning 1, even if we can't
2536 elf_uncompress_chdr (struct backtrace_state
*state
,
2537 const unsigned char *compressed
, size_t compressed_size
,
2538 uint16_t *zdebug_table
,
2539 backtrace_error_callback error_callback
, void *data
,
2540 unsigned char **uncompressed
, size_t *uncompressed_size
)
2542 const b_elf_chdr
*chdr
;
2545 *uncompressed
= NULL
;
2546 *uncompressed_size
= 0;
2548 /* The format starts with an ELF compression header. */
2549 if (compressed_size
< sizeof (b_elf_chdr
))
2552 chdr
= (const b_elf_chdr
*) compressed
;
2554 if (chdr
->ch_type
!= ELFCOMPRESS_ZLIB
)
2556 /* Unsupported compression algorithm. */
2560 if (*uncompressed
!= NULL
&& *uncompressed_size
>= chdr
->ch_size
)
2564 po
= (unsigned char *) backtrace_alloc (state
, chdr
->ch_size
,
2565 error_callback
, data
);
2570 if (!elf_zlib_inflate_and_verify (compressed
+ sizeof (b_elf_chdr
),
2571 compressed_size
- sizeof (b_elf_chdr
),
2572 zdebug_table
, po
, chdr
->ch_size
))
2576 *uncompressed_size
= chdr
->ch_size
;
2581 /* This function is a hook for testing the zlib support. It is only
2585 backtrace_uncompress_zdebug (struct backtrace_state
*state
,
2586 const unsigned char *compressed
,
2587 size_t compressed_size
,
2588 backtrace_error_callback error_callback
,
2589 void *data
, unsigned char **uncompressed
,
2590 size_t *uncompressed_size
)
2592 uint16_t *zdebug_table
;
2595 zdebug_table
= ((uint16_t *) backtrace_alloc (state
, ZDEBUG_TABLE_SIZE
,
2596 error_callback
, data
));
2597 if (zdebug_table
== NULL
)
2599 ret
= elf_uncompress_zdebug (state
, compressed
, compressed_size
,
2600 zdebug_table
, error_callback
, data
,
2601 uncompressed
, uncompressed_size
);
2602 backtrace_free (state
, zdebug_table
, ZDEBUG_TABLE_SIZE
,
2603 error_callback
, data
);
2607 /* Add the backtrace data for one ELF file. Returns 1 on success,
2608 0 on failure (in both cases descriptor is closed) or -1 if exe
2609 is non-zero and the ELF file is ET_DYN, which tells the caller that
2610 elf_add will need to be called on the descriptor again after
2611 base_address is determined. */
2614 elf_add (struct backtrace_state
*state
, const char *filename
, int descriptor
,
2615 uintptr_t base_address
, backtrace_error_callback error_callback
,
2616 void *data
, fileline
*fileline_fn
, int *found_sym
, int *found_dwarf
,
2617 struct dwarf_data
**fileline_entry
, int exe
, int debuginfo
,
2618 const char *with_buildid_data
, uint32_t with_buildid_size
)
2620 struct backtrace_view ehdr_view
;
2624 unsigned int shstrndx
;
2625 struct backtrace_view shdrs_view
;
2626 int shdrs_view_valid
;
2627 const b_elf_shdr
*shdrs
;
2628 const b_elf_shdr
*shstrhdr
;
2631 struct backtrace_view names_view
;
2632 int names_view_valid
;
2634 unsigned int symtab_shndx
;
2635 unsigned int dynsym_shndx
;
2637 struct debug_section_info sections
[DEBUG_MAX
];
2638 struct debug_section_info zsections
[DEBUG_MAX
];
2639 struct backtrace_view symtab_view
;
2640 int symtab_view_valid
;
2641 struct backtrace_view strtab_view
;
2642 int strtab_view_valid
;
2643 struct backtrace_view buildid_view
;
2644 int buildid_view_valid
;
2645 const char *buildid_data
;
2646 uint32_t buildid_size
;
2647 struct backtrace_view debuglink_view
;
2648 int debuglink_view_valid
;
2649 const char *debuglink_name
;
2650 uint32_t debuglink_crc
;
2651 struct backtrace_view debugaltlink_view
;
2652 int debugaltlink_view_valid
;
2653 const char *debugaltlink_name
;
2654 const char *debugaltlink_buildid_data
;
2655 uint32_t debugaltlink_buildid_size
;
2658 struct backtrace_view debug_view
;
2659 int debug_view_valid
;
2660 unsigned int using_debug_view
;
2661 uint16_t *zdebug_table
;
2662 struct elf_ppc64_opd_data opd_data
, *opd
;
2663 struct dwarf_sections dwarf_sections
;
2671 shdrs_view_valid
= 0;
2672 names_view_valid
= 0;
2673 symtab_view_valid
= 0;
2674 strtab_view_valid
= 0;
2675 buildid_view_valid
= 0;
2676 buildid_data
= NULL
;
2678 debuglink_view_valid
= 0;
2679 debuglink_name
= NULL
;
2681 debugaltlink_view_valid
= 0;
2682 debugaltlink_name
= NULL
;
2683 debugaltlink_buildid_data
= NULL
;
2684 debugaltlink_buildid_size
= 0;
2685 debug_view_valid
= 0;
2688 if (!backtrace_get_view (state
, descriptor
, 0, sizeof ehdr
, error_callback
,
2692 memcpy (&ehdr
, ehdr_view
.data
, sizeof ehdr
);
2694 backtrace_release_view (state
, &ehdr_view
, error_callback
, data
);
2696 if (ehdr
.e_ident
[EI_MAG0
] != ELFMAG0
2697 || ehdr
.e_ident
[EI_MAG1
] != ELFMAG1
2698 || ehdr
.e_ident
[EI_MAG2
] != ELFMAG2
2699 || ehdr
.e_ident
[EI_MAG3
] != ELFMAG3
)
2701 error_callback (data
, "executable file is not ELF", 0);
2704 if (ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
)
2706 error_callback (data
, "executable file is unrecognized ELF version", 0);
2710 #if BACKTRACE_ELF_SIZE == 32
2711 #define BACKTRACE_ELFCLASS ELFCLASS32
2713 #define BACKTRACE_ELFCLASS ELFCLASS64
2716 if (ehdr
.e_ident
[EI_CLASS
] != BACKTRACE_ELFCLASS
)
2718 error_callback (data
, "executable file is unexpected ELF class", 0);
2722 if (ehdr
.e_ident
[EI_DATA
] != ELFDATA2LSB
2723 && ehdr
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
2725 error_callback (data
, "executable file has unknown endianness", 0);
2729 /* If the executable is ET_DYN, it is either a PIE, or we are running
2730 directly a shared library with .interp. We need to wait for
2731 dl_iterate_phdr in that case to determine the actual base_address. */
2732 if (exe
&& ehdr
.e_type
== ET_DYN
)
2735 shoff
= ehdr
.e_shoff
;
2736 shnum
= ehdr
.e_shnum
;
2737 shstrndx
= ehdr
.e_shstrndx
;
2739 if ((shnum
== 0 || shstrndx
== SHN_XINDEX
)
2742 struct backtrace_view shdr_view
;
2743 const b_elf_shdr
*shdr
;
2745 if (!backtrace_get_view (state
, descriptor
, shoff
, sizeof shdr
,
2746 error_callback
, data
, &shdr_view
))
2749 shdr
= (const b_elf_shdr
*) shdr_view
.data
;
2752 shnum
= shdr
->sh_size
;
2754 if (shstrndx
== SHN_XINDEX
)
2756 shstrndx
= shdr
->sh_link
;
2758 /* Versions of the GNU binutils between 2.12 and 2.18 did
2759 not handle objects with more than SHN_LORESERVE sections
2760 correctly. All large section indexes were offset by
2761 0x100. There is more information at
2762 http://sourceware.org/bugzilla/show_bug.cgi?id-5900 .
2763 Fortunately these object files are easy to detect, as the
2764 GNU binutils always put the section header string table
2765 near the end of the list of sections. Thus if the
2766 section header string table index is larger than the
2767 number of sections, then we know we have to subtract
2768 0x100 to get the real section index. */
2769 if (shstrndx
>= shnum
&& shstrndx
>= SHN_LORESERVE
+ 0x100)
2773 backtrace_release_view (state
, &shdr_view
, error_callback
, data
);
2776 /* To translate PC to file/line when using DWARF, we need to find
2777 the .debug_info and .debug_line sections. */
2779 /* Read the section headers, skipping the first one. */
2781 if (!backtrace_get_view (state
, descriptor
, shoff
+ sizeof (b_elf_shdr
),
2782 (shnum
- 1) * sizeof (b_elf_shdr
),
2783 error_callback
, data
, &shdrs_view
))
2785 shdrs_view_valid
= 1;
2786 shdrs
= (const b_elf_shdr
*) shdrs_view
.data
;
2788 /* Read the section names. */
2790 shstrhdr
= &shdrs
[shstrndx
- 1];
2791 shstr_size
= shstrhdr
->sh_size
;
2792 shstr_off
= shstrhdr
->sh_offset
;
2794 if (!backtrace_get_view (state
, descriptor
, shstr_off
, shstrhdr
->sh_size
,
2795 error_callback
, data
, &names_view
))
2797 names_view_valid
= 1;
2798 names
= (const char *) names_view
.data
;
2803 memset (sections
, 0, sizeof sections
);
2804 memset (zsections
, 0, sizeof zsections
);
2806 /* Look for the symbol table. */
2807 for (i
= 1; i
< shnum
; ++i
)
2809 const b_elf_shdr
*shdr
;
2810 unsigned int sh_name
;
2814 shdr
= &shdrs
[i
- 1];
2816 if (shdr
->sh_type
== SHT_SYMTAB
)
2818 else if (shdr
->sh_type
== SHT_DYNSYM
)
2821 sh_name
= shdr
->sh_name
;
2822 if (sh_name
>= shstr_size
)
2824 error_callback (data
, "ELF section name out of range", 0);
2828 name
= names
+ sh_name
;
2830 for (j
= 0; j
< (int) DEBUG_MAX
; ++j
)
2832 if (strcmp (name
, dwarf_section_names
[j
]) == 0)
2834 sections
[j
].offset
= shdr
->sh_offset
;
2835 sections
[j
].size
= shdr
->sh_size
;
2836 sections
[j
].compressed
= (shdr
->sh_flags
& SHF_COMPRESSED
) != 0;
2841 if (name
[0] == '.' && name
[1] == 'z')
2843 for (j
= 0; j
< (int) DEBUG_MAX
; ++j
)
2845 if (strcmp (name
+ 2, dwarf_section_names
[j
] + 1) == 0)
2847 zsections
[j
].offset
= shdr
->sh_offset
;
2848 zsections
[j
].size
= shdr
->sh_size
;
2854 /* Read the build ID if present. This could check for any
2855 SHT_NOTE section with the right note name and type, but gdb
2856 looks for a specific section name. */
2857 if ((!debuginfo
|| with_buildid_data
!= NULL
)
2858 && !buildid_view_valid
2859 && strcmp (name
, ".note.gnu.build-id") == 0)
2861 const b_elf_note
*note
;
2863 if (!backtrace_get_view (state
, descriptor
, shdr
->sh_offset
,
2864 shdr
->sh_size
, error_callback
, data
,
2868 buildid_view_valid
= 1;
2869 note
= (const b_elf_note
*) buildid_view
.data
;
2870 if (note
->type
== NT_GNU_BUILD_ID
2871 && note
->namesz
== 4
2872 && strncmp (note
->name
, "GNU", 4) == 0
2873 && shdr
->sh_size
<= 12 + ((note
->namesz
+ 3) & ~ 3) + note
->descsz
)
2875 buildid_data
= ¬e
->name
[0] + ((note
->namesz
+ 3) & ~ 3);
2876 buildid_size
= note
->descsz
;
2879 if (with_buildid_size
!= 0)
2881 if (buildid_size
!= with_buildid_size
)
2884 if (memcmp (buildid_data
, with_buildid_data
, buildid_size
) != 0)
2889 /* Read the debuglink file if present. */
2891 && !debuglink_view_valid
2892 && strcmp (name
, ".gnu_debuglink") == 0)
2894 const char *debuglink_data
;
2897 if (!backtrace_get_view (state
, descriptor
, shdr
->sh_offset
,
2898 shdr
->sh_size
, error_callback
, data
,
2902 debuglink_view_valid
= 1;
2903 debuglink_data
= (const char *) debuglink_view
.data
;
2904 crc_offset
= strnlen (debuglink_data
, shdr
->sh_size
);
2905 crc_offset
= (crc_offset
+ 3) & ~3;
2906 if (crc_offset
+ 4 <= shdr
->sh_size
)
2908 debuglink_name
= debuglink_data
;
2909 debuglink_crc
= *(const uint32_t*)(debuglink_data
+ crc_offset
);
2913 if (!debugaltlink_view_valid
2914 && strcmp (name
, ".gnu_debugaltlink") == 0)
2916 const char *debugaltlink_data
;
2917 size_t debugaltlink_name_len
;
2919 if (!backtrace_get_view (state
, descriptor
, shdr
->sh_offset
,
2920 shdr
->sh_size
, error_callback
, data
,
2921 &debugaltlink_view
))
2924 debugaltlink_view_valid
= 1;
2925 debugaltlink_data
= (const char *) debugaltlink_view
.data
;
2926 debugaltlink_name
= debugaltlink_data
;
2927 debugaltlink_name_len
= strnlen (debugaltlink_data
, shdr
->sh_size
);
2928 if (debugaltlink_name_len
< shdr
->sh_size
)
2930 /* Include terminating zero. */
2931 debugaltlink_name_len
+= 1;
2933 debugaltlink_buildid_data
2934 = debugaltlink_data
+ debugaltlink_name_len
;
2935 debugaltlink_buildid_size
= shdr
->sh_size
- debugaltlink_name_len
;
2939 /* Read the .opd section on PowerPC64 ELFv1. */
2940 if (ehdr
.e_machine
== EM_PPC64
2941 && (ehdr
.e_flags
& EF_PPC64_ABI
) < 2
2942 && shdr
->sh_type
== SHT_PROGBITS
2943 && strcmp (name
, ".opd") == 0)
2945 if (!backtrace_get_view (state
, descriptor
, shdr
->sh_offset
,
2946 shdr
->sh_size
, error_callback
, data
,
2951 opd
->addr
= shdr
->sh_addr
;
2952 opd
->data
= (const char *) opd_data
.view
.data
;
2953 opd
->size
= shdr
->sh_size
;
2957 if (symtab_shndx
== 0)
2958 symtab_shndx
= dynsym_shndx
;
2959 if (symtab_shndx
!= 0 && !debuginfo
)
2961 const b_elf_shdr
*symtab_shdr
;
2962 unsigned int strtab_shndx
;
2963 const b_elf_shdr
*strtab_shdr
;
2964 struct elf_syminfo_data
*sdata
;
2966 symtab_shdr
= &shdrs
[symtab_shndx
- 1];
2967 strtab_shndx
= symtab_shdr
->sh_link
;
2968 if (strtab_shndx
>= shnum
)
2970 error_callback (data
,
2971 "ELF symbol table strtab link out of range", 0);
2974 strtab_shdr
= &shdrs
[strtab_shndx
- 1];
2976 if (!backtrace_get_view (state
, descriptor
, symtab_shdr
->sh_offset
,
2977 symtab_shdr
->sh_size
, error_callback
, data
,
2980 symtab_view_valid
= 1;
2982 if (!backtrace_get_view (state
, descriptor
, strtab_shdr
->sh_offset
,
2983 strtab_shdr
->sh_size
, error_callback
, data
,
2986 strtab_view_valid
= 1;
2988 sdata
= ((struct elf_syminfo_data
*)
2989 backtrace_alloc (state
, sizeof *sdata
, error_callback
, data
));
2993 if (!elf_initialize_syminfo (state
, base_address
,
2994 symtab_view
.data
, symtab_shdr
->sh_size
,
2995 strtab_view
.data
, strtab_shdr
->sh_size
,
2996 error_callback
, data
, sdata
, opd
))
2998 backtrace_free (state
, sdata
, sizeof *sdata
, error_callback
, data
);
3002 /* We no longer need the symbol table, but we hold on to the
3003 string table permanently. */
3004 backtrace_release_view (state
, &symtab_view
, error_callback
, data
);
3005 symtab_view_valid
= 0;
3009 elf_add_syminfo_data (state
, sdata
);
3012 backtrace_release_view (state
, &shdrs_view
, error_callback
, data
);
3013 shdrs_view_valid
= 0;
3014 backtrace_release_view (state
, &names_view
, error_callback
, data
);
3015 names_view_valid
= 0;
3017 /* If the debug info is in a separate file, read that one instead. */
3019 if (buildid_data
!= NULL
)
3023 d
= elf_open_debugfile_by_buildid (state
, buildid_data
, buildid_size
,
3024 error_callback
, data
);
3029 backtrace_release_view (state
, &buildid_view
, error_callback
, data
);
3030 if (debuglink_view_valid
)
3031 backtrace_release_view (state
, &debuglink_view
, error_callback
,
3033 if (debugaltlink_view_valid
)
3034 backtrace_release_view (state
, &debugaltlink_view
, error_callback
,
3036 ret
= elf_add (state
, "", d
, base_address
, error_callback
, data
,
3037 fileline_fn
, found_sym
, found_dwarf
, NULL
, 0, 1, NULL
,
3040 backtrace_close (d
, error_callback
, data
);
3042 backtrace_close (descriptor
, error_callback
, data
);
3047 if (buildid_view_valid
)
3049 backtrace_release_view (state
, &buildid_view
, error_callback
, data
);
3050 buildid_view_valid
= 0;
3055 backtrace_release_view (state
, &opd
->view
, error_callback
, data
);
3059 if (debuglink_name
!= NULL
)
3063 d
= elf_open_debugfile_by_debuglink (state
, filename
, debuglink_name
,
3064 debuglink_crc
, error_callback
,
3070 backtrace_release_view (state
, &debuglink_view
, error_callback
,
3072 if (debugaltlink_view_valid
)
3073 backtrace_release_view (state
, &debugaltlink_view
, error_callback
,
3075 ret
= elf_add (state
, "", d
, base_address
, error_callback
, data
,
3076 fileline_fn
, found_sym
, found_dwarf
, NULL
, 0, 1, NULL
,
3079 backtrace_close (d
, error_callback
, data
);
3081 backtrace_close(descriptor
, error_callback
, data
);
3086 if (debuglink_view_valid
)
3088 backtrace_release_view (state
, &debuglink_view
, error_callback
, data
);
3089 debuglink_view_valid
= 0;
3092 struct dwarf_data
*fileline_altlink
= NULL
;
3093 if (debugaltlink_name
!= NULL
)
3097 d
= elf_open_debugfile_by_debuglink (state
, filename
, debugaltlink_name
,
3098 0, error_callback
, data
);
3103 ret
= elf_add (state
, filename
, d
, base_address
, error_callback
, data
,
3104 fileline_fn
, found_sym
, found_dwarf
, &fileline_altlink
,
3105 0, 1, debugaltlink_buildid_data
,
3106 debugaltlink_buildid_size
);
3107 backtrace_release_view (state
, &debugaltlink_view
, error_callback
,
3109 debugaltlink_view_valid
= 0;
3112 backtrace_close (d
, error_callback
, data
);
3118 if (debugaltlink_view_valid
)
3120 backtrace_release_view (state
, &debugaltlink_view
, error_callback
, data
);
3121 debugaltlink_view_valid
= 0;
3124 /* Read all the debug sections in a single view, since they are
3125 probably adjacent in the file. If any of sections are
3126 uncompressed, we never release this view. */
3130 for (i
= 0; i
< (int) DEBUG_MAX
; ++i
)
3134 if (sections
[i
].size
!= 0)
3136 if (min_offset
== 0 || sections
[i
].offset
< min_offset
)
3137 min_offset
= sections
[i
].offset
;
3138 end
= sections
[i
].offset
+ sections
[i
].size
;
3139 if (end
> max_offset
)
3142 if (zsections
[i
].size
!= 0)
3144 if (min_offset
== 0 || zsections
[i
].offset
< min_offset
)
3145 min_offset
= zsections
[i
].offset
;
3146 end
= zsections
[i
].offset
+ zsections
[i
].size
;
3147 if (end
> max_offset
)
3151 if (min_offset
== 0 || max_offset
== 0)
3153 if (!backtrace_close (descriptor
, error_callback
, data
))
3158 if (!backtrace_get_view (state
, descriptor
, min_offset
,
3159 max_offset
- min_offset
,
3160 error_callback
, data
, &debug_view
))
3162 debug_view_valid
= 1;
3164 /* We've read all we need from the executable. */
3165 if (!backtrace_close (descriptor
, error_callback
, data
))
3169 using_debug_view
= 0;
3170 for (i
= 0; i
< (int) DEBUG_MAX
; ++i
)
3172 if (sections
[i
].size
== 0)
3173 sections
[i
].data
= NULL
;
3176 sections
[i
].data
= ((const unsigned char *) debug_view
.data
3177 + (sections
[i
].offset
- min_offset
));
3181 if (zsections
[i
].size
== 0)
3182 zsections
[i
].data
= NULL
;
3184 zsections
[i
].data
= ((const unsigned char *) debug_view
.data
3185 + (zsections
[i
].offset
- min_offset
));
3188 /* Uncompress the old format (--compress-debug-sections=zlib-gnu). */
3190 zdebug_table
= NULL
;
3191 for (i
= 0; i
< (int) DEBUG_MAX
; ++i
)
3193 if (sections
[i
].size
== 0 && zsections
[i
].size
> 0)
3195 unsigned char *uncompressed_data
;
3196 size_t uncompressed_size
;
3198 if (zdebug_table
== NULL
)
3200 zdebug_table
= ((uint16_t *)
3201 backtrace_alloc (state
, ZDEBUG_TABLE_SIZE
,
3202 error_callback
, data
));
3203 if (zdebug_table
== NULL
)
3207 uncompressed_data
= NULL
;
3208 uncompressed_size
= 0;
3209 if (!elf_uncompress_zdebug (state
, zsections
[i
].data
,
3210 zsections
[i
].size
, zdebug_table
,
3211 error_callback
, data
,
3212 &uncompressed_data
, &uncompressed_size
))
3214 sections
[i
].data
= uncompressed_data
;
3215 sections
[i
].size
= uncompressed_size
;
3216 sections
[i
].compressed
= 0;
3220 /* Uncompress the official ELF format
3221 (--compress-debug-sections=zlib-gabi). */
3222 for (i
= 0; i
< (int) DEBUG_MAX
; ++i
)
3224 unsigned char *uncompressed_data
;
3225 size_t uncompressed_size
;
3227 if (sections
[i
].size
== 0 || !sections
[i
].compressed
)
3230 if (zdebug_table
== NULL
)
3232 zdebug_table
= ((uint16_t *)
3233 backtrace_alloc (state
, ZDEBUG_TABLE_SIZE
,
3234 error_callback
, data
));
3235 if (zdebug_table
== NULL
)
3239 uncompressed_data
= NULL
;
3240 uncompressed_size
= 0;
3241 if (!elf_uncompress_chdr (state
, sections
[i
].data
, sections
[i
].size
,
3242 zdebug_table
, error_callback
, data
,
3243 &uncompressed_data
, &uncompressed_size
))
3245 sections
[i
].data
= uncompressed_data
;
3246 sections
[i
].size
= uncompressed_size
;
3247 sections
[i
].compressed
= 0;
3252 if (zdebug_table
!= NULL
)
3253 backtrace_free (state
, zdebug_table
, ZDEBUG_TABLE_SIZE
,
3254 error_callback
, data
);
3256 if (debug_view_valid
&& using_debug_view
== 0)
3258 backtrace_release_view (state
, &debug_view
, error_callback
, data
);
3259 debug_view_valid
= 0;
3262 for (i
= 0; i
< (int) DEBUG_MAX
; ++i
)
3264 dwarf_sections
.data
[i
] = sections
[i
].data
;
3265 dwarf_sections
.size
[i
] = sections
[i
].size
;
3268 if (!backtrace_dwarf_add (state
, base_address
, &dwarf_sections
,
3269 ehdr
.e_ident
[EI_DATA
] == ELFDATA2MSB
,
3271 error_callback
, data
, fileline_fn
,
3280 if (shdrs_view_valid
)
3281 backtrace_release_view (state
, &shdrs_view
, error_callback
, data
);
3282 if (names_view_valid
)
3283 backtrace_release_view (state
, &names_view
, error_callback
, data
);
3284 if (symtab_view_valid
)
3285 backtrace_release_view (state
, &symtab_view
, error_callback
, data
);
3286 if (strtab_view_valid
)
3287 backtrace_release_view (state
, &strtab_view
, error_callback
, data
);
3288 if (debuglink_view_valid
)
3289 backtrace_release_view (state
, &debuglink_view
, error_callback
, data
);
3290 if (debugaltlink_view_valid
)
3291 backtrace_release_view (state
, &debugaltlink_view
, error_callback
, data
);
3292 if (buildid_view_valid
)
3293 backtrace_release_view (state
, &buildid_view
, error_callback
, data
);
3294 if (debug_view_valid
)
3295 backtrace_release_view (state
, &debug_view
, error_callback
, data
);
3297 backtrace_release_view (state
, &opd
->view
, error_callback
, data
);
3298 if (descriptor
!= -1)
3299 backtrace_close (descriptor
, error_callback
, data
);
3303 /* Data passed to phdr_callback. */
3307 struct backtrace_state
*state
;
3308 backtrace_error_callback error_callback
;
3310 fileline
*fileline_fn
;
3313 const char *exe_filename
;
3317 /* Callback passed to dl_iterate_phdr. Load debug info from shared
3322 __attribute__ ((__force_align_arg_pointer__
))
3324 phdr_callback (struct dl_phdr_info
*info
, size_t size ATTRIBUTE_UNUSED
,
3327 struct phdr_data
*pd
= (struct phdr_data
*) pdata
;
3328 const char *filename
;
3331 fileline elf_fileline_fn
;
3334 /* There is not much we can do if we don't have the module name,
3335 unless executable is ET_DYN, where we expect the very first
3336 phdr_callback to be for the PIE. */
3337 if (info
->dlpi_name
== NULL
|| info
->dlpi_name
[0] == '\0')
3339 if (pd
->exe_descriptor
== -1)
3341 filename
= pd
->exe_filename
;
3342 descriptor
= pd
->exe_descriptor
;
3343 pd
->exe_descriptor
= -1;
3347 if (pd
->exe_descriptor
!= -1)
3349 backtrace_close (pd
->exe_descriptor
, pd
->error_callback
, pd
->data
);
3350 pd
->exe_descriptor
= -1;
3353 filename
= info
->dlpi_name
;
3354 descriptor
= backtrace_open (info
->dlpi_name
, pd
->error_callback
,
3355 pd
->data
, &does_not_exist
);
3360 if (elf_add (pd
->state
, filename
, descriptor
, info
->dlpi_addr
,
3361 pd
->error_callback
, pd
->data
, &elf_fileline_fn
, pd
->found_sym
,
3362 &found_dwarf
, NULL
, 0, 0, NULL
, 0))
3366 *pd
->found_dwarf
= 1;
3367 *pd
->fileline_fn
= elf_fileline_fn
;
3374 /* Initialize the backtrace data we need from an ELF executable. At
3375 the ELF level, all we need to do is find the debug info
3379 backtrace_initialize (struct backtrace_state
*state
, const char *filename
,
3380 int descriptor
, backtrace_error_callback error_callback
,
3381 void *data
, fileline
*fileline_fn
)
3386 fileline elf_fileline_fn
= elf_nodebug
;
3387 struct phdr_data pd
;
3389 ret
= elf_add (state
, filename
, descriptor
, 0, error_callback
, data
,
3390 &elf_fileline_fn
, &found_sym
, &found_dwarf
, NULL
, 1, 0, NULL
,
3396 pd
.error_callback
= error_callback
;
3398 pd
.fileline_fn
= &elf_fileline_fn
;
3399 pd
.found_sym
= &found_sym
;
3400 pd
.found_dwarf
= &found_dwarf
;
3401 pd
.exe_filename
= filename
;
3402 pd
.exe_descriptor
= ret
< 0 ? descriptor
: -1;
3404 dl_iterate_phdr (phdr_callback
, (void *) &pd
);
3406 if (!state
->threaded
)
3409 state
->syminfo_fn
= elf_syminfo
;
3410 else if (state
->syminfo_fn
== NULL
)
3411 state
->syminfo_fn
= elf_nosyms
;
3416 backtrace_atomic_store_pointer (&state
->syminfo_fn
, elf_syminfo
);
3418 (void) __sync_bool_compare_and_swap (&state
->syminfo_fn
, NULL
,
3422 if (!state
->threaded
)
3423 *fileline_fn
= state
->fileline_fn
;
3425 *fileline_fn
= backtrace_atomic_load_pointer (&state
->fileline_fn
);
3427 if (*fileline_fn
== NULL
|| *fileline_fn
== elf_nodebug
)
3428 *fileline_fn
= elf_fileline_fn
;