vieter-v
/
v
2
0
Fork 0
Code Issues Pull Requests Releases Activity
v/thirdparty/libbacktrace/linux.c

3866 lines
111 KiB
C
Raw Blame History

// elf.c:
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#ifdef HAVE_DL_ITERATE_PHDR
#include <link.h>
#endif
#ifndef S_ISLNK
#ifndef S_IFLNK
#define S_IFLNK 0120000
#endif
#ifndef S_IFMT
#define S_IFMT 0170000
#endif
#define S_ISLNK(m) (((m)&S_IFMT) == S_IFLNK)
#endif
#ifndef __GNUC__
#define __builtin_prefetch(p, r, l)
#define unlikely(x) (x)
#else
#define unlikely(x) __builtin_expect(!!(x), 0)
#endif
#if !defined(HAVE_DECL_STRNLEN) || !HAVE_DECL_STRNLEN
static size_t xstrnlen(const char *s, size_t maxlen) {
size_t i;
for (i = 0; i < maxlen; ++i)
if (s[i] == '\0') break;
return i;
}
#define strnlen xstrnlen
#endif
#ifndef HAVE_LSTAT
static int xlstat(const char *path ATTRIBUTE_UNUSED,
struct stat *st ATTRIBUTE_UNUSED) {
return -1;
}
#define lstat xlstat
#endif
#ifndef HAVE_READLINK
static ssize_t xreadlink(const char *path ATTRIBUTE_UNUSED,
char *buf ATTRIBUTE_UNUSED,
size_t bufsz ATTRIBUTE_UNUSED) {
return -1;
}
#define readlink xreadlink
#endif
#ifndef HAVE_DL_ITERATE_PHDR
#define dl_phdr_info x_dl_phdr_info
#define dl_iterate_phdr x_dl_iterate_phdr
struct dl_phdr_info {
uintptr_t dlpi_addr;
const char *dlpi_name;
};
static int dl_iterate_phdr(int (*callback)(struct dl_phdr_info *, size_t,
void *) ATTRIBUTE_UNUSED,
void *data ATTRIBUTE_UNUSED) {
return 0;
}
#endif
#if BACKTRACE_ELF_SIZE != 32 && BACKTRACE_ELF_SIZE != 64
#error "Unknown BACKTRACE_ELF_SIZE"
#endif
#undef EI_NIDENT
#undef EI_MAG0
#undef EI_MAG1
#undef EI_MAG2
#undef EI_MAG3
#undef EI_CLASS
#undef EI_DATA
#undef EI_VERSION
#undef ELF_MAG0
#undef ELF_MAG1
#undef ELF_MAG2
#undef ELF_MAG3
#undef ELFCLASS32
#undef ELFCLASS64
#undef ELFDATA2LSB
#undef ELFDATA2MSB
#undef EV_CURRENT
#undef ET_DYN
#undef EM_PPC64
#undef EF_PPC64_ABI
#undef SHN_LORESERVE
#undef SHN_XINDEX
#undef SHN_UNDEF
#undef SHT_PROGBITS
#undef SHT_SYMTAB
#undef SHT_STRTAB
#undef SHT_DYNSYM
#undef SHF_COMPRESSED
#undef STT_OBJECT
#undef STT_FUNC
#undef NT_GNU_BUILD_ID
#undef ELFCOMPRESS_ZLIB
typedef uint16_t b_elf_half;
typedef uint32_t b_elf_word;
typedef int32_t b_elf_sword;
#if BACKTRACE_ELF_SIZE == 32
typedef uint32_t b_elf_addr;
typedef uint32_t b_elf_off;
typedef uint32_t b_elf_wxword;
#else
typedef uint64_t b_elf_addr;
typedef uint64_t b_elf_off;
typedef uint64_t b_elf_xword;
typedef int64_t b_elf_sxword;
typedef uint64_t b_elf_wxword;
#endif
#define EI_NIDENT 16
typedef struct {
unsigned char e_ident[EI_NIDENT];
b_elf_half e_type;
b_elf_half e_machine;
b_elf_word e_version;
b_elf_addr e_entry;
b_elf_off e_phoff;
b_elf_off e_shoff;
b_elf_word e_flags;
b_elf_half e_ehsize;
b_elf_half e_phentsize;
b_elf_half e_phnum;
b_elf_half e_shentsize;
b_elf_half e_shnum;
b_elf_half e_shstrndx;
} b_elf_ehdr;
#define EI_MAG0 0
#define EI_MAG1 1
#define EI_MAG2 2
#define EI_MAG3 3
#define EI_CLASS 4
#define EI_DATA 5
#define EI_VERSION 6
#define ELFMAG0 0x7f
#define ELFMAG1 'E'
#define ELFMAG2 'L'
#define ELFMAG3 'F'
#define ELFCLASS32 1
#define ELFCLASS64 2
#define ELFDATA2LSB 1
#define ELFDATA2MSB 2
#define EV_CURRENT 1
#define ET_DYN 3
#define EM_PPC64 21
#define EF_PPC64_ABI 3
typedef struct {
b_elf_word sh_name;
b_elf_word sh_type;
b_elf_wxword sh_flags;
b_elf_addr sh_addr;
b_elf_off sh_offset;
b_elf_wxword sh_size;
b_elf_word sh_link;
b_elf_word sh_info;
b_elf_wxword sh_addralign;
b_elf_wxword sh_entsize;
} b_elf_shdr;
#define SHN_UNDEF 0x0000
#define SHN_LORESERVE 0xFF00
#define SHN_XINDEX 0xFFFF
#define SHT_PROGBITS 1
#define SHT_SYMTAB 2
#define SHT_STRTAB 3
#define SHT_DYNSYM 11
#define SHF_COMPRESSED 0x800
#if BACKTRACE_ELF_SIZE == 32
typedef struct {
b_elf_word st_name;
b_elf_addr st_value;
b_elf_word st_size;
unsigned char st_info;
unsigned char st_other;
b_elf_half st_shndx;
} b_elf_sym;
#else
typedef struct {
b_elf_word st_name;
unsigned char st_info;
unsigned char st_other;
b_elf_half st_shndx;
b_elf_addr st_value;
b_elf_xword st_size;
} b_elf_sym;
#endif
#define STT_OBJECT 1
#define STT_FUNC 2
typedef struct {
uint32_t namesz;
uint32_t descsz;
uint32_t type;
char name[1];
} b_elf_note;
#define NT_GNU_BUILD_ID 3
#if BACKTRACE_ELF_SIZE == 32
typedef struct {
b_elf_word ch_type;
b_elf_word ch_size;
b_elf_word ch_addralign;
} b_elf_chdr;
#else
typedef struct {
b_elf_word ch_type;
b_elf_word ch_reserved;
b_elf_xword ch_size;
b_elf_xword ch_addralign;
} b_elf_chdr;
#endif
#define ELFCOMPRESS_ZLIB 1
static const char *const dwarf_section_names[DEBUG_MAX] = {
".debug_info", ".debug_line", ".debug_abbrev",
".debug_ranges", ".debug_str", ".debug_addr",
".debug_str_offsets", ".debug_line_str", ".debug_rnglists"};
struct debug_section_info {
off_t offset;
size_t size;
const unsigned char *data;
int compressed;
};
struct elf_symbol {
const char *name;
uintptr_t address;
size_t size;
};
struct elf_syminfo_data {
struct elf_syminfo_data *next;
struct elf_symbol *symbols;
size_t count;
};
struct elf_view {
struct backtrace_view view;
int release;
};
struct elf_ppc64_opd_data {
b_elf_addr addr;
const char *data;
size_t size;
struct elf_view view;
};
static int elf_get_view(struct backtrace_state *state, int descriptor,
const unsigned char *memory, size_t memory_size,
off_t offset, uint64_t size,
backtrace_error_callback error_callback, void *data,
struct elf_view *view) {
if (memory == NULL) {
view->release = 1;
return backtrace_get_view(state, descriptor, offset, size, error_callback,
data, &view->view);
} else {
if ((uint64_t)offset + size > (uint64_t)memory_size) {
error_callback(data, "out of range for in-memory file", 0);
return 0;
}
view->view.data = (const void *)(memory + offset);
view->view.base = NULL;
view->view.len = size;
view->release = 0;
return 1;
}
}
static void elf_release_view(struct backtrace_state *state,
struct elf_view *view,
backtrace_error_callback error_callback,
void *data) {
if (view->release)
backtrace_release_view(state, &view->view, error_callback, data);
}
static uint32_t elf_crc32(uint32_t crc, const unsigned char *buf, size_t len) {
static const uint32_t crc32_table[256] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d};
const unsigned char *end;
crc = ~crc;
for (end = buf + len; buf < end; ++buf)
crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
return ~crc;
}
static uint32_t elf_crc32_file(struct backtrace_state *state, int descriptor,
backtrace_error_callback error_callback,
void *data) {
struct stat st;
struct backtrace_view file_view;
uint32_t ret;
if (fstat(descriptor, &st) < 0) {
error_callback(data, "fstat", errno);
return 0;
}
if (!backtrace_get_view(state, descriptor, 0, st.st_size, error_callback,
data, &file_view))
return 0;
ret = elf_crc32(0, (const unsigned char *)file_view.data, st.st_size);
backtrace_release_view(state, &file_view, error_callback, data);
return ret;
}
static void elf_nosyms(struct backtrace_state *state ATTRIBUTE_UNUSED,
uintptr_t addr ATTRIBUTE_UNUSED,
backtrace_syminfo_callback callback ATTRIBUTE_UNUSED,
backtrace_error_callback error_callback, void *data) {
error_callback(data, "no symbol table in ELF executable", -1);
}
static int elf_nodebug(struct backtrace_state *state, uintptr_t pc,
backtrace_full_callback callback,
backtrace_error_callback error_callback, void *data) {
if (state->syminfo_fn != NULL && state->syminfo_fn != elf_nosyms) {
struct backtrace_call_full bdata;
bdata.full_callback = callback;
bdata.full_error_callback = error_callback;
bdata.full_data = data;
bdata.ret = 0;
state->syminfo_fn(state, pc, backtrace_syminfo_to_full_callback,
backtrace_syminfo_to_full_error_callback, &bdata);
return bdata.ret;
}
error_callback(data, "no debug info in ELF executable", -1);
return 0;
}
static int elf_symbol_compare(const void *v1, const void *v2) {
const struct elf_symbol *e1 = (const struct elf_symbol *)v1;
const struct elf_symbol *e2 = (const struct elf_symbol *)v2;
if (e1->address < e2->address)
return -1;
else if (e1->address > e2->address)
return 1;
else
return 0;
}
static int elf_symbol_search(const void *vkey, const void *ventry) {
const uintptr_t *key = (const uintptr_t *)vkey;
const struct elf_symbol *entry = (const struct elf_symbol *)ventry;
uintptr_t addr;
addr = *key;
if (addr < entry->address)
return -1;
else if (addr >= entry->address + entry->size)
return 1;
else
return 0;
}
static int elf_initialize_syminfo(
struct backtrace_state *state, uintptr_t base_address,
const unsigned char *symtab_data, size_t symtab_size,
const unsigned char *strtab, size_t strtab_size,
backtrace_error_callback error_callback, void *data,
struct elf_syminfo_data *sdata, struct elf_ppc64_opd_data *opd) {
size_t sym_count;
const b_elf_sym *sym;
size_t elf_symbol_count;
size_t elf_symbol_size;
struct elf_symbol *elf_symbols;
size_t i;
unsigned int j;
sym_count = symtab_size / sizeof(b_elf_sym);
sym = (const b_elf_sym *)symtab_data;
elf_symbol_count = 0;
for (i = 0; i < sym_count; ++i, ++sym) {
int info;
info = sym->st_info & 0xf;
if ((info == STT_FUNC || info == STT_OBJECT) && sym->st_shndx != SHN_UNDEF)
++elf_symbol_count;
}
elf_symbol_size = elf_symbol_count * sizeof(struct elf_symbol);
elf_symbols = ((struct elf_symbol *)backtrace_alloc(state, elf_symbol_size,
error_callback, data));
if (elf_symbols == NULL) return 0;
sym = (const b_elf_sym *)symtab_data;
j = 0;
for (i = 0; i < sym_count; ++i, ++sym) {
int info;
info = sym->st_info & 0xf;
if (info != STT_FUNC && info != STT_OBJECT) continue;
if (sym->st_shndx == SHN_UNDEF) continue;
if (sym->st_name >= strtab_size) {
error_callback(data, "symbol string index out of range", 0);
backtrace_free(state, elf_symbols, elf_symbol_size, error_callback, data);
return 0;
}
elf_symbols[j].name = (const char *)strtab + sym->st_name;
if (opd && sym->st_value >= opd->addr &&
sym->st_value < opd->addr + opd->size)
elf_symbols[j].address =
*(const b_elf_addr *)(opd->data + (sym->st_value - opd->addr));
else
elf_symbols[j].address = sym->st_value;
elf_symbols[j].address += base_address;
elf_symbols[j].size = sym->st_size;
++j;
}
backtrace_qsort(elf_symbols, elf_symbol_count, sizeof(struct elf_symbol),
elf_symbol_compare);
sdata->next = NULL;
sdata->symbols = elf_symbols;
sdata->count = elf_symbol_count;
return 1;
}
static void elf_add_syminfo_data(struct backtrace_state *state,
struct elf_syminfo_data *edata) {
if (!state->threaded) {
struct elf_syminfo_data **pp;
for (pp = (struct elf_syminfo_data **)(void *)&state->syminfo_data;
*pp != NULL; pp = &(*pp)->next)
;
*pp = edata;
} else {
while (1) {
struct elf_syminfo_data **pp;
pp = (struct elf_syminfo_data **)(void *)&state->syminfo_data;
while (1) {
struct elf_syminfo_data *p;
p = backtrace_atomic_load_pointer(pp);
if (p == NULL) break;
pp = &p->next;
}
if (__sync_bool_compare_and_swap(pp, NULL, edata)) break;
}
}
}
static void elf_syminfo(
struct backtrace_state *state, uintptr_t addr,
backtrace_syminfo_callback callback,
backtrace_error_callback error_callback ATTRIBUTE_UNUSED, void *data) {
struct elf_syminfo_data *edata;
struct elf_symbol *sym = NULL;
if (!state->threaded) {
for (edata = (struct elf_syminfo_data *)state->syminfo_data; edata != NULL;
edata = edata->next) {
sym = ((struct elf_symbol *)bsearch(&addr, edata->symbols, edata->count,
sizeof(struct elf_symbol),
elf_symbol_search));
if (sym != NULL) break;
}
} else {
struct elf_syminfo_data **pp;
pp = (struct elf_syminfo_data **)(void *)&state->syminfo_data;
while (1) {
edata = backtrace_atomic_load_pointer(pp);
if (edata == NULL) break;
sym = ((struct elf_symbol *)bsearch(&addr, edata->symbols, edata->count,
sizeof(struct elf_symbol),
elf_symbol_search));
if (sym != NULL) break;
pp = &edata->next;
}
}
if (sym == NULL)
callback(data, addr, NULL, 0, 0);
else
callback(data, addr, sym->name, sym->address, sym->size);
}
static int elf_is_symlink(const char *filename) {
struct stat st;
if (lstat(filename, &st) < 0) return 0;
return S_ISLNK(st.st_mode);
}
static char *elf_readlink(struct backtrace_state *state, const char *filename,
backtrace_error_callback error_callback, void *data,
size_t *plen) {
size_t len;
char *buf;
len = 128;
while (1) {
ssize_t rl;
buf = backtrace_alloc(state, len, error_callback, data);
if (buf == NULL) return NULL;
rl = readlink(filename, buf, len);
if (rl < 0) {
backtrace_free(state, buf, len, error_callback, data);
return NULL;
}
if ((size_t)rl < len - 1) {
buf[rl] = '\0';
*plen = len;
return buf;
}
backtrace_free(state, buf, len, error_callback, data);
len *= 2;
}
}
#define SYSTEM_BUILD_ID_DIR "/usr/lib/debug/.build-id/"
static int elf_open_debugfile_by_buildid(
struct backtrace_state *state, const char *buildid_data,
size_t buildid_size, backtrace_error_callback error_callback, void *data) {
const char *const prefix = SYSTEM_BUILD_ID_DIR;
const size_t prefix_len = strlen(prefix);
const char *const suffix = ".debug";
const size_t suffix_len = strlen(suffix);
size_t len;
char *bd_filename;
char *t;
size_t i;
int ret;
int does_not_exist;
len = prefix_len + buildid_size * 2 + suffix_len + 2;
bd_filename = backtrace_alloc(state, len, error_callback, data);
if (bd_filename == NULL) return -1;
t = bd_filename;
memcpy(t, prefix, prefix_len);
t += prefix_len;
for (i = 0; i < buildid_size; i++) {
unsigned char b;
unsigned char nib;
b = (unsigned char)buildid_data[i];
nib = (b & 0xf0) >> 4;
*t++ = nib < 10 ? '0' + nib : 'a' + nib - 10;
nib = b & 0x0f;
*t++ = nib < 10 ? '0' + nib : 'a' + nib - 10;
if (i == 0) *t++ = '/';
}
memcpy(t, suffix, suffix_len);
t[suffix_len] = '\0';
ret = backtrace_open(bd_filename, error_callback, data, &does_not_exist);
backtrace_free(state, bd_filename, len, error_callback, data);
return ret;
}
static int elf_try_debugfile(struct backtrace_state *state, const char *prefix,
size_t prefix_len, const char *prefix2,
size_t prefix2_len, const char *debuglink_name,
backtrace_error_callback error_callback,
void *data) {
size_t debuglink_len;
size_t try_len;
char *try;
int does_not_exist;
int ret;
debuglink_len = strlen(debuglink_name);
try_len = prefix_len + prefix2_len + debuglink_len + 1;
try = backtrace_alloc(state, try_len, error_callback, data);
if (try == NULL) return -1;
memcpy(try, prefix, prefix_len);
memcpy(try + prefix_len, prefix2, prefix2_len);
memcpy(try + prefix_len + prefix2_len, debuglink_name, debuglink_len);
try[prefix_len + prefix2_len + debuglink_len] = '\0';
ret = backtrace_open(try, error_callback, data, &does_not_exist);
backtrace_free(state, try, try_len, error_callback, data);
return ret;
}
static int elf_find_debugfile_by_debuglink(
struct backtrace_state *state, const char *filename,
const char *debuglink_name, backtrace_error_callback error_callback,
void *data) {
int ret;
char *alc;
size_t alc_len;
const char *slash;
int ddescriptor;
const char *prefix;
size_t prefix_len;
ret = -1;
alc = NULL;
alc_len = 0;
while (elf_is_symlink(filename)) {
char *new_buf;
size_t new_len;
new_buf = elf_readlink(state, filename, error_callback, data, &new_len);
if (new_buf == NULL) break;
if (new_buf[0] == '/')
filename = new_buf;
else {
slash = strrchr(filename, '/');
if (slash == NULL)
filename = new_buf;
else {
size_t clen;
char *c;
slash++;
clen = slash - filename + strlen(new_buf) + 1;
c = backtrace_alloc(state, clen, error_callback, data);
if (c == NULL) goto done;
memcpy(c, filename, slash - filename);
memcpy(c + (slash - filename), new_buf, strlen(new_buf));
c[slash - filename + strlen(new_buf)] = '\0';
backtrace_free(state, new_buf, new_len, error_callback, data);
filename = c;
new_buf = c;
new_len = clen;
}
}
if (alc != NULL) backtrace_free(state, alc, alc_len, error_callback, data);
alc = new_buf;
alc_len = new_len;
}
slash = strrchr(filename, '/');
if (slash == NULL) {
prefix = "";
prefix_len = 0;
} else {
slash++;
prefix = filename;
prefix_len = slash - filename;
}
ddescriptor = elf_try_debugfile(state, prefix, prefix_len, "", 0,
debuglink_name, error_callback, data);
if (ddescriptor >= 0) {
ret = ddescriptor;
goto done;
}
ddescriptor =
elf_try_debugfile(state, prefix, prefix_len, ".debug/", strlen(".debug/"),
debuglink_name, error_callback, data);
if (ddescriptor >= 0) {
ret = ddescriptor;
goto done;
}
ddescriptor = elf_try_debugfile(state, "/usr/lib/debug/",
strlen("/usr/lib/debug/"), prefix, prefix_len,
debuglink_name, error_callback, data);
if (ddescriptor >= 0) ret = ddescriptor;
done:
if (alc != NULL && alc_len > 0)
backtrace_free(state, alc, alc_len, error_callback, data);
return ret;
}
static int elf_open_debugfile_by_debuglink(
struct backtrace_state *state, const char *filename,
const char *debuglink_name, uint32_t debuglink_crc,
backtrace_error_callback error_callback, void *data) {
int ddescriptor;
ddescriptor = elf_find_debugfile_by_debuglink(state, filename, debuglink_name,
error_callback, data);
if (ddescriptor < 0) return -1;
if (debuglink_crc != 0) {
uint32_t got_crc;
got_crc = elf_crc32_file(state, ddescriptor, error_callback, data);
if (got_crc != debuglink_crc) {
backtrace_close(ddescriptor, error_callback, data);
return -1;
}
}
return ddescriptor;
}
static void elf_uncompress_failed(void) {}
static int elf_zlib_fetch(const unsigned char **ppin,
const unsigned char *pinend, uint64_t *pval,
unsigned int *pbits) {
unsigned int bits;
const unsigned char *pin;
uint64_t val;
uint32_t next;
bits = *pbits;
if (bits >= 15) return 1;
pin = *ppin;
val = *pval;
if (unlikely(pinend - pin < 4)) {
elf_uncompress_failed();
return 0;
}
#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \
defined(__ORDER_BIG_ENDIAN__) && \
(__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ || \
__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
next = *(const uint32_t *)pin;
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
next = __builtin_bswap32(next);
#endif
#else
next = pin[0] | (pin[1] << 8) | (pin[2] << 16) | (pin[3] << 24);
#endif
val |= (uint64_t)next << bits;
bits += 32;
pin += 4;
__builtin_prefetch(pin, 0, 0);
*ppin = pin;
*pval = val;
*pbits = bits;
return 1;
}
#define HUFFMAN_TABLE_SIZE (1024)
#define HUFFMAN_VALUE_MASK 0x01ff
#define HUFFMAN_BITS_SHIFT 9
#define HUFFMAN_BITS_MASK 0x7
#define HUFFMAN_SECONDARY_SHIFT 12
#define ZDEBUG_TABLE_SIZE \
(2 * HUFFMAN_TABLE_SIZE * sizeof(uint16_t) + (286 + 30) * sizeof(uint16_t) + \
(286 + 30) * sizeof(unsigned char))
#define ZDEBUG_TABLE_CODELEN_OFFSET \
(2 * HUFFMAN_TABLE_SIZE * sizeof(uint16_t) + (286 + 30) * sizeof(uint16_t))
#define ZDEBUG_TABLE_WORK_OFFSET (2 * HUFFMAN_TABLE_SIZE * sizeof(uint16_t))
#ifdef BACKTRACE_GENERATE_FIXED_HUFFMAN_TABLE
static size_t final_next_secondary;
#endif
static int elf_zlib_inflate_table(unsigned char *codes, size_t codes_len,
uint16_t *zdebug_table, uint16_t *table) {
uint16_t count[16];
uint16_t start[16];
uint16_t prev[16];
uint16_t firstcode[7];
uint16_t *next;
size_t i;
size_t j;
unsigned int code;
size_t next_secondary;
next =
(uint16_t *)(((unsigned char *)zdebug_table) + ZDEBUG_TABLE_WORK_OFFSET);
memset(&count[0], 0, 16 * sizeof(uint16_t));
for (i = 0; i < codes_len; ++i) {
if (unlikely(codes[i] >= 16)) {
elf_uncompress_failed();
return 0;
}
if (count[codes[i]] == 0) {
start[codes[i]] = i;
prev[codes[i]] = i;
} else {
next[prev[codes[i]]] = i;
prev[codes[i]] = i;
}
++count[codes[i]];
}
memset(table, 0, HUFFMAN_TABLE_SIZE * sizeof(uint16_t));
code = 0;
for (j = 1; j <= 8; ++j) {
unsigned int jcnt;
unsigned int val;
jcnt = count[j];
if (jcnt == 0) continue;
if (unlikely(jcnt > (1U << j))) {
elf_uncompress_failed();
return 0;
}
val = start[j];
for (i = 0; i < jcnt; ++i) {
uint16_t tval;
size_t ind;
unsigned int incr;
if (unlikely((val & ~HUFFMAN_VALUE_MASK) != 0)) {
elf_uncompress_failed();
return 0;
}
tval = val | ((j - 1) << HUFFMAN_BITS_SHIFT);
for (ind = code; ind < 0x100; ind += 1 << j) {
if (unlikely(table[ind] != 0)) {
elf_uncompress_failed();
return 0;
}
table[ind] = tval;
}
if (i + 1 < jcnt) val = next[val];
incr = 1U << (j - 1);
while ((code & incr) != 0) incr >>= 1;
if (incr == 0)
code = 0;
else {
code &= incr - 1;
code += incr;
}
}
}
for (j = 9; j < 16; j++) {
unsigned int jcnt;
unsigned int k;
jcnt = count[j];
if (jcnt == 0) continue;
firstcode[j - 9] = code;
for (k = 0; k < j; ++k) {
if ((jcnt & (1U << k)) != 0) {
unsigned int m;
unsigned int bit;
bit = 1U << (j - k - 1);
for (m = 0; m < j - k; ++m, bit >>= 1) {
if ((code & bit) == 0) {
code += bit;
break;
}
code &= ~bit;
}
jcnt &= ~(1U << k);
}
}
if (unlikely(jcnt != 0)) {
elf_uncompress_failed();
return 0;
}
}
next_secondary = 0;
for (j = 15; j >= 9; j--) {
unsigned int jcnt;
unsigned int val;
size_t primary;
size_t secondary;
size_t secondary_bits;
jcnt = count[j];
if (jcnt == 0) continue;
val = start[j];
code = firstcode[j - 9];
primary = 0x100;
secondary = 0;
secondary_bits = 0;
for (i = 0; i < jcnt; ++i) {
uint16_t tval;
size_t ind;
unsigned int incr;
if ((code & 0xff) != primary) {
uint16_t tprimary;
primary = code & 0xff;
tprimary = table[primary];
if (tprimary == 0) {
if (unlikely((next_secondary & HUFFMAN_VALUE_MASK) !=
next_secondary)) {
elf_uncompress_failed();
return 0;
}
secondary = next_secondary;
secondary_bits = j - 8;
next_secondary += 1 << secondary_bits;
table[primary] = (secondary + ((j - 8) << HUFFMAN_BITS_SHIFT) +
(1U << HUFFMAN_SECONDARY_SHIFT));
} else {
if (unlikely((tprimary & (1U << HUFFMAN_SECONDARY_SHIFT)) == 0)) {
elf_uncompress_failed();
return 0;
}
secondary = tprimary & HUFFMAN_VALUE_MASK;
secondary_bits =
((tprimary >> HUFFMAN_BITS_SHIFT) & HUFFMAN_BITS_MASK);
if (unlikely(secondary_bits < j - 8)) {
elf_uncompress_failed();
return 0;
}
}
}
tval = val | ((j - 8) << HUFFMAN_BITS_SHIFT);
for (ind = code >> 8; ind < (1U << secondary_bits);
ind += 1U << (j - 8)) {
if (unlikely(table[secondary + 0x100 + ind] != 0)) {
elf_uncompress_failed();
return 0;
}
table[secondary + 0x100 + ind] = tval;
}
if (i + 1 < jcnt) val = next[val];
incr = 1U << (j - 1);
while ((code & incr) != 0) incr >>= 1;
if (incr == 0)
code = 0;
else {
code &= incr - 1;
code += incr;
}
}
}
#ifdef BACKTRACE_GENERATE_FIXED_HUFFMAN_TABLE
final_next_secondary = next_secondary;
#endif
return 1;
}
static const uint16_t elf_zlib_default_table[0x170] = {
0xd00, 0xe50, 0xe10, 0xf18, 0xd10, 0xe70, 0xe30, 0x1230, 0xd08, 0xe60,
0xe20, 0x1210, 0xe00, 0xe80, 0xe40, 0x1250, 0xd04, 0xe58, 0xe18, 0x1200,
0xd14, 0xe78, 0xe38, 0x1240, 0xd0c, 0xe68, 0xe28, 0x1220, 0xe08, 0xe88,
0xe48, 0x1260, 0xd02, 0xe54, 0xe14, 0xf1c, 0xd12, 0xe74, 0xe34, 0x1238,
0xd0a, 0xe64, 0xe24, 0x1218, 0xe04, 0xe84, 0xe44, 0x1258, 0xd06, 0xe5c,
0xe1c, 0x1208, 0xd16, 0xe7c, 0xe3c, 0x1248, 0xd0e, 0xe6c, 0xe2c, 0x1228,
0xe0c, 0xe8c, 0xe4c, 0x1268, 0xd01, 0xe52, 0xe12, 0xf1a, 0xd11, 0xe72,
0xe32, 0x1234, 0xd09, 0xe62, 0xe22, 0x1214, 0xe02, 0xe82, 0xe42, 0x1254,
0xd05, 0xe5a, 0xe1a, 0x1204, 0xd15, 0xe7a, 0xe3a, 0x1244, 0xd0d, 0xe6a,
0xe2a, 0x1224, 0xe0a, 0xe8a, 0xe4a, 0x1264, 0xd03, 0xe56, 0xe16, 0xf1e,
0xd13, 0xe76, 0xe36, 0x123c, 0xd0b, 0xe66, 0xe26, 0x121c, 0xe06, 0xe86,
0xe46, 0x125c, 0xd07, 0xe5e, 0xe1e, 0x120c, 0xd17, 0xe7e, 0xe3e, 0x124c,
0xd0f, 0xe6e, 0xe2e, 0x122c, 0xe0e, 0xe8e, 0xe4e, 0x126c, 0xd00, 0xe51,
0xe11, 0xf19, 0xd10, 0xe71, 0xe31, 0x1232, 0xd08, 0xe61, 0xe21, 0x1212,
0xe01, 0xe81, 0xe41, 0x1252, 0xd04, 0xe59, 0xe19, 0x1202, 0xd14, 0xe79,
0xe39, 0x1242, 0xd0c, 0xe69, 0xe29, 0x1222, 0xe09, 0xe89, 0xe49, 0x1262,
0xd02, 0xe55, 0xe15, 0xf1d, 0xd12, 0xe75, 0xe35, 0x123a, 0xd0a, 0xe65,
0xe25, 0x121a, 0xe05, 0xe85, 0xe45, 0x125a, 0xd06, 0xe5d, 0xe1d, 0x120a,
0xd16, 0xe7d, 0xe3d, 0x124a, 0xd0e, 0xe6d, 0xe2d, 0x122a, 0xe0d, 0xe8d,
0xe4d, 0x126a, 0xd01, 0xe53, 0xe13, 0xf1b, 0xd11, 0xe73, 0xe33, 0x1236,
0xd09, 0xe63, 0xe23, 0x1216, 0xe03, 0xe83, 0xe43, 0x1256, 0xd05, 0xe5b,
0xe1b, 0x1206, 0xd15, 0xe7b, 0xe3b, 0x1246, 0xd0d, 0xe6b, 0xe2b, 0x1226,
0xe0b, 0xe8b, 0xe4b, 0x1266, 0xd03, 0xe57, 0xe17, 0xf1f, 0xd13, 0xe77,
0xe37, 0x123e, 0xd0b, 0xe67, 0xe27, 0x121e, 0xe07, 0xe87, 0xe47, 0x125e,
0xd07, 0xe5f, 0xe1f, 0x120e, 0xd17, 0xe7f, 0xe3f, 0x124e, 0xd0f, 0xe6f,
0xe2f, 0x122e, 0xe0f, 0xe8f, 0xe4f, 0x126e, 0x290, 0x291, 0x292, 0x293,
0x294, 0x295, 0x296, 0x297, 0x298, 0x299, 0x29a, 0x29b, 0x29c, 0x29d,
0x29e, 0x29f, 0x2a0, 0x2a1, 0x2a2, 0x2a3, 0x2a4, 0x2a5, 0x2a6, 0x2a7,
0x2a8, 0x2a9, 0x2aa, 0x2ab, 0x2ac, 0x2ad, 0x2ae, 0x2af, 0x2b0, 0x2b1,
0x2b2, 0x2b3, 0x2b4, 0x2b5, 0x2b6, 0x2b7, 0x2b8, 0x2b9, 0x2ba, 0x2bb,
0x2bc, 0x2bd, 0x2be, 0x2bf, 0x2c0, 0x2c1, 0x2c2, 0x2c3, 0x2c4, 0x2c5,
0x2c6, 0x2c7, 0x2c8, 0x2c9, 0x2ca, 0x2cb, 0x2cc, 0x2cd, 0x2ce, 0x2cf,
0x2d0, 0x2d1, 0x2d2, 0x2d3, 0x2d4, 0x2d5, 0x2d6, 0x2d7, 0x2d8, 0x2d9,
0x2da, 0x2db, 0x2dc, 0x2dd, 0x2de, 0x2df, 0x2e0, 0x2e1, 0x2e2, 0x2e3,
0x2e4, 0x2e5, 0x2e6, 0x2e7, 0x2e8, 0x2e9, 0x2ea, 0x2eb, 0x2ec, 0x2ed,
0x2ee, 0x2ef, 0x2f0, 0x2f1, 0x2f2, 0x2f3, 0x2f4, 0x2f5, 0x2f6, 0x2f7,
0x2f8, 0x2f9, 0x2fa, 0x2fb, 0x2fc, 0x2fd, 0x2fe, 0x2ff,
};
static const uint16_t elf_zlib_default_dist_table[0x100] = {
0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c, 0x802, 0x812, 0x80a,
0x81a, 0x806, 0x816, 0x80e, 0x81e, 0x801, 0x811, 0x809, 0x819, 0x805, 0x815,
0x80d, 0x81d, 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f, 0x800,
0x810, 0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c, 0x802, 0x812, 0x80a, 0x81a,
0x806, 0x816, 0x80e, 0x81e, 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d,
0x81d, 0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f, 0x800, 0x810,
0x808, 0x818, 0x804, 0x814, 0x80c, 0x81c, 0x802, 0x812, 0x80a, 0x81a, 0x806,
0x816, 0x80e, 0x81e, 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d,
0x803, 0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f, 0x800, 0x810, 0x808,
0x818, 0x804, 0x814, 0x80c, 0x81c, 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816,
0x80e, 0x81e, 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d, 0x803,
0x813, 0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f, 0x800, 0x810, 0x808, 0x818,
0x804, 0x814, 0x80c, 0x81c, 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e,
0x81e, 0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d, 0x803, 0x813,
0x80b, 0x81b, 0x807, 0x817, 0x80f, 0x81f, 0x800, 0x810, 0x808, 0x818, 0x804,
0x814, 0x80c, 0x81c, 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e,
0x801, 0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d, 0x803, 0x813, 0x80b,
0x81b, 0x807, 0x817, 0x80f, 0x81f, 0x800, 0x810, 0x808, 0x818, 0x804, 0x814,
0x80c, 0x81c, 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e, 0x801,
0x811, 0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d, 0x803, 0x813, 0x80b, 0x81b,
0x807, 0x817, 0x80f, 0x81f, 0x800, 0x810, 0x808, 0x818, 0x804, 0x814, 0x80c,
0x81c, 0x802, 0x812, 0x80a, 0x81a, 0x806, 0x816, 0x80e, 0x81e, 0x801, 0x811,
0x809, 0x819, 0x805, 0x815, 0x80d, 0x81d, 0x803, 0x813, 0x80b, 0x81b, 0x807,
0x817, 0x80f, 0x81f,
};
static int elf_zlib_inflate(const unsigned char *pin, size_t sin,
uint16_t *zdebug_table, unsigned char *pout,
size_t sout) {
unsigned char *porigout;
const unsigned char *pinend;
unsigned char *poutend;
porigout = pout;
pinend = pin + sin;
poutend = pout + sout;
while ((pinend - pin) > 4) {
uint64_t val;
unsigned int bits;
int last;
if (unlikely((pin[0] & 0xf) != 8)) {
elf_uncompress_failed();
return 0;
}
if (unlikely((pin[0] >> 4) > 7)) {
elf_uncompress_failed();
return 0;
}
if (unlikely((pin[1] & 0x20) != 0)) {
elf_uncompress_failed();
return 0;
}
val = (pin[0] << 8) | pin[1];
if (unlikely(val % 31 != 0)) {
elf_uncompress_failed();
return 0;
}
pin += 2;
val = 0;
bits = 0;
while ((((uintptr_t)pin) & 3) != 0) {
val |= (uint64_t)*pin << bits;
bits += 8;
++pin;
}
last = 0;
while (!last) {
unsigned int type;
const uint16_t *tlit;
const uint16_t *tdist;
if (!elf_zlib_fetch(&pin, pinend, &val, &bits)) return 0;
last = val & 1;
type = (val >> 1) & 3;
val >>= 3;
bits -= 3;
if (unlikely(type == 3)) {
elf_uncompress_failed();
return 0;
}
if (type == 0) {
uint16_t len;
uint16_t lenc;
while (bits >= 8) {
--pin;
bits -= 8;
}
val = 0;
bits = 0;
if (unlikely((pinend - pin) < 4)) {
elf_uncompress_failed();
return 0;
}
len = pin[0] | (pin[1] << 8);
lenc = pin[2] | (pin[3] << 8);
pin += 4;
lenc = ~lenc;
if (unlikely(len != lenc)) {
elf_uncompress_failed();
return 0;
}
if (unlikely(len > (unsigned int)(pinend - pin) ||
len > (unsigned int)(poutend - pout))) {
elf_uncompress_failed();
return 0;
}
memcpy(pout, pin, len);
pout += len;
pin += len;
while ((((uintptr_t)pin) & 3) != 0) {
val |= (uint64_t)*pin << bits;
bits += 8;
++pin;
}
continue;
}
if (type == 1) {
tlit = elf_zlib_default_table;
tdist = elf_zlib_default_dist_table;
} else {
unsigned int nlit;
unsigned int ndist;
unsigned int nclen;
unsigned char codebits[19];
unsigned char *plenbase;
unsigned char *plen;
unsigned char *plenend;
if (!elf_zlib_fetch(&pin, pinend, &val, &bits)) return 0;
nlit = (val & 0x1f) + 257;
val >>= 5;
ndist = (val & 0x1f) + 1;
val >>= 5;
nclen = (val & 0xf) + 4;
val >>= 4;
bits -= 14;
if (unlikely(nlit > 286 || ndist > 30)) {
elf_uncompress_failed();
return 0;
}
memset(&codebits[0], 0, 19);
if (!elf_zlib_fetch(&pin, pinend, &val, &bits)) return 0;
codebits[16] = val & 7;
codebits[17] = (val >> 3) & 7;
codebits[18] = (val >> 6) & 7;
codebits[0] = (val >> 9) & 7;
val >>= 12;
bits -= 12;
if (nclen == 4) goto codebitsdone;
codebits[8] = val & 7;
val >>= 3;
bits -= 3;
if (nclen == 5) goto codebitsdone;
if (!elf_zlib_fetch(&pin, pinend, &val, &bits)) return 0;
codebits[7] = val & 7;
val >>= 3;
bits -= 3;
if (nclen == 6) goto codebitsdone;
codebits[9] = val & 7;
val >>= 3;
bits -= 3;
if (nclen == 7) goto codebitsdone;
codebits[6] = val & 7;
val >>= 3;
bits -= 3;
if (nclen == 8) goto codebitsdone;
codebits[10] = val & 7;
val >>= 3;
bits -= 3;
if (nclen == 9) goto codebitsdone;
codebits[5] = val & 7;
val >>= 3;
bits -= 3;
if (nclen == 10) goto codebitsdone;
if (!elf_zlib_fetch(&pin, pinend, &val, &bits)) return 0;
codebits[11] = val & 7;
val >>= 3;
bits -= 3;
if (nclen == 11) goto codebitsdone;
codebits[4] = val & 7;
val >>= 3;
bits -= 3;
if (nclen == 12) goto codebitsdone;
codebits[12] = val & 7;
val >>= 3;
bits -= 3;
if (nclen == 13) goto codebitsdone;
codebits[3] = val & 7;
val >>= 3;
bits -= 3;
if (nclen == 14) goto codebitsdone;
codebits[13] = val & 7;
val >>= 3;
bits -= 3;
if (nclen == 15) goto codebitsdone;
if (!elf_zlib_fetch(&pin, pinend, &val, &bits)) return 0;
codebits[2] = val & 7;
val >>= 3;
bits -= 3;
if (nclen == 16) goto codebitsdone;
codebits[14] = val & 7;
val >>= 3;
bits -= 3;
if (nclen == 17) goto codebitsdone;
codebits[1] = val & 7;
val >>= 3;
bits -= 3;
if (nclen == 18) goto codebitsdone;
codebits[15] = val & 7;
val >>= 3;
bits -= 3;
codebitsdone:
if (!elf_zlib_inflate_table(codebits, 19, zdebug_table, zdebug_table))
return 0;
plenbase =
(((unsigned char *)zdebug_table) + ZDEBUG_TABLE_CODELEN_OFFSET);
plen = plenbase;
plenend = plen + nlit + ndist;
while (plen < plenend) {
uint16_t t;
unsigned int b;
uint16_t v;
if (!elf_zlib_fetch(&pin, pinend, &val, &bits)) return 0;
t = zdebug_table[val & 0xff];
if (unlikely((t & (1U << HUFFMAN_SECONDARY_SHIFT)) != 0)) {
elf_uncompress_failed();
return 0;
}
b = (t >> HUFFMAN_BITS_SHIFT) & HUFFMAN_BITS_MASK;
val >>= b + 1;
bits -= b + 1;
v = t & HUFFMAN_VALUE_MASK;
if (v < 16)
*plen++ = v;
else if (v == 16) {
unsigned int c;
unsigned int prev;
if (unlikely(plen == plenbase)) {
elf_uncompress_failed();
return 0;
}
c = 3 + (val & 0x3);
val >>= 2;
bits -= 2;
if (unlikely((unsigned int)(plenend - plen) < c)) {
elf_uncompress_failed();
return 0;
}
prev = plen[-1];
switch (c) {
case 6:
*plen++ = prev;
ATTRIBUTE_FALLTHROUGH;
case 5:
*plen++ = prev;
ATTRIBUTE_FALLTHROUGH;
case 4:
*plen++ = prev;
}
*plen++ = prev;
*plen++ = prev;
*plen++ = prev;
} else if (v == 17) {
unsigned int c;
c = 3 + (val & 0x7);
val >>= 3;
bits -= 3;
if (unlikely((unsigned int)(plenend - plen) < c)) {
elf_uncompress_failed();
return 0;
}
switch (c) {
case 10:
*plen++ = 0;
ATTRIBUTE_FALLTHROUGH;
case 9:
*plen++ = 0;
ATTRIBUTE_FALLTHROUGH;
case 8:
*plen++ = 0;
ATTRIBUTE_FALLTHROUGH;
case 7:
*plen++ = 0;
ATTRIBUTE_FALLTHROUGH;
case 6:
*plen++ = 0;
ATTRIBUTE_FALLTHROUGH;
case 5:
*plen++ = 0;
ATTRIBUTE_FALLTHROUGH;
case 4:
*plen++ = 0;
}
*plen++ = 0;
*plen++ = 0;
*plen++ = 0;
} else if (v == 18) {
unsigned int c;
c = 11 + (val & 0x7f);
val >>= 7;
bits -= 7;
if (unlikely((unsigned int)(plenend - plen) < c)) {
elf_uncompress_failed();
return 0;
}
memset(plen, 0, c);
plen += c;
} else {
elf_uncompress_failed();
return 0;
}
}
plen = plenbase;
if (unlikely(plen[256] == 0)) {
elf_uncompress_failed();
return 0;
}
if (!elf_zlib_inflate_table(plen, nlit, zdebug_table, zdebug_table))
return 0;
if (!elf_zlib_inflate_table(plen + nlit, ndist, zdebug_table,
zdebug_table + HUFFMAN_TABLE_SIZE))
return 0;
tlit = zdebug_table;
tdist = zdebug_table + HUFFMAN_TABLE_SIZE;
}
while (1) {
uint16_t t;
unsigned int b;
uint16_t v;
unsigned int lit;
if (!elf_zlib_fetch(&pin, pinend, &val, &bits)) return 0;
t = tlit[val & 0xff];
b = (t >> HUFFMAN_BITS_SHIFT) & HUFFMAN_BITS_MASK;
v = t & HUFFMAN_VALUE_MASK;
if ((t & (1U << HUFFMAN_SECONDARY_SHIFT)) == 0) {
lit = v;
val >>= b + 1;
bits -= b + 1;
} else {
t = tlit[v + 0x100 + ((val >> 8) & ((1U << b) - 1))];
b = (t >> HUFFMAN_BITS_SHIFT) & HUFFMAN_BITS_MASK;
lit = t & HUFFMAN_VALUE_MASK;
val >>= b + 8;
bits -= b + 8;
}
if (lit < 256) {
if (unlikely(pout == poutend)) {
elf_uncompress_failed();
return 0;
}
*pout++ = lit;
__builtin_prefetch(pout, 1, 3);
} else if (lit == 256) {
break;
} else {
unsigned int dist;
unsigned int len;
if (lit < 265)
len = lit - 257 + 3;
else if (lit == 285)
len = 258;
else if (unlikely(lit > 285)) {
elf_uncompress_failed();
return 0;
} else {
unsigned int extra;
if (!elf_zlib_fetch(&pin, pinend, &val, &bits)) return 0;
lit -= 265;
extra = (lit >> 2) + 1;
len = (lit & 3) << extra;
len += 11;
len += ((1U << (extra - 1)) - 1) << 3;
len += val & ((1U << extra) - 1);
val >>= extra;
bits -= extra;
}
if (!elf_zlib_fetch(&pin, pinend, &val, &bits)) return 0;
t = tdist[val & 0xff];
b = (t >> HUFFMAN_BITS_SHIFT) & HUFFMAN_BITS_MASK;
v = t & HUFFMAN_VALUE_MASK;
if ((t & (1U << HUFFMAN_SECONDARY_SHIFT)) == 0) {
dist = v;
val >>= b + 1;
bits -= b + 1;
} else {
t = tdist[v + 0x100 + ((val >> 8) & ((1U << b) - 1))];
b = (t >> HUFFMAN_BITS_SHIFT) & HUFFMAN_BITS_MASK;
dist = t & HUFFMAN_VALUE_MASK;
val >>= b + 8;
bits -= b + 8;
}
if (dist == 0) {
if (unlikely(pout == porigout)) {
elf_uncompress_failed();
return 0;
}
if (unlikely((unsigned int)(poutend - pout) < len)) {
elf_uncompress_failed();
return 0;
}
memset(pout, pout[-1], len);
pout += len;
} else if (unlikely(dist > 29)) {
elf_uncompress_failed();
return 0;
} else {
if (dist < 4)
dist = dist + 1;
else {
unsigned int extra;
if (!elf_zlib_fetch(&pin, pinend, &val, &bits)) return 0;
dist -= 4;
extra = (dist >> 1) + 1;
dist = (dist & 1) << extra;
dist += 5;
dist += ((1U << (extra - 1)) - 1) << 2;
dist += val & ((1U << extra) - 1);
val >>= extra;
bits -= extra;
}
if (unlikely((unsigned int)(pout - porigout) < dist)) {
elf_uncompress_failed();
return 0;
}
if (unlikely((unsigned int)(poutend - pout) < len)) {
elf_uncompress_failed();
return 0;
}
if (dist >= len) {
memcpy(pout, pout - dist, len);
pout += len;
} else {
while (len > 0) {
unsigned int copy;
copy = len < dist ? len : dist;
memcpy(pout, pout - dist, copy);
len -= copy;
pout += copy;
}
}
}
}
}
}
}
if (unlikely(pout != poutend)) {
elf_uncompress_failed();
return 0;
}
return 1;
}
static int elf_zlib_verify_checksum(const unsigned char *checkbytes,
const unsigned char *uncompressed,
size_t uncompressed_size) {
unsigned int i;
unsigned int cksum;
const unsigned char *p;
uint32_t s1;
uint32_t s2;
size_t hsz;
cksum = 0;
for (i = 0; i < 4; i++) cksum = (cksum << 8) | checkbytes[i];
s1 = 1;
s2 = 0;
p = uncompressed;
hsz = uncompressed_size;
while (hsz >= 5552) {
for (i = 0; i < 5552; i += 16) {
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
}
hsz -= 5552;
s1 %= 65521;
s2 %= 65521;
}
while (hsz >= 16) {
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
s1 = s1 + *p++;
s2 = s2 + s1;
hsz -= 16;
}
for (i = 0; i < hsz; ++i) {
s1 = s1 + *p++;
s2 = s2 + s1;
}
s1 %= 65521;
s2 %= 65521;
if (unlikely((s2 << 16) + s1 != cksum)) {
elf_uncompress_failed();
return 0;
}
return 1;
}
static int elf_zlib_inflate_and_verify(const unsigned char *pin, size_t sin,
uint16_t *zdebug_table,
unsigned char *pout, size_t sout) {
if (!elf_zlib_inflate(pin, sin, zdebug_table, pout, sout)) return 0;
if (!elf_zlib_verify_checksum(pin + sin - 4, pout, sout)) return 0;
return 1;
}
static int elf_uncompress_zdebug(struct backtrace_state *state,
const unsigned char *compressed,
size_t compressed_size, uint16_t *zdebug_table,
backtrace_error_callback error_callback,
void *data, unsigned char **uncompressed,
size_t *uncompressed_size) {
size_t sz;
size_t i;
unsigned char *po;
*uncompressed = NULL;
*uncompressed_size = 0;
if (compressed_size < 12 || memcmp(compressed, "ZLIB", 4) != 0) return 1;
sz = 0;
for (i = 0; i < 8; i++) sz = (sz << 8) | compressed[i + 4];
if (*uncompressed != NULL && *uncompressed_size >= sz)
po = *uncompressed;
else {
po = (unsigned char *)backtrace_alloc(state, sz, error_callback, data);
if (po == NULL) return 0;
}
if (!elf_zlib_inflate_and_verify(compressed + 12, compressed_size - 12,
zdebug_table, po, sz))
return 1;
*uncompressed = po;
*uncompressed_size = sz;
return 1;
}
static int elf_uncompress_chdr(struct backtrace_state *state,
const unsigned char *compressed,
size_t compressed_size, uint16_t *zdebug_table,
backtrace_error_callback error_callback,
void *data, unsigned char **uncompressed,
size_t *uncompressed_size) {
const b_elf_chdr *chdr;
unsigned char *po;
*uncompressed = NULL;
*uncompressed_size = 0;
if (compressed_size < sizeof(b_elf_chdr)) return 1;
chdr = (const b_elf_chdr *)compressed;
if (chdr->ch_type != ELFCOMPRESS_ZLIB) {
return 1;
}
if (*uncompressed != NULL && *uncompressed_size >= chdr->ch_size)
po = *uncompressed;
else {
po = (unsigned char *)backtrace_alloc(state, chdr->ch_size, error_callback,
data);
if (po == NULL) return 0;
}
if (!elf_zlib_inflate_and_verify(compressed + sizeof(b_elf_chdr),
compressed_size - sizeof(b_elf_chdr),
zdebug_table, po, chdr->ch_size))
return 1;
*uncompressed = po;
*uncompressed_size = chdr->ch_size;
return 1;
}
int backtrace_uncompress_zdebug(struct backtrace_state *state,
const unsigned char *compressed,
size_t compressed_size,
backtrace_error_callback error_callback,
void *data, unsigned char **uncompressed,
size_t *uncompressed_size) {
uint16_t *zdebug_table;
int ret;
zdebug_table = ((uint16_t *)backtrace_alloc(state, ZDEBUG_TABLE_SIZE,
error_callback, data));
if (zdebug_table == NULL) return 0;
ret = elf_uncompress_zdebug(state, compressed, compressed_size, zdebug_table,
error_callback, data, uncompressed,
uncompressed_size);
backtrace_free(state, zdebug_table, ZDEBUG_TABLE_SIZE, error_callback, data);
return ret;
}
#define LZMA_STATES (12)
#define LZMA_POS_STATES (16)
#define LZMA_DIST_STATES (4)
#define LZMA_DIST_SLOTS (64)
#define LZMA_DIST_MODEL_START (4)
#define LZMA_DIST_MODEL_END (14)
#define LZMA_FULL_DISTANCES (128)
#define LZMA_ALIGN_SIZE (16)
#define LZMA_LEN_LOW_SYMBOLS (8)
#define LZMA_LEN_MID_SYMBOLS (8)
#define LZMA_LEN_HIGH_SYMBOLS (256)
#define LZMA_LITERAL_CODERS_MAX (16)
#define LZMA_LITERAL_CODER_SIZE (0x300)
#define LZMA_PROB_IS_MATCH_LEN (LZMA_STATES * LZMA_POS_STATES)
#define LZMA_PROB_IS_REP_LEN LZMA_STATES
#define LZMA_PROB_IS_REP0_LEN LZMA_STATES
#define LZMA_PROB_IS_REP1_LEN LZMA_STATES
#define LZMA_PROB_IS_REP2_LEN LZMA_STATES
#define LZMA_PROB_IS_REP0_LONG_LEN (LZMA_STATES * LZMA_POS_STATES)
#define LZMA_PROB_DIST_SLOT_LEN (LZMA_DIST_STATES * LZMA_DIST_SLOTS)
#define LZMA_PROB_DIST_SPECIAL_LEN (LZMA_FULL_DISTANCES - LZMA_DIST_MODEL_END)
#define LZMA_PROB_DIST_ALIGN_LEN LZMA_ALIGN_SIZE
#define LZMA_PROB_MATCH_LEN_CHOICE_LEN 1
#define LZMA_PROB_MATCH_LEN_CHOICE2_LEN 1
#define LZMA_PROB_MATCH_LEN_LOW_LEN (LZMA_POS_STATES * LZMA_LEN_LOW_SYMBOLS)
#define LZMA_PROB_MATCH_LEN_MID_LEN (LZMA_POS_STATES * LZMA_LEN_MID_SYMBOLS)
#define LZMA_PROB_MATCH_LEN_HIGH_LEN LZMA_LEN_HIGH_SYMBOLS
#define LZMA_PROB_REP_LEN_CHOICE_LEN 1
#define LZMA_PROB_REP_LEN_CHOICE2_LEN 1
#define LZMA_PROB_REP_LEN_LOW_LEN (LZMA_POS_STATES * LZMA_LEN_LOW_SYMBOLS)
#define LZMA_PROB_REP_LEN_MID_LEN (LZMA_POS_STATES * LZMA_LEN_MID_SYMBOLS)
#define LZMA_PROB_REP_LEN_HIGH_LEN LZMA_LEN_HIGH_SYMBOLS
#define LZMA_PROB_LITERAL_LEN \
(LZMA_LITERAL_CODERS_MAX * LZMA_LITERAL_CODER_SIZE)
#define LZMA_PROB_IS_MATCH_OFFSET 0
#define LZMA_PROB_IS_REP_OFFSET \
(LZMA_PROB_IS_MATCH_OFFSET + LZMA_PROB_IS_MATCH_LEN)
#define LZMA_PROB_IS_REP0_OFFSET \
(LZMA_PROB_IS_REP_OFFSET + LZMA_PROB_IS_REP_LEN)
#define LZMA_PROB_IS_REP1_OFFSET \
(LZMA_PROB_IS_REP0_OFFSET + LZMA_PROB_IS_REP0_LEN)
#define LZMA_PROB_IS_REP2_OFFSET \
(LZMA_PROB_IS_REP1_OFFSET + LZMA_PROB_IS_REP1_LEN)
#define LZMA_PROB_IS_REP0_LONG_OFFSET \
(LZMA_PROB_IS_REP2_OFFSET + LZMA_PROB_IS_REP2_LEN)
#define LZMA_PROB_DIST_SLOT_OFFSET \
(LZMA_PROB_IS_REP0_LONG_OFFSET + LZMA_PROB_IS_REP0_LONG_LEN)
#define LZMA_PROB_DIST_SPECIAL_OFFSET \
(LZMA_PROB_DIST_SLOT_OFFSET + LZMA_PROB_DIST_SLOT_LEN)
#define LZMA_PROB_DIST_ALIGN_OFFSET \
(LZMA_PROB_DIST_SPECIAL_OFFSET + LZMA_PROB_DIST_SPECIAL_LEN)
#define LZMA_PROB_MATCH_LEN_CHOICE_OFFSET \
(LZMA_PROB_DIST_ALIGN_OFFSET + LZMA_PROB_DIST_ALIGN_LEN)
#define LZMA_PROB_MATCH_LEN_CHOICE2_OFFSET \
(LZMA_PROB_MATCH_LEN_CHOICE_OFFSET + LZMA_PROB_MATCH_LEN_CHOICE_LEN)
#define LZMA_PROB_MATCH_LEN_LOW_OFFSET \
(LZMA_PROB_MATCH_LEN_CHOICE2_OFFSET + LZMA_PROB_MATCH_LEN_CHOICE2_LEN)
#define LZMA_PROB_MATCH_LEN_MID_OFFSET \
(LZMA_PROB_MATCH_LEN_LOW_OFFSET + LZMA_PROB_MATCH_LEN_LOW_LEN)
#define LZMA_PROB_MATCH_LEN_HIGH_OFFSET \
(LZMA_PROB_MATCH_LEN_MID_OFFSET + LZMA_PROB_MATCH_LEN_MID_LEN)
#define LZMA_PROB_REP_LEN_CHOICE_OFFSET \
(LZMA_PROB_MATCH_LEN_HIGH_OFFSET + LZMA_PROB_MATCH_LEN_HIGH_LEN)
#define LZMA_PROB_REP_LEN_CHOICE2_OFFSET \
(LZMA_PROB_REP_LEN_CHOICE_OFFSET + LZMA_PROB_REP_LEN_CHOICE_LEN)
#define LZMA_PROB_REP_LEN_LOW_OFFSET \
(LZMA_PROB_REP_LEN_CHOICE2_OFFSET + LZMA_PROB_REP_LEN_CHOICE2_LEN)
#define LZMA_PROB_REP_LEN_MID_OFFSET \
(LZMA_PROB_REP_LEN_LOW_OFFSET + LZMA_PROB_REP_LEN_LOW_LEN)
#define LZMA_PROB_REP_LEN_HIGH_OFFSET \
(LZMA_PROB_REP_LEN_MID_OFFSET + LZMA_PROB_REP_LEN_MID_LEN)
#define LZMA_PROB_LITERAL_OFFSET \
(LZMA_PROB_REP_LEN_HIGH_OFFSET + LZMA_PROB_REP_LEN_HIGH_LEN)
#define LZMA_PROB_TOTAL_COUNT (LZMA_PROB_LITERAL_OFFSET + LZMA_PROB_LITERAL_LEN)
#if LZMA_PROB_TOTAL_COUNT != 1846 + (1 << 4) * 0x300
#error Wrong number of LZMA probabilities
#endif
#define LZMA_IS_MATCH(state, pos) \
(LZMA_PROB_IS_MATCH_OFFSET + (state)*LZMA_POS_STATES + (pos))
#define LZMA_IS_REP(state) (LZMA_PROB_IS_REP_OFFSET + (state))
#define LZMA_IS_REP0(state) (LZMA_PROB_IS_REP0_OFFSET + (state))
#define LZMA_IS_REP1(state) (LZMA_PROB_IS_REP1_OFFSET + (state))
#define LZMA_IS_REP2(state) (LZMA_PROB_IS_REP2_OFFSET + (state))
#define LZMA_IS_REP0_LONG(state, pos) \
(LZMA_PROB_IS_REP0_LONG_OFFSET + (state)*LZMA_POS_STATES + (pos))
#define LZMA_DIST_SLOT(dist, slot) \
(LZMA_PROB_DIST_SLOT_OFFSET + (dist)*LZMA_DIST_SLOTS + (slot))
#define LZMA_DIST_SPECIAL(dist) (LZMA_PROB_DIST_SPECIAL_OFFSET + (dist))
#define LZMA_DIST_ALIGN(dist) (LZMA_PROB_DIST_ALIGN_OFFSET + (dist))
#define LZMA_MATCH_LEN_CHOICE LZMA_PROB_MATCH_LEN_CHOICE_OFFSET
#define LZMA_MATCH_LEN_CHOICE2 LZMA_PROB_MATCH_LEN_CHOICE2_OFFSET
#define LZMA_MATCH_LEN_LOW(pos, sym) \
(LZMA_PROB_MATCH_LEN_LOW_OFFSET + (pos)*LZMA_LEN_LOW_SYMBOLS + (sym))
#define LZMA_MATCH_LEN_MID(pos, sym) \
(LZMA_PROB_MATCH_LEN_MID_OFFSET + (pos)*LZMA_LEN_MID_SYMBOLS + (sym))
#define LZMA_MATCH_LEN_HIGH(sym) (LZMA_PROB_MATCH_LEN_HIGH_OFFSET + (sym))
#define LZMA_REP_LEN_CHOICE LZMA_PROB_REP_LEN_CHOICE_OFFSET
#define LZMA_REP_LEN_CHOICE2 LZMA_PROB_REP_LEN_CHOICE2_OFFSET
#define LZMA_REP_LEN_LOW(pos, sym) \
(LZMA_PROB_REP_LEN_LOW_OFFSET + (pos)*LZMA_LEN_LOW_SYMBOLS + (sym))
#define LZMA_REP_LEN_MID(pos, sym) \
(LZMA_PROB_REP_LEN_MID_OFFSET + (pos)*LZMA_LEN_MID_SYMBOLS + (sym))
#define LZMA_REP_LEN_HIGH(sym) (LZMA_PROB_REP_LEN_HIGH_OFFSET + (sym))
#define LZMA_LITERAL(code, size) \
(LZMA_PROB_LITERAL_OFFSET + (code)*LZMA_LITERAL_CODER_SIZE + (size))
static int elf_lzma_varint(const unsigned char *compressed,
size_t compressed_size, size_t *poffset,
uint64_t *val) {
size_t off;
int i;
uint64_t v;
unsigned char b;
off = *poffset;
i = 0;
v = 0;
while (1) {
if (unlikely(off >= compressed_size)) {
elf_uncompress_failed();
return 0;
}
b = compressed[off];
v |= (b & 0x7f) << (i * 7);
++off;
if ((b & 0x80) == 0) {
*poffset = off;
*val = v;
return 1;
}
++i;
if (unlikely(i >= 9)) {
elf_uncompress_failed();
return 0;
}
}
}
static void elf_lzma_range_normalize(const unsigned char *compressed,
size_t compressed_size, size_t *poffset,
uint32_t *prange, uint32_t *pcode) {
if (*prange < (1U << 24)) {
if (unlikely(*poffset >= compressed_size)) {
elf_uncompress_failed();
return;
}
*prange <<= 8;
*pcode <<= 8;
*pcode += compressed[*poffset];
++*poffset;
}
}
static int elf_lzma_bit(const unsigned char *compressed, size_t compressed_size,
uint16_t *prob, size_t *poffset, uint32_t *prange,
uint32_t *pcode) {
uint32_t bound;
elf_lzma_range_normalize(compressed, compressed_size, poffset, prange, pcode);
bound = (*prange >> 11) * (uint32_t)*prob;
if (*pcode < bound) {
*prange = bound;
*prob += ((1U << 11) - *prob) >> 5;
return 0;
} else {
*prange -= bound;
*pcode -= bound;
*prob -= *prob >> 5;
return 1;
}
}
static uint32_t elf_lzma_integer(const unsigned char *compressed,
size_t compressed_size, uint16_t *probs,
uint32_t bits, size_t *poffset,
uint32_t *prange, uint32_t *pcode) {
uint32_t sym;
uint32_t i;
sym = 1;
for (i = 0; i < bits; i++) {
int bit;
bit = elf_lzma_bit(compressed, compressed_size, probs + sym, poffset,
prange, pcode);
sym <<= 1;
sym += bit;
}
return sym - (1 << bits);
}
static uint32_t elf_lzma_reverse_integer(const unsigned char *compressed,
size_t compressed_size,
uint16_t *probs, uint32_t bits,
size_t *poffset, uint32_t *prange,
uint32_t *pcode) {
uint32_t sym;
uint32_t val;
uint32_t i;
sym = 1;
val = 0;
for (i = 0; i < bits; i++) {
int bit;
bit = elf_lzma_bit(compressed, compressed_size, probs + sym, poffset,
prange, pcode);
sym <<= 1;
sym += bit;
val += bit << i;
}
return val;
}
static uint32_t elf_lzma_len(const unsigned char *compressed,
size_t compressed_size, uint16_t *probs,
int is_rep, unsigned int pos_state,
size_t *poffset, uint32_t *prange,
uint32_t *pcode) {
uint16_t *probs_choice;
uint16_t *probs_sym;
uint32_t bits;
uint32_t len;
probs_choice = probs + (is_rep ? LZMA_REP_LEN_CHOICE : LZMA_MATCH_LEN_CHOICE);
if (elf_lzma_bit(compressed, compressed_size, probs_choice, poffset, prange,
pcode)) {
probs_choice =
probs + (is_rep ? LZMA_REP_LEN_CHOICE2 : LZMA_MATCH_LEN_CHOICE2);
if (elf_lzma_bit(compressed, compressed_size, probs_choice, poffset, prange,
pcode)) {
probs_sym =
probs + (is_rep ? LZMA_REP_LEN_HIGH(0) : LZMA_MATCH_LEN_HIGH(0));
bits = 8;
len = 2 + 8 + 8;
} else {
probs_sym = probs + (is_rep ? LZMA_REP_LEN_MID(pos_state, 0)
: LZMA_MATCH_LEN_MID(pos_state, 0));
bits = 3;
len = 2 + 8;
}
} else {
probs_sym = probs + (is_rep ? LZMA_REP_LEN_LOW(pos_state, 0)
: LZMA_MATCH_LEN_LOW(pos_state, 0));
bits = 3;
len = 2;
}
len += elf_lzma_integer(compressed, compressed_size, probs_sym, bits, poffset,
prange, pcode);
return len;
}
static int elf_uncompress_lzma_block(const unsigned char *compressed,
size_t compressed_size,
unsigned char check, uint16_t *probs,
unsigned char *uncompressed,
size_t uncompressed_size,
size_t *poffset) {
size_t off;
size_t block_header_offset;
size_t block_header_size;
unsigned char block_flags;
uint64_t header_compressed_size;
uint64_t header_uncompressed_size;
unsigned char lzma2_properties;
uint32_t computed_crc;
uint32_t stream_crc;
size_t uncompressed_offset;
size_t dict_start_offset;
unsigned int lc;
unsigned int lp;
unsigned int pb;
uint32_t range;
uint32_t code;
uint32_t lstate;
uint32_t dist[4];
off = *poffset;
block_header_offset = off;
if (unlikely(off >= compressed_size)) {
elf_uncompress_failed();
return 0;
}
block_header_size = (compressed[off] + 1) * 4;
if (unlikely(off + block_header_size > compressed_size)) {
elf_uncompress_failed();
return 0;
}
block_flags = compressed[off + 1];
if (unlikely((block_flags & 0x3c) != 0)) {
elf_uncompress_failed();
return 0;
}
off += 2;
header_compressed_size = 0;
if ((block_flags & 0x40) != 0) {
*poffset = off;
if (!elf_lzma_varint(compressed, compressed_size, poffset,
&header_compressed_size))
return 0;
off = *poffset;
}
header_uncompressed_size = 0;
if ((block_flags & 0x80) != 0) {
*poffset = off;
if (!elf_lzma_varint(compressed, compressed_size, poffset,
&header_uncompressed_size))
return 0;
off = *poffset;
}
if (unlikely((block_flags & 0x3) != 0)) {
elf_uncompress_failed();
return 0;
}
if (unlikely(off + 2 >= block_header_offset + block_header_size)) {
elf_uncompress_failed();
return 0;
}
if (unlikely(compressed[off] != 0x21)) {
elf_uncompress_failed();
return 0;
}
++off;
if (unlikely(compressed[off] != 1)) {
elf_uncompress_failed();
return 0;
}
++off;
lzma2_properties = compressed[off];
++off;
if (unlikely(lzma2_properties > 40)) {
elf_uncompress_failed();
return 0;
}
if (unlikely(off + 4 > compressed_size)) {
elf_uncompress_failed();
return 0;
}
off = (off + 3) & ~(size_t)3;
if (unlikely(off + 4 > compressed_size)) {
elf_uncompress_failed();
return 0;
}
computed_crc =
elf_crc32(0, compressed + block_header_offset, block_header_size - 4);
stream_crc = (compressed[off] | (compressed[off + 1] << 8) |
(compressed[off + 2] << 16) | (compressed[off + 3] << 24));
if (unlikely(computed_crc != stream_crc)) {
elf_uncompress_failed();
return 0;
}
off += 4;
uncompressed_offset = 0;
dict_start_offset = 0;
lc = 0;
lp = 0;
pb = 0;
lstate = 0;
while (off < compressed_size) {
unsigned char control;
range = 0xffffffff;
code = 0;
control = compressed[off];
++off;
if (unlikely(control == 0)) {
break;
}
if (control == 1 || control >= 0xe0) {
dict_start_offset = uncompressed_offset;
}
if (control < 0x80) {
size_t chunk_size;
if (unlikely(control > 2)) {
elf_uncompress_failed();
return 0;
}
if (unlikely(off + 2 > compressed_size)) {
elf_uncompress_failed();
return 0;
}
chunk_size = compressed[off] << 8;
chunk_size += compressed[off + 1];
++chunk_size;
off += 2;
if (unlikely(off + chunk_size > compressed_size)) {
elf_uncompress_failed();
return 0;
}
if (unlikely(uncompressed_offset + chunk_size > uncompressed_size)) {
elf_uncompress_failed();
return 0;
}
memcpy(uncompressed + uncompressed_offset, compressed + off, chunk_size);
uncompressed_offset += chunk_size;
off += chunk_size;
} else {
size_t uncompressed_chunk_start;
size_t uncompressed_chunk_size;
size_t compressed_chunk_size;
size_t limit;
if (unlikely(off + 4 >= compressed_size)) {
elf_uncompress_failed();
return 0;
}
uncompressed_chunk_start = uncompressed_offset;
uncompressed_chunk_size = (control & 0x1f) << 16;
uncompressed_chunk_size += compressed[off] << 8;
uncompressed_chunk_size += compressed[off + 1];
++uncompressed_chunk_size;
compressed_chunk_size = compressed[off + 2] << 8;
compressed_chunk_size += compressed[off + 3];
++compressed_chunk_size;
off += 4;
if (control >= 0xc0) {
unsigned char props;
if (unlikely(off >= compressed_size)) {
elf_uncompress_failed();
return 0;
}
props = compressed[off];
++off;
if (unlikely(props > (4 * 5 + 4) * 9 + 8)) {
elf_uncompress_failed();
return 0;
}
pb = 0;
while (props >= 9 * 5) {
props -= 9 * 5;
++pb;
}
lp = 0;
while (props > 9) {
props -= 9;
++lp;
}
lc = props;
if (unlikely(lc + lp > 4)) {
elf_uncompress_failed();
return 0;
}
}
if (control >= 0xa0) {
size_t i;
lstate = 0;
memset(&dist, 0, sizeof dist);
for (i = 0; i < LZMA_PROB_TOTAL_COUNT; i++) probs[i] = 1 << 10;
range = 0xffffffff;
code = 0;
}
if (unlikely(off + 5 > compressed_size)) {
elf_uncompress_failed();
return 0;
}
code = ((compressed[off + 1] << 24) + (compressed[off + 2] << 16) +
(compressed[off + 3] << 8) + compressed[off + 4]);
off += 5;
limit = off + compressed_chunk_size;
*poffset = off;
while (*poffset < limit) {
unsigned int pos_state;
if (unlikely(uncompressed_offset ==
(uncompressed_chunk_start + uncompressed_chunk_size))) {
break;
}
pos_state =
((uncompressed_offset - dict_start_offset) & ((1 << pb) - 1));
if (elf_lzma_bit(compressed, compressed_size,
probs + LZMA_IS_MATCH(lstate, pos_state), poffset,
&range, &code)) {
uint32_t len;
if (elf_lzma_bit(compressed, compressed_size,
probs + LZMA_IS_REP(lstate), poffset, &range,
&code)) {
int short_rep;
uint32_t next_dist;
short_rep = 0;
if (elf_lzma_bit(compressed, compressed_size,
probs + LZMA_IS_REP0(lstate), poffset, &range,
&code)) {
if (elf_lzma_bit(compressed, compressed_size,
probs + LZMA_IS_REP1(lstate), poffset, &range,
&code)) {
if (elf_lzma_bit(compressed, compressed_size,
probs + LZMA_IS_REP2(lstate), poffset, &range,
&code)) {
next_dist = dist[3];
dist[3] = dist[2];
} else {
next_dist = dist[2];
}
dist[2] = dist[1];
} else {
next_dist = dist[1];
}
dist[1] = dist[0];
dist[0] = next_dist;
} else {
if (!elf_lzma_bit(compressed, compressed_size,
(probs + LZMA_IS_REP0_LONG(lstate, pos_state)),
poffset, &range, &code))
short_rep = 1;
}
if (lstate < 7)
lstate = short_rep ? 9 : 8;
else
lstate = 11;
if (short_rep)
len = 1;
else
len = elf_lzma_len(compressed, compressed_size, probs, 1,
pos_state, poffset, &range, &code);
} else {
uint32_t dist_state;
uint32_t dist_slot;
uint16_t *probs_dist;
if (lstate < 7)
lstate = 7;
else
lstate = 10;
dist[3] = dist[2];
dist[2] = dist[1];
dist[1] = dist[0];
len = elf_lzma_len(compressed, compressed_size, probs, 0, pos_state,
poffset, &range, &code);
if (len < 4 + 2)
dist_state = len - 2;
else
dist_state = 3;
probs_dist = probs + LZMA_DIST_SLOT(dist_state, 0);
dist_slot = elf_lzma_integer(compressed, compressed_size,
probs_dist, 6, poffset, &range, &code);
if (dist_slot < LZMA_DIST_MODEL_START)
dist[0] = dist_slot;
else {
uint32_t limit;
limit = (dist_slot >> 1) - 1;
dist[0] = 2 + (dist_slot & 1);
if (dist_slot < LZMA_DIST_MODEL_END) {
dist[0] <<= limit;
probs_dist =
(probs + LZMA_DIST_SPECIAL(dist[0] - dist_slot - 1));
dist[0] += elf_lzma_reverse_integer(compressed, compressed_size,
probs_dist, limit, poffset,
&range, &code);
} else {
uint32_t dist0;
uint32_t i;
dist0 = dist[0];
for (i = 0; i < limit - 4; i++) {
uint32_t mask;
elf_lzma_range_normalize(compressed, compressed_size, poffset,
&range, &code);
range >>= 1;
code -= range;
mask = -(code >> 31);
code += range & mask;
dist0 <<= 1;
dist0 += mask + 1;
}
dist0 <<= 4;
probs_dist = probs + LZMA_DIST_ALIGN(0);
dist0 += elf_lzma_reverse_integer(compressed, compressed_size,
probs_dist, 4, poffset,
&range, &code);
dist[0] = dist0;
}
}
}
if (unlikely(uncompressed_offset - dict_start_offset < dist[0] + 1)) {
elf_uncompress_failed();
return 0;
}
if (unlikely(uncompressed_offset + len > uncompressed_size)) {
elf_uncompress_failed();
return 0;
}
if (dist[0] == 0) {
memset(uncompressed + uncompressed_offset,
uncompressed[uncompressed_offset - 1], len);
uncompressed_offset += len;
} else if (dist[0] + 1 >= len) {
memcpy(uncompressed + uncompressed_offset,
uncompressed + uncompressed_offset - dist[0] - 1, len);
uncompressed_offset += len;
} else {
while (len > 0) {
uint32_t copy;
copy = len < dist[0] + 1 ? len : dist[0] + 1;
memcpy(uncompressed + uncompressed_offset,
(uncompressed + uncompressed_offset - dist[0] - 1), copy);
len -= copy;
uncompressed_offset += copy;
}
}
} else {
unsigned char prev;
unsigned char low;
size_t high;
uint16_t *lit_probs;
unsigned int sym;
if (uncompressed_offset > 0)
prev = uncompressed[uncompressed_offset - 1];
else
prev = 0;
low = prev >> (8 - lc);
high = (((uncompressed_offset - dict_start_offset) & ((1 << lp) - 1))
<< lc);
lit_probs = probs + LZMA_LITERAL(low + high, 0);
if (lstate < 7)
sym = elf_lzma_integer(compressed, compressed_size, lit_probs, 8,
poffset, &range, &code);
else {
unsigned int match;
unsigned int bit;
unsigned int match_bit;
unsigned int idx;
sym = 1;
if (uncompressed_offset >= dist[0] + 1)
match = uncompressed[uncompressed_offset - dist[0] - 1];
else
match = 0;
match <<= 1;
bit = 0x100;
do {
match_bit = match & bit;
match <<= 1;
idx = bit + match_bit + sym;
sym <<= 1;
if (elf_lzma_bit(compressed, compressed_size, lit_probs + idx,
poffset, &range, &code)) {
++sym;
bit &= match_bit;
} else {
bit &= ~match_bit;
}
} while (sym < 0x100);
}
if (unlikely(uncompressed_offset >= uncompressed_size)) {
elf_uncompress_failed();
return 0;
}
uncompressed[uncompressed_offset] = (unsigned char)sym;
++uncompressed_offset;
if (lstate <= 3)
lstate = 0;
else if (lstate <= 9)
lstate -= 3;
else
lstate -= 6;
}
}
elf_lzma_range_normalize(compressed, compressed_size, poffset, &range,
&code);
off = *poffset;
}
}
off = (off + 3) & ~(size_t)3;
if (unlikely(off > compressed_size)) {
elf_uncompress_failed();
return 0;
}
switch (check) {
case 0:
break;
case 1:
if (unlikely(off + 4 > compressed_size)) {
elf_uncompress_failed();
return 0;
}
computed_crc = elf_crc32(0, uncompressed, uncompressed_offset);
stream_crc = (compressed[off] | (compressed[off + 1] << 8) |
(compressed[off + 2] << 16) | (compressed[off + 3] << 24));
if (computed_crc != stream_crc) {
elf_uncompress_failed();
return 0;
}
off += 4;
break;
case 4:
if (unlikely(off + 8 > compressed_size)) {
elf_uncompress_failed();
return 0;
}
off += 8;
break;
case 10:
if (unlikely(off + 32 > compressed_size)) {
elf_uncompress_failed();
return 0;
}
off += 32;
break;
default:
elf_uncompress_failed();
return 0;
}
*poffset = off;
return 1;
}
static int elf_uncompress_lzma(struct backtrace_state *state,
const unsigned char *compressed,
size_t compressed_size,
backtrace_error_callback error_callback,
void *data, unsigned char **uncompressed,
size_t *uncompressed_size) {
size_t header_size;
size_t footer_size;
unsigned char check;
uint32_t computed_crc;
uint32_t stream_crc;
size_t offset;
size_t index_size;
size_t footer_offset;
size_t index_offset;
uint64_t index_compressed_size;
uint64_t index_uncompressed_size;
unsigned char *mem;
uint16_t *probs;
size_t compressed_block_size;
header_size = 12;
footer_size = 12;
if (unlikely(compressed_size < header_size + footer_size)) {
elf_uncompress_failed();
return 0;
}
if (unlikely(memcmp(compressed,
"\375"
"7zXZ\0",
6) != 0)) {
elf_uncompress_failed();
return 0;
}
if (unlikely(compressed[6] != 0)) {
elf_uncompress_failed();
return 0;
}
check = compressed[7];
if (unlikely((check & 0xf8) != 0)) {
elf_uncompress_failed();
return 0;
}
computed_crc = elf_crc32(0, compressed + 6, 2);
stream_crc = (compressed[8] | (compressed[9] << 8) | (compressed[10] << 16) |
(compressed[11] << 24));
if (unlikely(computed_crc != stream_crc)) {
elf_uncompress_failed();
return 0;
}
offset = compressed_size;
if (unlikely(memcmp(compressed + offset - 2, "YZ", 2) != 0)) {
elf_uncompress_failed();
return 0;
}
offset -= 2;
if (unlikely(compressed[offset - 2] != 0 ||
compressed[offset - 1] != check)) {
elf_uncompress_failed();
return 0;
}
offset -= 2;
index_size =
(compressed[offset - 4] | (compressed[offset - 3] << 8) |
(compressed[offset - 2] << 16) | (compressed[offset - 1] << 24));
index_size = (index_size + 1) * 4;
offset -= 4;
computed_crc = elf_crc32(0, compressed + offset, 6);
stream_crc =
(compressed[offset - 4] | (compressed[offset - 3] << 8) |
(compressed[offset - 2] << 16) | (compressed[offset - 1] << 24));
if (unlikely(computed_crc != stream_crc)) {
elf_uncompress_failed();
return 0;
}
offset -= 4;
if (unlikely(offset < index_size + header_size)) {
elf_uncompress_failed();
return 0;
}
footer_offset = offset;
offset -= index_size;
index_offset = offset;
if (unlikely(compressed[offset] != 0)) {
elf_uncompress_failed();
return 0;
}
++offset;
if (unlikely(compressed[offset] == 0)) {
*uncompressed = NULL;
*uncompressed_size = 0;
return 1;
}
if (unlikely(compressed[offset] != 1)) {
elf_uncompress_failed();
return 0;
}
++offset;
if (!elf_lzma_varint(compressed, compressed_size, &offset,
&index_compressed_size))
return 0;
if (!elf_lzma_varint(compressed, compressed_size, &offset,
&index_uncompressed_size))
return 0;
offset = (offset + 3) & ~(size_t)3;
computed_crc = elf_crc32(0, compressed + index_offset, offset - index_offset);
stream_crc =
(compressed[offset] | (compressed[offset + 1] << 8) |
(compressed[offset + 2] << 16) | (compressed[offset + 3] << 24));
if (unlikely(computed_crc != stream_crc)) {
elf_uncompress_failed();
return 0;
}
offset += 4;
if (unlikely(offset != footer_offset)) {
elf_uncompress_failed();
return 0;
}
mem = (unsigned char *)backtrace_alloc(state, index_uncompressed_size,
error_callback, data);
if (unlikely(mem == NULL)) return 0;
*uncompressed = mem;
*uncompressed_size = index_uncompressed_size;
probs = ((uint16_t *)backtrace_alloc(
state, LZMA_PROB_TOTAL_COUNT * sizeof(uint16_t), error_callback, data));
if (unlikely(probs == NULL)) {
backtrace_free(state, mem, index_uncompressed_size, error_callback, data);
return 0;
}
offset = 12;
if (!elf_uncompress_lzma_block(compressed, compressed_size, check, probs, mem,
index_uncompressed_size, &offset)) {
backtrace_free(state, mem, index_uncompressed_size, error_callback, data);
return 0;
}
compressed_block_size = offset - 12;
if (unlikely(compressed_block_size !=
((index_compressed_size + 3) & ~(size_t)3))) {
elf_uncompress_failed();
backtrace_free(state, mem, index_uncompressed_size, error_callback, data);
return 0;
}
offset = (offset + 3) & ~(size_t)3;
if (unlikely(offset != index_offset)) {
elf_uncompress_failed();
backtrace_free(state, mem, index_uncompressed_size, error_callback, data);
return 0;
}
return 1;
}
int backtrace_uncompress_lzma(struct backtrace_state *state,
const unsigned char *compressed,
size_t compressed_size,
backtrace_error_callback error_callback,
void *data, unsigned char **uncompressed,
size_t *uncompressed_size) {
return elf_uncompress_lzma(state, compressed, compressed_size, error_callback,
data, uncompressed, uncompressed_size);
}
static int elf_add(struct backtrace_state *state, const char *filename,
int descriptor, const unsigned char *memory,
size_t memory_size, uintptr_t base_address,
backtrace_error_callback error_callback, void *data,
fileline *fileline_fn, int *found_sym, int *found_dwarf,
struct dwarf_data **fileline_entry, int exe, int debuginfo,
const char *with_buildid_data, uint32_t with_buildid_size) {
struct elf_view ehdr_view;
b_elf_ehdr ehdr;
off_t shoff;
unsigned int shnum;
unsigned int shstrndx;
struct elf_view shdrs_view;
int shdrs_view_valid;
const b_elf_shdr *shdrs;
const b_elf_shdr *shstrhdr;
size_t shstr_size;
off_t shstr_off;
struct elf_view names_view;
int names_view_valid;
const char *names;
unsigned int symtab_shndx;
unsigned int dynsym_shndx;
unsigned int i;
struct debug_section_info sections[DEBUG_MAX];
struct debug_section_info zsections[DEBUG_MAX];
struct elf_view symtab_view;
int symtab_view_valid;
struct elf_view strtab_view;
int strtab_view_valid;
struct elf_view buildid_view;
int buildid_view_valid;
const char *buildid_data;
uint32_t buildid_size;
struct elf_view debuglink_view;
int debuglink_view_valid;
const char *debuglink_name;
uint32_t debuglink_crc;
struct elf_view debugaltlink_view;
int debugaltlink_view_valid;
const char *debugaltlink_name;
const char *debugaltlink_buildid_data;
uint32_t debugaltlink_buildid_size;
struct elf_view gnu_debugdata_view;
int gnu_debugdata_view_valid;
size_t gnu_debugdata_size;
unsigned char *gnu_debugdata_uncompressed;
size_t gnu_debugdata_uncompressed_size;
off_t min_offset;
off_t max_offset;
off_t debug_size;
struct elf_view debug_view;
int debug_view_valid;
unsigned int using_debug_view;
uint16_t *zdebug_table;
struct elf_view split_debug_view[DEBUG_MAX];
unsigned char split_debug_view_valid[DEBUG_MAX];
struct elf_ppc64_opd_data opd_data, *opd;
struct dwarf_sections dwarf_sections;
if (!debuginfo) {
*found_sym = 0;
*found_dwarf = 0;
}
shdrs_view_valid = 0;
names_view_valid = 0;
symtab_view_valid = 0;
strtab_view_valid = 0;
buildid_view_valid = 0;
buildid_data = NULL;
buildid_size = 0;
debuglink_view_valid = 0;
debuglink_name = NULL;
debuglink_crc = 0;
debugaltlink_view_valid = 0;
debugaltlink_name = NULL;
debugaltlink_buildid_data = NULL;
debugaltlink_buildid_size = 0;
gnu_debugdata_view_valid = 0;
gnu_debugdata_size = 0;
debug_view_valid = 0;
memset(&split_debug_view_valid[0], 0, sizeof split_debug_view_valid);
opd = NULL;
if (!elf_get_view(state, descriptor, memory, memory_size, 0, sizeof ehdr,
error_callback, data, &ehdr_view))
goto fail;
memcpy(&ehdr, ehdr_view.view.data, sizeof ehdr);
elf_release_view(state, &ehdr_view, error_callback, data);
if (ehdr.e_ident[EI_MAG0] != ELFMAG0 || ehdr.e_ident[EI_MAG1] != ELFMAG1 ||
ehdr.e_ident[EI_MAG2] != ELFMAG2 || ehdr.e_ident[EI_MAG3] != ELFMAG3) {
error_callback(data, "executable file is not ELF", 0);
goto fail;
}
if (ehdr.e_ident[EI_VERSION] != EV_CURRENT) {
error_callback(data, "executable file is unrecognized ELF version", 0);
goto fail;
}
#if BACKTRACE_ELF_SIZE == 32
#define BACKTRACE_ELFCLASS ELFCLASS32
#else
#define BACKTRACE_ELFCLASS ELFCLASS64
#endif
if (ehdr.e_ident[EI_CLASS] != BACKTRACE_ELFCLASS) {
error_callback(data, "executable file is unexpected ELF class", 0);
goto fail;
}
if (ehdr.e_ident[EI_DATA] != ELFDATA2LSB &&
ehdr.e_ident[EI_DATA] != ELFDATA2MSB) {
error_callback(data, "executable file has unknown endianness", 0);
goto fail;
}
if (exe && ehdr.e_type == ET_DYN) return -1;
shoff = ehdr.e_shoff;
shnum = ehdr.e_shnum;
shstrndx = ehdr.e_shstrndx;
if ((shnum == 0 || shstrndx == SHN_XINDEX) && shoff != 0) {
struct elf_view shdr_view;
const b_elf_shdr *shdr;
if (!elf_get_view(state, descriptor, memory, memory_size, shoff,
sizeof shdr, error_callback, data, &shdr_view))
goto fail;
shdr = (const b_elf_shdr *)shdr_view.view.data;
if (shnum == 0) shnum = shdr->sh_size;
if (shstrndx == SHN_XINDEX) {
shstrndx = shdr->sh_link;
if (shstrndx >= shnum && shstrndx >= SHN_LORESERVE + 0x100)
shstrndx -= 0x100;
}
elf_release_view(state, &shdr_view, error_callback, data);
}
if (shnum == 0 || shstrndx == 0) goto fail;
if (!elf_get_view(
state, descriptor, memory, memory_size, shoff + sizeof(b_elf_shdr),
(shnum - 1) * sizeof(b_elf_shdr), error_callback, data, &shdrs_view))
goto fail;
shdrs_view_valid = 1;
shdrs = (const b_elf_shdr *)shdrs_view.view.data;
shstrhdr = &shdrs[shstrndx - 1];
shstr_size = shstrhdr->sh_size;
shstr_off = shstrhdr->sh_offset;
if (!elf_get_view(state, descriptor, memory, memory_size, shstr_off,
shstrhdr->sh_size, error_callback, data, &names_view))
goto fail;
names_view_valid = 1;
names = (const char *)names_view.view.data;
symtab_shndx = 0;
dynsym_shndx = 0;
memset(sections, 0, sizeof sections);
memset(zsections, 0, sizeof zsections);
for (i = 1; i < shnum; ++i) {
const b_elf_shdr *shdr;
unsigned int sh_name;
const char *name;
int j;
shdr = &shdrs[i - 1];
if (shdr->sh_type == SHT_SYMTAB)
symtab_shndx = i;
else if (shdr->sh_type == SHT_DYNSYM)
dynsym_shndx = i;
sh_name = shdr->sh_name;
if (sh_name >= shstr_size) {
error_callback(data, "ELF section name out of range", 0);
goto fail;
}
name = names + sh_name;
for (j = 0; j < (int)DEBUG_MAX; ++j) {
if (strcmp(name, dwarf_section_names[j]) == 0) {
sections[j].offset = shdr->sh_offset;
sections[j].size = shdr->sh_size;
sections[j].compressed = (shdr->sh_flags & SHF_COMPRESSED) != 0;
break;
}
}
if (name[0] == '.' && name[1] == 'z') {
for (j = 0; j < (int)DEBUG_MAX; ++j) {
if (strcmp(name + 2, dwarf_section_names[j] + 1) == 0) {
zsections[j].offset = shdr->sh_offset;
zsections[j].size = shdr->sh_size;
break;
}
}
}
if ((!debuginfo || with_buildid_data != NULL) && !buildid_view_valid &&
strcmp(name, ".note.gnu.build-id") == 0) {
const b_elf_note *note;
if (!elf_get_view(state, descriptor, memory, memory_size, shdr->sh_offset,
shdr->sh_size, error_callback, data, &buildid_view))
goto fail;
buildid_view_valid = 1;
note = (const b_elf_note *)buildid_view.view.data;
if (note->type == NT_GNU_BUILD_ID && note->namesz == 4 &&
strncmp(note->name, "GNU", 4) == 0 &&
shdr->sh_size <= 12 + ((note->namesz + 3) & ~3) + note->descsz) {
buildid_data = &note->name[0] + ((note->namesz + 3) & ~3);
buildid_size = note->descsz;
}
if (with_buildid_size != 0) {
if (buildid_size != with_buildid_size) goto fail;
if (memcmp(buildid_data, with_buildid_data, buildid_size) != 0)
goto fail;
}
}
if (!debuginfo && !debuglink_view_valid &&
strcmp(name, ".gnu_debuglink") == 0) {
const char *debuglink_data;
size_t crc_offset;
if (!elf_get_view(state, descriptor, memory, memory_size, shdr->sh_offset,
shdr->sh_size, error_callback, data, &debuglink_view))
goto fail;
debuglink_view_valid = 1;
debuglink_data = (const char *)debuglink_view.view.data;
crc_offset = strnlen(debuglink_data, shdr->sh_size);
crc_offset = (crc_offset + 3) & ~3;
if (crc_offset + 4 <= shdr->sh_size) {
debuglink_name = debuglink_data;
debuglink_crc = *(const uint32_t *)(debuglink_data + crc_offset);
}
}
if (!debugaltlink_view_valid && strcmp(name, ".gnu_debugaltlink") == 0) {
const char *debugaltlink_data;
size_t debugaltlink_name_len;
if (!elf_get_view(state, descriptor, memory, memory_size, shdr->sh_offset,
shdr->sh_size, error_callback, data,
&debugaltlink_view))
goto fail;
debugaltlink_view_valid = 1;
debugaltlink_data = (const char *)debugaltlink_view.view.data;
debugaltlink_name = debugaltlink_data;
debugaltlink_name_len = strnlen(debugaltlink_data, shdr->sh_size);
if (debugaltlink_name_len < shdr->sh_size) {
debugaltlink_name_len += 1;
debugaltlink_buildid_data = debugaltlink_data + debugaltlink_name_len;
debugaltlink_buildid_size = shdr->sh_size - debugaltlink_name_len;
}
}
if (!gnu_debugdata_view_valid && strcmp(name, ".gnu_debugdata") == 0) {
if (!elf_get_view(state, descriptor, memory, memory_size, shdr->sh_offset,
shdr->sh_size, error_callback, data,
&gnu_debugdata_view))
goto fail;
gnu_debugdata_size = shdr->sh_size;
gnu_debugdata_view_valid = 1;
}
if (ehdr.e_machine == EM_PPC64 && (ehdr.e_flags & EF_PPC64_ABI) < 2 &&
shdr->sh_type == SHT_PROGBITS && strcmp(name, ".opd") == 0) {
if (!elf_get_view(state, descriptor, memory, memory_size, shdr->sh_offset,
shdr->sh_size, error_callback, data, &opd_data.view))
goto fail;
opd = &opd_data;
opd->addr = shdr->sh_addr;
opd->data = (const char *)opd_data.view.view.data;
opd->size = shdr->sh_size;
}
}
if (symtab_shndx == 0) symtab_shndx = dynsym_shndx;
if (symtab_shndx != 0 && !debuginfo) {
const b_elf_shdr *symtab_shdr;
unsigned int strtab_shndx;
const b_elf_shdr *strtab_shdr;
struct elf_syminfo_data *sdata;
symtab_shdr = &shdrs[symtab_shndx - 1];
strtab_shndx = symtab_shdr->sh_link;
if (strtab_shndx >= shnum) {
error_callback(data, "ELF symbol table strtab link out of range", 0);
goto fail;
}
strtab_shdr = &shdrs[strtab_shndx - 1];
if (!elf_get_view(state, descriptor, memory, memory_size,
symtab_shdr->sh_offset, symtab_shdr->sh_size,
error_callback, data, &symtab_view))
goto fail;
symtab_view_valid = 1;
if (!elf_get_view(state, descriptor, memory, memory_size,
strtab_shdr->sh_offset, strtab_shdr->sh_size,
error_callback, data, &strtab_view))
goto fail;
strtab_view_valid = 1;
sdata = ((struct elf_syminfo_data *)backtrace_alloc(state, sizeof *sdata,
error_callback, data));
if (sdata == NULL) goto fail;
if (!elf_initialize_syminfo(state, base_address, symtab_view.view.data,
symtab_shdr->sh_size, strtab_view.view.data,
strtab_shdr->sh_size, error_callback, data,
sdata, opd)) {
backtrace_free(state, sdata, sizeof *sdata, error_callback, data);
goto fail;
}
elf_release_view(state, &symtab_view, error_callback, data);
symtab_view_valid = 0;
strtab_view_valid = 0;
*found_sym = 1;
elf_add_syminfo_data(state, sdata);
}
elf_release_view(state, &shdrs_view, error_callback, data);
shdrs_view_valid = 0;
elf_release_view(state, &names_view, error_callback, data);
names_view_valid = 0;
if (buildid_data != NULL) {
int d;
d = elf_open_debugfile_by_buildid(state, buildid_data, buildid_size,
error_callback, data);
if (d >= 0) {
int ret;
elf_release_view(state, &buildid_view, error_callback, data);
if (debuglink_view_valid)
elf_release_view(state, &debuglink_view, error_callback, data);
if (debugaltlink_view_valid)
elf_release_view(state, &debugaltlink_view, error_callback, data);
ret = elf_add(state, "", d, NULL, 0, base_address, error_callback, data,
fileline_fn, found_sym, found_dwarf, NULL, 0, 1, NULL, 0);
if (ret < 0)
backtrace_close(d, error_callback, data);
else if (descriptor >= 0)
backtrace_close(descriptor, error_callback, data);
return ret;
}
}
if (buildid_view_valid) {
elf_release_view(state, &buildid_view, error_callback, data);
buildid_view_valid = 0;
}
if (opd) {
elf_release_view(state, &opd->view, error_callback, data);
opd = NULL;
}
if (debuglink_name != NULL) {
int d;
d = elf_open_debugfile_by_debuglink(state, filename, debuglink_name,
debuglink_crc, error_callback, data);
if (d >= 0) {
int ret;
elf_release_view(state, &debuglink_view, error_callback, data);
if (debugaltlink_view_valid)
elf_release_view(state, &debugaltlink_view, error_callback, data);
ret = elf_add(state, "", d, NULL, 0, base_address, error_callback, data,
fileline_fn, found_sym, found_dwarf, NULL, 0, 1, NULL, 0);
if (ret < 0)
backtrace_close(d, error_callback, data);
else if (descriptor >= 0)
backtrace_close(descriptor, error_callback, data);
return ret;
}
}
if (debuglink_view_valid) {
elf_release_view(state, &debuglink_view, error_callback, data);
debuglink_view_valid = 0;
}
struct dwarf_data *fileline_altlink = NULL;
if (debugaltlink_name != NULL) {
int d;
d = elf_open_debugfile_by_debuglink(state, filename, debugaltlink_name, 0,
error_callback, data);
if (d >= 0) {
int ret;
ret =
elf_add(state, filename, d, NULL, 0, base_address, error_callback,
data, fileline_fn, found_sym, found_dwarf, &fileline_altlink,
0, 1, debugaltlink_buildid_data, debugaltlink_buildid_size);
elf_release_view(state, &debugaltlink_view, error_callback, data);
debugaltlink_view_valid = 0;
if (ret < 0) {
backtrace_close(d, error_callback, data);
return ret;
}
}
}
if (debugaltlink_view_valid) {
elf_release_view(state, &debugaltlink_view, error_callback, data);
debugaltlink_view_valid = 0;
}
if (gnu_debugdata_view_valid) {
int ret;
ret = elf_uncompress_lzma(
state, ((const unsigned char *)gnu_debugdata_view.view.data),
gnu_debugdata_size, error_callback, data, &gnu_debugdata_uncompressed,
&gnu_debugdata_uncompressed_size);
elf_release_view(state, &gnu_debugdata_view, error_callback, data);
gnu_debugdata_view_valid = 0;
if (ret) {
ret = elf_add(state, filename, -1, gnu_debugdata_uncompressed,
gnu_debugdata_uncompressed_size, base_address,
error_callback, data, fileline_fn, found_sym, found_dwarf,
NULL, 0, 0, NULL, 0);
if (ret >= 0 && descriptor >= 0)
backtrace_close(descriptor, error_callback, data);
return ret;
}
}
min_offset = 0;
max_offset = 0;
debug_size = 0;
for (i = 0; i < (int)DEBUG_MAX; ++i) {
off_t end;
if (sections[i].size != 0) {
if (min_offset == 0 || sections[i].offset < min_offset)
min_offset = sections[i].offset;
end = sections[i].offset + sections[i].size;
if (end > max_offset) max_offset = end;
debug_size += sections[i].size;
}
if (zsections[i].size != 0) {
if (min_offset == 0 || zsections[i].offset < min_offset)
min_offset = zsections[i].offset;
end = zsections[i].offset + zsections[i].size;
if (end > max_offset) max_offset = end;
debug_size += zsections[i].size;
}
}
if (min_offset == 0 || max_offset == 0) {
if (descriptor >= 0) {
if (!backtrace_close(descriptor, error_callback, data)) goto fail;
}
return 1;
}
if (max_offset - min_offset < 0x20000000 ||
max_offset - min_offset < debug_size + 0x10000) {
if (!elf_get_view(state, descriptor, memory, memory_size, min_offset,
max_offset - min_offset, error_callback, data,
&debug_view))
goto fail;
debug_view_valid = 1;
} else {
memset(&split_debug_view[0], 0, sizeof split_debug_view);
for (i = 0; i < (int)DEBUG_MAX; ++i) {
struct debug_section_info *dsec;
if (sections[i].size != 0)
dsec = &sections[i];
else if (zsections[i].size != 0)
dsec = &zsections[i];
else
continue;
if (!elf_get_view(state, descriptor, memory, memory_size, dsec->offset,
dsec->size, error_callback, data, &split_debug_view[i]))
goto fail;
split_debug_view_valid[i] = 1;
if (sections[i].size != 0)
sections[i].data =
((const unsigned char *)split_debug_view[i].view.data);
else
zsections[i].data =
((const unsigned char *)split_debug_view[i].view.data);
}
}
if (descriptor >= 0) {
if (!backtrace_close(descriptor, error_callback, data)) goto fail;
descriptor = -1;
}
using_debug_view = 0;
if (debug_view_valid) {
for (i = 0; i < (int)DEBUG_MAX; ++i) {
if (sections[i].size == 0)
sections[i].data = NULL;
else {
sections[i].data = ((const unsigned char *)debug_view.view.data +
(sections[i].offset - min_offset));
++using_debug_view;
}
if (zsections[i].size == 0)
zsections[i].data = NULL;
else
zsections[i].data = ((const unsigned char *)debug_view.view.data +
(zsections[i].offset - min_offset));
}
}
zdebug_table = NULL;
for (i = 0; i < (int)DEBUG_MAX; ++i) {
if (sections[i].size == 0 && zsections[i].size > 0) {
unsigned char *uncompressed_data;
size_t uncompressed_size;
if (zdebug_table == NULL) {
zdebug_table = ((uint16_t *)backtrace_alloc(state, ZDEBUG_TABLE_SIZE,
error_callback, data));
if (zdebug_table == NULL) goto fail;
}
uncompressed_data = NULL;
uncompressed_size = 0;
if (!elf_uncompress_zdebug(state, zsections[i].data, zsections[i].size,
zdebug_table, error_callback, data,
&uncompressed_data, &uncompressed_size))
goto fail;
sections[i].data = uncompressed_data;
sections[i].size = uncompressed_size;
sections[i].compressed = 0;
if (split_debug_view_valid[i]) {
elf_release_view(state, &split_debug_view[i], error_callback, data);
split_debug_view_valid[i] = 0;
}
}
}
for (i = 0; i < (int)DEBUG_MAX; ++i) {
unsigned char *uncompressed_data;
size_t uncompressed_size;
if (sections[i].size == 0 || !sections[i].compressed) continue;
if (zdebug_table == NULL) {
zdebug_table = ((uint16_t *)backtrace_alloc(state, ZDEBUG_TABLE_SIZE,
error_callback, data));
if (zdebug_table == NULL) goto fail;
}
uncompressed_data = NULL;
uncompressed_size = 0;
if (!elf_uncompress_chdr(state, sections[i].data, sections[i].size,
zdebug_table, error_callback, data,
&uncompressed_data, &uncompressed_size))
goto fail;
sections[i].data = uncompressed_data;
sections[i].size = uncompressed_size;
sections[i].compressed = 0;
if (debug_view_valid)
--using_debug_view;
else if (split_debug_view_valid[i]) {
elf_release_view(state, &split_debug_view[i], error_callback, data);
split_debug_view_valid[i] = 0;
}
}
if (zdebug_table != NULL)
backtrace_free(state, zdebug_table, ZDEBUG_TABLE_SIZE, error_callback,
data);
if (debug_view_valid && using_debug_view == 0) {
elf_release_view(state, &debug_view, error_callback, data);
debug_view_valid = 0;
}
for (i = 0; i < (int)DEBUG_MAX; ++i) {
dwarf_sections.data[i] = sections[i].data;
dwarf_sections.size[i] = sections[i].size;
}
if (!backtrace_dwarf_add(state, base_address, &dwarf_sections,
ehdr.e_ident[EI_DATA] == ELFDATA2MSB,
fileline_altlink, error_callback, data, fileline_fn,
fileline_entry))
goto fail;
*found_dwarf = 1;
return 1;
fail:
if (shdrs_view_valid)
elf_release_view(state, &shdrs_view, error_callback, data);
if (names_view_valid)
elf_release_view(state, &names_view, error_callback, data);
if (symtab_view_valid)
elf_release_view(state, &symtab_view, error_callback, data);
if (strtab_view_valid)
elf_release_view(state, &strtab_view, error_callback, data);
if (debuglink_view_valid)
elf_release_view(state, &debuglink_view, error_callback, data);
if (debugaltlink_view_valid)
elf_release_view(state, &debugaltlink_view, error_callback, data);
if (gnu_debugdata_view_valid)
elf_release_view(state, &gnu_debugdata_view, error_callback, data);
if (buildid_view_valid)
elf_release_view(state, &buildid_view, error_callback, data);
if (debug_view_valid)
elf_release_view(state, &debug_view, error_callback, data);
for (i = 0; i < (int)DEBUG_MAX; ++i) {
if (split_debug_view_valid[i])
elf_release_view(state, &split_debug_view[i], error_callback, data);
}
if (opd) elf_release_view(state, &opd->view, error_callback, data);
if (descriptor >= 0) backtrace_close(descriptor, error_callback, data);
return 0;
}
struct phdr_data {
struct backtrace_state *state;
backtrace_error_callback error_callback;
void *data;
fileline *fileline_fn;
int *found_sym;
int *found_dwarf;
const char *exe_filename;
int exe_descriptor;
};
static int
#ifdef __i386__
__attribute__((__force_align_arg_pointer__))
#endif
phdr_callback(struct dl_phdr_info *info, size_t size ATTRIBUTE_UNUSED,
void *pdata) {
struct phdr_data *pd = (struct phdr_data *)pdata;
const char *filename;
int descriptor;
int does_not_exist;
fileline elf_fileline_fn;
int found_dwarf;
if (info->dlpi_name == NULL || info->dlpi_name[0] == '\0') {
if (pd->exe_descriptor == -1) return 0;
filename = pd->exe_filename;
descriptor = pd->exe_descriptor;
pd->exe_descriptor = -1;
} else {
if (pd->exe_descriptor != -1) {
backtrace_close(pd->exe_descriptor, pd->error_callback, pd->data);
pd->exe_descriptor = -1;
}
filename = info->dlpi_name;
descriptor = backtrace_open(info->dlpi_name, pd->error_callback, pd->data,
&does_not_exist);
if (descriptor < 0) return 0;
}
if (elf_add(pd->state, filename, descriptor, NULL, 0, info->dlpi_addr,
pd->error_callback, pd->data, &elf_fileline_fn, pd->found_sym,
&found_dwarf, NULL, 0, 0, NULL, 0)) {
if (found_dwarf) {
*pd->found_dwarf = 1;
*pd->fileline_fn = elf_fileline_fn;
}
}
return 0;
}
int backtrace_initialize(struct backtrace_state *state, const char *filename,
int descriptor,
backtrace_error_callback error_callback, void *data,
fileline *fileline_fn) {
int ret;
int found_sym;
int found_dwarf;
fileline elf_fileline_fn = elf_nodebug;
struct phdr_data pd;
ret =
elf_add(state, filename, descriptor, NULL, 0, 0, error_callback, data,
&elf_fileline_fn, &found_sym, &found_dwarf, NULL, 1, 0, NULL, 0);
if (!ret) return 0;
pd.state = state;
pd.error_callback = error_callback;
pd.data = data;
pd.fileline_fn = &elf_fileline_fn;
pd.found_sym = &found_sym;
pd.found_dwarf = &found_dwarf;
pd.exe_filename = filename;
pd.exe_descriptor = ret < 0 ? descriptor : -1;
dl_iterate_phdr(phdr_callback, (void *)&pd);
if (!state->threaded) {
if (found_sym)
state->syminfo_fn = elf_syminfo;
else if (state->syminfo_fn == NULL)
state->syminfo_fn = elf_nosyms;
} else {
if (found_sym)
backtrace_atomic_store_pointer(&state->syminfo_fn, elf_syminfo);
else
(void)__sync_bool_compare_and_swap(&state->syminfo_fn, NULL, elf_nosyms);
}
if (!state->threaded)
*fileline_fn = state->fileline_fn;
else
*fileline_fn = backtrace_atomic_load_pointer(&state->fileline_fn);
if (*fileline_fn == NULL || *fileline_fn == elf_nodebug)
*fileline_fn = elf_fileline_fn;
return 1;
}
// mmapio.c:
#include <errno.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
#ifndef HAVE_DECL_GETPAGESIZE
extern int getpagesize(void);
#endif
#ifndef MAP_FAILED
#define MAP_FAILED ((void *)-1)
#endif
int backtrace_get_view(struct backtrace_state *state ATTRIBUTE_UNUSED,
int descriptor, off_t offset, uint64_t size,
backtrace_error_callback error_callback, void *data,
struct backtrace_view *view) {
size_t pagesize;
unsigned int inpage;
off_t pageoff;
void *map;
if ((uint64_t)(size_t)size != size) {
error_callback(data, "file size too large", 0);
return 0;
}
pagesize = getpagesize();
inpage = offset % pagesize;
pageoff = offset - inpage;
size += inpage;
size = (size + (pagesize - 1)) & ~(pagesize - 1);
map = mmap(NULL, size, PROT_READ, MAP_PRIVATE, descriptor, pageoff);
if (map == MAP_FAILED) {
error_callback(data, "mmap", errno);
return 0;
}
view->data = (char *)map + inpage;
view->base = map;
view->len = size;
return 1;
}
void backtrace_release_view(struct backtrace_state *state ATTRIBUTE_UNUSED,
struct backtrace_view *view,
backtrace_error_callback error_callback,
void *data) {
union {
const void *cv;
void *v;
} const_cast;
const_cast.cv = view->base;
if (munmap(const_cast.v, view->len) < 0)
error_callback(data, "munmap", errno);
}
// mmap.c:
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
#ifndef HAVE_DECL_GETPAGESIZE
extern int getpagesize(void);
#endif
#ifndef MAP_ANONYMOUS
#define MAP_ANONYMOUS MAP_ANON
#endif
#ifndef MAP_FAILED
#define MAP_FAILED ((void *)-1)
#endif
struct backtrace_freelist_struct {
struct backtrace_freelist_struct *next;
size_t size;
};
static void backtrace_free_locked(struct backtrace_state *state, void *addr,
size_t size) {
if (size >= sizeof(struct backtrace_freelist_struct)) {
size_t c;
struct backtrace_freelist_struct **ppsmall;
struct backtrace_freelist_struct **pp;
struct backtrace_freelist_struct *p;
c = 0;
ppsmall = NULL;
for (pp = &state->freelist; *pp != NULL; pp = &(*pp)->next) {
if (ppsmall == NULL || (*pp)->size < (*ppsmall)->size) ppsmall = pp;
++c;
}
if (c >= 16) {
if (size <= (*ppsmall)->size) return;
*ppsmall = (*ppsmall)->next;
}
p = (struct backtrace_freelist_struct *)addr;
p->next = state->freelist;
p->size = size;
state->freelist = p;
}
}
void *backtrace_alloc(struct backtrace_state *state, size_t size,
backtrace_error_callback error_callback, void *data) {
void *ret;
int locked;
struct backtrace_freelist_struct **pp;
size_t pagesize;
size_t asksize;
void *page;
ret = NULL;
if (!state->threaded)
locked = 1;
else
locked = __sync_lock_test_and_set(&state->lock_alloc, 1) == 0;
if (locked) {
for (pp = &state->freelist; *pp != NULL; pp = &(*pp)->next) {
if ((*pp)->size >= size) {
struct backtrace_freelist_struct *p;
p = *pp;
*pp = p->next;
size = (size + 7) & ~(size_t)7;
if (size < p->size)
backtrace_free_locked(state, (char *)p + size, p->size - size);
ret = (void *)p;
break;
}
}
if (state->threaded) __sync_lock_release(&state->lock_alloc);
}
if (ret == NULL) {
pagesize = getpagesize();
asksize = (size + pagesize - 1) & ~(pagesize - 1);
page = mmap(NULL, asksize, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (page == MAP_FAILED) {
if (error_callback) error_callback(data, "mmap", errno);
} else {
size = (size + 7) & ~(size_t)7;
if (size < asksize)
backtrace_free(state, (char *)page + size, asksize - size,
error_callback, data);
ret = page;
}
}
return ret;
}
void backtrace_free(struct backtrace_state *state, void *addr, size_t size,
backtrace_error_callback error_callback ATTRIBUTE_UNUSED,
void *data ATTRIBUTE_UNUSED) {
int locked;
if (size >= 16 * 4096) {
size_t pagesize;
pagesize = getpagesize();
if (((uintptr_t)addr & (pagesize - 1)) == 0 &&
(size & (pagesize - 1)) == 0) {
if (munmap(addr, size) == 0) return;
}
}
if (!state->threaded)
locked = 1;
else
locked = __sync_lock_test_and_set(&state->lock_alloc, 1) == 0;
if (locked) {
backtrace_free_locked(state, addr, size);
if (state->threaded) __sync_lock_release(&state->lock_alloc);
}
}
void *backtrace_vector_grow(struct backtrace_state *state, size_t size,
backtrace_error_callback error_callback, void *data,
struct backtrace_vector *vec) {
void *ret;
if (size > vec->alc) {
size_t pagesize;
size_t alc;
void *base;
pagesize = getpagesize();
alc = vec->size + size;
if (vec->size == 0)
alc = 16 * size;
else if (alc < pagesize) {
alc *= 2;
if (alc > pagesize) alc = pagesize;
} else {
alc *= 2;
alc = (alc + pagesize - 1) & ~(pagesize - 1);
}
base = backtrace_alloc(state, alc, error_callback, data);
if (base == NULL) return NULL;
if (vec->base != NULL) {
memcpy(base, vec->base, vec->size);
backtrace_free(state, vec->base, vec->size + vec->alc, error_callback,
data);
}
vec->base = base;
vec->alc = alc - vec->size;
}
ret = (char *)vec->base + vec->size;
vec->size += size;
vec->alc -= size;
return ret;
}
void *backtrace_vector_finish(struct backtrace_state *state ATTRIBUTE_UNUSED,
struct backtrace_vector *vec,
backtrace_error_callback error_callback
ATTRIBUTE_UNUSED,
void *data ATTRIBUTE_UNUSED) {
void *ret;
ret = vec->base;
vec->base = (char *)vec->base + vec->size;
vec->size = 0;
return ret;
}
int backtrace_vector_release(struct backtrace_state *state,
struct backtrace_vector *vec,
backtrace_error_callback error_callback,
void *data) {
size_t size;
size_t alc;
size_t aligned;
size = vec->size;
alc = vec->alc;
aligned = (size + 7) & ~(size_t)7;
alc -= aligned - size;
backtrace_free(state, (char *)vec->base + aligned, alc, error_callback, data);
vec->alc = 0;
if (vec->size == 0) vec->base = NULL;
return 1;
}
Reference in New Issue View Git Blame Copy Permalink