kit

objdump.c (54501B)

---

 #include <kit/archive.h>
 #include <kit/core.h>
 #include <kit/disasm.h>
 #include <kit/dwarf.h>
 #include <kit/object.h>
 #include <stdio.h>
 #include <string.h>
 
 #include "driver.h"
 
 /* `kit objdump` — print section/symbol info, disassembly, hex contents,
  * and relocations for object files and archives. Archives are auto-detected
  * by magic; each member is dumped in turn. All display logic lives here;
  * the library supplies data-access APIs. */
 
 #define OBJDUMP_TOOL "objdump"
 
 #define MAX_J_FILTERS 16
 
 typedef struct ObjdumpOpts {
   int f;          /* -f: file header           */
   int h;          /* -h: section headers       */
   int t;          /* -t: symbol table          */
   int d;          /* -d: disasm exec sections  */
   int D;          /* -D: disasm all sections   */
   int r;          /* -r: relocations           */
   int s;          /* -s: hex section contents  */
   int p;          /* -p / --private-headers: program/dynamic headers (image) */
   int T;          /* -T / --dynamic-syms: dynamic symbol table */
   int R;          /* -R / --dynamic-reloc: dynamic relocations */
   unsigned dwarf; /* --dwarf: bitmask of OBJDUMP_DWARF_* (0 = off) */
   const char* j[MAX_J_FILTERS];
   int nj;
 } ObjdumpOpts;
 
 /* --dwarf section selectors. */
 #define OBJDUMP_DWARF_INFO 0x1u
 #define OBJDUMP_DWARF_ABBREV 0x2u
 #define OBJDUMP_DWARF_LINE 0x4u
 #define OBJDUMP_DWARF_STR 0x8u
 #define OBJDUMP_DWARF_ALL                                           \
   (OBJDUMP_DWARF_INFO | OBJDUMP_DWARF_ABBREV | OBJDUMP_DWARF_LINE | \
    OBJDUMP_DWARF_STR)
 
 static void objdump_usage(void) {
   driver_errf(OBJDUMP_TOOL, "%.*s",
               KIT_SLICE_ARG(KIT_SLICE_LIT(
                   "usage: kit objdump [-h] [-t] [-d] [-D] [-r] [-s] [-p] "
                   "[-T] [-R] [-j NAME ...] input...\n"
                   "       kit objdump --help    for full option reference")));
 }
 
 void driver_help_objdump(void) {
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "kit objdump — print info about object files and archives\n"
           "\n"
           "USAGE\n"
           "  kit objdump [options] input ...\n"
           "\n"
           "DESCRIPTION\n"
           "  Prints section/symbol info, disassembly, hex contents, and\n"
           "  relocations for object files (ELF / COFF / Mach-O / Wasm) and "
           "`ar`\n"
           "  archives. Archives are auto-detected by magic; each member is\n"
           "  dumped in turn with an `archive(member)` label.\n"
           "\n"
           "  With no operation flags the default is `-h -t` (section headers "
           "+\n"
           "  symbol table), matching GNU objdump's default-ish behaviour.\n"
           "\n"
           "OPERATIONS (any combination)\n"
           "  -f                Print the file header: architecture, format,\n"
           "                    section / symbol counts, HAS_RELOC / HAS_SYMS\n"
           "                    flags, and (for PE images) image base,\n"
           "                    entry point, and subsystem.\n"
           "  -h                Print section headers (idx, name, size, align,\n"
           "                    flags). For COFF inputs the raw\n"
           "                    IMAGE_SCN_* Characteristics value is appended\n"
           "                    on a continuation line and COMDAT groups are\n"
           "                    printed after the section table. NOTE: this is\n"
           "                    the GNU objdump meaning of -h — it does NOT\n"
           "                    print this help; use --help.\n"
           "  -t                Print the symbol table\n"
           "  -d                Disassemble executable sections\n"
           "  -D                Disassemble all sections\n"
           "  -r                Print relocation records\n"
           "  -s                Print section contents as a hex+ASCII dump\n"
           "  -p, --private-headers\n"
           "                    Print the linked-image view: entry point, load\n"
           "                    segments (program headers), and dynamic\n"
           "                    dependencies. For PE images, the optional\n"
           "                    header, data directories, and import lists.\n"
           "  -T, --dynamic-syms\n"
           "                    Print the dynamic symbol table (.dynsym /\n"
           "                    export table). Empty for relocatable objects.\n"
           "  -R, --dynamic-reloc\n"
           "                    Print dynamic relocation records. Empty for\n"
           "                    relocatable objects.\n"
           "  -x                Aggregate: -f -h -r -t\n"
           "  --dwarf[=LIST]    Dump DWARF debug sections. LIST is a comma-\n"
           "                    separated subset of info, abbrev, line, str;\n"
           "                    bare --dwarf dumps all four.\n"
           "\n"
           "FILTERS\n"
           "  -j NAME           Restrict output to the named section. "
           "Repeatable;\n"
           "                    affects -h / -t / -d / -D / -r / -s.\n"
           "\n"
           "SUPPORTED INPUTS\n"
           "  *.o / *.obj       Single object file (ELF / COFF / Mach-O / "
           "Wasm)\n"
           "  *.a               POSIX `ar` archive — every object member is "
           "dumped\n"
           "                    in turn with an `<archive>(<member>)` label\n"
           "\n"
           "GETTING HELP\n"
           "  --help            Show this help and exit (-h is `section "
           "headers`)\n"
           "\n"
           "EXAMPLES\n"
           "  kit objdump -d a.o\n"
           "  kit objdump -h -j .text -j .rodata a.o\n"
           "  kit objdump -t libfoo.a\n"
           "\n"
           "EXIT CODES\n"
           "  0   success           1   parse / I/O error           2   bad "
           "usage\n")));
 }
 
 /* ---- PE/COFF display helpers ----
  *
  * PE executables / DLLs now open through kit_obj_open like every other
  * format, so the image data (optional-header scalars, data directories,
  * imports) arrive through the neutral image API — kit_obj_image_info, the
  * raw-fields iterator (KitObjImageRaw), and the dependency iterator. The
  * helpers below only map PE numeric constants to the symbolic names
  * objdump prints (data-directory index, subsystem). */
 
 /* Data-directory index (IMAGE_DIRECTORY_ENTRY_IMPORT). */
 #define PE_DIR_IMPORT 1u
 
 /* COFF-specific Characteristics bits we surface as tags. Kept in sync
  * with src/obj/coff.h's IMAGE_SCN_* values; objdump only needs the
  * diagnostic-visible subset. */
 #define OBJDUMP_IMAGE_SCN_LNK_INFO 0x00000200u
 #define OBJDUMP_IMAGE_SCN_LNK_REMOVE 0x00000800u
 #define OBJDUMP_IMAGE_SCN_LNK_COMDAT 0x00001000u
 #define OBJDUMP_IMAGE_SCN_GPREL 0x00008000u
 #define OBJDUMP_IMAGE_SCN_MEM_DISCARDABLE 0x02000000u
 #define OBJDUMP_IMAGE_SCN_MEM_SHARED 0x10000000u
 
 static int j_match(const ObjdumpOpts* o, KitSlice name);
 
 
 /* Names match the IMAGE_DIRECTORY_ENTRY_* index. Keep aligned with the
  * order in coff.h to avoid drift. */
 static const char* pe_dir_name(uint32_t i) {
   switch (i) {
     case 0:
       return "EXPORT";
     case 1:
       return "IMPORT";
     case 2:
       return "RESOURCE";
     case 3:
       return "EXCEPTION";
     case 4:
       return "SECURITY";
     case 5:
       return "BASERELOC";
     case 6:
       return "DEBUG";
     case 7:
       return "ARCHITECTURE";
     case 8:
       return "GLOBALPTR";
     case 9:
       return "TLS";
     case 10:
       return "LOAD_CONFIG";
     case 11:
       return "BOUND_IMPORT";
     case 12:
       return "IAT";
     case 13:
       return "DELAY_IMPORT";
     case 14:
       return "COM_DESCRIPTOR";
     case 15:
       return "RESERVED";
     default:
       return "?";
   }
 }
 
 static const char* pe_subsystem_name(uint16_t s) {
   switch (s) {
     case 1:
       return "NATIVE";
     case 2:
       return "WINDOWS_GUI";
     case 3:
       return "WINDOWS_CUI";
     case 5:
       return "OS2_CUI";
     case 7:
       return "POSIX_CUI";
     case 9:
       return "WINDOWS_CE_GUI";
     case 10:
       return "EFI_APPLICATION";
     case 11:
       return "EFI_BOOT_SERVICE_DRIVER";
     case 12:
       return "EFI_RUNTIME_DRIVER";
     case 13:
       return "EFI_ROM";
     case 14:
       return "XBOX";
     case 16:
       return "WINDOWS_BOOT_APPLICATION";
     default:
       return "UNKNOWN";
   }
 }
 
 
 /* Render objdump's "file format" spelling: the obj layer's canonical bare
  * name (elf/coff/macho/wasm) plus the bitwidth suffix this tool presents.
  * wasm carries no suffix; an out-of-range fmt renders "unknown". The bare
  * name is the single source of truth (kit_obj_fmt_name); the suffix is
  * legitimate tool presentation. `buf` must hold at least FMT_STR_CAP bytes. */
 #define FMT_STR_CAP 16
 static const char* fmt_str(KitObjFmt fmt, uint8_t ptr_size, char* buf,
                            size_t cap) {
   const char* base = kit_obj_fmt_name(fmt);
   if (!base) return "unknown";
   if (fmt == KIT_OBJ_WASM) return base; /* wasm has no bitwidth suffix */
   snprintf(buf, cap, "%s%s", base, ptr_size == 8 ? "64" : "32");
   return buf;
 }
 
 static const char* arch_str(KitArchKind arch) {
   switch (arch) {
     case KIT_ARCH_X86_64:
       return "x86_64";
     case KIT_ARCH_X86_32:
       return "i386";
     case KIT_ARCH_ARM_64:
       return "arm64";
     case KIT_ARCH_ARM_32:
       return "arm";
     case KIT_ARCH_RV64:
       return "riscv64";
     case KIT_ARCH_RV32:
       return "riscv32";
     case KIT_ARCH_WASM:
       return "wasm32";
   }
   return "unknown";
 }
 
 /* Collected PE optional-header escape-hatch view, gathered from the neutral
  * raw-fields iterator (KitObjImageRaw): the 16 data directories plus the
  * Subsystem / DllCharacteristics scalars. Returns 0 if the image carries no
  * raw fields (i.e. not a PE image). */
 typedef struct PeRaw {
   uint16_t subsystem;
   uint16_t dllchars;
   uint32_t dir_rva[16];
   uint32_t dir_size[16];
 } PeRaw;
 
 static int pe_collect_raw(KitObjFile* f, PeRaw* out) {
   KitObjImageRawIter* it = NULL;
   KitObjImageRaw r;
   memset(out, 0, sizeof *out);
   if (kit_obj_image_rawiter_new(f, &it) != KIT_OK) return 0;
   while (kit_obj_image_rawiter_next(it, &r) == KIT_ITER_ITEM) {
     if (r.tag < 16) {
       out->dir_rva[r.tag] = (uint32_t)r.value;
       out->dir_size[r.tag] = (uint32_t)r.extra;
     } else if (r.tag == KIT_OBJ_RAW_PE_SUBSYSTEM) {
       out->subsystem = (uint16_t)r.value;
     } else if (r.tag == KIT_OBJ_RAW_PE_DLLCHARS) {
       out->dllchars = (uint16_t)r.value;
     }
   }
   kit_obj_image_rawiter_free(it);
   return 1;
 }
 
 /* PE-image `-p`: the GNU objdump "PE32+ private headers" view — optional
  * header highlights, data directories, and the import tables — rendered
  * entirely from the neutral image API (kit_obj_image_info + the raw-fields
  * iterator + the dependency iterator). */
 static void dump_pe_private(KitObjFile* f, const char* label) {
   PeRaw raw;
   KitObjImageInfo info;
   KitTargetSpec target = kit_obj_target(f);
   KitObjDepIter* dit = NULL;
   KitObjDepInfo dep;
   uint32_t i;
   int have_imports = 0;
   if (!pe_collect_raw(f, &raw)) return;
   if (kit_obj_image_info(f, &info) != KIT_OK) return;
 
   driver_printf("\n%.*s:\tPE32+ private headers\n",
                 KIT_SLICE_ARG(kit_slice_cstr(label)));
   driver_printf("  Magic:               0x20b  (PE32+)\n");
   driver_printf("  Machine:             %.*s\n",
                 KIT_SLICE_ARG(kit_slice_cstr(arch_str(target.arch))));
   driver_printf("  ImageBase:           0x%llx\n",
                 (unsigned long long)info.image_base);
   driver_printf(
       "  AddressOfEntryPoint: 0x%llx\n",
       (unsigned long long)(info.entry > info.image_base
                                ? info.entry - info.image_base
                                : 0));
   driver_printf("  Subsystem:           %u  (%.*s)\n", (unsigned)raw.subsystem,
                 KIT_SLICE_ARG(kit_slice_cstr(pe_subsystem_name(raw.subsystem))));
   driver_printf("  DllCharacteristics:  0x%04x\n", (unsigned)raw.dllchars);
 
   driver_printf("\nData Directories:\n");
   driver_printf("  Idx Name            RVA        Size\n");
   for (i = 0; i < 16; ++i) {
     if (raw.dir_rva[i] == 0 && raw.dir_size[i] == 0) continue;
     driver_printf("  %2u  %-14s  0x%08x 0x%08x\n", i, pe_dir_name(i),
                   raw.dir_rva[i], raw.dir_size[i]);
   }
 
   if (kit_obj_depiter_new(f, &dit) == KIT_OK) {
     while (kit_obj_depiter_next(dit, &dep) == KIT_ITER_ITEM) {
       uint32_t k;
       if (!have_imports) {
         driver_printf("\nThe Import Tables:\n");
         have_imports = 1;
       }
       driver_printf("  DLL Name: %.*s\n", KIT_SLICE_ARG(dep.name));
       for (k = 0; k < dep.nimports; ++k)
         driver_printf("    Name:     %.*s\n", KIT_SLICE_ARG(dep.imports[k]));
     }
     kit_obj_depiter_free(dit);
   }
   driver_printf("\n");
 }
 
 static char sym_bind_char(KitSymBind b) {
   switch (b) {
     case KIT_SB_LOCAL:
       return 'l';
     case KIT_SB_GLOBAL:
       return 'g';
     case KIT_SB_WEAK:
       return 'w';
   }
   return ' ';
 }
 
 static char sym_kind_char(KitSymKind k) {
   switch (k) {
     case KIT_SK_FUNC:
       return 'F';
     case KIT_SK_OBJ:
       return 'O';
     case KIT_SK_SECTION:
       return 'S';
     case KIT_SK_FILE:
       return 'f';
     case KIT_SK_TLS:
       return 'T';
     case KIT_SK_ABS:
       return 'A';
     case KIT_SK_COMMON:
       return 'C';
     case KIT_SK_UNDEF:
       return 'U';
     case KIT_SK_NOTYPE:
       return 'n';
     case KIT_SK_IFUNC:
       return 'i';
   }
   return ' ';
 }
 
 static int j_match(const ObjdumpOpts* o, KitSlice name) {
   int i;
   if (o->nj == 0) return 1;
   for (i = 0; i < o->nj; ++i) {
     if (kit_slice_eq_cstr(name, o->j[i])) return 1;
   }
   return 0;
 }
 
 /* Compose the comma-separated flag tag list GNU objdump prints in -h.
  * For COFF inputs, `coff_chars` is the raw IMAGE_SECTION_HEADER.Characteristics
  * value; for other formats it should be 0. */
 static void render_sec_flags(const KitObjSecInfo* sec, KitObjFmt fmt,
                              uint32_t coff_chars, char* buf, size_t cap) {
   size_t n = 0;
   const char* tags[16];
   int nt = 0;
   int i;
   int is_bss = (sec->kind == KIT_SEC_BSS);
 
   if (!is_bss && sec->size > 0) tags[nt++] = "CONTENTS";
   if (sec->flags & KIT_SF_ALLOC) tags[nt++] = "ALLOC";
   if ((sec->flags & KIT_SF_ALLOC) && !is_bss) tags[nt++] = "LOAD";
   if ((sec->flags & KIT_SF_ALLOC) && !(sec->flags & KIT_SF_WRITE))
     tags[nt++] = "READONLY";
   if (sec->flags & KIT_SF_EXEC) tags[nt++] = "CODE";
   if ((sec->flags & KIT_SF_WRITE) && !(sec->flags & KIT_SF_EXEC) &&
       (sec->flags & KIT_SF_ALLOC))
     tags[nt++] = "DATA";
   if (sec->flags & KIT_SF_TLS) tags[nt++] = "TLS";
   if (sec->flags & KIT_SF_MERGE) tags[nt++] = "MERGE";
   if (sec->flags & KIT_SF_STRINGS) tags[nt++] = "STRINGS";
   if (sec->kind == KIT_SEC_DEBUG) tags[nt++] = "DEBUGGING";
 
   if (fmt == KIT_OBJ_COFF) {
     if (coff_chars & OBJDUMP_IMAGE_SCN_LNK_COMDAT) tags[nt++] = "LINK_ONCE";
     if (coff_chars & OBJDUMP_IMAGE_SCN_LNK_INFO) tags[nt++] = "LINK_INFO";
     if (coff_chars & OBJDUMP_IMAGE_SCN_LNK_REMOVE) tags[nt++] = "LINK_REMOVE";
     if (coff_chars & OBJDUMP_IMAGE_SCN_MEM_DISCARDABLE)
       tags[nt++] = "DISCARDABLE";
     if (coff_chars & OBJDUMP_IMAGE_SCN_MEM_SHARED) tags[nt++] = "SHARED";
     if (coff_chars & OBJDUMP_IMAGE_SCN_GPREL) tags[nt++] = "GPREL";
   }
 
   for (i = 0; i < nt && n + 1 < cap; ++i) {
     const char* t = tags[i];
     if (i > 0 && n + 1 < cap) buf[n++] = ',';
     while (*t && n + 1 < cap) buf[n++] = *t++;
   }
   if (sec->entsize && n + 1 < cap) {
     char tmp[32];
     int k = snprintf(tmp, sizeof tmp, "%.*sentsize=%u",
                      KIT_SLICE_ARG(kit_slice_cstr(n ? "," : "")), sec->entsize);
     size_t j;
     for (j = 0; k > 0 && j < (size_t)k && n + 1 < cap; ++j) buf[n++] = tmp[j];
   }
   buf[n] = '\0';
 }
 
 static void dump_sections(KitObjFile* f, const ObjdumpOpts* opts) {
   uint32_t nsec = kit_obj_nsections(f);
   KitObjFmt fmt = kit_obj_fmt(f);
   uint32_t i;
   char flagbuf[160];
 
   driver_printf("Sections:\n");
   driver_printf("Idx Name                 Size      Align  Flags\n");
   for (i = 0; i < nsec; ++i) {
     KitObjSecInfo sec;
     uint32_t raw_type = 0;
     if (kit_obj_section(f, i, &sec) != KIT_OK) continue;
     if (!j_match(opts, sec.name)) continue;
     kit_obj_section_format_flags(f, i, &raw_type, NULL);
     render_sec_flags(&sec, fmt, raw_type, flagbuf, sizeof(flagbuf));
     driver_printf(
         "%3u %-20s %08llx  2**%-2u  %.*s\n", i,
         sec.name.len ? sec.name.s : "(anon)", (unsigned long long)sec.size,
         sec.align ? (unsigned)__builtin_ctz(sec.align ? sec.align : 1) : 0,
         KIT_SLICE_ARG(kit_slice_cstr(flagbuf)));
     /* Show the raw IMAGE_SCN_* value on a continuation line for COFF
      * inputs — useful when diagnosing why a section ended up with the
      * tags it did. The hex is much shorter than printing every set bit
      * by name, and the tag list above already covers the bits that
      * change behaviour at link time. */
     if (fmt == KIT_OBJ_COFF && raw_type) {
       driver_printf(
           "                                              Characteristics: "
           "0x%08x\n",
           raw_type);
     }
   }
   driver_printf("\n");
 }
 
 /* GNU objdump prints COMDAT group membership immediately after the
  * section header table. The reader exposes groups uniformly across
  * formats (ELF SHT_GROUP and COFF COMDAT both arrive here) so we just
  * iterate.  Output is silent when the object carries no groups. */
 static void dump_groups(KitObjFile* f, const ObjdumpOpts* opts) {
   KitObjGroupIter* it = NULL;
   KitObjGroupInfo g;
   int printed_header = 0;
   (void)opts;
 
   if (kit_obj_groupiter_new(f, &it) != KIT_OK) return;
   while (kit_obj_groupiter_next(it, &g) == KIT_ITER_ITEM) {
     uint32_t k;
     if (!printed_header) {
       driver_printf("COMDAT groups:\n");
       printed_header = 1;
     }
     driver_printf("  group %.*s (signature sym #%u, %u section%.*s)\n",
                   KIT_SLICE_ARG(g.name.len ? g.name : KIT_SLICE_LIT("(anon)")),
                   (unsigned)g.signature, (unsigned)g.nsections,
                   KIT_SLICE_ARG(kit_slice_cstr(g.nsections == 1 ? "" : "s")));
     for (k = 0; k < g.nsections; ++k) {
       KitObjSection sid = g.sections[k];
       KitObjSecInfo si;
       if (sid == KIT_SECTION_NONE) continue;
       if (kit_obj_section(f, sid, &si) != KIT_OK) continue;
       driver_printf(
           "    [%3u] %.*s\n", (unsigned)sid,
           KIT_SLICE_ARG(si.name.len ? si.name : KIT_SLICE_LIT("(anon)")));
     }
   }
   kit_obj_groupiter_free(it);
   if (printed_header) driver_printf("\n");
 }
 
 /* `dynamic` selects the dynamic symbol table (.dynsym / export trie) via
  * kit_obj_dynsymiter_new instead of the static .symtab. Both share the
  * KitObjSymInfo shape and the same _next/_free, so the body is identical. */
 static void dump_symbols(KitObjFile* f, const ObjdumpOpts* opts, int dynamic) {
   KitObjSymIter* it = NULL;
   KitObjSymInfo sym;
   KitStatus st;
 
   driver_printf(dynamic ? "DYNAMIC SYMBOL TABLE:\n" : "SYMBOL TABLE:\n");
   st = dynamic ? kit_obj_dynsymiter_new(f, &it) : kit_obj_symiter_new(f, &it);
   if (st != KIT_OK) return;
   for (;;) {
     KitIterResult r = kit_obj_symiter_next(it, &sym);
     KitSlice secname;
     if (r != KIT_ITER_ITEM) break;
     if (sym.section == KIT_SECTION_NONE) {
       secname = KIT_SLICE_LIT("*UND*");
     } else {
       KitObjSecInfo sec;
       if (kit_obj_section(f, sym.section, &sec) != KIT_OK) continue;
       secname = sec.name.len ? sec.name : KIT_SLICE_LIT("(none)");
       if (opts->nj && !j_match(opts, secname)) continue;
     }
     driver_printf(
         "%016llx %c   %c %-18s %016llx %.*s\n", (unsigned long long)sym.value,
         sym_bind_char(sym.bind), sym_kind_char(sym.kind), secname.s,
         (unsigned long long)sym.size,
         KIT_SLICE_ARG(sym.name.len ? sym.name : KIT_SLICE_LIT("(none)")));
   }
   kit_obj_symiter_free(it);
   driver_printf("\n");
 }
 
 static void dump_hex(KitObjFile* f, const ObjdumpOpts* opts) {
   uint32_t nsec = kit_obj_nsections(f);
   uint32_t i;
 
   for (i = 0; i < nsec; ++i) {
     KitObjSecInfo sec;
     size_t len = 0;
     const uint8_t* data = NULL;
     size_t ofs;
 
     if (kit_obj_section(f, i, &sec) != KIT_OK) continue;
     if (!j_match(opts, sec.name)) continue;
     if (kit_obj_section_data(f, i, &data, &len) != KIT_OK) continue;
     if (!data || len == 0) continue;
 
     driver_printf(
         "Contents of section %.*s:\n",
         KIT_SLICE_ARG(sec.name.len ? sec.name : KIT_SLICE_LIT("(anon)")));
     for (ofs = 0; ofs < len; ofs += 16) {
       size_t j;
       char ascii[17];
       driver_printf(" %04llx ", (unsigned long long)ofs);
       for (j = 0; j < 16; ++j) {
         if (ofs + j < len) {
           driver_printf("%02x", data[ofs + j]);
           ascii[j] = (data[ofs + j] >= 32 && data[ofs + j] < 127)
                          ? (char)data[ofs + j]
                          : '.';
         } else {
           driver_printf("  ");
           ascii[j] = ' ';
         }
         if ((j & 1) == 1) driver_printf(" ");
       }
       ascii[16] = '\0';
       driver_printf(" %.*s\n", KIT_SLICE_ARG(kit_slice_cstr(ascii)));
     }
   }
   driver_printf("\n");
 }
 
 static void dump_relocs(KitObjFile* f, const ObjdumpOpts* opts) {
   KitObjRelocIter* it = NULL;
   KitObjReloc r;
   uint32_t cur_sec = (uint32_t)-1;
   int printed_header = 0;
   int emitted_any = 0;
 
   if (kit_obj_reliter_new(f, &it) != KIT_OK) return;
   for (;;) {
     KitObjSecInfo sec;
     KitIterResult res = kit_obj_reliter_next(it, &r);
     if (res != KIT_ITER_ITEM) break;
     if (kit_obj_section(f, r.section, &sec) != KIT_OK) continue;
     if (!j_match(opts, sec.name)) continue;
 
     if (r.section != cur_sec) {
       if (printed_header) driver_printf("\n");
       driver_printf(
           "RELOCATION RECORDS FOR [%.*s]:\n",
           KIT_SLICE_ARG(sec.name.len ? sec.name : KIT_SLICE_LIT("(anon)")));
       driver_printf("OFFSET           TYPE              VALUE\n");
       cur_sec = r.section;
       printed_header = 1;
     }
 
     if (r.addend) {
       driver_printf(
           "%016llx %-17s %.*s%c0x%llx\n", (unsigned long long)r.offset,
           r.kind_name.len ? r.kind_name.s : "?",
           KIT_SLICE_ARG(r.sym_name.len ? r.sym_name : KIT_SLICE_LIT("*ABS*")),
           r.addend < 0 ? '-' : '+',
           (unsigned long long)(r.addend < 0 ? -r.addend : r.addend));
     } else {
       driver_printf(
           "%016llx %-17s %.*s\n", (unsigned long long)r.offset,
           r.kind_name.len ? r.kind_name.s : "?",
           KIT_SLICE_ARG(r.sym_name.len ? r.sym_name : KIT_SLICE_LIT("*ABS*")));
     }
     emitted_any = 1;
   }
   kit_obj_reliter_free(it);
   if (emitted_any) driver_printf("\n");
 }
 
 /* Find a symbol whose value is exactly `value`. When `section_idx` is a real
  * index the match is scoped to that section; pass OBJDUMP_SEC_ANY to match by
  * address across the whole symbol table — used by the segment-fallback path,
  * where the disassembled bytes have no owning section. */
 #define OBJDUMP_SEC_ANY UINT32_MAX
 
 static KitSlice objdump_sym_at(KitObjFile* f, uint32_t section_idx,
                                uint64_t value) {
   KitObjSymIter* it = NULL;
   KitObjSymInfo sym;
   KitSlice best = KIT_SLICE_NULL;
 
   if (kit_obj_symiter_new(f, &it) != KIT_OK) return KIT_SLICE_NULL;
   for (;;) {
     KitIterResult r = kit_obj_symiter_next(it, &sym);
     if (r != KIT_ITER_ITEM) break;
     if (section_idx != OBJDUMP_SEC_ANY && sym.section != section_idx) continue;
     if (sym.value != value) continue;
     if (!sym.name.len) continue;
     if (sym.kind == KIT_SK_SECTION) continue;
     best = sym.name;
     if (sym.kind == KIT_SK_FUNC || sym.bind != KIT_SB_LOCAL) break;
   }
   kit_obj_symiter_free(it);
   return best;
 }
 
 /* Disassemble `len` bytes at `data`, treating `vaddr` as the address of the
  * first byte. Symbol labels are looked up via `sym_section` (a real section
  * index, or OBJDUMP_SEC_ANY for the segment-fallback path). */
 static void disasm_buffer(const KitDisasmContext* dctx, KitObjFile* f,
                           const uint8_t* data, size_t len, uint64_t vaddr,
                           uint32_t sym_section) {
   KitDisasmIter* dis = NULL;
   KitInsn insn;
 
   if (kit_disasm_iter_new(dctx, data, len, vaddr, f, &dis) != KIT_OK) return;
   for (;;) {
     KitIterResult r = kit_disasm_iter_next(dis, &insn);
     uint32_t b;
     KitSlice label;
     if (r != KIT_ITER_ITEM) break;
     label = objdump_sym_at(f, sym_section, insn.vaddr);
     if (label.len)
       driver_printf("%016llx <%.*s>:\n", (unsigned long long)insn.vaddr,
                     KIT_SLICE_ARG(label));
     driver_printf("%8llx:\t", (unsigned long long)insn.vaddr);
     for (b = 0; b < insn.nbytes; ++b) driver_printf("%02x ", insn.bytes[b]);
     for (b = insn.nbytes; b < 8; ++b) driver_printf("   ");
     driver_printf("\t%.*s", KIT_SLICE_ARG(insn.mnemonic));
     if (insn.operands.len) {
       driver_printf(" %.*s", KIT_SLICE_ARG(insn.operands));
     }
     if (insn.annotation.len) {
       driver_printf(" # %.*s", KIT_SLICE_ARG(insn.annotation));
     }
     driver_printf("\n");
   }
   kit_disasm_iter_free(dis);
 }
 
 /* Fallback for fully section-stripped images (objcopy --strip-sections,
  * packers): the section table is gone, but the code still lives in the
  * executable PT_LOAD segments. We disassemble each such segment's file
  * contents directly, using its vaddr as the base. `image` is the raw file
  * bytes; segment file_off/file_size index into it. Returns the number of
  * segments disassembled. Format-agnostic — driven entirely by the segment
  * iterator, no ELF/Mach-O special-casing. */
 static uint32_t dump_disasm_segments(const KitDisasmContext* dctx,
                                      KitObjFile* f, const ObjdumpOpts* opts,
                                      const KitSlice* image) {
   KitObjSegIter* sit = NULL;
   KitObjSegInfo seg;
   uint32_t emitted = 0;
 
   if (!image || kit_obj_segiter_new(f, &sit) != KIT_OK) return 0;
   while (kit_obj_segiter_next(sit, &seg) == KIT_ITER_ITEM) {
     if (!(seg.perms & KIT_SEG_X)) continue;
     if (!j_match(opts, seg.name)) continue;
     if (seg.file_size == 0) continue;
     if (seg.file_off > image->len || seg.file_size > image->len - seg.file_off)
       continue;
 
     driver_printf(
         "Disassembly of segment %.*s:\n\n",
         KIT_SLICE_ARG(seg.name.len ? seg.name : KIT_SLICE_LIT("LOAD")));
     disasm_buffer(dctx, f, (const uint8_t*)image->data + seg.file_off,
                   (size_t)seg.file_size, seg.vaddr, OBJDUMP_SEC_ANY);
     driver_printf("\n");
     emitted++;
   }
   kit_obj_segiter_free(sit);
   return emitted;
 }
 
 static void dump_disasm(const KitDisasmContext* dctx, KitObjFile* f,
                         const ObjdumpOpts* opts, const KitSlice* image) {
   uint32_t nsec = kit_obj_nsections(f);
   uint32_t i;
   uint32_t emitted = 0;
   KitDisasmContext file_dctx;
   KitTarget* file_target = NULL;
   KitTargetOptions topts;
 
   if (!dctx) return;
   file_dctx = *dctx;
   memset(&topts, 0, sizeof topts);
   topts.spec = kit_obj_target(f);
   if (kit_target_new(&dctx->context, &topts, &file_target) != KIT_OK) return;
   file_dctx.target = file_target;
 
   for (i = 0; i < nsec; ++i) {
     KitObjSecInfo sec;
     size_t len = 0;
     const uint8_t* data = NULL;
     int want;
 
     if (kit_obj_section(f, i, &sec) != KIT_OK) continue;
     want = opts->D ? 1 : ((sec.flags & KIT_SF_EXEC) != 0);
     if (!want) continue;
     if (!j_match(opts, sec.name)) continue;
 
     if (kit_obj_section_data(f, i, &data, &len) != KIT_OK) continue;
     if (!data || len == 0) continue;
 
     driver_printf(
         "Disassembly of section %.*s:\n\n",
         KIT_SLICE_ARG(sec.name.len ? sec.name : KIT_SLICE_LIT("(anon)")));
     /* sec.addr is the load vaddr for a linked image, 0 for a relocatable
      * object — so branch/call targets resolve correctly in both. */
     disasm_buffer(&file_dctx, f, data, len, sec.addr, i);
     driver_printf("\n");
     emitted++;
   }
 
   /* No disassemblable sections, but this is a linked image: the section table
    * was stripped. Fall back to the executable load segments. */
   if (emitted == 0 && kit_obj_kind(f) != KIT_OBJ_KIND_REL)
     dump_disasm_segments(&file_dctx, f, opts, image);
   kit_target_free(file_target);
 }
 
 /* `-f`: GNU objdump-style file header summary. Object files have no
  * meaningful entry point so start address is always 0. For a PE image we
  * also surface the Windows subsystem (via the raw-fields escape hatch). The
  * flags line summarizes whether the input has symbols and relocations so
  * it's clear at a glance whether further -t / -r work is going to be
  * productive. */
 static void dump_file_header(KitObjFile* f, const char* label) {
   KitTargetSpec target = kit_obj_target(f);
   KitObjFmt fmt = kit_obj_fmt(f);
   KitObjSymIter* sit = NULL;
   KitObjRelocIter* rit = NULL;
   uint32_t nsec = kit_obj_nsections(f);
   uint32_t nsym = 0;
   int has_relocs = 0;
   unsigned flags = 0;
   KitObjKind kind = kit_obj_kind(f);
   KitObjImageInfo info;
   int have_info = kit_obj_image_info(f, &info) == KIT_OK;
   const char* sep = "";
 
   if (kit_obj_symiter_new(f, &sit) == KIT_OK) {
     KitObjSymInfo s;
     while (kit_obj_symiter_next(sit, &s) == KIT_ITER_ITEM) nsym++;
     kit_obj_symiter_free(sit);
   }
   if (kit_obj_reliter_new(f, &rit) == KIT_OK) {
     KitObjReloc r;
     if (kit_obj_reliter_next(rit, &r) == KIT_ITER_ITEM) has_relocs = 1;
     kit_obj_reliter_free(rit);
   }
   /* GNU objdump's BFD flag bits: 0x01 HAS_RELOC, 0x02 EXEC_P, 0x10 HAS_SYMS,
    * 0x40 DYNAMIC, 0x100 D_PAGED. */
   if (has_relocs) flags |= 0x0001u;
   if (kind == KIT_OBJ_KIND_EXEC) flags |= 0x0002u;
   if (nsym) flags |= 0x0010u;
   if (kind == KIT_OBJ_KIND_DYN) flags |= 0x0040u;
   if (kind != KIT_OBJ_KIND_REL) flags |= 0x0100u;
 
   driver_printf("architecture: %.*s, flags 0x%08x:\n",
                 KIT_SLICE_ARG(kit_slice_cstr(arch_str(target.arch))), flags);
 #define OBJDUMP_FLAG(bit, name)         \
   do {                                  \
     if (flags & (bit)) {                \
       driver_printf("%s%s", sep, name); \
       sep = ", ";                       \
     }                                   \
   } while (0)
   OBJDUMP_FLAG(0x0001u, "HAS_RELOC");
   OBJDUMP_FLAG(0x0002u, "EXEC_P");
   OBJDUMP_FLAG(0x0010u, "HAS_SYMS");
   OBJDUMP_FLAG(0x0040u, "DYNAMIC");
   OBJDUMP_FLAG(0x0100u, "D_PAGED");
 #undef OBJDUMP_FLAG
   if (flags) driver_printf("\n");
   driver_printf("start address 0x%016llx\n",
                 have_info ? (unsigned long long)info.entry : 0ull);
   {
     char fmt_buf[FMT_STR_CAP];
     driver_printf(
         "format: %.*s, sections: %u, symbols: %u\n\n",
         KIT_SLICE_ARG(kit_slice_cstr(
             fmt_str(fmt, target.ptr_size, fmt_buf, sizeof fmt_buf))),
         nsec, nsym);
   }
   if (fmt == KIT_OBJ_COFF && kind != KIT_OBJ_KIND_REL) {
     PeRaw raw;
     if (pe_collect_raw(f, &raw))
       driver_printf(
           "subsystem: %u (%.*s)\n\n", (unsigned)raw.subsystem,
           KIT_SLICE_ARG(kit_slice_cstr(pe_subsystem_name(raw.subsystem))));
   }
   (void)label;
 }
 
 /* ---- DWARF structural dump (`--dwarf`) ----
  *
  * Pulls the raw .debug_info / .debug_abbrev / .debug_line / .debug_str
  * structure out via the kit_dwarf_*_iter API and formats it. The library
  * hands back numeric DWARF codes; the symbolic-name tables below live here
  * (display logic stays in the driver). Unknown codes fall back to hex. */
 
 static const char* dw_tag_name(uint32_t tag) {
   switch (tag) {
     case 0x01:
       return "DW_TAG_array_type";
     case 0x04:
       return "DW_TAG_enumeration_type";
     case 0x05:
       return "DW_TAG_formal_parameter";
     case 0x0b:
       return "DW_TAG_lexical_block";
     case 0x0d:
       return "DW_TAG_member";
     case 0x0f:
       return "DW_TAG_pointer_type";
     case 0x11:
       return "DW_TAG_compile_unit";
     case 0x13:
       return "DW_TAG_structure_type";
     case 0x15:
       return "DW_TAG_subroutine_type";
     case 0x16:
       return "DW_TAG_typedef";
     case 0x17:
       return "DW_TAG_union_type";
     case 0x18:
       return "DW_TAG_unspecified_parameters";
     case 0x1d:
       return "DW_TAG_inlined_subroutine";
     case 0x21:
       return "DW_TAG_subrange_type";
     case 0x24:
       return "DW_TAG_base_type";
     case 0x26:
       return "DW_TAG_const_type";
     case 0x28:
       return "DW_TAG_enumerator";
     case 0x2e:
       return "DW_TAG_subprogram";
     case 0x34:
       return "DW_TAG_variable";
     case 0x35:
       return "DW_TAG_volatile_type";
     case 0x37:
       return "DW_TAG_restrict_type";
     case 0x3b:
       return "DW_TAG_unspecified_type";
     default:
       return NULL;
   }
 }
 
 static const char* dw_at_name(uint32_t at) {
   switch (at) {
     case 0x01:
       return "DW_AT_sibling";
     case 0x02:
       return "DW_AT_location";
     case 0x03:
       return "DW_AT_name";
     case 0x0b:
       return "DW_AT_byte_size";
     case 0x0d:
       return "DW_AT_bit_size";
     case 0x10:
       return "DW_AT_stmt_list";
     case 0x11:
       return "DW_AT_low_pc";
     case 0x12:
       return "DW_AT_high_pc";
     case 0x13:
       return "DW_AT_language";
     case 0x1b:
       return "DW_AT_comp_dir";
     case 0x1c:
       return "DW_AT_const_value";
     case 0x25:
       return "DW_AT_producer";
     case 0x27:
       return "DW_AT_prototyped";
     case 0x2f:
       return "DW_AT_upper_bound";
     case 0x34:
       return "DW_AT_artificial";
     case 0x37:
       return "DW_AT_count";
     case 0x38:
       return "DW_AT_data_member_location";
     case 0x39:
       return "DW_AT_decl_column";
     case 0x3a:
       return "DW_AT_decl_file";
     case 0x3b:
       return "DW_AT_decl_line";
     case 0x3c:
       return "DW_AT_declaration";
     case 0x3e:
       return "DW_AT_encoding";
     case 0x3f:
       return "DW_AT_external";
     case 0x40:
       return "DW_AT_frame_base";
     case 0x49:
       return "DW_AT_type";
     case 0x6e:
       return "DW_AT_linkage_name";
     case 0x88:
       return "DW_AT_alignment";
     default:
       return NULL;
   }
 }
 
 static const char* dw_form_name(uint32_t form) {
   switch (form) {
     case 0x01:
       return "DW_FORM_addr";
     case 0x05:
       return "DW_FORM_data2";
     case 0x06:
       return "DW_FORM_data4";
     case 0x07:
       return "DW_FORM_data8";
     case 0x08:
       return "DW_FORM_string";
     case 0x09:
       return "DW_FORM_block";
     case 0x0b:
       return "DW_FORM_data1";
     case 0x0c:
       return "DW_FORM_flag";
     case 0x0d:
       return "DW_FORM_sdata";
     case 0x0e:
       return "DW_FORM_strp";
     case 0x0f:
       return "DW_FORM_udata";
     case 0x10:
       return "DW_FORM_ref_addr";
     case 0x11:
       return "DW_FORM_ref1";
     case 0x12:
       return "DW_FORM_ref2";
     case 0x13:
       return "DW_FORM_ref4";
     case 0x14:
       return "DW_FORM_ref8";
     case 0x15:
       return "DW_FORM_ref_udata";
     case 0x17:
       return "DW_FORM_sec_offset";
     case 0x18:
       return "DW_FORM_exprloc";
     case 0x19:
       return "DW_FORM_flag_present";
     case 0x1a:
       return "DW_FORM_strx";
     case 0x1b:
       return "DW_FORM_addrx";
     case 0x1f:
       return "DW_FORM_line_strp";
     case 0x21:
       return "DW_FORM_implicit_const";
     case 0x25:
       return "DW_FORM_strx1";
     default:
       return NULL;
   }
 }
 
 /* Print a symbolic DWARF code or, when unknown, its hex value. */
 static void dw_emit_code(const char* name, uint32_t val) {
   if (name)
     driver_printf("%s", name);
   else
     driver_printf("0x%x", val);
 }
 
 static void dw_emit_attr_value(const KitDwarfAttr* a) {
   switch (a->form_class) {
     case KIT_DWARF_FC_STRING:
       driver_printf("\"%.*s\"", KIT_SLICE_ARG(a->str));
       break;
     case KIT_DWARF_FC_SDATA:
       driver_printf("%lld", (long long)a->s);
       break;
     case KIT_DWARF_FC_FLAG:
       driver_printf("%s", a->u ? "true" : "false");
       break;
     case KIT_DWARF_FC_BLOCK: {
       uint32_t i;
       driver_printf("%u byte block:", a->block_len);
       for (i = 0; i < a->block_len; ++i) driver_printf(" %02x", a->block[i]);
       break;
     }
     case KIT_DWARF_FC_ADDR:
     case KIT_DWARF_FC_REF:
     case KIT_DWARF_FC_UDATA:
     default:
       driver_printf("0x%llx", (unsigned long long)a->u);
       break;
   }
 }
 
 static void dump_dwarf_die_attrs(KitDebugInfo* dbg, uint32_t die_offset,
                                  uint32_t depth) {
   KitDwarfAttrIter* ai = NULL;
   KitDwarfAttr a;
   uint32_t k;
   if (kit_dwarf_attr_iter_new(dbg, die_offset, &ai) != KIT_OK) return;
   while (kit_dwarf_attr_iter_next(ai, &a) == KIT_ITER_ITEM) {
     for (k = 0; k <= depth + 1; ++k) driver_printf("  ");
     dw_emit_code(dw_at_name(a.attr), a.attr);
     driver_printf(" (");
     dw_emit_code(dw_form_name(a.form), a.form);
     driver_printf(") = ");
     dw_emit_attr_value(&a);
     driver_printf("\n");
   }
   kit_dwarf_attr_iter_free(ai);
 }
 
 static void dump_dwarf_info(KitDebugInfo* dbg) {
   KitDwarfCuIter* cui = NULL;
   KitDwarfDieIter* dii = NULL;
   KitDwarfCu cu;
   KitDwarfDie die;
   driver_printf(".debug_info contents:\n");
   if (kit_dwarf_cu_iter_new(dbg, &cui) == KIT_OK) {
     while (kit_dwarf_cu_iter_next(cui, &cu) == KIT_ITER_ITEM) {
       driver_printf(
           "  Compilation Unit @ offset 0x%x: version %u, abbrev_offset 0x%x, "
           "addr_size %u, length 0x%x\n",
           cu.offset, (unsigned)cu.version, cu.abbrev_offset,
           (unsigned)cu.address_size, cu.length);
     }
     kit_dwarf_cu_iter_free(cui);
   }
   if (kit_dwarf_die_iter_new(dbg, &dii) != KIT_OK) return;
   while (kit_dwarf_die_iter_next(dii, &die) == KIT_ITER_ITEM) {
     uint32_t k;
     for (k = 0; k <= die.depth; ++k) driver_printf("  ");
     driver_printf("<0x%x> ", die.offset);
     dw_emit_code(dw_tag_name(die.tag), die.tag);
     driver_printf("\n");
     dump_dwarf_die_attrs(dbg, die.offset, die.depth);
   }
   kit_dwarf_die_iter_free(dii);
   driver_printf("\n");
 }
 
 static void dump_dwarf_abbrev(KitDebugInfo* dbg) {
   KitDwarfAbbrevIter* it = NULL;
   KitDwarfAbbrev ab;
   uint32_t cur_table = 0xffffffffu;
   driver_printf(".debug_abbrev contents:\n");
   if (kit_dwarf_abbrev_iter_new(dbg, &it) != KIT_OK) return;
   while (kit_dwarf_abbrev_iter_next(it, &ab) == KIT_ITER_ITEM) {
     KitDwarfAbbrevAttrIter* ait = NULL;
     KitDwarfAbbrevAttr aa;
     if (ab.table_offset != cur_table) {
       cur_table = ab.table_offset;
       driver_printf("  Abbrev table @ offset 0x%x:\n", cur_table);
     }
     driver_printf("    [%llu] ", (unsigned long long)ab.code);
     dw_emit_code(dw_tag_name(ab.tag), ab.tag);
     driver_printf(" %s\n",
                   ab.has_children ? "[has children]" : "[no children]");
     if (kit_dwarf_abbrev_attr_iter_new(dbg, ab.table_offset, ab.code, &ait) !=
         KIT_OK)
       continue;
     while (kit_dwarf_abbrev_attr_iter_next(ait, &aa) == KIT_ITER_ITEM) {
       driver_printf("        ");
       dw_emit_code(dw_at_name(aa.attr), aa.attr);
       driver_printf("  ");
       dw_emit_code(dw_form_name(aa.form), aa.form);
       driver_printf("\n");
     }
     kit_dwarf_abbrev_attr_iter_free(ait);
   }
   kit_dwarf_abbrev_iter_free(it);
   driver_printf("\n");
 }
 
 static void dump_dwarf_line(KitDebugInfo* dbg) {
   KitDwarfCuIter* cui = NULL;
   KitDwarfCu cu;
   driver_printf(".debug_line contents:\n");
   if (kit_dwarf_cu_iter_new(dbg, &cui) != KIT_OK) return;
   while (kit_dwarf_cu_iter_next(cui, &cu) == KIT_ITER_ITEM) {
     KitDwarfLineIter* li = NULL;
     KitDwarfLineRow row;
     if (kit_dwarf_line_iter_new(dbg, cu.offset, &li) != KIT_OK) continue;
     driver_printf("  CU @ offset 0x%x:\n", cu.offset);
     driver_printf("    %-18s %-6s %-6s %-4s %s\n", "Address", "File", "Line",
                   "Col", "Flags");
     while (kit_dwarf_line_iter_next(li, &row) == KIT_ITER_ITEM) {
       driver_printf("    0x%016llx %-6u %-6u %-4u %s%s\n",
                     (unsigned long long)row.address, row.file_index, row.line,
                     row.column, row.is_stmt ? "stmt " : "",
                     row.end_sequence ? "end_seq" : "");
     }
     kit_dwarf_line_iter_free(li);
   }
   kit_dwarf_cu_iter_free(cui);
   driver_printf("\n");
 }
 
 static void dump_dwarf_str(KitDebugInfo* dbg) {
   KitDwarfStrIter* it = NULL;
   KitDwarfStr s;
   driver_printf(".debug_str contents:\n");
   if (kit_dwarf_str_iter_new(dbg, &it) != KIT_OK) return;
   while (kit_dwarf_str_iter_next(it, &s) == KIT_ITER_ITEM) {
     driver_printf("  0x%x  \"%.*s\"\n", s.offset, KIT_SLICE_ARG(s.str));
   }
   kit_dwarf_str_iter_free(it);
   driver_printf("\n");
 }
 
 static void dump_dwarf(const KitContext* ctx, KitObjFile* f,
                        const ObjdumpOpts* opts) {
   KitDebugInfo* dbg = NULL;
   if (kit_dwarf_open(ctx, f, &dbg) != KIT_OK || !dbg) {
     driver_errf(OBJDUMP_TOOL, "no DWARF debug info found");
     return;
   }
   if (opts->dwarf & OBJDUMP_DWARF_INFO) dump_dwarf_info(dbg);
   if (opts->dwarf & OBJDUMP_DWARF_ABBREV) dump_dwarf_abbrev(dbg);
   if (opts->dwarf & OBJDUMP_DWARF_LINE) dump_dwarf_line(dbg);
   if (opts->dwarf & OBJDUMP_DWARF_STR) dump_dwarf_str(dbg);
   kit_dwarf_free(dbg);
 }
 
 /* Dynamic relocations (-R). Unlike section relocations these aren't grouped
  * by section, so we print one flat table in GNU `objdump -R` style. */
 static void dump_dynrelocs(KitObjFile* f) {
   KitObjRelocIter* it = NULL;
   KitObjReloc r;
   int any = 0;
 
   if (kit_obj_dynreliter_new(f, &it) != KIT_OK) return;
   for (;;) {
     KitIterResult res = kit_obj_reliter_next(it, &r);
     if (res != KIT_ITER_ITEM) break;
     if (!any) {
       driver_printf("DYNAMIC RELOCATION RECORDS\n");
       driver_printf("OFFSET           TYPE              VALUE\n");
       any = 1;
     }
     if (r.addend) {
       driver_printf(
           "%016llx %-17s %.*s%c0x%llx\n", (unsigned long long)r.offset,
           r.kind_name.len ? r.kind_name.s : "?",
           KIT_SLICE_ARG(r.sym_name.len ? r.sym_name : KIT_SLICE_LIT("*ABS*")),
           r.addend < 0 ? '-' : '+',
           (unsigned long long)(r.addend < 0 ? -r.addend : r.addend));
     } else {
       driver_printf(
           "%016llx %-17s %.*s\n", (unsigned long long)r.offset,
           r.kind_name.len ? r.kind_name.s : "?",
           KIT_SLICE_ARG(r.sym_name.len ? r.sym_name : KIT_SLICE_LIT("*ABS*")));
     }
   }
   kit_obj_reliter_free(it);
   driver_printf(any ? "\n" : "DYNAMIC RELOCATION RECORDS (none)\n\n");
 }
 
 static const char* seg_perms_str(uint32_t perms) {
   static char b[4];
   b[0] = (perms & KIT_SEG_R) ? 'r' : '-';
   b[1] = (perms & KIT_SEG_W) ? 'w' : '-';
   b[2] = (perms & KIT_SEG_X) ? 'x' : '-';
   b[3] = '\0';
   return b;
 }
 
 /* align is a power of two; report it as 2**N like GNU objdump. */
 static unsigned u32_log2(uint32_t v) {
   unsigned n = 0;
   while (v > 1) {
     v >>= 1;
     ++n;
   }
   return n;
 }
 
 /* Private/program headers (-p): the linked-image view. PE images get the
  * GNU objdump "PE32+ private headers" rendering (optional header + data
  * directories + import tables); ELF / Mach-O get the entry/segments/dynamic
  * view. Both are driven by the neutral kit_obj image API. Relocatable
  * objects have no image and report so. */
 static void dump_private(KitObjFile* f, const char* label) {
   KitObjImageInfo info;
   KitObjSegIter* sit = NULL;
   KitObjDepIter* dit = NULL;
   KitObjSegInfo seg;
   KitObjDepInfo dep;
   int have_info;
 
   if (kit_obj_fmt(f) == KIT_OBJ_COFF && kit_obj_kind(f) != KIT_OBJ_KIND_REL) {
     dump_pe_private(f, label);
     return;
   }
 
   if (kit_obj_kind(f) == KIT_OBJ_KIND_REL) {
     driver_printf(
         "Private headers:\n"
         "  relocatable object — no program or dynamic headers\n\n");
     return;
   }
 
   have_info = kit_obj_image_info(f, &info) == KIT_OK;
   if (have_info) {
     driver_printf("Image:\n");
     driver_printf("  entry point  0x%016llx\n", (unsigned long long)info.entry);
     driver_printf("  image base   0x%016llx\n",
                   (unsigned long long)info.image_base);
     if (info.interp.len)
       driver_printf("  interpreter  %.*s\n", KIT_SLICE_ARG(info.interp));
     driver_printf("\n");
   }
 
   driver_printf("Program Header:\n");
   if (kit_obj_segiter_new(f, &sit) == KIT_OK) {
     int any = 0;
     while (kit_obj_segiter_next(sit, &seg) == KIT_ITER_ITEM) {
       any = 1;
       driver_printf(
           "  %-12.*s off 0x%016llx vaddr 0x%016llx align 2**%u\n"
           "               filesz 0x%016llx memsz 0x%016llx flags %s\n",
           KIT_SLICE_ARG(seg.name.len ? seg.name : KIT_SLICE_LIT("LOAD")),
           (unsigned long long)seg.file_off, (unsigned long long)seg.vaddr,
           u32_log2(seg.align), (unsigned long long)seg.file_size,
           (unsigned long long)seg.vsize, seg_perms_str(seg.perms));
     }
     kit_obj_segiter_free(sit);
     if (!any) driver_printf("  (none)\n");
   }
   driver_printf("\n");
 
   driver_printf("Dynamic Section:\n");
   if (have_info && info.soname.len)
     driver_printf("  SONAME       %.*s\n", KIT_SLICE_ARG(info.soname));
   if (kit_obj_depiter_new(f, &dit) == KIT_OK) {
     while (kit_obj_depiter_next(dit, &dep) == KIT_ITER_ITEM) {
       uint32_t k;
       driver_printf("  NEEDED       %.*s\n", KIT_SLICE_ARG(dep.name));
       for (k = 0; k < dep.nimports; ++k)
         driver_printf("                 %.*s\n", KIT_SLICE_ARG(dep.imports[k]));
     }
     kit_obj_depiter_free(dit);
   }
   {
     KitObjRpathIter* rit = NULL;
     KitSlice rpath;
     if (kit_obj_rpathiter_new(f, &rit) == KIT_OK) {
       while (kit_obj_rpathiter_next(rit, &rpath) == KIT_ITER_ITEM)
         driver_printf("  RPATH        %.*s\n", KIT_SLICE_ARG(rpath));
       kit_obj_rpathiter_free(rit);
     }
   }
   driver_printf("\n");
 }
 
 static void dump_obj(const KitContext* ctx, const KitDisasmContext* dctx,
                      const char* label, KitObjFile* f, const ObjdumpOpts* opts,
                      const KitSlice* image) {
   KitTargetSpec target = kit_obj_target(f);
   KitObjFmt fmt = kit_obj_fmt(f);
   char fmt_buf[FMT_STR_CAP];
 
   driver_printf(
       "%.*s:\tfile format %.*s-%.*s\n\n",
       KIT_SLICE_ARG(kit_slice_cstr(label)),
       KIT_SLICE_ARG(
           kit_slice_cstr(fmt_str(fmt, target.ptr_size, fmt_buf, sizeof fmt_buf))),
       KIT_SLICE_ARG(kit_slice_cstr(arch_str(target.arch))));
 
   if (opts->f) dump_file_header(f, label);
   if (opts->h) dump_sections(f, opts);
   if (opts->h) dump_groups(f, opts);
   if (opts->t) dump_symbols(f, opts, 0);
   if (opts->T) dump_symbols(f, opts, 1);
   if (opts->p) dump_private(f, label);
   if (opts->s) dump_hex(f, opts);
   if (opts->d || opts->D) dump_disasm(dctx, f, opts, image);
   if (opts->r) dump_relocs(f, opts);
   if (opts->R) dump_dynrelocs(f);
   if (opts->dwarf) dump_dwarf(ctx, f, opts);
 }
 
 static int dump_archive(const char* path, const KitSlice* input,
                         const KitContext* ctx, const KitDisasmContext* dctx,
                         const ObjdumpOpts* opts) {
   KitArIter* it = NULL;
   KitArMember member;
   char label[256];
   int j;
 
   driver_printf("In archive %.*s:\n\n", KIT_SLICE_ARG(kit_slice_cstr(path)));
 
   if (kit_ar_iter_new(ctx, input, &it) != KIT_OK) return 1;
   for (;;) {
     KitIterResult r = kit_ar_iter_next(it, &member);
     KitSlice min;
     KitObjFile* f = NULL;
     if (r != KIT_ITER_ITEM) break;
 
     /* Build "archive.a(member.o)" label. */
     j = 0;
     {
       const char* p = path;
       while (*p && j < 230) label[j++] = *p++;
     }
     label[j++] = '(';
     {
       size_t k = 0;
       while (k < member.name.len && j < 252) label[j++] = member.name.s[k++];
     }
     label[j++] = ')';
     label[j] = '\0';
 
     min.data = member.data;
     min.len = member.size;
 
     if (kit_obj_open(ctx, member.name, &min, &f) != KIT_OK) {
       driver_errf(OBJDUMP_TOOL, "failed to parse member: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(label)));
       continue;
     }
     dump_obj(ctx, dctx, label, f, opts, &min);
     kit_obj_free(f);
   }
   kit_ar_iter_free(it);
 
   return 0;
 }
 
 static int parse_short_flags(const char* arg, ObjdumpOpts* o) {
   const char* p;
   for (p = arg + 1; *p; ++p) {
     switch (*p) {
       case 'f':
         o->f = 1;
         break;
       case 'h':
         o->h = 1;
         break;
       case 't':
         o->t = 1;
         break;
       case 'd':
         o->d = 1;
         break;
       case 'D':
         o->D = 1;
         break;
       case 'r':
         o->r = 1;
         break;
       case 's':
         o->s = 1;
         break;
       case 'p':
         o->p = 1;
         break;
       case 'T':
         o->T = 1;
         break;
       case 'R':
         o->R = 1;
         break;
       case 'x':
         o->f = 1;
         o->h = 1;
         o->r = 1;
         o->t = 1;
         break;
       default:
         driver_errf(OBJDUMP_TOOL, "unknown flag: -%c", *p);
         return -1;
     }
   }
   return 0;
 }
 
 static int parse_long_flag(const char* arg, ObjdumpOpts* o) {
   if (driver_streq(arg, "--file-headers")) {
     o->f = 1;
     return 1;
   }
   if (driver_streq(arg, "--section-headers")) {
     o->h = 1;
     return 1;
   }
   if (driver_streq(arg, "--syms")) {
     o->t = 1;
     return 1;
   }
   if (driver_streq(arg, "--reloc")) {
     o->r = 1;
     return 1;
   }
   if (driver_streq(arg, "--full-contents")) {
     o->s = 1;
     return 1;
   }
   if (driver_streq(arg, "--disassemble")) {
     o->d = 1;
     return 1;
   }
   if (driver_streq(arg, "--all-headers")) {
     o->f = 1;
     o->h = 1;
     o->r = 1;
     o->t = 1;
     return 1;
   }
   if (driver_streq(arg, "--private-headers")) {
     o->p = 1;
     return 1;
   }
   if (driver_streq(arg, "--dynamic-syms")) {
     o->T = 1;
     return 1;
   }
   if (driver_streq(arg, "--dynamic-reloc")) {
     o->R = 1;
     return 1;
   }
   return 0;
 }
 
 /* Match one comma-separated --dwarf section selector against `tok` of
  * length `n`. Returns the OBJDUMP_DWARF_* bit, or 0 if unrecognized. */
 static unsigned dwarf_sel_bit(const char* tok, size_t n) {
   if (n == 4 && memcmp(tok, "info", 4) == 0) return OBJDUMP_DWARF_INFO;
   if (n == 6 && memcmp(tok, "abbrev", 6) == 0) return OBJDUMP_DWARF_ABBREV;
   if (n == 4 && memcmp(tok, "line", 4) == 0) return OBJDUMP_DWARF_LINE;
   if (n == 3 && memcmp(tok, "str", 3) == 0) return OBJDUMP_DWARF_STR;
   return 0;
 }
 
 /* Parse a `--dwarf` / `--dwarf=sec,sec` argument into o->dwarf. Returns 1
  * if `arg` was a dwarf flag (handled), 0 if not, -1 on a bad selector. */
 static int parse_dwarf_flag(const char* arg, ObjdumpOpts* o) {
   const char *list, *p;
   if (driver_streq(arg, "--dwarf")) {
     o->dwarf = OBJDUMP_DWARF_ALL;
     return 1;
   }
   if (strncmp(arg, "--dwarf=", 8) != 0) return 0;
   list = arg + 8;
   for (p = list; *p;) {
     const char* start = p;
     unsigned bit;
     while (*p && *p != ',') ++p;
     bit = dwarf_sel_bit(start, (size_t)(p - start));
     if (!bit) return -1;
     o->dwarf |= bit;
     if (*p == ',') ++p;
   }
   if (!o->dwarf) return -1;
   return 1;
 }
 
 int driver_objdump(int argc, char** argv) {
   DriverEnv env;
   ObjdumpOpts opts = {0};
   int i;
   int rc = 0;
   int saw_input = 0;
   int saw_op = 0;
   KitContext ctx;
   KitDisasmContext dctx;
   KitDisasmContext* dctx_p = NULL;
 
   /* For objdump, -h means "section headers" (GNU objdump convention),
    * so we only honour --help / -help (and bare invocation) as help. */
   if (argc < 2 || driver_argv_wants_help(argc, argv, 0)) {
     driver_help_objdump();
     return 0;
   }
 
   driver_env_init(&env);
   ctx = driver_env_to_context(&env);
 
   /* First pass: parse flags. */
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
     if (a[0] != '-' || a[1] == '\0') continue;
     if (driver_streq(a, "-j")) {
       if (i + 1 >= argc) {
         driver_errf(OBJDUMP_TOOL, "%.*s",
                     KIT_SLICE_ARG(KIT_SLICE_LIT("-j requires a section name")));
         rc = 2;
         goto done;
       }
       if (opts.nj >= MAX_J_FILTERS) {
         driver_errf(OBJDUMP_TOOL, "%.*s",
                     KIT_SLICE_ARG(KIT_SLICE_LIT("too many -j filters")));
         rc = 2;
         goto done;
       }
       opts.j[opts.nj++] = argv[++i];
       continue;
     }
     {
       int dr = parse_dwarf_flag(a, &opts);
       if (dr < 0) {
         driver_errf(OBJDUMP_TOOL, "%.*s",
                     KIT_SLICE_ARG(KIT_SLICE_LIT(
                         "--dwarf sections: info, abbrev, line, str")));
         rc = 2;
         goto done;
       }
       if (dr > 0) continue;
     }
     if (parse_long_flag(a, &opts)) continue;
     if (parse_short_flags(a, &opts) != 0) {
       objdump_usage();
       rc = 2;
       goto done;
     }
   }
 
   saw_op = opts.f || opts.h || opts.t || opts.d || opts.D || opts.r || opts.s ||
            opts.p || opts.T || opts.R || opts.dwarf != 0;
   if (!saw_op) { /* Default = -h -t (matches the prior behavior). */
     opts.h = 1;
     opts.t = 1;
   }
 
   /* Disassembler context: a target + ctx value pair. Disasm consults
    * the per-file object reader for annotation. */
   if (opts.d || opts.D) {
     dctx.target = NULL;
     dctx.context = ctx;
     dctx_p = &dctx;
   }
 
   /* Second pass: process inputs. */
   for (i = 1; i < argc && rc == 0; ++i) {
     const char* a = argv[i];
     KitFileData fd = {0};
     KitSlice input;
     KitBinFmt bin;
 
     if (a[0] == '-' && a[1] != '\0') {
       if (driver_streq(a, "-j")) ++i;
       continue;
     }
     saw_input = 1;
 
     if (ctx.file_io->read_all(ctx.file_io->user, a, &fd) != KIT_OK) {
       driver_errf(OBJDUMP_TOOL, "failed to read: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(a)));
       rc = 1;
       break;
     }
 
     input.data = fd.data;
     input.len = fd.size;
 
     bin = kit_detect_fmt(input.data, input.len);
     switch (bin) {
       case KIT_BIN_AR:
         rc = dump_archive(a, &input, &ctx, dctx_p, &opts);
         break;
       case KIT_BIN_ELF:
       case KIT_BIN_COFF:
       case KIT_BIN_PE:
       case KIT_BIN_MACHO:
       case KIT_BIN_WASM: {
         KitObjFile* f = NULL;
         /* PE executables / DLLs open through kit_obj_open like every other
          * format (read_coff dispatches the DOS 'MZ' magic to the image
          * reader); the whole dump flows through the neutral dump_obj path. */
         if (kit_obj_open(&ctx, kit_slice_cstr(a), &input, &f) != KIT_OK) {
           driver_errf(OBJDUMP_TOOL, "failed to parse: %.*s",
                       KIT_SLICE_ARG(kit_slice_cstr(a)));
           rc = 1;
         } else {
           dump_obj(&ctx, dctx_p, a, f, &opts, &input);
           kit_obj_free(f);
         }
         break;
       }
       case KIT_BIN_UNKNOWN:
       default:
         driver_errf(OBJDUMP_TOOL, "unsupported file format: %.*s",
                     KIT_SLICE_ARG(kit_slice_cstr(a)));
         rc = 1;
         break;
     }
 
     ctx.file_io->release(ctx.file_io->user, &fd);
   }
 
   if (rc == 0 && !saw_input) {
     objdump_usage();
     rc = 2;
   }
 
 done:
   driver_env_fini(&env);
   return rc;
 }