v/thirdparty/libbacktrace/windows.c

// pecoff.c:
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>

typedef struct {
  uint16_t machine;
  uint16_t number_of_sections;
  uint32_t time_date_stamp;
  uint32_t pointer_to_symbol_table;
  uint32_t number_of_symbols;
  uint16_t size_of_optional_header;
  uint16_t characteristics;
} b_coff_file_header;

typedef struct {
  uint16_t magic;
  uint8_t major_linker_version;
  uint8_t minor_linker_version;
  uint32_t size_of_code;
  uint32_t size_of_initialized_data;
  uint32_t size_of_uninitialized_data;
  uint32_t address_of_entry_point;
  uint32_t base_of_code;
  union {
    struct {
      uint32_t base_of_data;
      uint32_t image_base;
    } pe;
    struct {
      uint64_t image_base;
    } pep;
  } u;
} b_coff_optional_header;

#define PE_MAGIC 0x10b
#define PEP_MAGIC 0x20b

typedef struct {
  char name[8];
  uint32_t virtual_size;
  uint32_t virtual_address;
  uint32_t size_of_raw_data;
  uint32_t pointer_to_raw_data;
  uint32_t pointer_to_relocations;
  uint32_t pointer_to_line_numbers;
  uint16_t number_of_relocations;
  uint16_t number_of_line_numbers;
  uint32_t characteristics;
} b_coff_section_header;

typedef union {
  char short_name[8];
  struct {
    unsigned char zeroes[4];
    unsigned char off[4];
  } long_name;
} b_coff_name;

typedef struct {
  b_coff_name name;
  unsigned char value[4];
  unsigned char section_number[2];
  unsigned char type[2];
  unsigned char storage_class;
  unsigned char number_of_aux_symbols;
} b_coff_external_symbol;

#define N_TBSHFT 4
#define IMAGE_SYM_DTYPE_FUNCTION 2

#define SYM_SZ 18

typedef struct {
  const char *name;
  uint32_t value;
  int16_t sec;
  uint16_t type;
  uint16_t sc;
} b_coff_internal_symbol;

static const char *const debug_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;
};

struct coff_symbol {
  const char *name;

  uintptr_t address;
};

struct coff_syminfo_data {
  struct coff_syminfo_data *next;

  struct coff_symbol *symbols;

  size_t count;
};

static int coff_nodebug(struct backtrace_state *state ATTRIBUTE_UNUSED,
                        uintptr_t pc ATTRIBUTE_UNUSED,
                        backtrace_full_callback callback ATTRIBUTE_UNUSED,
                        backtrace_error_callback error_callback, void *data) {
  error_callback(data, "no debug info in PE/COFF executable", -1);
  return 0;
}

static void coff_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 PE/COFF executable", -1);
}

static uint32_t coff_read4(const unsigned char *p) {
  uint32_t res;

  memcpy(&res, p, 4);
  return res;
}

static uint16_t coff_read2(const unsigned char *p) {
  uint16_t res;

  memcpy(&res, p, sizeof(res));
  return res;
}

static size_t coff_short_name_len(const char *name) {
  int i;

  for (i = 0; i < 8; i++)
    if (name[i] == 0) return i;
  return 8;
}

static int coff_short_name_eq(const char *name, const char *cname) {
  int i;

  for (i = 0; i < 8; i++) {
    if (name[i] != cname[i]) return 0;
    if (name[i] == 0) return 1;
  }
  return name[8] == 0;
}

static int coff_long_name_eq(const char *name, unsigned int off,
                             struct backtrace_view *str_view) {
  if (off >= str_view->len) return 0;
  return strcmp(name, (const char *)str_view->data + off) == 0;
}

static int coff_symbol_compare(const void *v1, const void *v2) {
  const struct coff_symbol *e1 = (const struct coff_symbol *)v1;
  const struct coff_symbol *e2 = (const struct coff_symbol *)v2;

  if (e1->address < e2->address)
    return -1;
  else if (e1->address > e2->address)
    return 1;
  else
    return 0;
}

static int coff_expand_symbol(b_coff_internal_symbol *isym,
                              const b_coff_external_symbol *sym,
                              uint16_t sects_num, const unsigned char *strtab,
                              size_t strtab_size) {
  isym->type = coff_read2(sym->type);
  isym->sec = coff_read2(sym->section_number);
  isym->sc = sym->storage_class;

  if (isym->sec > 0 && (uint16_t)isym->sec > sects_num) return -1;
  if (sym->name.short_name[0] != 0)
    isym->name = sym->name.short_name;
  else {
    uint32_t off = coff_read4(sym->name.long_name.off);

    if (off >= strtab_size) return -1;
    isym->name = (const char *)strtab + off;
  }
  return 0;
}

static int coff_is_function_symbol(const b_coff_internal_symbol *isym) {
  return (isym->type >> N_TBSHFT) == IMAGE_SYM_DTYPE_FUNCTION && isym->sec > 0;
}

static int coff_initialize_syminfo(
    struct backtrace_state *state, uintptr_t base_address, int is_64,
    const b_coff_section_header *sects, size_t sects_num,
    const b_coff_external_symbol *syms, size_t syms_size,
    const unsigned char *strtab, size_t strtab_size,
    backtrace_error_callback error_callback, void *data,
    struct coff_syminfo_data *sdata) {
  size_t syms_count;
  char *coff_symstr;
  size_t coff_symstr_len;
  size_t coff_symbol_count;
  size_t coff_symbol_size;
  struct coff_symbol *coff_symbols;
  struct coff_symbol *coff_sym;
  char *coff_str;
  size_t i;

  syms_count = syms_size / SYM_SZ;

  coff_symbol_count = 0;
  coff_symstr_len = 0;
  for (i = 0; i < syms_count; ++i) {
    const b_coff_external_symbol *asym = &syms[i];
    b_coff_internal_symbol isym;

    if (coff_expand_symbol(&isym, asym, sects_num, strtab, strtab_size) < 0) {
      error_callback(data, "invalid section or offset in coff symbol", 0);
      return 0;
    }
    if (coff_is_function_symbol(&isym)) {
      ++coff_symbol_count;
      if (asym->name.short_name[0] != 0)
        coff_symstr_len += coff_short_name_len(asym->name.short_name) + 1;
    }

    i += asym->number_of_aux_symbols;
  }

  coff_symbol_size = (coff_symbol_count + 1) * sizeof(struct coff_symbol);
  coff_symbols = ((struct coff_symbol *)backtrace_alloc(state, coff_symbol_size,
                                                        error_callback, data));
  if (coff_symbols == NULL) return 0;

  if (coff_symstr_len > 0) {
    coff_symstr =
        ((char *)backtrace_alloc(state, coff_symstr_len, error_callback, data));
    if (coff_symstr == NULL) {
      backtrace_free(state, coff_symbols, coff_symbol_size, error_callback,
                     data);
      return 0;
    }
  } else
    coff_symstr = NULL;

  coff_sym = coff_symbols;
  coff_str = coff_symstr;
  for (i = 0; i < syms_count; ++i) {
    const b_coff_external_symbol *asym = &syms[i];
    b_coff_internal_symbol isym;

    if (coff_expand_symbol(&isym, asym, sects_num, strtab, strtab_size)) {
      abort();
    }
    if (coff_is_function_symbol(&isym)) {
      const char *name;
      int16_t secnum;

      if (asym->name.short_name[0] != 0) {
        size_t len = coff_short_name_len(isym.name);
        name = coff_str;
        memcpy(coff_str, isym.name, len);
        coff_str[len] = 0;
        coff_str += len + 1;
      } else
        name = isym.name;

      if (!is_64) {
        if (name[0] == '_') name++;
      }

      secnum = coff_read2(asym->section_number);

      coff_sym->name = name;
      coff_sym->address = (coff_read4(asym->value) +
                           sects[secnum - 1].virtual_address + base_address);
      coff_sym++;
    }

    i += asym->number_of_aux_symbols;
  }

  coff_sym->name = NULL;
  coff_sym->address = -1;

  backtrace_qsort(coff_symbols, coff_symbol_count, sizeof(struct coff_symbol),
                  coff_symbol_compare);

  sdata->next = NULL;
  sdata->symbols = coff_symbols;
  sdata->count = coff_symbol_count;

  return 1;
}

static void coff_add_syminfo_data(struct backtrace_state *state,
                                  struct coff_syminfo_data *sdata) {
  if (!state->threaded) {
    struct coff_syminfo_data **pp;

    for (pp = (struct coff_syminfo_data **)(void *)&state->syminfo_data;
         *pp != NULL; pp = &(*pp)->next)
      ;
    *pp = sdata;
  } else {
    while (1) {
      struct coff_syminfo_data **pp;

      pp = (struct coff_syminfo_data **)(void *)&state->syminfo_data;

      while (1) {
        struct coff_syminfo_data *p;

        p = backtrace_atomic_load_pointer(pp);

        if (p == NULL) break;

        pp = &p->next;
      }

      if (__sync_bool_compare_and_swap(pp, NULL, sdata)) break;
    }
  }
}

static int coff_symbol_search(const void *vkey, const void *ventry) {
  const uintptr_t *key = (const uintptr_t *)vkey;
  const struct coff_symbol *entry = (const struct coff_symbol *)ventry;
  uintptr_t addr;

  addr = *key;
  if (addr < entry->address)
    return -1;
  else if (addr >= entry[1].address)
    return 1;
  else
    return 0;
}

static void coff_syminfo(
    struct backtrace_state *state, uintptr_t addr,
    backtrace_syminfo_callback callback,
    backtrace_error_callback error_callback ATTRIBUTE_UNUSED, void *data) {
  struct coff_syminfo_data *sdata;
  struct coff_symbol *sym = NULL;

  if (!state->threaded) {
    for (sdata = (struct coff_syminfo_data *)state->syminfo_data; sdata != NULL;
         sdata = sdata->next) {
      sym = ((struct coff_symbol *)bsearch(&addr, sdata->symbols, sdata->count,
                                           sizeof(struct coff_symbol),
                                           coff_symbol_search));
      if (sym != NULL) break;
    }
  } else {
    struct coff_syminfo_data **pp;

    pp = (struct coff_syminfo_data **)(void *)&state->syminfo_data;
    while (1) {
      sdata = backtrace_atomic_load_pointer(pp);
      if (sdata == NULL) break;

      sym = ((struct coff_symbol *)bsearch(&addr, sdata->symbols, sdata->count,
                                           sizeof(struct coff_symbol),
                                           coff_symbol_search));
      if (sym != NULL) break;

      pp = &sdata->next;
    }
  }

  if (sym == NULL)
    callback(data, addr, NULL, 0, 0);
  else
    callback(data, addr, sym->name, sym->address, 0);
}

static int coff_add(struct backtrace_state *state, int descriptor,
                    backtrace_error_callback error_callback, void *data,
                    fileline *fileline_fn, int *found_sym, int *found_dwarf) {
  struct backtrace_view fhdr_view;
  off_t fhdr_off;
  int magic_ok;
  b_coff_file_header fhdr;
  off_t opt_sects_off;
  size_t opt_sects_size;
  unsigned int sects_num;
  struct backtrace_view sects_view;
  int sects_view_valid;
  const b_coff_optional_header *opt_hdr;
  const b_coff_section_header *sects;
  struct backtrace_view str_view;
  int str_view_valid;
  size_t str_size;
  off_t str_off;
  struct backtrace_view syms_view;
  off_t syms_off;
  size_t syms_size;
  int syms_view_valid;
  unsigned int syms_num;
  unsigned int i;
  struct debug_section_info sections[DEBUG_MAX];
  off_t min_offset;
  off_t max_offset;
  struct backtrace_view debug_view;
  int debug_view_valid;
  int is_64;
  uintptr_t image_base;
  struct dwarf_sections dwarf_sections;

  *found_sym = 0;
  *found_dwarf = 0;

  sects_view_valid = 0;
  syms_view_valid = 0;
  str_view_valid = 0;
  debug_view_valid = 0;

  if (!backtrace_get_view(state, descriptor, 0, 0x40, error_callback, data,
                          &fhdr_view))
    goto fail;

  {
    const unsigned char *vptr = fhdr_view.data;

    if (vptr[0] == 'M' && vptr[1] == 'Z')
      fhdr_off = coff_read4(vptr + 0x3c);
    else
      fhdr_off = 0;
  }

  backtrace_release_view(state, &fhdr_view, error_callback, data);

  if (!backtrace_get_view(state, descriptor, fhdr_off,
                          sizeof(b_coff_file_header) + 4, error_callback, data,
                          &fhdr_view))
    goto fail;

  if (fhdr_off != 0) {
    const char *magic = (const char *)fhdr_view.data;
    magic_ok = memcmp(magic, "PE\0", 4) == 0;
    fhdr_off += 4;

    memcpy(&fhdr, fhdr_view.data + 4, sizeof fhdr);
  } else {
    memcpy(&fhdr, fhdr_view.data, sizeof fhdr);

    magic_ok = 0;
  }
  backtrace_release_view(state, &fhdr_view, error_callback, data);

  if (!magic_ok) {
    error_callback(data, "executable file is not COFF", 0);
    goto fail;
  }

  sects_num = fhdr.number_of_sections;
  syms_num = fhdr.number_of_symbols;

  opt_sects_off = fhdr_off + sizeof(fhdr);
  opt_sects_size = (fhdr.size_of_optional_header +
                    sects_num * sizeof(b_coff_section_header));

  if (!backtrace_get_view(state, descriptor, opt_sects_off, opt_sects_size,
                          error_callback, data, &sects_view))
    goto fail;
  sects_view_valid = 1;
  opt_hdr = (const b_coff_optional_header *)sects_view.data;
  sects = (const b_coff_section_header *)(sects_view.data +
                                          fhdr.size_of_optional_header);

  is_64 = 0;
  if (fhdr.size_of_optional_header > sizeof(*opt_hdr)) {
    if (opt_hdr->magic == PE_MAGIC)
      image_base = opt_hdr->u.pe.image_base;
    else if (opt_hdr->magic == PEP_MAGIC) {
      image_base = opt_hdr->u.pep.image_base;
      is_64 = 1;
    } else {
      error_callback(data, "bad magic in PE optional header", 0);
      goto fail;
    }
  } else
    image_base = 0;

  if (fhdr.pointer_to_symbol_table == 0) {
    str_off = 0;
    str_size = 0;
    syms_num = 0;
    syms_size = 0;
  } else {
    syms_off = fhdr.pointer_to_symbol_table;
    syms_size = syms_num * SYM_SZ;

    if (!backtrace_get_view(state, descriptor, syms_off, syms_size + 4,
                            error_callback, data, &syms_view))
      goto fail;
    syms_view_valid = 1;

    str_size = coff_read4(syms_view.data + syms_size);

    str_off = syms_off + syms_size;

    if (str_size > 4) {
      if (!backtrace_get_view(state, descriptor, str_off, str_size,
                              error_callback, data, &str_view))
        goto fail;
      str_view_valid = 1;
    }
  }

  memset(sections, 0, sizeof sections);

  for (i = 0; i < sects_num; ++i) {
    const b_coff_section_header *s = sects + i;
    unsigned int str_off;
    int j;

    if (s->name[0] == '/') {
      str_off = atoi(s->name + 1);
    } else
      str_off = 0;

    for (j = 0; j < (int)DEBUG_MAX; ++j) {
      const char *dbg_name = debug_section_names[j];
      int match;

      if (str_off != 0)
        match = coff_long_name_eq(dbg_name, str_off, &str_view);
      else
        match = coff_short_name_eq(dbg_name, s->name);
      if (match) {
        sections[j].offset = s->pointer_to_raw_data;
        sections[j].size = s->virtual_size <= s->size_of_raw_data
                               ? s->virtual_size
                               : s->size_of_raw_data;
        break;
      }
    }
  }

  if (syms_num != 0) {
    struct coff_syminfo_data *sdata;

    sdata = ((struct coff_syminfo_data *)backtrace_alloc(state, sizeof *sdata,
                                                         error_callback, data));
    if (sdata == NULL) goto fail;

    if (!coff_initialize_syminfo(state, image_base, is_64, sects, sects_num,
                                 syms_view.data, syms_size, str_view.data,
                                 str_size, error_callback, data, sdata)) {
      backtrace_free(state, sdata, sizeof *sdata, error_callback, data);
      goto fail;
    }

    *found_sym = 1;

    coff_add_syminfo_data(state, sdata);
  }

  backtrace_release_view(state, &sects_view, error_callback, data);
  sects_view_valid = 0;
  if (syms_view_valid) {
    backtrace_release_view(state, &syms_view, error_callback, data);
    syms_view_valid = 0;
  }

  min_offset = 0;
  max_offset = 0;
  for (i = 0; i < (int)DEBUG_MAX; ++i) {
    off_t end;

    if (sections[i].size == 0) continue;
    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;
  }
  if (min_offset == 0 || max_offset == 0) {
    if (!backtrace_close(descriptor, error_callback, data)) goto fail;
    *fileline_fn = coff_nodebug;
    return 1;
  }

  if (!backtrace_get_view(state, descriptor, min_offset,
                          max_offset - min_offset, error_callback, data,
                          &debug_view))
    goto fail;
  debug_view_valid = 1;

  if (!backtrace_close(descriptor, error_callback, data)) goto fail;
  descriptor = -1;

  for (i = 0; i < (int)DEBUG_MAX; ++i) {
    size_t size = sections[i].size;
    dwarf_sections.size[i] = size;
    if (size == 0)
      dwarf_sections.data[i] = NULL;
    else
      dwarf_sections.data[i] = ((const unsigned char *)debug_view.data +
                                (sections[i].offset - min_offset));
  }

  if (!backtrace_dwarf_add(state, 0, &dwarf_sections, 0, NULL, error_callback,
                           data, fileline_fn, NULL))
    goto fail;

  *found_dwarf = 1;

  return 1;

fail:
  if (sects_view_valid)
    backtrace_release_view(state, &sects_view, error_callback, data);
  if (str_view_valid)
    backtrace_release_view(state, &str_view, error_callback, data);
  if (syms_view_valid)
    backtrace_release_view(state, &syms_view, error_callback, data);
  if (debug_view_valid)
    backtrace_release_view(state, &debug_view, error_callback, data);
  if (descriptor != -1) backtrace_close(descriptor, error_callback, data);
  return 0;
}

int backtrace_initialize(struct backtrace_state *state,
                         const char *filename ATTRIBUTE_UNUSED, int descriptor,
                         backtrace_error_callback error_callback, void *data,
                         fileline *fileline_fn) {
  int ret;
  int found_sym;
  int found_dwarf;
  fileline coff_fileline_fn;

  ret = coff_add(state, descriptor, error_callback, data, &coff_fileline_fn,
                 &found_sym, &found_dwarf);
  if (!ret) return 0;

  if (!state->threaded) {
    if (found_sym)
      state->syminfo_fn = coff_syminfo;
    else if (state->syminfo_fn == NULL)
      state->syminfo_fn = coff_nosyms;
  } else {
    if (found_sym)
      backtrace_atomic_store_pointer(&state->syminfo_fn, coff_syminfo);
    else
      (void)__sync_bool_compare_and_swap(&state->syminfo_fn, NULL, coff_nosyms);
  }

  if (!state->threaded) {
    if (state->fileline_fn == NULL || state->fileline_fn == coff_nodebug)
      *fileline_fn = coff_fileline_fn;
  } else {
    fileline current_fn;

    current_fn = backtrace_atomic_load_pointer(&state->fileline_fn);
    if (current_fn == NULL || current_fn == coff_nodebug)
      *fileline_fn = coff_fileline_fn;
  }

  return 1;
}

// read.c:
#include <errno.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

int backtrace_get_view(struct backtrace_state *state, int descriptor,
                       off_t offset, uint64_t size,
                       backtrace_error_callback error_callback, void *data,
                       struct backtrace_view *view) {
  uint64_t got;
  ssize_t r;

  if ((uint64_t)(size_t)size != size) {
    error_callback(data, "file size too large", 0);
    return 0;
  }

  if (lseek(descriptor, offset, SEEK_SET) < 0) {
    error_callback(data, "lseek", errno);
    return 0;
  }

  view->base = backtrace_alloc(state, size, error_callback, data);
  if (view->base == NULL) return 0;
  view->data = view->base;
  view->len = size;

  got = 0;
  while (got < size) {
    r = read(descriptor, view->base, size - got);
    if (r < 0) {
      error_callback(data, "read", errno);
      free(view->base);
      return 0;
    }
    if (r == 0) break;
    got += (uint64_t)r;
  }

  if (got < size) {
    error_callback(data, "file too short", 0);
    free(view->base);
    return 0;
  }

  return 1;
}

void backtrace_release_view(struct backtrace_state *state,
                            struct backtrace_view *view,
                            backtrace_error_callback error_callback,
                            void *data) {
  backtrace_free(state, view->base, view->len, error_callback, data);
  view->data = NULL;
  view->base = NULL;
}

// alloc.c:
#include <errno.h>
#include <stdlib.h>
#include <sys/types.h>

void *backtrace_alloc(struct backtrace_state *state ATTRIBUTE_UNUSED,
                      size_t size, backtrace_error_callback error_callback,
                      void *data) {
  void *ret;

  ret = malloc(size);
  if (ret == NULL) {
    if (error_callback) error_callback(data, "malloc", errno);
  }
  return ret;
}

void backtrace_free(struct backtrace_state *state ATTRIBUTE_UNUSED, void *p,
                    size_t size ATTRIBUTE_UNUSED,
                    backtrace_error_callback error_callback ATTRIBUTE_UNUSED,
                    void *data ATTRIBUTE_UNUSED) {
  free(p);
}

void *backtrace_vector_grow(struct backtrace_state *state ATTRIBUTE_UNUSED,
                            size_t size,
                            backtrace_error_callback error_callback, void *data,
                            struct backtrace_vector *vec) {
  void *ret;

  if (size > vec->alc) {
    size_t alc;
    void *base;

    if (vec->size == 0)
      alc = 32 * size;
    else if (vec->size >= 4096)
      alc = vec->size + 4096;
    else
      alc = 2 * vec->size;

    if (alc < vec->size + size) alc = vec->size + size;

    base = realloc(vec->base, alc);
    if (base == NULL) {
      error_callback(data, "realloc", errno);
      return NULL;
    }

    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,
                              struct backtrace_vector *vec,
                              backtrace_error_callback error_callback,
                              void *data) {
  void *ret;

  if (!backtrace_vector_release(state, vec, error_callback, data)) return NULL;
  ret = vec->base;
  vec->base = NULL;
  vec->size = 0;
  vec->alc = 0;
  return ret;
}

int backtrace_vector_release(struct backtrace_state *state ATTRIBUTE_UNUSED,
                             struct backtrace_vector *vec,
                             backtrace_error_callback error_callback,
                             void *data) {
  vec->alc = 0;

  if (vec->size == 0) {
    free(vec->base);
    vec->base = NULL;
    return 1;
  }

  vec->base = realloc(vec->base, vec->size);
  if (vec->base == NULL) {
    error_callback(data, "realloc", errno);
    return 0;
  }

  return 1;
}