#include <fcntl.h>
#include <inttypes.h>
#include <mach-o/compact_unwind_encoding.h>
#include <mach-o/loader.h>
#include <mach-o/nlist.h>
#include <mach/machine.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/errno.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>

enum {
  UNWIND_ARM64_MODE_MASK = 0x0F000000,
  UNWIND_ARM64_MODE_FRAMELESS = 0x02000000,
  UNWIND_ARM64_MODE_DWARF = 0x03000000,
  UNWIND_ARM64_MODE_FRAME = 0x04000000,

  UNWIND_ARM64_FRAME_X19_X20_PAIR = 0x00000001,
  UNWIND_ARM64_FRAME_X21_X22_PAIR = 0x00000002,
  UNWIND_ARM64_FRAME_X23_X24_PAIR = 0x00000004,
  UNWIND_ARM64_FRAME_X25_X26_PAIR = 0x00000008,
  UNWIND_ARM64_FRAME_X27_X28_PAIR = 0x00000010,
  UNWIND_ARM64_FRAME_D8_D9_PAIR = 0x00000100,
  UNWIND_ARM64_FRAME_D10_D11_PAIR = 0x00000200,
  UNWIND_ARM64_FRAME_D12_D13_PAIR = 0x00000400,
  UNWIND_ARM64_FRAME_D14_D15_PAIR = 0x00000800,

  UNWIND_ARM64_FRAMELESS_STACK_SIZE_MASK = 0x00FFF000,
  UNWIND_ARM64_DWARF_SECTION_OFFSET = 0x00FFFFFF,
};

enum {
  UNWIND_ARM_MODE_MASK = 0x0F000000,
  UNWIND_ARM_MODE_FRAME = 0x01000000,
  UNWIND_ARM_MODE_FRAME_D = 0x02000000,
  UNWIND_ARM_MODE_DWARF = 0x04000000,

  UNWIND_ARM_FRAME_STACK_ADJUST_MASK = 0x00C00000,

  UNWIND_ARM_FRAME_FIRST_PUSH_R4 = 0x00000001,
  UNWIND_ARM_FRAME_FIRST_PUSH_R5 = 0x00000002,
  UNWIND_ARM_FRAME_FIRST_PUSH_R6 = 0x00000004,

  UNWIND_ARM_FRAME_SECOND_PUSH_R8 = 0x00000008,
  UNWIND_ARM_FRAME_SECOND_PUSH_R9 = 0x00000010,
  UNWIND_ARM_FRAME_SECOND_PUSH_R10 = 0x00000020,
  UNWIND_ARM_FRAME_SECOND_PUSH_R11 = 0x00000040,
  UNWIND_ARM_FRAME_SECOND_PUSH_R12 = 0x00000080,

  UNWIND_ARM_FRAME_D_REG_COUNT_MASK = 0x00000700,

  UNWIND_ARM_DWARF_SECTION_OFFSET = 0x00FFFFFF,
};

#define EXTRACT_BITS(value, mask)                                              \
  ((value >> __builtin_ctz(mask)) & (((1 << __builtin_popcount(mask))) - 1))

// A quick sketch of a program which can parse the compact unwind info
// used on Darwin systems for exception handling.  The output of
// unwinddump will be more authoritative/reliable but this program
// can dump at least the UNWIND_X86_64_MODE_RBP_FRAME format entries
// correctly.

struct symbol {
  uint64_t file_address;
  const char *name;
};

int symbol_compare(const void *a, const void *b) {
  return (int)((struct symbol *)a)->file_address -
         ((struct symbol *)b)->file_address;
}

struct baton {
  cpu_type_t cputype;

  uint8_t *mach_header_start;    // pointer into this program's address space
  uint8_t *compact_unwind_start; // pointer into this program's address space

  int addr_size; // 4 or 8 bytes, the size of addresses in this file

  uint64_t text_segment_vmaddr; // __TEXT segment vmaddr
  uint64_t text_segment_file_offset;

  uint64_t text_section_vmaddr; // __TEXT,__text section vmaddr
  uint64_t text_section_file_offset;

  uint64_t eh_section_file_address; // the file address of the __TEXT,__eh_frame
                                    // section

  uint8_t
      *lsda_array_start; // for the currently-being-processed first-level index
  uint8_t
      *lsda_array_end; // the lsda_array_start for the NEXT first-level index

  struct symbol *symbols;
  int symbols_count;

  uint64_t *function_start_addresses;
  int function_start_addresses_count;

  int current_index_table_number;

  struct unwind_info_section_header unwind_header;
  struct unwind_info_section_header_index_entry first_level_index_entry;
  struct unwind_info_compressed_second_level_page_header
      compressed_second_level_page_header;
  struct unwind_info_regular_second_level_page_header
      regular_second_level_page_header;
};

uint64_t read_leb128(uint8_t **offset) {
  uint64_t result = 0;
  int shift = 0;
  while (1) {
    uint8_t byte = **offset;
    *offset = *offset + 1;
    result |= (byte & 0x7f) << shift;
    if ((byte & 0x80) == 0)
      break;
    shift += 7;
  }

  return result;
}

// step through the load commands in a thin mach-o binary,
// find the cputype and the start of the __TEXT,__unwind_info
// section, return a pointer to that section or NULL if not found.

static void scan_macho_load_commands(struct baton *baton) {
  struct symtab_command symtab_cmd;
  uint64_t linkedit_segment_vmaddr;
  uint64_t linkedit_segment_file_offset;

  baton->compact_unwind_start = 0;

  uint32_t *magic = (uint32_t *)baton->mach_header_start;

  if (*magic != MH_MAGIC && *magic != MH_MAGIC_64) {
    printf("Unexpected magic number 0x%x in header, exiting.", *magic);
    exit(1);
  }

  bool is_64bit = false;
  if (*magic == MH_MAGIC_64)
    is_64bit = true;

  uint8_t *offset = baton->mach_header_start;

  struct mach_header mh;
  memcpy(&mh, offset, sizeof(struct mach_header));
  if (is_64bit)
    offset += sizeof(struct mach_header_64);
  else
    offset += sizeof(struct mach_header);

  if (is_64bit)
    baton->addr_size = 8;
  else
    baton->addr_size = 4;

  baton->cputype = mh.cputype;

  uint8_t *start_of_load_commands = offset;

  uint32_t cur_cmd = 0;
  while (cur_cmd < mh.ncmds &&
         (offset - start_of_load_commands) < mh.sizeofcmds) {
    struct load_command lc;
    uint32_t *lc_cmd = (uint32_t *)offset;
    uint32_t *lc_cmdsize = (uint32_t *)offset + 1;
    uint8_t *start_of_this_load_cmd = offset;

    if (*lc_cmd == LC_SEGMENT || *lc_cmd == LC_SEGMENT_64) {
      char segment_name[17];
      segment_name[0] = '\0';
      uint32_t nsects = 0;
      uint64_t segment_offset = 0;
      uint64_t segment_vmaddr = 0;

      if (*lc_cmd == LC_SEGMENT_64) {
        struct segment_command_64 seg;
        memcpy(&seg, offset, sizeof(struct segment_command_64));
        memcpy(&segment_name, &seg.segname, 16);
        segment_name[16] = '\0';
        nsects = seg.nsects;
        segment_offset = seg.fileoff;
        segment_vmaddr = seg.vmaddr;
        offset += sizeof(struct segment_command_64);
        if ((seg.flags & SG_PROTECTED_VERSION_1) == SG_PROTECTED_VERSION_1) {
          printf("Segment '%s' is encrypted.\n", segment_name);
        }
      }

      if (*lc_cmd == LC_SEGMENT) {
        struct segment_command seg;
        memcpy(&seg, offset, sizeof(struct segment_command));
        memcpy(&segment_name, &seg.segname, 16);
        segment_name[16] = '\0';
        nsects = seg.nsects;
        segment_offset = seg.fileoff;
        segment_vmaddr = seg.vmaddr;
        offset += sizeof(struct segment_command);
        if ((seg.flags & SG_PROTECTED_VERSION_1) == SG_PROTECTED_VERSION_1) {
          printf("Segment '%s' is encrypted.\n", segment_name);
        }
      }

      if (nsects != 0 && strcmp(segment_name, "__TEXT") == 0) {
        baton->text_segment_vmaddr = segment_vmaddr;
        baton->text_segment_file_offset = segment_offset;

        uint32_t current_sect = 0;
        while (current_sect < nsects &&
               (offset - start_of_this_load_cmd) < *lc_cmdsize) {
          char sect_name[17];
          memcpy(&sect_name, offset, 16);
          sect_name[16] = '\0';
          if (strcmp(sect_name, "__unwind_info") == 0) {
            if (is_64bit) {
              struct section_64 sect;
              memset(&sect, 0, sizeof(struct section_64));
              memcpy(&sect, offset, sizeof(struct section_64));
              baton->compact_unwind_start =
                  baton->mach_header_start + sect.offset;
            } else {
              struct section sect;
              memset(&sect, 0, sizeof(struct section));
              memcpy(&sect, offset, sizeof(struct section));
              baton->compact_unwind_start =
                  baton->mach_header_start + sect.offset;
            }
          }
          if (strcmp(sect_name, "__eh_frame") == 0) {
            if (is_64bit) {
              struct section_64 sect;
              memset(&sect, 0, sizeof(struct section_64));
              memcpy(&sect, offset, sizeof(struct section_64));
              baton->eh_section_file_address = sect.addr;
            } else {
              struct section sect;
              memset(&sect, 0, sizeof(struct section));
              memcpy(&sect, offset, sizeof(struct section));
              baton->eh_section_file_address = sect.addr;
            }
          }
          if (strcmp(sect_name, "__text") == 0) {
            if (is_64bit) {
              struct section_64 sect;
              memset(&sect, 0, sizeof(struct section_64));
              memcpy(&sect, offset, sizeof(struct section_64));
              baton->text_section_vmaddr = sect.addr;
              baton->text_section_file_offset = sect.offset;
            } else {
              struct section sect;
              memset(&sect, 0, sizeof(struct section));
              memcpy(&sect, offset, sizeof(struct section));
              baton->text_section_vmaddr = sect.addr;
            }
          }
          if (is_64bit) {
            offset += sizeof(struct section_64);
          } else {
            offset += sizeof(struct section);
          }
        }
      }

      if (strcmp(segment_name, "__LINKEDIT") == 0) {
        linkedit_segment_vmaddr = segment_vmaddr;
        linkedit_segment_file_offset = segment_offset;
      }
    }

    if (*lc_cmd == LC_SYMTAB) {
      memcpy(&symtab_cmd, offset, sizeof(struct symtab_command));
    }

    if (*lc_cmd == LC_DYSYMTAB) {
      struct dysymtab_command dysymtab_cmd;
      memcpy(&dysymtab_cmd, offset, sizeof(struct dysymtab_command));

      int nlist_size = 12;
      if (is_64bit)
        nlist_size = 16;

      char *string_table =
          (char *)(baton->mach_header_start + symtab_cmd.stroff);
      uint8_t *local_syms = baton->mach_header_start + symtab_cmd.symoff +
                            (dysymtab_cmd.ilocalsym * nlist_size);
      int local_syms_count = dysymtab_cmd.nlocalsym;
      uint8_t *exported_syms = baton->mach_header_start + symtab_cmd.symoff +
                               (dysymtab_cmd.iextdefsym * nlist_size);
      int exported_syms_count = dysymtab_cmd.nextdefsym;

      // We're only going to create records for a small number of these symbols
      // but to
      // simplify the memory management I'll allocate enough space to store all
      // of them.
      baton->symbols = (struct symbol *)malloc(
          sizeof(struct symbol) * (local_syms_count + exported_syms_count));
      baton->symbols_count = 0;

      for (int i = 0; i < local_syms_count; i++) {
        struct nlist_64 nlist;
        memset(&nlist, 0, sizeof(struct nlist_64));
        if (is_64bit) {
          memcpy(&nlist, local_syms + (i * nlist_size),
                 sizeof(struct nlist_64));
        } else {
          struct nlist nlist_32;
          memset(&nlist_32, 0, sizeof(struct nlist));
          memcpy(&nlist_32, local_syms + (i * nlist_size),
                 sizeof(struct nlist));
          nlist.n_un.n_strx = nlist_32.n_un.n_strx;
          nlist.n_type = nlist_32.n_type;
          nlist.n_sect = nlist_32.n_sect;
          nlist.n_desc = nlist_32.n_desc;
          nlist.n_value = nlist_32.n_value;
        }
        if ((nlist.n_type & N_STAB) == 0 &&
            ((nlist.n_type & N_EXT) == 1 ||
             ((nlist.n_type & N_TYPE) == N_TYPE && nlist.n_sect != NO_SECT)) &&
            nlist.n_value != 0 && nlist.n_value != baton->text_segment_vmaddr) {
          baton->symbols[baton->symbols_count].file_address = nlist.n_value;
          if (baton->cputype == CPU_TYPE_ARM)
            baton->symbols[baton->symbols_count].file_address =
                baton->symbols[baton->symbols_count].file_address & ~1;
          baton->symbols[baton->symbols_count].name =
              string_table + nlist.n_un.n_strx;
          baton->symbols_count++;
        }
      }

      for (int i = 0; i < exported_syms_count; i++) {
        struct nlist_64 nlist;
        memset(&nlist, 0, sizeof(struct nlist_64));
        if (is_64bit) {
          memcpy(&nlist, exported_syms + (i * nlist_size),
                 sizeof(struct nlist_64));
        } else {
          struct nlist nlist_32;
          memcpy(&nlist_32, exported_syms + (i * nlist_size),
                 sizeof(struct nlist));
          nlist.n_un.n_strx = nlist_32.n_un.n_strx;
          nlist.n_type = nlist_32.n_type;
          nlist.n_sect = nlist_32.n_sect;
          nlist.n_desc = nlist_32.n_desc;
          nlist.n_value = nlist_32.n_value;
        }
        if ((nlist.n_type & N_STAB) == 0 &&
            ((nlist.n_type & N_EXT) == 1 ||
             ((nlist.n_type & N_TYPE) == N_TYPE && nlist.n_sect != NO_SECT)) &&
            nlist.n_value != 0 && nlist.n_value != baton->text_segment_vmaddr) {
          baton->symbols[baton->symbols_count].file_address = nlist.n_value;
          if (baton->cputype == CPU_TYPE_ARM)
            baton->symbols[baton->symbols_count].file_address =
                baton->symbols[baton->symbols_count].file_address & ~1;
          baton->symbols[baton->symbols_count].name =
              string_table + nlist.n_un.n_strx;
          baton->symbols_count++;
        }
      }

      qsort(baton->symbols, baton->symbols_count, sizeof(struct symbol),
            symbol_compare);
    }

    if (*lc_cmd == LC_FUNCTION_STARTS) {
      struct linkedit_data_command function_starts_cmd;
      memcpy(&function_starts_cmd, offset,
             sizeof(struct linkedit_data_command));

      uint8_t *funcstarts_offset =
          baton->mach_header_start + function_starts_cmd.dataoff;
      uint8_t *function_end = funcstarts_offset + function_starts_cmd.datasize;
      int count = 0;

      while (funcstarts_offset < function_end) {
        if (read_leb128(&funcstarts_offset) != 0) {
          count++;
        }
      }

      baton->function_start_addresses =
          (uint64_t *)malloc(sizeof(uint64_t) * count);
      baton->function_start_addresses_count = count;

      funcstarts_offset =
          baton->mach_header_start + function_starts_cmd.dataoff;
      uint64_t current_pc = baton->text_segment_vmaddr;
      int i = 0;
      while (funcstarts_offset < function_end) {
        uint64_t func_start = read_leb128(&funcstarts_offset);
        if (func_start != 0) {
          current_pc += func_start;
          baton->function_start_addresses[i++] = current_pc;
        }
      }
    }

    offset = start_of_this_load_cmd + *lc_cmdsize;
    cur_cmd++;
  }

  // Augment the symbol table with the function starts table -- adding symbol
  // entries
  // for functions that were stripped.

  int unnamed_functions_to_add = 0;
  for (int i = 0; i < baton->function_start_addresses_count; i++) {
    struct symbol search_key;
    search_key.file_address = baton->function_start_addresses[i];
    if (baton->cputype == CPU_TYPE_ARM)
      search_key.file_address = search_key.file_address & ~1;
    struct symbol *sym =
        bsearch(&search_key, baton->symbols, baton->symbols_count,
                sizeof(struct symbol), symbol_compare);
    if (sym == NULL)
      unnamed_functions_to_add++;
  }

  baton->symbols = (struct symbol *)realloc(
      baton->symbols, sizeof(struct symbol) *
                          (baton->symbols_count + unnamed_functions_to_add));

  int current_unnamed_symbol = 1;
  int number_symbols_added = 0;
  for (int i = 0; i < baton->function_start_addresses_count; i++) {
    struct symbol search_key;
    search_key.file_address = baton->function_start_addresses[i];
    if (baton->cputype == CPU_TYPE_ARM)
      search_key.file_address = search_key.file_address & ~1;
    struct symbol *sym =
        bsearch(&search_key, baton->symbols, baton->symbols_count,
                sizeof(struct symbol), symbol_compare);
    if (sym == NULL) {
      char *name;
      asprintf(&name, "unnamed function #%d", current_unnamed_symbol++);
      baton->symbols[baton->symbols_count + number_symbols_added].file_address =
          baton->function_start_addresses[i];
      baton->symbols[baton->symbols_count + number_symbols_added].name = name;
      number_symbols_added++;
    }
  }
  baton->symbols_count += number_symbols_added;
  qsort(baton->symbols, baton->symbols_count, sizeof(struct symbol),
        symbol_compare);

  //    printf ("function start addresses\n");
  //    for (int i = 0; i < baton->function_start_addresses_count; i++)
  //    {
  //        printf ("0x%012llx\n", baton->function_start_addresses[i]);
  //    }

  //    printf ("symbol table names & addresses\n");
  //    for (int i = 0; i < baton->symbols_count; i++)
  //    {
  //        printf ("0x%012llx %s\n", baton->symbols[i].file_address,
  //        baton->symbols[i].name);
  //    }
}

void print_encoding_x86_64(struct baton baton, uint8_t *function_start,
                           uint32_t encoding) {
  int mode = encoding & UNWIND_X86_64_MODE_MASK;
  switch (mode) {
  case UNWIND_X86_64_MODE_RBP_FRAME: {
    printf("frame func: CFA is rbp+%d ", 16);
    printf(" rip=[CFA-8] rbp=[CFA-16]");
    uint32_t saved_registers_offset =
        EXTRACT_BITS(encoding, UNWIND_X86_64_RBP_FRAME_OFFSET);

    uint32_t saved_registers_locations =
        EXTRACT_BITS(encoding, UNWIND_X86_64_RBP_FRAME_REGISTERS);

    saved_registers_offset += 2;

    for (int i = 0; i < 5; i++) {
      switch (saved_registers_locations & 0x7) {
      case UNWIND_X86_64_REG_NONE:
        break;
      case UNWIND_X86_64_REG_RBX:
        printf(" rbx=[CFA-%d]", saved_registers_offset * 8);
        break;
      case UNWIND_X86_64_REG_R12:
        printf(" r12=[CFA-%d]", saved_registers_offset * 8);
        break;
      case UNWIND_X86_64_REG_R13:
        printf(" r13=[CFA-%d]", saved_registers_offset * 8);
        break;
      case UNWIND_X86_64_REG_R14:
        printf(" r14=[CFA-%d]", saved_registers_offset * 8);
        break;
      case UNWIND_X86_64_REG_R15:
        printf(" r15=[CFA-%d]", saved_registers_offset * 8);
        break;
      }
      saved_registers_offset--;
      saved_registers_locations >>= 3;
    }
  } break;

  case UNWIND_X86_64_MODE_STACK_IND:
  case UNWIND_X86_64_MODE_STACK_IMMD: {
    uint32_t stack_size =
        EXTRACT_BITS(encoding, UNWIND_X86_64_FRAMELESS_STACK_SIZE);
    uint32_t register_count =
        EXTRACT_BITS(encoding, UNWIND_X86_64_FRAMELESS_STACK_REG_COUNT);
    uint32_t permutation =
        EXTRACT_BITS(encoding, UNWIND_X86_64_FRAMELESS_STACK_REG_PERMUTATION);

    if (mode == UNWIND_X86_64_MODE_STACK_IND && function_start) {
      uint32_t stack_adjust =
          EXTRACT_BITS(encoding, UNWIND_X86_64_FRAMELESS_STACK_ADJUST);

      // offset into the function instructions; 0 == beginning of first
      // instruction
      uint32_t offset_to_subl_insn =
          EXTRACT_BITS(encoding, UNWIND_X86_64_FRAMELESS_STACK_SIZE);

      stack_size = *((uint32_t *)(function_start + offset_to_subl_insn));

      stack_size += stack_adjust * 8;

      printf("large stack ");
    }

    if (mode == UNWIND_X86_64_MODE_STACK_IND) {
      printf("frameless function: stack size %d, register count %d ",
             stack_size * 8, register_count);
    } else {
      printf("frameless function: stack size %d, register count %d ",
             stack_size, register_count);
    }

    if (register_count == 0) {
      printf(" no registers saved");
    } else {

      // We need to include (up to) 6 registers in 10 bits.
      // That would be 18 bits if we just used 3 bits per reg to indicate
      // the order they're saved on the stack.
      //
      // This is done with Lehmer code permutation, e.g. see
      // http://stackoverflow.com/questions/1506078/fast-permutation-number-permutation-mapping-algorithms
      int permunreg[6];

      // This decodes the variable-base number in the 10 bits
      // and gives us the Lehmer code sequence which can then
      // be decoded.

      switch (register_count) {
      case 6:
        permunreg[0] = permutation / 120; // 120 == 5!
        permutation -= (permunreg[0] * 120);
        permunreg[1] = permutation / 24; // 24 == 4!
        permutation -= (permunreg[1] * 24);
        permunreg[2] = permutation / 6; // 6 == 3!
        permutation -= (permunreg[2] * 6);
        permunreg[3] = permutation / 2; // 2 == 2!
        permutation -= (permunreg[3] * 2);
        permunreg[4] = permutation; // 1 == 1!
        permunreg[5] = 0;
        break;
      case 5:
        permunreg[0] = permutation / 120;
        permutation -= (permunreg[0] * 120);
        permunreg[1] = permutation / 24;
        permutation -= (permunreg[1] * 24);
        permunreg[2] = permutation / 6;
        permutation -= (permunreg[2] * 6);
        permunreg[3] = permutation / 2;
        permutation -= (permunreg[3] * 2);
        permunreg[4] = permutation;
        break;
      case 4:
        permunreg[0] = permutation / 60;
        permutation -= (permunreg[0] * 60);
        permunreg[1] = permutation / 12;
        permutation -= (permunreg[1] * 12);
        permunreg[2] = permutation / 3;
        permutation -= (permunreg[2] * 3);
        permunreg[3] = permutation;
        break;
      case 3:
        permunreg[0] = permutation / 20;
        permutation -= (permunreg[0] * 20);
        permunreg[1] = permutation / 4;
        permutation -= (permunreg[1] * 4);
        permunreg[2] = permutation;
        break;
      case 2:
        permunreg[0] = permutation / 5;
        permutation -= (permunreg[0] * 5);
        permunreg[1] = permutation;
        break;
      case 1:
        permunreg[0] = permutation;
        break;
      }

      // Decode the Lehmer code for this permutation of
      // the registers v. http://en.wikipedia.org/wiki/Lehmer_code

      int registers[6];
      bool used[7] = {false, false, false, false, false, false, false};
      for (int i = 0; i < register_count; i++) {
        int renum = 0;
        for (int j = 1; j < 7; j++) {
          if (used[j] == false) {
            if (renum == permunreg[i]) {
              registers[i] = j;
              used[j] = true;
              break;
            }
            renum++;
          }
        }
      }

      if (mode == UNWIND_X86_64_MODE_STACK_IND) {
        printf(" CFA is rsp+%d ", stack_size);
      } else {
        printf(" CFA is rsp+%d ", stack_size * 8);
      }

      uint32_t saved_registers_offset = 1;
      printf(" rip=[CFA-%d]", saved_registers_offset * 8);
      saved_registers_offset++;

      for (int i = (sizeof(registers) / sizeof(int)) - 1; i >= 0; i--) {
        switch (registers[i]) {
        case UNWIND_X86_64_REG_NONE:
          break;
        case UNWIND_X86_64_REG_RBX:
          printf(" rbx=[CFA-%d]", saved_registers_offset * 8);
          saved_registers_offset++;
          break;
        case UNWIND_X86_64_REG_R12:
          printf(" r12=[CFA-%d]", saved_registers_offset * 8);
          saved_registers_offset++;
          break;
        case UNWIND_X86_64_REG_R13:
          printf(" r13=[CFA-%d]", saved_registers_offset * 8);
          saved_registers_offset++;
          break;
        case UNWIND_X86_64_REG_R14:
          printf(" r14=[CFA-%d]", saved_registers_offset * 8);
          saved_registers_offset++;
          break;
        case UNWIND_X86_64_REG_R15:
          printf(" r15=[CFA-%d]", saved_registers_offset * 8);
          saved_registers_offset++;
          break;
        case UNWIND_X86_64_REG_RBP:
          printf(" rbp=[CFA-%d]", saved_registers_offset * 8);
          saved_registers_offset++;
          break;
        }
      }
    }

  } break;

  case UNWIND_X86_64_MODE_DWARF: {
    uint32_t dwarf_offset = encoding & UNWIND_X86_DWARF_SECTION_OFFSET;
    printf(
        "DWARF unwind instructions: FDE at offset %d (file address 0x%" PRIx64
        ")",
        dwarf_offset, dwarf_offset + baton.eh_section_file_address);
  } break;

  case 0: {
    printf(" no unwind information");
  } break;
  }
}

void print_encoding_i386(struct baton baton, uint8_t *function_start,
                         uint32_t encoding) {
  int mode = encoding & UNWIND_X86_MODE_MASK;
  switch (mode) {
  case UNWIND_X86_MODE_EBP_FRAME: {
    printf("frame func: CFA is ebp+%d ", 8);
    printf(" eip=[CFA-4] ebp=[CFA-8]");
    uint32_t saved_registers_offset =
        EXTRACT_BITS(encoding, UNWIND_X86_EBP_FRAME_OFFSET);

    uint32_t saved_registers_locations =
        EXTRACT_BITS(encoding, UNWIND_X86_EBP_FRAME_REGISTERS);

    saved_registers_offset += 2;

    for (int i = 0; i < 5; i++) {
      switch (saved_registers_locations & 0x7) {
      case UNWIND_X86_REG_NONE:
        break;
      case UNWIND_X86_REG_EBX:
        printf(" ebx=[CFA-%d]", saved_registers_offset * 4);
        break;
      case UNWIND_X86_REG_ECX:
        printf(" ecx=[CFA-%d]", saved_registers_offset * 4);
        break;
      case UNWIND_X86_REG_EDX:
        printf(" edx=[CFA-%d]", saved_registers_offset * 4);
        break;
      case UNWIND_X86_REG_EDI:
        printf(" edi=[CFA-%d]", saved_registers_offset * 4);
        break;
      case UNWIND_X86_REG_ESI:
        printf(" esi=[CFA-%d]", saved_registers_offset * 4);
        break;
      }
      saved_registers_offset--;
      saved_registers_locations >>= 3;
    }
  } break;

  case UNWIND_X86_MODE_STACK_IND:
  case UNWIND_X86_MODE_STACK_IMMD: {
    uint32_t stack_size =
        EXTRACT_BITS(encoding, UNWIND_X86_FRAMELESS_STACK_SIZE);
    uint32_t register_count =
        EXTRACT_BITS(encoding, UNWIND_X86_FRAMELESS_STACK_REG_COUNT);
    uint32_t permutation =
        EXTRACT_BITS(encoding, UNWIND_X86_FRAMELESS_STACK_REG_PERMUTATION);

    if (mode == UNWIND_X86_MODE_STACK_IND && function_start) {
      uint32_t stack_adjust =
          EXTRACT_BITS(encoding, UNWIND_X86_FRAMELESS_STACK_ADJUST);

      // offset into the function instructions; 0 == beginning of first
      // instruction
      uint32_t offset_to_subl_insn =
          EXTRACT_BITS(encoding, UNWIND_X86_FRAMELESS_STACK_SIZE);

      stack_size = *((uint32_t *)(function_start + offset_to_subl_insn));

      stack_size += stack_adjust * 4;

      printf("large stack ");
    }

    if (mode == UNWIND_X86_MODE_STACK_IND) {
      printf("frameless function: stack size %d, register count %d ",
             stack_size, register_count);
    } else {
      printf("frameless function: stack size %d, register count %d ",
             stack_size * 4, register_count);
    }

    if (register_count == 0) {
      printf(" no registers saved");
    } else {

      // We need to include (up to) 6 registers in 10 bits.
      // That would be 18 bits if we just used 3 bits per reg to indicate
      // the order they're saved on the stack.
      //
      // This is done with Lehmer code permutation, e.g. see
      // http://stackoverflow.com/questions/1506078/fast-permutation-number-permutation-mapping-algorithms
      int permunreg[6];

      // This decodes the variable-base number in the 10 bits
      // and gives us the Lehmer code sequence which can then
      // be decoded.

      switch (register_count) {
      case 6:
        permunreg[0] = permutation / 120; // 120 == 5!
        permutation -= (permunreg[0] * 120);
        permunreg[1] = permutation / 24; // 24 == 4!
        permutation -= (permunreg[1] * 24);
        permunreg[2] = permutation / 6; // 6 == 3!
        permutation -= (permunreg[2] * 6);
        permunreg[3] = permutation / 2; // 2 == 2!
        permutation -= (permunreg[3] * 2);
        permunreg[4] = permutation; // 1 == 1!
        permunreg[5] = 0;
        break;
      case 5:
        permunreg[0] = permutation / 120;
        permutation -= (permunreg[0] * 120);
        permunreg[1] = permutation / 24;
        permutation -= (permunreg[1] * 24);
        permunreg[2] = permutation / 6;
        permutation -= (permunreg[2] * 6);
        permunreg[3] = permutation / 2;
        permutation -= (permunreg[3] * 2);
        permunreg[4] = permutation;
        break;
      case 4:
        permunreg[0] = permutation / 60;
        permutation -= (permunreg[0] * 60);
        permunreg[1] = permutation / 12;
        permutation -= (permunreg[1] * 12);
        permunreg[2] = permutation / 3;
        permutation -= (permunreg[2] * 3);
        permunreg[3] = permutation;
        break;
      case 3:
        permunreg[0] = permutation / 20;
        permutation -= (permunreg[0] * 20);
        permunreg[1] = permutation / 4;
        permutation -= (permunreg[1] * 4);
        permunreg[2] = permutation;
        break;
      case 2:
        permunreg[0] = permutation / 5;
        permutation -= (permunreg[0] * 5);
        permunreg[1] = permutation;
        break;
      case 1:
        permunreg[0] = permutation;
        break;
      }

      // Decode the Lehmer code for this permutation of
      // the registers v. http://en.wikipedia.org/wiki/Lehmer_code

      int registers[6];
      bool used[7] = {false, false, false, false, false, false, false};
      for (int i = 0; i < register_count; i++) {
        int renum = 0;
        for (int j = 1; j < 7; j++) {
          if (used[j] == false) {
            if (renum == permunreg[i]) {
              registers[i] = j;
              used[j] = true;
              break;
            }
            renum++;
          }
        }
      }

      if (mode == UNWIND_X86_MODE_STACK_IND) {
        printf(" CFA is esp+%d ", stack_size);
      } else {
        printf(" CFA is esp+%d ", stack_size * 4);
      }

      uint32_t saved_registers_offset = 1;
      printf(" eip=[CFA-%d]", saved_registers_offset * 4);
      saved_registers_offset++;

      for (int i = (sizeof(registers) / sizeof(int)) - 1; i >= 0; i--) {
        switch (registers[i]) {
        case UNWIND_X86_REG_NONE:
          break;
        case UNWIND_X86_REG_EBX:
          printf(" ebx=[CFA-%d]", saved_registers_offset * 4);
          saved_registers_offset++;
          break;
        case UNWIND_X86_REG_ECX:
          printf(" ecx=[CFA-%d]", saved_registers_offset * 4);
          saved_registers_offset++;
          break;
        case UNWIND_X86_REG_EDX:
          printf(" edx=[CFA-%d]", saved_registers_offset * 4);
          saved_registers_offset++;
          break;
        case UNWIND_X86_REG_EDI:
          printf(" edi=[CFA-%d]", saved_registers_offset * 4);
          saved_registers_offset++;
          break;
        case UNWIND_X86_REG_ESI:
          printf(" esi=[CFA-%d]", saved_registers_offset * 4);
          saved_registers_offset++;
          break;
        case UNWIND_X86_REG_EBP:
          printf(" ebp=[CFA-%d]", saved_registers_offset * 4);
          saved_registers_offset++;
          break;
        }
      }
    }

  } break;

  case UNWIND_X86_MODE_DWARF: {
    uint32_t dwarf_offset = encoding & UNWIND_X86_DWARF_SECTION_OFFSET;
    printf(
        "DWARF unwind instructions: FDE at offset %d (file address 0x%" PRIx64
        ")",
        dwarf_offset, dwarf_offset + baton.eh_section_file_address);
  } break;

  case 0: {
    printf(" no unwind information");
  } break;
  }
}

void print_encoding_arm64(struct baton baton, uint8_t *function_start,
                          uint32_t encoding) {
  const int wordsize = 8;
  int mode = encoding & UNWIND_ARM64_MODE_MASK;
  switch (mode) {
  case UNWIND_ARM64_MODE_FRAME: {
    printf("frame func: CFA is fp+%d ", 16);
    printf(" pc=[CFA-8] fp=[CFA-16]");
    int reg_pairs_saved_count = 1;
    uint32_t saved_register_bits = encoding & 0xfff;
    if (saved_register_bits & UNWIND_ARM64_FRAME_X19_X20_PAIR) {
      int cfa_offset = reg_pairs_saved_count * -2 * wordsize;
      cfa_offset -= wordsize;
      printf(" x19=[CFA%d]", cfa_offset);
      cfa_offset -= wordsize;
      printf(" x20=[CFA%d]", cfa_offset);
      reg_pairs_saved_count++;
    }
    if (saved_register_bits & UNWIND_ARM64_FRAME_X21_X22_PAIR) {
      int cfa_offset = reg_pairs_saved_count * -2 * wordsize;
      cfa_offset -= wordsize;
      printf(" x21=[CFA%d]", cfa_offset);
      cfa_offset -= wordsize;
      printf(" x22=[CFA%d]", cfa_offset);
      reg_pairs_saved_count++;
    }
    if (saved_register_bits & UNWIND_ARM64_FRAME_X23_X24_PAIR) {
      int cfa_offset = reg_pairs_saved_count * -2 * wordsize;
      cfa_offset -= wordsize;
      printf(" x23=[CFA%d]", cfa_offset);
      cfa_offset -= wordsize;
      printf(" x24=[CFA%d]", cfa_offset);
      reg_pairs_saved_count++;
    }
    if (saved_register_bits & UNWIND_ARM64_FRAME_X25_X26_PAIR) {
      int cfa_offset = reg_pairs_saved_count * -2 * wordsize;
      cfa_offset -= wordsize;
      printf(" x25=[CFA%d]", cfa_offset);
      cfa_offset -= wordsize;
      printf(" x26=[CFA%d]", cfa_offset);
      reg_pairs_saved_count++;
    }
    if (saved_register_bits & UNWIND_ARM64_FRAME_X27_X28_PAIR) {
      int cfa_offset = reg_pairs_saved_count * -2 * wordsize;
      cfa_offset -= wordsize;
      printf(" x27=[CFA%d]", cfa_offset);
      cfa_offset -= wordsize;
      printf(" x28=[CFA%d]", cfa_offset);
      reg_pairs_saved_count++;
    }
    if (saved_register_bits & UNWIND_ARM64_FRAME_D8_D9_PAIR) {
      int cfa_offset = reg_pairs_saved_count * -2 * wordsize;
      cfa_offset -= wordsize;
      printf(" d8=[CFA%d]", cfa_offset);
      cfa_offset -= wordsize;
      printf(" d9=[CFA%d]", cfa_offset);
      reg_pairs_saved_count++;
    }
    if (saved_register_bits & UNWIND_ARM64_FRAME_D10_D11_PAIR) {
      int cfa_offset = reg_pairs_saved_count * -2 * wordsize;
      cfa_offset -= wordsize;
      printf(" d10=[CFA%d]", cfa_offset);
      cfa_offset -= wordsize;
      printf(" d11=[CFA%d]", cfa_offset);
      reg_pairs_saved_count++;
    }
    if (saved_register_bits & UNWIND_ARM64_FRAME_D12_D13_PAIR) {
      int cfa_offset = reg_pairs_saved_count * -2 * wordsize;
      cfa_offset -= wordsize;
      printf(" d12=[CFA%d]", cfa_offset);
      cfa_offset -= wordsize;
      printf(" d13=[CFA%d]", cfa_offset);
      reg_pairs_saved_count++;
    }
    if (saved_register_bits & UNWIND_ARM64_FRAME_D14_D15_PAIR) {
      int cfa_offset = reg_pairs_saved_count * -2 * wordsize;
      cfa_offset -= wordsize;
      printf(" d14=[CFA%d]", cfa_offset);
      cfa_offset -= wordsize;
      printf(" d15=[CFA%d]", cfa_offset);
      reg_pairs_saved_count++;
    }

  } break;

  case UNWIND_ARM64_MODE_FRAMELESS: {
    uint32_t stack_size = encoding & UNWIND_ARM64_FRAMELESS_STACK_SIZE_MASK;
    printf("frameless function: stack size %d ", stack_size * 16);

  } break;

  case UNWIND_ARM64_MODE_DWARF: {
    uint32_t dwarf_offset = encoding & UNWIND_ARM64_DWARF_SECTION_OFFSET;
    printf(
        "DWARF unwind instructions: FDE at offset %d (file address 0x%" PRIx64
        ")",
        dwarf_offset, dwarf_offset + baton.eh_section_file_address);
  } break;

  case 0: {
    printf(" no unwind information");
  } break;
  }
}

void print_encoding_armv7(struct baton baton, uint8_t *function_start,
                          uint32_t encoding) {
  const int wordsize = 4;
  int mode = encoding & UNWIND_ARM_MODE_MASK;
  switch (mode) {
  case UNWIND_ARM_MODE_FRAME_D:
  case UNWIND_ARM_MODE_FRAME: {
    int stack_adjust =
        EXTRACT_BITS(encoding, UNWIND_ARM_FRAME_STACK_ADJUST_MASK) * wordsize;

    printf("frame func: CFA is fp+%d ", (2 * wordsize) + stack_adjust);
    int cfa_offset = -stack_adjust;

    cfa_offset -= wordsize;
    printf(" pc=[CFA%d]", cfa_offset);
    cfa_offset -= wordsize;
    printf(" fp=[CFA%d]", cfa_offset);

    uint32_t saved_register_bits = encoding & 0xff;
    if (saved_register_bits & UNWIND_ARM_FRAME_FIRST_PUSH_R6) {
      cfa_offset -= wordsize;
      printf(" r6=[CFA%d]", cfa_offset);
    }
    if (saved_register_bits & UNWIND_ARM_FRAME_FIRST_PUSH_R5) {
      cfa_offset -= wordsize;
      printf(" r5=[CFA%d]", cfa_offset);
    }
    if (saved_register_bits & UNWIND_ARM_FRAME_FIRST_PUSH_R4) {
      cfa_offset -= wordsize;
      printf(" r4=[CFA%d]", cfa_offset);
    }
    if (saved_register_bits & UNWIND_ARM_FRAME_SECOND_PUSH_R12) {
      cfa_offset -= wordsize;
      printf(" r12=[CFA%d]", cfa_offset);
    }
    if (saved_register_bits & UNWIND_ARM_FRAME_SECOND_PUSH_R11) {
      cfa_offset -= wordsize;
      printf(" r11=[CFA%d]", cfa_offset);
    }
    if (saved_register_bits & UNWIND_ARM_FRAME_SECOND_PUSH_R10) {
      cfa_offset -= wordsize;
      printf(" r10=[CFA%d]", cfa_offset);
    }
    if (saved_register_bits & UNWIND_ARM_FRAME_SECOND_PUSH_R9) {
      cfa_offset -= wordsize;
      printf(" r9=[CFA%d]", cfa_offset);
    }
    if (saved_register_bits & UNWIND_ARM_FRAME_SECOND_PUSH_R8) {
      cfa_offset -= wordsize;
      printf(" r8=[CFA%d]", cfa_offset);
    }

    if (mode == UNWIND_ARM_MODE_FRAME_D) {
      uint32_t d_reg_bits =
          EXTRACT_BITS(encoding, UNWIND_ARM_FRAME_D_REG_COUNT_MASK);
      switch (d_reg_bits) {
      case 0:
        // vpush {d8}
        cfa_offset -= 8;
        printf(" d8=[CFA%d]", cfa_offset);
        break;
      case 1:
        // vpush {d10}
        // vpush {d8}
        cfa_offset -= 8;
        printf(" d10=[CFA%d]", cfa_offset);
        cfa_offset -= 8;
        printf(" d8=[CFA%d]", cfa_offset);
        break;
      case 2:
        // vpush {d12}
        // vpush {d10}
        // vpush {d8}
        cfa_offset -= 8;
        printf(" d12=[CFA%d]", cfa_offset);
        cfa_offset -= 8;
        printf(" d10=[CFA%d]", cfa_offset);
        cfa_offset -= 8;
        printf(" d8=[CFA%d]", cfa_offset);
        break;
      case 3:
        // vpush {d14}
        // vpush {d12}
        // vpush {d10}
        // vpush {d8}
        cfa_offset -= 8;
        printf(" d14=[CFA%d]", cfa_offset);
        cfa_offset -= 8;
        printf(" d12=[CFA%d]", cfa_offset);
        cfa_offset -= 8;
        printf(" d10=[CFA%d]", cfa_offset);
        cfa_offset -= 8;
        printf(" d8=[CFA%d]", cfa_offset);
        break;
      case 4:
        // vpush {d14}
        // vpush {d12}
        // sp = (sp - 24) & (-16);
        // vst   {d8, d9, d10}
        printf(" d14, d12, d10, d9, d8");
        break;
      case 5:
        // vpush {d14}
        // sp = (sp - 40) & (-16);
        // vst   {d8, d9, d10, d11}
        // vst   {d12}
        printf(" d14, d11, d10, d9, d8, d12");
        break;
      case 6:
        // sp = (sp - 56) & (-16);
        // vst   {d8, d9, d10, d11}
        // vst   {d12, d13, d14}
        printf(" d11, d10, d9, d8, d14, d13, d12");
        break;
      case 7:
        // sp = (sp - 64) & (-16);
        // vst   {d8, d9, d10, d11}
        // vst   {d12, d13, d14, d15}
        printf(" d11, d10, d9, d8, d15, d14, d13, d12");
        break;
      }
    }
  } break;

  case UNWIND_ARM_MODE_DWARF: {
    uint32_t dwarf_offset = encoding & UNWIND_ARM_DWARF_SECTION_OFFSET;
    printf(
        "DWARF unwind instructions: FDE at offset %d (file address 0x%" PRIx64
        ")",
        dwarf_offset, dwarf_offset + baton.eh_section_file_address);
  } break;

  case 0: {
    printf(" no unwind information");
  } break;
  }
}

void print_encoding(struct baton baton, uint8_t *function_start,
                    uint32_t encoding) {

  if (baton.cputype == CPU_TYPE_X86_64) {
    print_encoding_x86_64(baton, function_start, encoding);
  } else if (baton.cputype == CPU_TYPE_I386) {
    print_encoding_i386(baton, function_start, encoding);
  } else if (baton.cputype == CPU_TYPE_ARM64 || baton.cputype == CPU_TYPE_ARM64_32) {
    print_encoding_arm64(baton, function_start, encoding);
  } else if (baton.cputype == CPU_TYPE_ARM) {
    print_encoding_armv7(baton, function_start, encoding);
  } else {
    printf(" -- unsupported encoding arch -- ");
  }
}

void print_function_encoding(struct baton baton, uint32_t idx,
                             uint32_t encoding, uint32_t entry_encoding_index,
                             uint32_t entry_func_offset) {

  char *entry_encoding_index_str = "";
  if (entry_encoding_index != (uint32_t)-1) {
    asprintf(&entry_encoding_index_str, ", encoding #%d", entry_encoding_index);
  } else {
    asprintf(&entry_encoding_index_str, "");
  }

  uint64_t file_address = baton.first_level_index_entry.functionOffset +
                          entry_func_offset + baton.text_segment_vmaddr;

  if (baton.cputype == CPU_TYPE_ARM)
    file_address = file_address & ~1;

  printf(
      "    func [%d] offset %d (file addr 0x%" PRIx64 ")%s, encoding is 0x%x",
      idx, entry_func_offset, file_address, entry_encoding_index_str, encoding);

  struct symbol *symbol = NULL;
  for (int i = 0; i < baton.symbols_count; i++) {
    if (i == baton.symbols_count - 1 &&
        baton.symbols[i].file_address <= file_address) {
      symbol = &(baton.symbols[i]);
      break;
    } else {
      if (baton.symbols[i].file_address <= file_address &&
          baton.symbols[i + 1].file_address > file_address) {
        symbol = &(baton.symbols[i]);
        break;
      }
    }
  }

  printf("\n         ");
  if (symbol) {
    int offset = file_address - symbol->file_address;

    // FIXME this is a poor heuristic - if we're greater than 16 bytes past the
    // start of the function, this is the unwind info for a stripped function.
    // In reality the compact unwind entry may not line up exactly with the
    // function bounds.
    if (offset >= 0) {
      printf("name: %s", symbol->name);
      if (offset > 0) {
        printf(" + %d", offset);
      }
    }
    printf("\n         ");
  }

  print_encoding(baton, baton.mach_header_start +
                            baton.first_level_index_entry.functionOffset +
                            baton.text_section_file_offset + entry_func_offset,
                 encoding);

  bool has_lsda = encoding & UNWIND_HAS_LSDA;

  if (has_lsda) {
    uint32_t func_offset =
        entry_func_offset + baton.first_level_index_entry.functionOffset;

    int lsda_entry_number = -1;

    uint32_t low = 0;
    uint32_t high = (baton.lsda_array_end - baton.lsda_array_start) /
                    sizeof(struct unwind_info_section_header_lsda_index_entry);

    while (low < high) {
      uint32_t mid = (low + high) / 2;

      uint8_t *mid_lsda_entry_addr =
          (baton.lsda_array_start +
           (mid * sizeof(struct unwind_info_section_header_lsda_index_entry)));
      struct unwind_info_section_header_lsda_index_entry mid_lsda_entry;
      memcpy(&mid_lsda_entry, mid_lsda_entry_addr,
             sizeof(struct unwind_info_section_header_lsda_index_entry));
      if (mid_lsda_entry.functionOffset == func_offset) {
        lsda_entry_number =
            (mid_lsda_entry_addr - baton.lsda_array_start) /
            sizeof(struct unwind_info_section_header_lsda_index_entry);
        break;
      } else if (mid_lsda_entry.functionOffset < func_offset) {
        low = mid + 1;
      } else {
        high = mid;
      }
    }

    if (lsda_entry_number != -1) {
      printf(", LSDA entry #%d", lsda_entry_number);
    } else {
      printf(", LSDA entry not found");
    }
  }

  uint32_t pers_idx = EXTRACT_BITS(encoding, UNWIND_PERSONALITY_MASK);
  if (pers_idx != 0) {
    pers_idx--; // Change 1-based to 0-based index
    printf(", personality entry #%d", pers_idx);
  }

  printf("\n");
}

void print_second_level_index_regular(struct baton baton) {
  uint8_t *page_entries =
      baton.compact_unwind_start +
      baton.first_level_index_entry.secondLevelPagesSectionOffset +
      baton.regular_second_level_page_header.entryPageOffset;
  uint32_t entries_count = baton.regular_second_level_page_header.entryCount;

  uint8_t *offset = page_entries;

  uint32_t idx = 0;
  while (idx < entries_count) {
    uint32_t func_offset = *((uint32_t *)(offset));
    uint32_t encoding = *((uint32_t *)(offset + 4));

    // UNWIND_SECOND_LEVEL_REGULAR entries have a funcOffset which includes the
    // functionOffset from the containing index table already.
    // UNWIND_SECOND_LEVEL_COMPRESSED
    // entries only have the offset from the containing index table
    // functionOffset.
    // So strip off the containing index table functionOffset value here so they
    // can
    // be treated the same at the lower layers.

    print_function_encoding(baton, idx, encoding, (uint32_t)-1,
                            func_offset -
                                baton.first_level_index_entry.functionOffset);
    idx++;
    offset += 8;
  }
}

void print_second_level_index_compressed(struct baton baton) {
  uint8_t *this_index =
      baton.compact_unwind_start +
      baton.first_level_index_entry.secondLevelPagesSectionOffset;
  uint8_t *start_of_entries =
      this_index + baton.compressed_second_level_page_header.entryPageOffset;
  uint8_t *offset = start_of_entries;
  for (uint16_t idx = 0;
       idx < baton.compressed_second_level_page_header.entryCount; idx++) {
    uint32_t entry = *((uint32_t *)offset);
    offset += 4;
    uint32_t encoding;

    uint32_t entry_encoding_index =
        UNWIND_INFO_COMPRESSED_ENTRY_ENCODING_INDEX(entry);
    uint32_t entry_func_offset =
        UNWIND_INFO_COMPRESSED_ENTRY_FUNC_OFFSET(entry);

    if (entry_encoding_index < baton.unwind_header.commonEncodingsArrayCount) {
      // encoding is in common table in section header
      encoding =
          *((uint32_t *)(baton.compact_unwind_start +
                         baton.unwind_header.commonEncodingsArraySectionOffset +
                         (entry_encoding_index * sizeof(uint32_t))));
    } else {
      // encoding is in page specific table
      uint32_t page_encoding_index =
          entry_encoding_index - baton.unwind_header.commonEncodingsArrayCount;
      encoding = *((uint32_t *)(this_index +
                                baton.compressed_second_level_page_header
                                    .encodingsPageOffset +
                                (page_encoding_index * sizeof(uint32_t))));
    }

    print_function_encoding(baton, idx, encoding, entry_encoding_index,
                            entry_func_offset);
  }
}

void print_second_level_index(struct baton baton) {
  uint8_t *index_start =
      baton.compact_unwind_start +
      baton.first_level_index_entry.secondLevelPagesSectionOffset;

  if ((*(uint32_t *)index_start) == UNWIND_SECOND_LEVEL_REGULAR) {
    struct unwind_info_regular_second_level_page_header header;
    memcpy(&header, index_start,
           sizeof(struct unwind_info_regular_second_level_page_header));
    printf(
        "  UNWIND_SECOND_LEVEL_REGULAR #%d entryPageOffset %d, entryCount %d\n",
        baton.current_index_table_number, header.entryPageOffset,
        header.entryCount);
    baton.regular_second_level_page_header = header;
    print_second_level_index_regular(baton);
  }

  if ((*(uint32_t *)index_start) == UNWIND_SECOND_LEVEL_COMPRESSED) {
    struct unwind_info_compressed_second_level_page_header header;
    memcpy(&header, index_start,
           sizeof(struct unwind_info_compressed_second_level_page_header));
    printf("  UNWIND_SECOND_LEVEL_COMPRESSED #%d entryPageOffset %d, "
           "entryCount %d, encodingsPageOffset %d, encodingsCount %d\n",
           baton.current_index_table_number, header.entryPageOffset,
           header.entryCount, header.encodingsPageOffset,
           header.encodingsCount);
    baton.compressed_second_level_page_header = header;
    print_second_level_index_compressed(baton);
  }
}

void print_index_sections(struct baton baton) {
  uint8_t *index_section_offset =
      baton.compact_unwind_start + baton.unwind_header.indexSectionOffset;
  uint32_t index_count = baton.unwind_header.indexCount;

  uint32_t cur_idx = 0;

  uint8_t *offset = index_section_offset;
  while (cur_idx < index_count) {
    baton.current_index_table_number = cur_idx;
    struct unwind_info_section_header_index_entry index_entry;
    memcpy(&index_entry, offset,
           sizeof(struct unwind_info_section_header_index_entry));
    printf("index section #%d: functionOffset %d, "
           "secondLevelPagesSectionOffset %d, lsdaIndexArraySectionOffset %d\n",
           cur_idx, index_entry.functionOffset,
           index_entry.secondLevelPagesSectionOffset,
           index_entry.lsdaIndexArraySectionOffset);

    // secondLevelPagesSectionOffset == 0 means this is a sentinel entry
    if (index_entry.secondLevelPagesSectionOffset != 0) {
      struct unwind_info_section_header_index_entry next_index_entry;
      memcpy(&next_index_entry,
             offset + sizeof(struct unwind_info_section_header_index_entry),
             sizeof(struct unwind_info_section_header_index_entry));

      baton.lsda_array_start =
          baton.compact_unwind_start + index_entry.lsdaIndexArraySectionOffset;
      baton.lsda_array_end = baton.compact_unwind_start +
                             next_index_entry.lsdaIndexArraySectionOffset;

      uint8_t *lsda_entry_offset = baton.lsda_array_start;
      uint32_t lsda_count = 0;
      while (lsda_entry_offset < baton.lsda_array_end) {
        struct unwind_info_section_header_lsda_index_entry lsda_entry;
        memcpy(&lsda_entry, lsda_entry_offset,
               sizeof(struct unwind_info_section_header_lsda_index_entry));
        uint64_t function_file_address =
            baton.first_level_index_entry.functionOffset +
            lsda_entry.functionOffset + baton.text_segment_vmaddr;
        uint64_t lsda_file_address =
            lsda_entry.lsdaOffset + baton.text_segment_vmaddr;
        printf("    LSDA [%d] functionOffset %d (%d) (file address 0x%" PRIx64
               "), lsdaOffset %d (file address 0x%" PRIx64 ")\n",
               lsda_count, lsda_entry.functionOffset,
               lsda_entry.functionOffset - index_entry.functionOffset,
               function_file_address, lsda_entry.lsdaOffset, lsda_file_address);
        lsda_count++;
        lsda_entry_offset +=
            sizeof(struct unwind_info_section_header_lsda_index_entry);
      }

      printf("\n");

      baton.first_level_index_entry = index_entry;
      print_second_level_index(baton);
    }

    printf("\n");

    cur_idx++;
    offset += sizeof(struct unwind_info_section_header_index_entry);
  }
}

int main(int argc, char **argv) {
  struct stat st;
  char *file = argv[0];
  if (argc > 1)
    file = argv[1];
  int fd = open(file, O_RDONLY);
  if (fd == -1) {
    printf("Failed to open '%s'\n", file);
    exit(1);
  }
  fstat(fd, &st);
  uint8_t *file_mem =
      (uint8_t *)mmap(0, st.st_size, PROT_READ, MAP_PRIVATE | MAP_FILE, fd, 0);
  if (file_mem == MAP_FAILED) {
    printf("Failed to mmap() '%s'\n", file);
  }

  FILE *f = fopen("a.out", "r");

  struct baton baton;
  baton.mach_header_start = file_mem;
  baton.symbols = NULL;
  baton.symbols_count = 0;
  baton.function_start_addresses = NULL;
  baton.function_start_addresses_count = 0;

  scan_macho_load_commands(&baton);

  if (baton.compact_unwind_start == NULL) {
    printf("could not find __TEXT,__unwind_info section\n");
    exit(1);
  }

  struct unwind_info_section_header header;
  memcpy(&header, baton.compact_unwind_start,
         sizeof(struct unwind_info_section_header));
  printf("Header:\n");
  printf("  version %u\n", header.version);
  printf("  commonEncodingsArraySectionOffset is %d\n",
         header.commonEncodingsArraySectionOffset);
  printf("  commonEncodingsArrayCount is %d\n",
         header.commonEncodingsArrayCount);
  printf("  personalityArraySectionOffset is %d\n",
         header.personalityArraySectionOffset);
  printf("  personalityArrayCount is %d\n", header.personalityArrayCount);
  printf("  indexSectionOffset is %d\n", header.indexSectionOffset);
  printf("  indexCount is %d\n", header.indexCount);

  uint8_t *common_encodings =
      baton.compact_unwind_start + header.commonEncodingsArraySectionOffset;
  uint32_t encoding_idx = 0;
  while (encoding_idx < header.commonEncodingsArrayCount) {
    uint32_t encoding = *((uint32_t *)common_encodings);
    printf("    Common Encoding [%d]: 0x%x ", encoding_idx, encoding);
    print_encoding(baton, NULL, encoding);
    printf("\n");
    common_encodings += sizeof(uint32_t);
    encoding_idx++;
  }

  uint8_t *pers_arr =
      baton.compact_unwind_start + header.personalityArraySectionOffset;
  uint32_t pers_idx = 0;
  while (pers_idx < header.personalityArrayCount) {
    int32_t pers_delta = *((int32_t *)(baton.compact_unwind_start +
                                       header.personalityArraySectionOffset +
                                       (pers_idx * sizeof(uint32_t))));
    printf("    Personality [%d]: personality function ptr @ offset %d (file "
           "address 0x%" PRIx64 ")\n",
           pers_idx, pers_delta, baton.text_segment_vmaddr + pers_delta);
    pers_idx++;
    pers_arr += sizeof(uint32_t);
  }

  printf("\n");

  baton.unwind_header = header;

  print_index_sections(baton);

  return 0;
}
