kit

ld.c (116595B)

---

 #include <kit/core.h>
 #include <kit/link.h>
 #include <kit/object.h>
 #include <stdint.h>
 #include <string.h>
 
 #include "driver.h"
 #include "hosted.h"
 #include "lib_resolve.h"
 #include "link_flags.h"
 #include "link_inputs.h"
 #include "runtime.h"
 
 /* `kit ld` — link object/archive inputs into an executable, shared
  * library, or relocatable object. The driver loads each input via
  * env.file_io, optionally parses a `-T` linker script into the structured
  * form, and calls the public link APIs directly so the full link surface
  * (per-archive flags, group cycling, build-id, soname/rpath/exports) is
  * reachable without thickening the convenience KitOptions struct.
  *
  * Supported flags:
  *   -o out                            output path (required, exactly one)
  *   -e symbol                         entry symbol
  *   -T script.ld                      linker script (parsed, not raw)
  *   --support-dir DIR                 kit support root for compiler rt
  *   --sysroot DIR / -syslibroot DIR   hosted C runtime/sysroot root
  *   -L dir                            library search path (-l targets)
  *   -F dir                            framework search path
  *   -l c                              enable hosted CRT/libc expansion
  *   -l name                           resolves via -L (.so preferred unless
  *                                     -Bstatic/-static)
  *   -framework name                   resolves via -F / SDK framework dirs
  *   -static / -pie / -no-pie          target.pic
  *   -shared                           emit a shared library / dylib
  *   -r / --relocatable                emit a relocatable partial-link object
  *   -soname NAME                      DT_SONAME / LC_ID_DYLIB
  *   -rpath DIR                        DT_RPATH/DT_RUNPATH entry (repeatable)
  *   -rpath-link DIR                   shared-lib search at link time
  * (repeatable; accepted, currently advisory)
  *   --enable-new-dtags                rpath entries emit as DT_RUNPATH
  * (default)
  *   --disable-new-dtags               rpath entries emit as DT_RPATH
  *   -E / --export-dynamic             promote all defined globals to the
  * dynamic symbol table
  *   --eh-frame-hdr                    accepted for GNU ld compatibility
  *   --fix-cortex-a53-843419           accepted for GNU ld compatibility
  *   --whole-archive / --no-whole-archive
  *                                     positional state for following .a
  *   --gc-sections / --no-gc-sections  drop unreferenced sections
  *   -Bstatic / -Bdynamic              positional link-mode for following .a
  *   --as-needed / --no-as-needed      positional link-mode for following .a
  *   --start-group / --end-group       cyclic-resolution group of archives
  *   -z OPT / -zOPT                    GNU linker option compatibility
  *   --build-id={none|sha256|uuid|0xHEX}
  *   -m i386pep                        PE/COFF emulation selector (x86_64)
  *   --dynamicbase / --nxcompat        accepted for PE GNU ld compatibility
  */
 
 #define LD_TOOL "ld"
 
 typedef struct LdOptions {
   DriverEnv* env;
   const char* driver_path;
   size_t argv_bound;
 
   KitTargetSpec target;
 
   const char* output_path; /* -o */
   int output_seen;
   const char* script_path; /* -T */
   int no_default_libs; /* -nostdlib / -nodefaultlibs / --no-default-libs */
   int nostdlib;        /* -nostdlib: no CRT startup or default libraries */
   int nostartfiles;    /* -nostartfiles: caller supplies CRT startup */
   int pic_explicit;        /* -static / -pie / -no-pie / -shared seen */
   int target_explicit;     /* -target / --target seen */
   const char* support_dir; /* --support-dir */
   const char* sysroot;     /* --sysroot / KIT_SYSROOT */
   int pie; /* -pie was requested */
 
   /* Shared linker-flag model: entry, pe_subsystem, interp/soname/rpath, the
    * -Wl, comma flags (defsym/section-start/build-id/map/symbols/cref/...), and
    * the owned FLAG-string pool that backs them. Populated via the
    * driver_link_flags_record_* family and consumed by
    * driver_link_flags_fill_options. */
   DriverLinkFlags lf;
 
   /* Shared link-input model: object/archive/dso arrays, the ordered link-item
    * list, the -L/-F search paths, and the positional archive flag state
    * (cur_whole_archive/cur_link_mode/cur_group_id). ld resolves -l/-framework
    * eagerly into archives/dsos rather than via the pending-lib model, to
    * preserve GNU GROUP / positional link ordering. */
   DriverLinkInputSet inputs;
 
   int lib_dirs_precollected; /* first pass collected argv -L / --library-path */
   char** owned_paths; /* INPUT-path strings: sysroot-rewritten -L/-F dirs and
                        * hosted libdir strings (the FLAG strings live in lf). */
   size_t* owned_path_sizes;
   uint32_t nowned_paths;
   size_t cap_owned_paths; /* grows independently of argv_bound */
 
   /* Shared-library output state. */
   int shared;          /* -shared */
   int relocatable;     /* -r / --relocatable */
   const char** rpath_links; /* -rpath-link DIR (advisory) */
   uint32_t nrpath_links;
   int export_dynamic;    /* -E / --export-dynamic */
   int static_link;       /* -static: hosted libc should pick static profile */
   int wants_hosted_libc; /* libc request: expand crt + libc via hosted resolver */
   int windows_ucrt_target; /* *-windows-gnullvm: MinGW UCRT hosted profile */
   int explicit_crt_start; /* caller supplied crt1/Scrt1/rcrt1-style start */
   int has_compiler_runtime; /* caller supplied compiler builtins/runtime */
   DriverHostedPlan hosted;
   /* Sink for the hosted profile's system includes/defines required by the
    * shared driver_link_inputs_apply_hosted contract. ld never compiles, so
    * these are populated but unused (only the plan's lib dirs + crt inputs +
    * interp matter to the linker). */
   DriverCflags cf;
 
   uint8_t next_group_id; /* increments on --start-group / GROUP() */
 
   /* Opt-in: treat `/...` arguments as MSVC link.exe flags. Off by
    * default so legacy paths like `/usr/lib/foo.o` remain inputs. */
   int ms_link_driver;
 } LdOptions;
 
 static void ld_usage(void) {
   driver_errf(LD_TOOL, "%.*s",
               KIT_SLICE_ARG(KIT_SLICE_LIT(
                   "usage: kit ld -o out [options...] inputs.o|inputs.a...\n"
                   "       kit ld --help    for full option reference")));
 }
 
 void driver_help_ld(void) {
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "kit ld — link objects and archives into native-format outputs\n"
           "\n"
           "USAGE\n"
           "  kit ld -o OUT [options] inputs.o ... inputs.a ...\n"
           "  kit ld -shared -o libfoo.so [options] inputs.o ...\n"
           "  kit ld -r -o partial.o inputs.o ...\n"
           "\n"
           "DESCRIPTION\n"
           "  Loads each input directly, optionally parses a -T linker script,\n"
           "  and emits an executable (default), partial-link object (-r), or\n"
           "  ELF shared library (-shared). The full link surface is exposed:\n"
           "  per-archive flags,\n"
           "  cyclic-resolution groups, build-id, soname/rpath/exports.\n"
           "\n"
           "INPUTS AND FORMATS\n"
           "  Relocatable ELF, Mach-O, and COFF objects and POSIX ar archives\n"
           "  are accepted. An explicit -target is authoritative; otherwise\n"
           "  the first target-bearing input selects the output target. The\n"
           "  public link boundary validates raw objects, builders, every\n"
           "  archive member, and dynamic/import inputs before creating output.\n"
           "  ELF supports executable, shared, and partial-link output. Mach-O\n"
           "  and PE/COFF support executable and partial-link shapes; -shared\n"
           "  is ELF-only.\n"
           "\n"
           "OUTPUT\n"
           "  -o PATH                   Output path (required, exactly one)\n"
           "  -shared                   Emit a position-independent ELF shared\n"
           "                            library instead of an executable\n"
           "  -r, --relocatable         Emit a relocatable partial-link object\n"
           "\n"
           "ENTRY / SCRIPT\n"
           "  -e SYMBOL                 Entry symbol\n"
           "  --subsystem NAME          PE subsystem: console or windows\n"
           "  -T SCRIPT.ld              Use a linker script (parsed, not raw)\n"
           "\n"
           "TARGET\n"
           "  -static                   Non-PIC, non-PIE\n"
           "  -pie                      Position-independent executable\n"
           "  -no-pie                   Disable PIE\n"
           "  -target TRIPLE            Authoritative output target\n"
           "  --support-dir DIR         kit support root for compiler "
           "runtime\n"
           "  --sysroot DIR             hosted C runtime/sysroot root\n"
           "  (target is otherwise auto-detected from the first object input)\n"
           "  Support is resolved from the canonical executable path; a\n"
           "  relocated release discovers its sibling support automatically.\n"
           "  --support-dir remains an authoritative override. -l c engages\n"
           "  hosted resolution; native macOS discovers its SDK automatically.\n"
           "  Other cross-hosted links need --sysroot unless the caller supplies\n"
           "  its own startup objects and system libraries.\n"
           "\n"
           "LIBRARY RESOLUTION\n"
           "  -L DIR                    Add library search path\n"
           "  -l c                      Add hosted CRT objects and libc\n"
           "  -l NAME                   Resolve via -L (.so preferred unless "
           "static)\n"
           "\n"
           "POSITIONAL ARCHIVE STATE (apply to following .a inputs)\n"
           "  --whole-archive           Pull every member of following "
           "archives\n"
           "  --no-whole-archive        Reset (default behaviour)\n"
           "  -Bstatic                  Force static link mode\n"
           "  -Bdynamic                 Force dynamic link mode\n"
           "  --as-needed               Link only if a real reference exists\n"
           "  --no-as-needed            Reset to dynamic\n"
           "  --start-group ...\n"
           "    --end-group             Cyclic-resolution archive group\n"
           "  Outside a group, archives are searched left to right: place an\n"
           "  object that references a symbol before the archive defining it.\n")));
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "\n"
           "SHARED-LIBRARY OPTIONS (require -shared)\n"
           "  -soname NAME              DT_SONAME / LC_ID_DYLIB\n"
           "  -soname=NAME              equivalent attached form\n"
           "  -rpath DIR                DT_RPATH/DT_RUNPATH entry (repeatable)\n"
           "  -rpath=DIR                attached form\n"
           "  -rpath-link DIR           Link-time-only search path (advisory)\n"
           "  --enable-new-dtags        rpaths land in DT_RUNPATH (default)\n"
           "  --disable-new-dtags       rpaths land in DT_RPATH\n"
           "\n"
           "SECTION GC\n"
           "  --gc-sections             Drop sections unreferenced from the "
           "entry\n"
           "                            symbol, init/fini arrays, "
           "SHF_GNU_RETAIN,\n"
           "                            and __start_/__stop_ section "
           "references\n"
           "  --no-gc-sections          Disable section GC (default)\n"
           "  -E, --export-dynamic      Promote defined globals into dynsym\n"
           "                            (no-op for -shared; recorded for exe)\n"
           "  --eh-frame-hdr            Accepted for GNU ld compatibility\n"
           "  -S, --strip-debug         Omit debug info from linked output\n"
           "  --no-undefined            Reject unresolved symbols\n"
           "  --allow-undefined         Permit unresolved strong symbols\n"
           "  -z defs                   Same as --no-undefined\n"
           "  --map FILE, -Map FILE     Write a deterministic link map\n"
           "  --symbols FILE            Write post-link absolute symbols\n"
           "  --symbols-format=nm       Symbol output format (default)\n"
           "\n"
           "BUILD ID\n"
           "  --build-id                Same as --build-id=sha256\n"
           "  --build-id=MODE           none | sha256 | uuid | 0xHEX\n"
           "\n"
           "EXAMPLES\n"
           "  # Hosted link with a user-supplied sysroot.\n"
           "  SYSROOT=/replace/with/hosted-sysroot\n"
           "  kit ld --sysroot \"$SYSROOT\" -l c -o hello hello.o\n"
           "  # Archive order: main.o references symbols in libfoo.a.\n"
           "  kit ld -o app main.o libfoo.a\n"
           "  kit ld -r -o combined.o a.o b.o\n"
           "  kit ld -shared -soname libfoo.so.1 -o libfoo.so foo.pic.o\n"
           "  # Freestanding final link; link.ld must define the memory map.\n"
           "  kit ld -T link.ld \\\n"
           "    -e _start -o kernel.elf start.o\n"
           "\n"
           "GETTING HELP\n"
           "  -h, --help                Show this help and exit\n"
           "\n"
           "EXIT CODES\n"
           "  0   success           1   link error           2   bad usage\n")));
 }
 
 /* ---------- argv-sized scratch arrays ---------- */
 
 static int ld_alloc_arrays(LdOptions* o, int argc) {
   size_t bound = (size_t)argc + 32u;
   o->argv_bound = bound;
   o->owned_paths = driver_alloc_zeroed(o->env, bound * sizeof(*o->owned_paths));
   o->owned_path_sizes =
       driver_alloc_zeroed(o->env, bound * sizeof(*o->owned_path_sizes));
   o->cap_owned_paths = bound;
   o->rpath_links = driver_alloc_zeroed(o->env, bound * sizeof(*o->rpath_links));
   if (!o->owned_paths || !o->owned_path_sizes || !o->rpath_links) {
     driver_errf(LD_TOOL, "out of memory");
     return 1;
   }
   if (driver_link_flags_init(&o->lf, o->env, LD_TOOL, (uint32_t)bound) != 0)
     return 1;
   if (driver_link_inputs_init(&o->inputs, o->env, LD_TOOL, bound) != 0)
     return 1;
   /* Sized for the hosted profile's includes/defines only (ld parses no -D/-I);
    * see the cf comment in LdOptions. */
   if (driver_cflags_init(&o->cf, o->env,
                          (int)(DRIVER_HOSTED_MAX_DEFINES +
                                DRIVER_HOSTED_MAX_INCLUDES)) != 0) {
     driver_errf(LD_TOOL, "out of memory");
     return 1;
   }
   return 0;
 }
 
 /* ---------- positional archive bookkeeping ---------- */
 
 static int ld_str_prefix(const char* s, const char* prefix) {
   size_t n = driver_strlen(prefix);
   return driver_strneq(s, prefix, n);
 }
 
 static const char* ld_basename(const char* path) {
   const char* slash = strrchr(path, '/');
   return slash ? slash + 1 : path;
 }
 
 static int ld_is_compiler_runtime_archive(const char* path) {
   const char* base = ld_basename(path);
   if ((ld_str_prefix(base, "libcompiler_builtins") &&
        (driver_has_suffix(base, ".rlib") || driver_has_suffix(base, ".a"))) ||
       (ld_str_prefix(base, "libclang_rt.builtins") &&
        driver_has_suffix(base, ".a")) ||
       driver_streq(base, "libgcc.a") || driver_streq(base, "libgcc_eh.a")) {
     return 1;
   }
   return 0;
 }
 
 static int ld_is_compiler_runtime_libname(const char* name) {
   return driver_streq(name, "gcc") || driver_streq(name, "gcc_eh") ||
          driver_streq(name, "compiler_builtins") ||
          ld_str_prefix(name, "clang_rt.builtins");
 }
 
 static int ld_is_crt_start_object(const char* path) {
   const char* base = ld_basename(path);
   return driver_streq(base, "crt1.o") || driver_streq(base, "Scrt1.o") ||
          driver_streq(base, "rcrt1.o") || driver_streq(base, "gcrt1.o") ||
          driver_streq(base, "crt0.o");
 }
 
 static void ld_note_object_path(LdOptions* o, const char* path) {
   if (ld_is_crt_start_object(path)) o->explicit_crt_start = 1;
 }
 
 /* Fill the next free archive slot in the shared input set (without ordering)
  * and return its index, noting compiler-runtime archives along the way. */
 static uint32_t ld_add_archive_slot(LdOptions* o, const char* path, int owned,
                                     size_t owned_size, uint8_t whole_archive,
                                     uint8_t link_mode, uint8_t group_id) {
   DriverArchiveInput* a = &o->inputs.archives[o->inputs.narchives++];
   if (ld_is_compiler_runtime_archive(path)) o->has_compiler_runtime = 1;
   a->path = path;
   a->owned = owned;
   a->owned_size = owned_size;
   a->whole_archive = whole_archive;
   a->link_mode = link_mode;
   a->group_id = group_id;
   return o->inputs.narchives - 1u;
 }
 
 static uint32_t ld_add_dso_slot(LdOptions* o, const char* path, int owned,
                                 size_t owned_size) {
   DriverDsoInput* d = &o->inputs.dsos[o->inputs.ndsos++];
   d->path = path;
   d->owned = owned;
   d->owned_size = owned_size;
   return o->inputs.ndsos - 1u;
 }
 
 static uint32_t ld_add_object_slot(LdOptions* o, const char* path) {
   ld_note_object_path(o, path);
   o->inputs.object_files[o->inputs.nobject_files++] = path;
   return o->inputs.nobject_files - 1u;
 }
 
 static void ld_push_object(LdOptions* o, const char* path) {
   uint32_t idx = ld_add_object_slot(o, path);
   driver_link_inputs_push(&o->inputs, DRIVER_LINK_OBJECT, idx);
 }
 
 static void ld_push_archive(LdOptions* o, const char* path, int owned,
                             size_t owned_size) {
   uint32_t idx = ld_add_archive_slot(
       o, path, owned, owned_size, o->inputs.cur_whole_archive,
       o->inputs.cur_link_mode, o->inputs.cur_group_id);
   driver_link_inputs_push(&o->inputs, DRIVER_LINK_ARCHIVE, idx);
 }
 
 static void ld_push_dso(LdOptions* o, const char* path, int owned,
                         size_t owned_size) {
   uint32_t idx = ld_add_dso_slot(o, path, owned, owned_size);
   driver_link_inputs_push(&o->inputs, DRIVER_LINK_DSO, idx);
 }
 
 static int ld_order_capacity(LdOptions* o, uint32_t nmore) {
   if (o->inputs.nlink_items + nmore <= o->argv_bound) return 0;
   driver_errf(LD_TOOL, "too many linker inputs");
   return 1;
 }
 
 static int ld_archive_capacity(LdOptions* o) {
   if (o->inputs.narchives < o->argv_bound) return 0;
   driver_errf(LD_TOOL, "too many archive inputs");
   return 1;
 }
 
 static int ld_dso_capacity(LdOptions* o) {
   if (o->inputs.ndsos < o->argv_bound) return 0;
   driver_errf(LD_TOOL, "too many shared-object inputs");
   return 1;
 }
 
 static int ld_object_capacity(LdOptions* o) {
   if (o->inputs.nobject_files < o->argv_bound) return 0;
   driver_errf(LD_TOOL, "too many object inputs");
   return 1;
 }
 
 /* Filename ends in `.so` (with no further extension) or in `.so.N`
  * for some run of digits and dots. */
 static int driver_is_so_filename(const char* path) {
   size_t n = driver_strlen(path);
   size_t i;
   /* Walk from the end: trim trailing ".N" / ".N.N" sequences if any,
    * then check that we land on ".so". */
   i = n;
   while (i > 0) {
     /* Strip a trailing ".<digits>" cluster (e.g. ".1", ".26"). */
     size_t end = i;
     size_t j = i;
     while (j > 0) {
       char c = path[j - 1];
       if (c >= '0' && c <= '9') {
         --j;
         continue;
       }
       break;
     }
     if (j < end && j > 0 && path[j - 1] == '.') {
       i = j - 1;
       continue;
     }
     break;
   }
   if (i >= 3 && path[i - 3] == '.' && path[i - 2] == 's' && path[i - 1] == 'o')
     return 1;
   return 0;
 }
 
 static char* ld_join2(DriverEnv* env, const char* a, const char* b,
                       size_t* out_size) {
   size_t alen = driver_strlen(a);
   size_t blen = driver_strlen(b);
   size_t slash = (alen > 0 && a[alen - 1] != '/') ? 1u : 0u;
   size_t bytes = alen + slash + blen + 1u;
   char* out = driver_alloc(env, bytes);
   size_t off = 0;
   if (!out) return NULL;
   if (alen) {
     driver_memcpy(out + off, a, alen);
     off += alen;
   }
   if (slash) out[off++] = '/';
   if (blen) {
     driver_memcpy(out + off, b, blen);
     off += blen;
   }
   out[off] = '\0';
   if (out_size) *out_size = bytes;
   return out;
 }
 
 /* Ensure room for one more owned string. The owned-string pool is NOT bounded
  * by argc: a single -Wl token (--section-start / --defsym) mints two or three
  * owned cstrings, so a fixed argv+N cap would reject valid input. Double the
  * two parallel arrays together when full. */
 static int ld_grow_owned(LdOptions* o) {
   size_t nc;
   char** np;
   size_t* ns;
   if (o->nowned_paths < o->cap_owned_paths) return 0;
   nc = o->cap_owned_paths ? o->cap_owned_paths * 2u : 8u;
   if (nc <= o->cap_owned_paths) {
     driver_errf(LD_TOOL, "out of memory");
     return 1;
   }
   np = driver_alloc_zeroed(o->env, nc * sizeof(*np));
   ns = driver_alloc_zeroed(o->env, nc * sizeof(*ns));
   if (!np || !ns) {
     if (np) driver_free(o->env, np, nc * sizeof(*np));
     if (ns) driver_free(o->env, ns, nc * sizeof(*ns));
     driver_errf(LD_TOOL, "out of memory");
     return 1;
   }
   if (o->owned_paths) {
     driver_memcpy(np, o->owned_paths, o->nowned_paths * sizeof(*np));
     driver_free(o->env, o->owned_paths, o->cap_owned_paths * sizeof(*np));
   }
   if (o->owned_path_sizes) {
     driver_memcpy(ns, o->owned_path_sizes, o->nowned_paths * sizeof(*ns));
     driver_free(o->env, o->owned_path_sizes, o->cap_owned_paths * sizeof(*ns));
   }
   o->owned_paths = np;
   o->owned_path_sizes = ns;
   o->cap_owned_paths = nc;
   return 0;
 }
 
 static int ld_own_path(LdOptions* o, char* path, size_t size,
                        const char** out) {
   if (!path) {
     driver_errf(LD_TOOL, "out of memory");
     return 1;
   }
   if (ld_grow_owned(o) != 0) {
     driver_free(o->env, path, size);
     return 1;
   }
   o->owned_paths[o->nowned_paths] = path;
   o->owned_path_sizes[o->nowned_paths] = size;
   o->nowned_paths++;
   if (out) *out = path;
   return 0;
 }
 
 static int ld_add_lib_dir(LdOptions* o, const char* dir) {
   if (o->inputs.nlib_search_paths >= o->argv_bound) {
     driver_errf(LD_TOOL, "too many library search paths");
     return 1;
   }
   o->inputs.lib_search_paths[o->inputs.nlib_search_paths++] = dir;
   return 0;
 }
 
 static int ld_add_framework_dir(LdOptions* o, const char* dir) {
   if (o->inputs.nframework_search_paths >= o->argv_bound) {
     driver_errf(LD_TOOL, "too many framework search paths");
     return 1;
   }
   o->inputs.framework_search_paths[o->inputs.nframework_search_paths++] = dir;
   return 0;
 }
 
 static int ld_add_sysroot_libdir(LdOptions* o) {
   char* path;
   size_t size;
   const char* owned;
   if (!o->sysroot || !o->sysroot[0]) return 0;
   path = ld_join2(o->env, o->sysroot, "lib", &size);
   if (ld_own_path(o, path, size, &owned) != 0) return 1;
   if (ld_add_lib_dir(o, owned) != 0) return 1;
   path = ld_join2(o->env, o->sysroot, "usr/lib", &size);
   if (ld_own_path(o, path, size, &owned) != 0) return 1;
   if (ld_add_lib_dir(o, owned) != 0) return 1;
   if (o->target.os == KIT_OS_WINDOWS) {
     path = ld_join2(o->env, o->sysroot, "lib/windows", &size);
     if (ld_own_path(o, path, size, &owned) != 0) return 1;
     if (ld_add_lib_dir(o, owned) != 0) return 1;
   }
   return 0;
 }
 
 static int ld_add_sysroot_framework_dirs(LdOptions* o) {
   char* path;
   size_t size;
   const char* owned;
   if (!driver_target_uses_framework_dirs(o->target)) return 0;
   if (!o->sysroot || !o->sysroot[0]) return 0;
   path = ld_join2(o->env, o->sysroot, "System/Library/Frameworks", &size);
   if (ld_own_path(o, path, size, &owned) != 0) return 1;
   if (ld_add_framework_dir(o, owned) != 0) return 1;
   path =
       ld_join2(o->env, o->sysroot, "System/Library/PrivateFrameworks", &size);
   if (ld_own_path(o, path, size, &owned) != 0) return 1;
   if (ld_add_framework_dir(o, owned) != 0) return 1;
   return 0;
 }
 
 static int ld_sysroot_rewrite_path(LdOptions* o, const char* path,
                                    const char** out) {
   const char* tail;
   char* joined;
   size_t size;
   if (!path || path[0] != '=' || !o->sysroot || !o->sysroot[0]) {
     *out = path;
     return 0;
   }
   tail = path + 1;
   if (tail[0] == '/') tail++;
   joined = ld_join2(o->env, o->sysroot, tail, &size);
   return ld_own_path(o, joined, size, out);
 }
 
 static int ld_note_library_request(LdOptions* o, const char* name) {
   if (ld_is_compiler_runtime_libname(name)) o->has_compiler_runtime = 1;
   if (driver_streq(name, "c") && !o->nostdlib && !o->nostartfiles &&
       !o->explicit_crt_start) {
     o->wants_hosted_libc = 1;
     return 1;
   }
   if (o->windows_ucrt_target &&
       (driver_streq(name, "msvcrt") || driver_streq(name, "ucrt")) &&
       !o->nostdlib && !o->nostartfiles && !o->explicit_crt_start) {
     o->wants_hosted_libc = 1;
     return 1;
   }
   return 0;
 }
 
 static const char* ld_windows_runtime_alias(LdOptions* o, const char* name) {
   if (o->target.os != KIT_OS_WINDOWS) return NULL;
   if (driver_streq(name, "gcc_eh")) return "unwind";
   if (!driver_streq(name, "gcc")) return NULL;
   switch (o->target.arch) {
     case KIT_ARCH_X86_64:
       return "clang_rt.builtins-x86_64";
     case KIT_ARCH_ARM_64:
       return "clang_rt.builtins-aarch64";
     default:
       return NULL;
   }
 }
 
 static LibResolveKind ld_kind_for_exact_lib(const char* leaf) {
   if (driver_has_suffix(leaf, ".tbd")) return LIB_RESOLVE_KIND_TBD;
   if (driver_has_suffix(leaf, ".so") || driver_has_suffix(leaf, ".dylib"))
     return LIB_RESOLVE_KIND_SHARED;
   return LIB_RESOLVE_KIND_ARCHIVE;
 }
 
 static int ld_resolve_exact_library(LdOptions* o, const char* leaf,
                                     char** out_path, size_t* out_size,
                                     LibResolveKind* out_kind) {
   uint32_t i;
   if (!leaf || !leaf[0]) return 1;
   for (i = 0; i < o->inputs.nlib_search_paths; ++i) {
     size_t size = 0;
     char* cand =
         driver_path_join(o->env, o->inputs.lib_search_paths[i], leaf, &size);
     if (!cand) return 1;
     if (driver_path_exists(cand)) {
       *out_path = cand;
       *out_size = size;
       if (out_kind) *out_kind = ld_kind_for_exact_lib(leaf);
       return 0;
     }
     driver_free(o->env, cand, size);
   }
   if (driver_path_exists(leaf)) {
     size_t n = driver_strlen(leaf);
     char* cand = driver_alloc(o->env, n + 1u);
     if (!cand) return 1;
     driver_memcpy(cand, leaf, n + 1u);
     *out_path = cand;
     *out_size = n + 1u;
     if (out_kind) *out_kind = ld_kind_for_exact_lib(leaf);
     return 0;
   }
   return 1;
 }
 
 static int ld_resolve_library(LdOptions* o, const char* name,
                               LibResolveMode mode, LibResolveOS resolve_os,
                               char** out_path, size_t* out_size,
                               LibResolveKind* out_kind) {
   const char* alias;
   if (name && name[0] == ':')
     return ld_resolve_exact_library(o, name + 1, out_path, out_size, out_kind);
   if (driver_lib_resolve_for_os(o->env, name, mode, resolve_os,
                                 o->inputs.lib_search_paths,
                                 o->inputs.nlib_search_paths, out_path, out_size,
                                 out_kind) == 0)
     return 0;
   if (resolve_os != LIB_RESOLVE_OS_WINDOWS) return 1;
   alias = ld_windows_runtime_alias(o, name);
   if (!alias) return 1;
   return driver_lib_resolve_for_os(o->env, alias, mode, resolve_os,
                                    o->inputs.lib_search_paths,
                                    o->inputs.nlib_search_paths, out_path,
                                    out_size, out_kind);
 }
 
 static int ld_resolve_framework(LdOptions* o, const char* name,
                                 char** out_path, size_t* out_size) {
   LibResolveKind kind;
   return driver_framework_resolve(o->env, name, o->inputs.framework_search_paths,
                                   o->inputs.nframework_search_paths, out_path,
                                   out_size, &kind);
 }
 
 static int ld_push_framework(LdOptions* o, const char* name) {
   char* resolved;
   size_t resolved_size;
   if (!name || !name[0]) {
     driver_errf(LD_TOOL, "-framework requires an argument");
     return 1;
   }
   if (ld_resolve_framework(o, name, &resolved, &resolved_size) != 0) {
     driver_errf(LD_TOOL, "cannot find -framework %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(name)));
     return 1;
   }
   ld_push_dso(o, resolved, 1, resolved_size);
   return 0;
 }
 
 static int ld_tok_eq(const char* tok, size_t n, const char* lit) {
   size_t ln = driver_strlen(lit);
   return n == ln && driver_strneq(tok, lit, ln);
 }
 
 static int ld_tok_prefix(const char* tok, size_t n, const char* lit) {
   size_t ln = driver_strlen(lit);
   return n >= ln && driver_strneq(tok, lit, ln);
 }
 
 static int ld_span_to_owned_cstr(LdOptions* o, const char* s, size_t n,
                                  const char** out) {
   size_t bytes = n + 1u;
   char* buf;
   if (bytes == 0) {
     driver_errf(LD_TOOL, "out of memory");
     return 1;
   }
   buf = driver_alloc(o->env, bytes);
   if (!buf) {
     driver_errf(LD_TOOL, "out of memory");
     return 1;
   }
   if (n) driver_memcpy(buf, s, n);
   buf[n] = '\0';
   return ld_own_path(o, buf, bytes, out);
 }
 
 static int ld_set_target_triple(LdOptions* o, const char* triple) {
   KitTargetSpec t;
   uint8_t pic;
   if (!triple) {
     driver_errf(LD_TOOL, "-target requires an argument");
     return 1;
   }
   if (driver_target_from_triple(triple, &t) != 0) {
     driver_err_unknown_target(LD_TOOL, triple);
     return 1;
   }
   o->windows_ucrt_target = strstr(triple, "windows-gnullvm") != NULL;
   pic = o->target.pic;
   o->target = t;
   if (o->pic_explicit)
     o->target.pic = pic;
   else
     o->target.pic = driver_default_pic(o->target.obj, o->target.os);
   o->target_explicit = 1;
   return 0;
 }
 
 static int ld_set_gnu_emulation(LdOptions* o, const char* emu) {
   uint8_t pic;
   KitTargetSpec t;
   if (!emu) {
     driver_errf(LD_TOOL, "-m requires an argument");
     return 1;
   }
   if (driver_streq(emu, "i386pep")) {
     memset(&t, 0, sizeof t);
     t.arch = KIT_ARCH_X86_64;
     t.os = KIT_OS_WINDOWS;
     t.obj = KIT_OBJ_COFF;
     t.ptr_size = 8;
     t.ptr_align = 8;
   } else if (driver_streq(emu, "arm64pe")) {
     memset(&t, 0, sizeof t);
     t.arch = KIT_ARCH_ARM_64;
     t.os = KIT_OS_WINDOWS;
     t.obj = KIT_OBJ_COFF;
     t.ptr_size = 8;
     t.ptr_align = 8;
   } else {
     driver_errf(LD_TOOL, "unsupported GNU ld emulation: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(emu)));
     return 1;
   }
   if (o->target_explicit) return 0;
   pic = o->target.pic;
   o->target = t;
   if (o->pic_explicit)
     o->target.pic = pic;
   else
     o->target.pic = driver_default_pic(o->target.obj, o->target.os);
   return 0;
 }
 
 static int ld_is_pe_gnu_noop(const char* tok, size_t n) {
   return ld_tok_eq(tok, n, "--dynamicbase") ||
          ld_tok_eq(tok, n, "--disable-auto-image-base") ||
          ld_tok_eq(tok, n, "--enable-auto-image-base") ||
          ld_tok_eq(tok, n, "--high-entropy-va") ||
          ld_tok_eq(tok, n, "--nxcompat");
 }
 
 static int ld_is_cc_driver_noop(const char* tok, size_t n) {
   return ld_tok_eq(tok, n, "-m32") || ld_tok_eq(tok, n, "-m64") ||
          ld_tok_eq(tok, n, "-fno-use-linker-plugin") ||
          ld_tok_eq(tok, n, "-nolibc") ||
          ld_tok_prefix(tok, n, "--unwindlib=");
 }
 
 static int ld_parse_wl(LdOptions* o, const char* arg) {
   const char* p = arg;
   int expect_rpath = 0;
   int expect_soname = 0;
   int expect_interp = 0;
   int expect_z = 0;
   int expect_emulation = 0;
   int expect_map = 0;
   int expect_symbols = 0;
   int expect_defsym = 0;
   int expect_section_start = 0;
   int expect_cref = 0;
   int expect_orphan = 0;
   int expect_framework = 0;
   int expect_framework_dir = 0;
   while (*p) {
     const char* tok = p;
     size_t n = 0;
     while (p[n] && p[n] != ',') ++n;
     p = tok + n + (tok[n] == ',' ? 1u : 0u);
 
     if (expect_rpath || expect_soname || expect_interp || expect_z ||
         expect_emulation || expect_map || expect_symbols || expect_defsym ||
         expect_section_start || expect_cref || expect_orphan ||
         expect_framework || expect_framework_dir) {
       if (expect_defsym) {
         if (driver_link_flags_record_defsym(&o->lf, tok, n) != 0) return 1;
       } else if (expect_section_start) {
         if (driver_link_flags_record_section_start(&o->lf, tok, n) != 0)
           return 1;
       } else if (expect_framework) {
         const char* owned;
         if (ld_span_to_owned_cstr(o, tok, n, &owned) != 0) return 1;
         if (ld_push_framework(o, owned) != 0) return 1;
       } else if (expect_framework_dir) {
         const char* owned;
         if (ld_span_to_owned_cstr(o, tok, n, &owned) != 0) return 1;
         if (ld_add_framework_dir(o, owned) != 0) return 1;
       } else if (expect_cref) {
         if (driver_link_flags_record_cref(&o->lf, tok, n) != 0) return 1;
       } else if (expect_orphan) {
         if (driver_link_flags_record_orphan_handling(&o->lf, tok, n) != 0)
           return 1;
       } else if (expect_rpath) {
         const char* owned;
         if (ld_span_to_owned_cstr(o, tok, n, &owned) != 0) return 1;
         o->lf.rpaths[o->lf.nrpaths++] = owned;
       } else if (expect_soname) {
         const char* owned;
         if (ld_span_to_owned_cstr(o, tok, n, &owned) != 0) return 1;
         o->lf.soname = owned;
       } else if (expect_interp) {
         const char* owned;
         if (ld_span_to_owned_cstr(o, tok, n, &owned) != 0) return 1;
         o->lf.interp_path = owned;
       } else if (expect_z) {
         if (driver_link_flags_record_z(&o->lf, tok, n) != 0) return 1;
       } else if (expect_emulation) {
         const char* owned;
         if (ld_span_to_owned_cstr(o, tok, n, &owned) != 0) return 1;
         if (ld_set_gnu_emulation(o, owned) != 0) return 1;
       } else if (expect_map) {
         if (driver_link_flags_record_map(&o->lf, tok, n) != 0) return 1;
       } else if (expect_symbols) {
         if (driver_link_flags_record_symbols(&o->lf, tok, n) != 0) return 1;
       }
       expect_rpath = expect_soname = expect_interp = expect_z =
           expect_emulation = expect_map = expect_symbols = expect_defsym =
               expect_section_start = expect_cref = expect_orphan =
                   expect_framework = expect_framework_dir = 0;
       continue;
     }
 
     if (ld_tok_eq(tok, n, "-dead_strip") ||
         ld_tok_eq(tok, n, "--gc-sections")) {
       o->lf.gc_sections = 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "--no-gc-sections")) {
       o->lf.gc_sections = 0;
       continue;
     }
     if (ld_tok_eq(tok, n, "--no-undefined")) {
       o->lf.allow_undefined = 0;
       continue;
     }
     if (ld_tok_eq(tok, n, "--allow-undefined") ||
         ld_tok_eq(tok, n, "--allow-shlib-undefined")) {
       o->lf.allow_undefined = 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "--map") || ld_tok_eq(tok, n, "-Map")) {
       expect_map = 1;
       continue;
     }
     if (ld_tok_prefix(tok, n, "--map=")) {
       if (driver_link_flags_record_map(&o->lf, tok + 6, n - 6u) != 0) return 1;
       continue;
     }
     if (ld_tok_prefix(tok, n, "-Map=")) {
       if (n == 5) {
         driver_errf(LD_TOOL, "-Map requires a non-empty path");
         return 1;
       }
       if (driver_link_flags_record_map(&o->lf, tok + 5, n - 5u) != 0) return 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "--symbols")) {
       expect_symbols = 1;
       continue;
     }
     if (ld_tok_prefix(tok, n, "--symbols=")) {
       if (driver_link_flags_record_symbols(&o->lf, tok + 10, n - 10u) != 0)
         return 1;
       continue;
     }
     if (ld_tok_prefix(tok, n, "--symbols-format=")) {
       if (driver_link_flags_record_symbols_format(&o->lf, tok + 17, n - 17u) !=
           0)
         return 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "-Bstatic")) {
       o->inputs.cur_link_mode = KIT_LM_STATIC;
       continue;
     }
     if (ld_tok_eq(tok, n, "-Bdynamic")) {
       o->inputs.cur_link_mode = KIT_LM_DYNAMIC;
       continue;
     }
     if (ld_tok_eq(tok, n, "--as-needed")) {
       o->inputs.cur_link_mode = KIT_LM_AS_NEEDED;
       continue;
     }
     if (ld_tok_eq(tok, n, "--no-as-needed")) {
       o->inputs.cur_link_mode = KIT_LM_DYNAMIC;
       continue;
     }
     if (ld_tok_eq(tok, n, "--whole-archive")) {
       o->inputs.cur_whole_archive = 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "--no-whole-archive")) {
       o->inputs.cur_whole_archive = 0;
       continue;
     }
     if (ld_tok_eq(tok, n, "-z")) {
       expect_z = 1;
       continue;
     }
     if (n > 2 && tok[0] == '-' && tok[1] == 'z') {
       if (driver_link_flags_record_z(&o->lf, tok + 2, n - 2) != 0) return 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "--eh-frame-hdr") ||
         ld_tok_eq(tok, n, "--fix-cortex-a53-843419"))
       continue;
     if (ld_is_cc_driver_noop(tok, n)) continue;
     if (ld_is_pe_gnu_noop(tok, n)) continue;
     if (ld_tok_eq(tok, n, "-m")) {
       expect_emulation = 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "-nostdlib")) {
       o->no_default_libs = 1;
       o->nostdlib = 1;
       o->nostartfiles = 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "-nostartfiles")) {
       o->nostartfiles = 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "-nodefaultlibs") ||
         ld_tok_eq(tok, n, "--no-default-libs")) {
       o->no_default_libs = 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "-S") || ld_tok_eq(tok, n, "--strip-debug")) {
       o->lf.strip_debug = 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "-E") || ld_tok_eq(tok, n, "--export-dynamic")) {
       o->export_dynamic = 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "--enable-new-dtags")) {
       o->lf.new_dtags = 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "--disable-new-dtags")) {
       o->lf.new_dtags = 0;
       continue;
     }
     if (ld_tok_eq(tok, n, "-rpath")) {
       expect_rpath = 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "-framework")) {
       expect_framework = 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "-F")) {
       expect_framework_dir = 1;
       continue;
     }
     if (n > 2 && tok[0] == '-' && tok[1] == 'F') {
       const char* owned;
       if (ld_span_to_owned_cstr(o, tok + 2, n - 2u, &owned) != 0) return 1;
       if (ld_add_framework_dir(o, owned) != 0) return 1;
       continue;
     }
     if (ld_tok_prefix(tok, n, "-rpath=")) {
       const char* owned;
       if (ld_span_to_owned_cstr(o, tok + 7, n - 7u, &owned) != 0) return 1;
       o->lf.rpaths[o->lf.nrpaths++] = owned;
       continue;
     }
     if (ld_tok_eq(tok, n, "-soname")) {
       expect_soname = 1;
       continue;
     }
     if (ld_tok_prefix(tok, n, "-soname=")) {
       const char* owned;
       if (ld_span_to_owned_cstr(o, tok + 8, n - 8u, &owned) != 0) return 1;
       o->lf.soname = owned;
       continue;
     }
     if (ld_tok_eq(tok, n, "-dynamic-linker") ||
         ld_tok_eq(tok, n, "--dynamic-linker")) {
       expect_interp = 1;
       continue;
     }
     if (ld_tok_prefix(tok, n, "-dynamic-linker=")) {
       const char* owned;
       if (ld_span_to_owned_cstr(o, tok + 16, n - 16u, &owned) != 0) return 1;
       o->lf.interp_path = owned;
       continue;
     }
     /* -Tdata / -Tbss section base overrides. */
     if (ld_tok_eq(tok, n, "-Tdata") || ld_tok_eq(tok, n, "-Tbss")) {
       const char* secname = ld_tok_eq(tok, n, "-Tdata") ? ".data" : ".bss";
       const char* atok = p;
       size_t an = 0;
       const char* addr_owned;
       if (!*atok) {
         driver_errf(LD_TOOL, "%.*s requires an address", (int)n, tok);
         return 1;
       }
       while (atok[an] && atok[an] != ',') ++an;
       p = atok + an + (atok[an] == ',' ? 1u : 0u);
       if (ld_span_to_owned_cstr(o, atok, an, &addr_owned) != 0) return 1;
       if (driver_link_flags_record_section_addr(&o->lf, secname, addr_owned) !=
           0)
         return 1;
       continue;
     }
     if (ld_tok_prefix(tok, n, "-Tdata=")) {
       const char* addr_owned;
       if (ld_span_to_owned_cstr(o, tok + 7, n - 7u, &addr_owned) != 0) return 1;
       if (driver_link_flags_record_section_addr(&o->lf, ".data", addr_owned) !=
           0)
         return 1;
       continue;
     }
     if (ld_tok_prefix(tok, n, "-Tbss=")) {
       const char* addr_owned;
       if (ld_span_to_owned_cstr(o, tok + 6, n - 6u, &addr_owned) != 0) return 1;
       if (driver_link_flags_record_section_addr(&o->lf, ".bss", addr_owned) !=
           0)
         return 1;
       continue;
     }
     if (ld_tok_prefix(tok, n, "--defsym=")) {
       if (driver_link_flags_record_defsym(&o->lf, tok + 9, n - 9u) != 0)
         return 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "--defsym")) {
       expect_defsym = 1;
       continue;
     }
     if (ld_tok_prefix(tok, n, "--section-start=")) {
       if (driver_link_flags_record_section_start(&o->lf, tok + 16, n - 16u) != 0)
         return 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "--section-start")) {
       expect_section_start = 1;
       continue;
     }
     if (ld_tok_prefix(tok, n, "--cref=")) {
       if (driver_link_flags_record_cref(&o->lf, tok + 7, n - 7u) != 0) return 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "--cref")) {
       expect_cref = 1;
       continue;
     }
     if (ld_tok_prefix(tok, n, "--orphan-handling=")) {
       if (driver_link_flags_record_orphan_handling(&o->lf, tok + 18, n - 18u) !=
           0)
         return 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "--orphan-handling")) {
       expect_orphan = 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "--fatal-warnings")) {
       o->lf.fatal_warnings = 1;
       continue;
     }
     if (ld_tok_eq(tok, n, "--no-fatal-warnings")) {
       o->lf.fatal_warnings = 0;
       continue;
     }
     if (ld_tok_eq(tok, n, "--print-memory-usage")) {
       o->lf.print_memory_usage = 1;
       continue;
     }
 
     driver_errf(LD_TOOL, "unsupported -Wl, token: %.*s", (int)n, tok);
     return 1;
   }
   if (expect_rpath || expect_soname || expect_interp || expect_z ||
       expect_emulation || expect_map || expect_symbols || expect_defsym ||
       expect_section_start || expect_cref || expect_orphan ||
       expect_framework || expect_framework_dir) {
     driver_errf(LD_TOOL, "-Wl option requires another comma argument");
     return 1;
   }
   return 0;
 }
 
 /* ---------- GNU input-script expansion (.so text scripts) ---------- */
 
 typedef struct LdInputScript {
   LdOptions* o;
   const char* script_path;
   const char* script_dir;
   const char* p;
   const char* end;
   uint32_t order_pos;
   uint32_t insert_pos;
   uint8_t saw_input_directive;
   uint8_t added;
 } LdInputScript;
 
 static int ld_is_space_char(char c) {
   return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' ||
          c == '\v';
 }
 
 static int ld_is_ident_char(char c) {
   return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
          (c >= '0' && c <= '9') || c == '_';
 }
 
 static char ld_ascii_upper(char c) {
   return (c >= 'a' && c <= 'z') ? (char)(c - 'a' + 'A') : c;
 }
 
 static int ld_span_eq_ci(const char* s, size_t n, const char* lit) {
   size_t ln = driver_strlen(lit);
   size_t i;
   if (n != ln) return 0;
   for (i = 0; i < n; ++i)
     if (ld_ascii_upper(s[i]) != ld_ascii_upper(lit[i])) return 0;
   return 1;
 }
 
 static void ld_script_skip_ws(LdInputScript* s) {
   for (;;) {
     while (s->p < s->end && ld_is_space_char(*s->p)) ++s->p;
     if (s->p + 1 < s->end && s->p[0] == '/' && s->p[1] == '*') {
       s->p += 2;
       while (s->p + 1 < s->end && !(s->p[0] == '*' && s->p[1] == '/')) ++s->p;
       if (s->p + 1 < s->end) s->p += 2;
       continue;
     }
     if (s->p < s->end && *s->p == '#') {
       while (s->p < s->end && *s->p != '\n') ++s->p;
       continue;
     }
     if (s->p < s->end && (*s->p == ';' || *s->p == ',')) {
       ++s->p;
       continue;
     }
     break;
   }
 }
 
 static int ld_script_try_kw(LdInputScript* s, const char* kw) {
   const char* p;
   size_t n = driver_strlen(kw);
   ld_script_skip_ws(s);
   if ((size_t)(s->end - s->p) < n) return 0;
   if (!ld_span_eq_ci(s->p, n, kw)) return 0;
   p = s->p + n;
   if (p < s->end && ld_is_ident_char(*p)) return 0;
   s->p = p;
   return 1;
 }
 
 static void ld_script_skip_balanced(LdInputScript* s) {
   int depth = 0;
   if (s->p >= s->end || *s->p != '(') return;
   while (s->p < s->end) {
     char c = *s->p++;
     if (c == '"' || c == '\'') {
       char q = c;
       while (s->p < s->end) {
         c = *s->p++;
         if (c == '\\' && s->p < s->end) {
           ++s->p;
           continue;
         }
         if (c == q) break;
       }
       continue;
     }
     if (c == '(') {
       ++depth;
     } else if (c == ')') {
       --depth;
       if (depth == 0) return;
     }
   }
 }
 
 static int ld_script_next_token(LdInputScript* s, const char** out,
                                 size_t* out_len) {
   const char* start;
   char quote;
   ld_script_skip_ws(s);
   if (s->p >= s->end || *s->p == ')') return 0;
   if (*s->p == '(') return 0;
   quote = *s->p;
   if (quote == '"' || quote == '\'') {
     ++s->p;
     start = s->p;
     while (s->p < s->end && *s->p != quote) {
       if (*s->p == '\\' && s->p + 1 < s->end)
         s->p += 2;
       else
         ++s->p;
     }
     *out = start;
     *out_len = (size_t)(s->p - start);
     if (s->p < s->end) ++s->p;
     return 1;
   }
   start = s->p;
   while (s->p < s->end && !ld_is_space_char(*s->p) && *s->p != '(' &&
          *s->p != ')' && *s->p != ';' && *s->p != ',')
     ++s->p;
   if (s->p == start) {
     ++s->p;
     return 0;
   }
   *out = start;
   *out_len = (size_t)(s->p - start);
   return 1;
 }
 
 static int ld_path_has_slash(const char* s) {
   while (*s) {
     if (*s == '/' || *s == '\\') return 1;
     ++s;
   }
   return 0;
 }
 
 static int ld_script_dirname(LdOptions* o, const char* path, const char** out) {
   const char* slash = strrchr(path, '/');
   size_t n;
   if (!slash) {
     *out = "";
     return 0;
   }
   n = (size_t)(slash - path);
   if (n == 0) n = 1; /* root directory */
   return ld_span_to_owned_cstr(o, path, n, out);
 }
 
 static int ld_script_resolve_file(LdInputScript* s, const char* name,
                                   const char** out_path, int* out_owned,
                                   size_t* out_size) {
   LdOptions* o = s->o;
   const char* rewritten;
   uint32_t i;
   *out_path = NULL;
   *out_owned = 0;
   *out_size = 0;
 
   if (name[0] == '/' || name[0] == '=' || ld_path_has_slash(name)) {
     if (ld_sysroot_rewrite_path(o, name, &rewritten) != 0) return 1;
     if (!driver_path_exists(rewritten)) {
       driver_errf(LD_TOOL, "%.*s: linker script input not found: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(s->script_path)),
                   KIT_SLICE_ARG(kit_slice_cstr(rewritten)));
       return 1;
     }
     *out_path = rewritten;
     return 0;
   }
 
   if (s->script_dir && s->script_dir[0]) {
     size_t size = 0;
     char* cand = driver_path_join(o->env, s->script_dir, name, &size);
     if (!cand) {
       driver_errf(LD_TOOL, "out of memory");
       return 1;
     }
     if (driver_path_exists(cand)) {
       *out_path = cand;
       *out_owned = 1;
       *out_size = size;
       return 0;
     }
     driver_free(o->env, cand, size);
   }
 
   for (i = 0; i < o->inputs.nlib_search_paths; ++i) {
     size_t size = 0;
     char* cand =
         driver_path_join(o->env, o->inputs.lib_search_paths[i], name, &size);
     if (!cand) {
       driver_errf(LD_TOOL, "out of memory");
       return 1;
     }
     if (driver_path_exists(cand)) {
       *out_path = cand;
       *out_owned = 1;
       *out_size = size;
       return 0;
     }
     driver_free(o->env, cand, size);
   }
 
   if (driver_path_exists(name)) {
     *out_path = name;
     return 0;
   }
 
   driver_errf(LD_TOOL, "%.*s: linker script input not found: %.*s",
               KIT_SLICE_ARG(kit_slice_cstr(s->script_path)),
               KIT_SLICE_ARG(kit_slice_cstr(name)));
   return 1;
 }
 
 /* The GNU INPUT()/GROUP() expander replaces the DSO-script link item at
  * `order_pos` with the script's first input, then inserts the rest just after
  * it — preserving the script's position in the overall link order. */
 static int ld_script_add_order(LdInputScript* s, uint8_t kind, uint32_t index) {
   if (!s->added) {
     s->o->inputs.link_items[s->order_pos].kind = kind;
     s->o->inputs.link_items[s->order_pos].index = index;
     s->insert_pos = s->order_pos + 1u;
     s->added = 1;
     return 0;
   }
   if (ld_order_capacity(s->o, 1) != 0) return 1;
   driver_link_inputs_insert(&s->o->inputs, s->insert_pos, kind, index);
   s->insert_pos++;
   return 0;
 }
 
 static int ld_script_add_path(LdInputScript* s, const char* path, int owned,
                               size_t owned_size, int as_needed,
                               uint8_t group_id) {
   LdOptions* o = s->o;
   if (driver_has_suffix(path, ".a") || driver_has_suffix(path, ".rlib")) {
     uint32_t idx;
     if (ld_archive_capacity(o) != 0) goto fail;
     idx = ld_add_archive_slot(
         o, path, owned, owned_size, o->inputs.cur_whole_archive,
         as_needed ? KIT_LM_AS_NEEDED : o->inputs.cur_link_mode, group_id);
     return ld_script_add_order(s, DRIVER_LINK_ARCHIVE, idx);
   }
   if (driver_is_so_filename(path) || driver_has_suffix(path, ".dylib") ||
       driver_has_suffix(path, ".tbd")) {
     uint32_t idx;
     if (as_needed) goto skip;
     if (ld_dso_capacity(o) != 0) goto fail;
     idx = ld_add_dso_slot(o, path, owned, owned_size);
     return ld_script_add_order(s, DRIVER_LINK_DSO, idx);
   }
   {
     uint32_t idx;
     const char* keep = path;
     if (owned) {
       if (ld_own_path(o, (char*)path, owned_size, &keep) != 0) return 1;
       owned = 0;
       owned_size = 0;
     }
     if (ld_object_capacity(o) != 0) return 1;
     idx = ld_add_object_slot(o, keep);
     return ld_script_add_order(s, DRIVER_LINK_OBJECT, idx);
   }
 
 skip:
   if (owned) driver_free(o->env, (void*)path, owned_size);
   return 0;
 fail:
   if (owned) driver_free(o->env, (void*)path, owned_size);
   return 1;
 }
 
 static int ld_script_add_token(LdInputScript* s, const char* tok, size_t n,
                                int as_needed, uint8_t group_id) {
   LdOptions* o = s->o;
   const char* owned_tok = NULL;
   const char* path = NULL;
   int owned_path = 0;
   size_t path_size = 0;
 
   if (n == 0) return 0;
 
   if (n > 2 && tok[0] == '-' && tok[1] == 'l' && tok[2] != ':') {
     char* resolved = NULL;
     size_t resolved_size = 0;
     LibResolveKind kind;
     LibResolveMode mode = (o->inputs.cur_link_mode == KIT_LM_STATIC)
                               ? LIB_RESOLVE_STATIC_ONLY
                               : LIB_RESOLVE_DYNAMIC_PREFER;
     LibResolveOS resolve_os = (o->target.os == KIT_OS_WINDOWS)
                                   ? LIB_RESOLVE_OS_WINDOWS
                                   : LIB_RESOLVE_OS_POSIX;
     if (ld_span_to_owned_cstr(o, tok + 2, n - 2u, &owned_tok) != 0) return 1;
     if (ld_resolve_library(o, owned_tok, mode, resolve_os, &resolved,
                            &resolved_size, &kind) != 0) {
       driver_errf(LD_TOOL, "%.*s: cannot resolve linker script input -l%.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(s->script_path)),
                   KIT_SLICE_ARG(kit_slice_cstr(owned_tok)));
       return 1;
     }
     if ((kind == LIB_RESOLVE_KIND_SHARED || kind == LIB_RESOLVE_KIND_TBD) &&
         as_needed) {
       driver_free(o->env, resolved, resolved_size);
       return 0;
     }
     return ld_script_add_path(s, resolved, 1, resolved_size, as_needed,
                               group_id);
   }
 
   if (n > 3 && tok[0] == '-' && tok[1] == 'l' && tok[2] == ':') {
     tok += 3;
     n -= 3;
   } else if (tok[0] == '-') {
     driver_errf(LD_TOOL, "%.*s: unsupported linker script token: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(s->script_path)), (int)n, tok);
     return 1;
   }
 
   if (ld_span_to_owned_cstr(o, tok, n, &owned_tok) != 0) return 1;
   if (ld_script_resolve_file(s, owned_tok, &path, &owned_path, &path_size) != 0)
     return 1;
   return ld_script_add_path(s, path, owned_path, path_size, as_needed,
                             group_id);
 }
 
 static int ld_script_parse_list(LdInputScript* s, int as_needed,
                                 uint8_t group_id, int group_directive);
 
 static int ld_script_parse_nested(LdInputScript* s, int as_needed,
                                   uint8_t group_id) {
   if (ld_script_try_kw(s, "AS_NEEDED"))
     return ld_script_parse_list(s, 1, group_id, 0) == 0 ? 1 : -1;
   if (ld_script_try_kw(s, "INPUT"))
     return ld_script_parse_list(s, as_needed, group_id, 0) == 0 ? 1 : -1;
   if (ld_script_try_kw(s, "GROUP"))
     return ld_script_parse_list(s, as_needed, group_id, 1) == 0 ? 1 : -1;
   return 0;
 }
 
 static int ld_script_parse_list(LdInputScript* s, int as_needed,
                                 uint8_t group_id, int group_directive) {
   LdOptions* o = s->o;
   ld_script_skip_ws(s);
   if (s->p >= s->end || *s->p != '(') {
     driver_errf(LD_TOOL, "%.*s: expected '(' in linker script input list",
                 KIT_SLICE_ARG(kit_slice_cstr(s->script_path)));
     return 1;
   }
   ++s->p;
   s->saw_input_directive = 1;
   if (group_directive && group_id == 0) {
     if (o->next_group_id == UINT8_MAX) {
       driver_errf(LD_TOOL, "too many GROUP directives in linker scripts");
       return 1;
     }
     group_id = ++o->next_group_id;
   }
   for (;;) {
     const char* tok;
     size_t n;
     ld_script_skip_ws(s);
     if (s->p >= s->end) {
       driver_errf(LD_TOOL, "%.*s: unterminated linker script input list",
                   KIT_SLICE_ARG(kit_slice_cstr(s->script_path)));
       return 1;
     }
     if (*s->p == ')') {
       ++s->p;
       return 0;
     }
     {
       int nested = ld_script_parse_nested(s, as_needed, group_id);
       if (nested < 0) return 1;
       if (nested > 0) continue;
     }
     ld_script_skip_ws(s);
     if (s->p < s->end && *s->p == ')') continue;
     if (!ld_script_next_token(s, &tok, &n)) {
       driver_errf(LD_TOOL, "%.*s: malformed linker script input",
                   KIT_SLICE_ARG(kit_slice_cstr(s->script_path)));
       return 1;
     }
     if (ld_script_add_token(s, tok, n, as_needed, group_id) != 0) return 1;
   }
 }
 
 static int ld_script_parse_input(LdInputScript* s) {
   while (s->p < s->end) {
     const char* tok;
     size_t n;
     ld_script_skip_ws(s);
     if (s->p >= s->end) break;
     if (ld_script_try_kw(s, "INPUT")) {
       if (ld_script_parse_list(s, 0, 0, 0) != 0) return 1;
       continue;
     }
     if (ld_script_try_kw(s, "GROUP")) {
       if (ld_script_parse_list(s, 0, 0, 1) != 0) return 1;
       continue;
     }
     if (ld_script_try_kw(s, "AS_NEEDED")) {
       if (ld_script_parse_list(s, 1, 0, 0) != 0) return 1;
       continue;
     }
     if (!ld_script_next_token(s, &tok, &n)) {
       if (s->p < s->end && *s->p == '(')
         ld_script_skip_balanced(s);
       else if (s->p < s->end)
         ++s->p;
       continue;
     }
     ld_script_skip_ws(s);
     if (s->p < s->end && *s->p == '(') ld_script_skip_balanced(s);
   }
   if (s->saw_input_directive && !s->added) {
     driver_errf(LD_TOOL, "%.*s: linker script did not add any inputs",
                 KIT_SLICE_ARG(kit_slice_cstr(s->script_path)));
     return 1;
   }
   return 0;
 }
 
 static int ld_try_expand_dso_script(LdOptions* o, uint32_t order_pos,
                                     int* changed) {
   const KitFileIO* io = &o->env->file_io;
   const DriverLinkItem* ord = &o->inputs.link_items[order_pos];
   const char* path;
   KitFileData fd;
   LdInputScript s;
   const char* dir = NULL;
   int rc = 0;
   if (ord->kind != DRIVER_LINK_DSO) return 0;
   if (ord->index >= o->inputs.ndsos) return 0;
   path = o->inputs.dsos[ord->index].path;
   if (!path || !io->read_all) return 0;
   memset(&fd, 0, sizeof fd);
   if (io->read_all(io->user, path, &fd) != KIT_OK) {
     driver_errf(LD_TOOL, "failed to read: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(path)));
     return 1;
   }
   if (kit_detect_fmt(fd.data, fd.size) != KIT_BIN_UNKNOWN) {
     if (io->release) io->release(io->user, &fd);
     return 0;
   }
   if (ld_script_dirname(o, path, &dir) != 0) {
     if (io->release) io->release(io->user, &fd);
     return 1;
   }
   memset(&s, 0, sizeof s);
   s.o = o;
   s.script_path = path;
   s.script_dir = dir;
   s.p = (const char*)fd.data;
   s.end = s.p + fd.size;
   s.order_pos = order_pos;
   s.insert_pos = order_pos + 1u;
   if (ld_script_parse_input(&s) != 0) {
     rc = 1;
   } else if (s.added) {
     *changed = 1;
   }
   if (io->release) io->release(io->user, &fd);
   return rc;
 }
 
 static int ld_expand_dso_scripts(LdOptions* o) {
   uint32_t pass;
   for (pass = 0; pass < 8u; ++pass) {
     uint32_t i;
     int changed = 0;
     for (i = 0; i < o->inputs.nlink_items; ++i) {
       if (ld_try_expand_dso_script(o, i, &changed) != 0) return 1;
     }
     if (!changed) return 0;
   }
   driver_errf(LD_TOOL, "too many nested linker-script inputs");
   return 1;
 }
 
 /* ---------- argv parser ---------- */
 
 /* If `arg` starts with `prefix` followed by '=', returns the tail past the
  * '='; otherwise returns NULL. */
 static const char* arg_eq_value(const char* arg, const char* prefix) {
   size_t n = driver_strlen(prefix);
   if (!driver_strneq(arg, prefix, n)) return NULL;
   if (arg[n] != '=') return NULL;
   return arg + n + 1;
 }
 
 /* Compare an MSVC-style flag against `arg`, case-insensitive on the
  * key. MSVC accepts both `/` and `-` as the lead char and is
  * case-insensitive in the key part — we accept `/KEY:val`, `/key:val`,
  * `-KEY:val`. Returns the tail past the colon, or NULL on mismatch. */
 static const char* ms_flag_value(const char* arg, const char* key) {
   size_t klen = driver_strlen(key);
   size_t i;
   if (arg[0] != '/' && arg[0] != '-') return NULL;
   for (i = 0; i < klen; ++i) {
     char a = arg[1 + i];
     char k = key[i];
     if (a >= 'a' && a <= 'z') a = (char)(a - 'a' + 'A');
     if (k >= 'a' && k <= 'z') k = (char)(k - 'a' + 'A');
     if (a != k) return NULL;
   }
   if (arg[1 + klen] != ':') return NULL;
   return arg + 1 + klen + 1;
 }
 
 /* Same shape as ms_flag_value but for bare flags (no `:value`). */
 static int ms_flag_match(const char* arg, const char* key) {
   size_t klen = driver_strlen(key);
   size_t i;
   if (arg[0] != '/' && arg[0] != '-') return 0;
   for (i = 0; i < klen; ++i) {
     char a = arg[1 + i];
     char k = key[i];
     if (a >= 'a' && a <= 'z') a = (char)(a - 'a' + 'A');
     if (k >= 'a' && k <= 'z') k = (char)(k - 'a' + 'A');
     if (a != k) return 0;
   }
   return arg[1 + klen] == '\0';
 }
 
 /* Parse one MSVC-style argument. Recognized subset (others warn and
  * skip — match-but-no-op so legacy build scripts pass cleanly):
  *   /OUT:path                  → o->output_path
  *   /ENTRY:sym                 → o->entry
  *   /SUBSYSTEM:CONSOLE|WINDOWS → PE optional-header subsystem; WINDOWS
  *                                also defaults entry to WinMainCRTStartup.
  *   /DEFAULTLIB:name           → equivalent to -l<name>; resolved
  *                                lazily in the same path as -l.
  *   /LIBPATH:dir               → equivalent to -L dir
  *
  * Returns 1 if consumed, 0 if not a recognized MS flag (caller falls
  * through to its existing behaviour), -1 on hard error. */
 static int ld_try_ms_flag(LdOptions* o, const char* a) {
   const char* val;
   if (!o->ms_link_driver) return 0;
   if (a[0] != '/' && a[0] != '-') return 0;
 
   if ((val = ms_flag_value(a, "OUT")) != NULL) {
     if (o->output_seen) {
       driver_errf(LD_TOOL, "/OUT specified after -o");
       return -1;
     }
     o->output_path = val;
     o->output_seen = 1;
     return 1;
   }
   if ((val = ms_flag_value(a, "ENTRY")) != NULL) {
     o->lf.entry = val;
     return 1;
   }
   if ((val = ms_flag_value(a, "LIBPATH")) != NULL) {
     if (ld_add_lib_dir(o, val) != 0) return -1;
     return 1;
   }
   if ((val = ms_flag_value(a, "DEFAULTLIB")) != NULL) {
     /* Resolve eagerly like -l does, using whatever current link-mode
      * state is in effect. Windows mode triggers the .lib/.dll.a/.a
      * suffix list. */
     char* resolved;
     size_t resolved_size;
     LibResolveKind kind;
     LibResolveMode mode = (o->inputs.cur_link_mode == KIT_LM_STATIC)
                               ? LIB_RESOLVE_STATIC_ONLY
                               : LIB_RESOLVE_DYNAMIC_PREFER;
     if (ld_resolve_library(o, val, mode, LIB_RESOLVE_OS_WINDOWS, &resolved,
                            &resolved_size, &kind) != 0) {
       driver_errf(LD_TOOL, "/DEFAULTLIB: cannot find %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(val)));
       return -1;
     }
     if (kind == LIB_RESOLVE_KIND_SHARED || kind == LIB_RESOLVE_KIND_TBD) {
       ld_push_dso(o, resolved, 1, resolved_size);
     } else {
       ld_push_archive(o, resolved, 1, resolved_size);
     }
     return 1;
   }
   if ((val = ms_flag_value(a, "SUBSYSTEM")) != NULL) {
     if (driver_link_flags_record_pe_subsystem(&o->lf, val,
                                               driver_strlen(val)) != 0)
       return -1;
     return 1;
   }
   if (ms_flag_match(a, "NOLOGO") || ms_flag_match(a, "VERBOSE") ||
       ms_flag_match(a, "INCREMENTAL") || ms_flag_match(a, "DEBUG") ||
       ms_flag_match(a, "DYNAMICBASE") || ms_flag_match(a, "NXCOMPAT")) {
     /* Common flags every Windows build script sets; silently accept. */
     return 1;
   }
 
   /* Any other `/key[:val]` shape under --ms-link-driver: warn + skip.
    * We treat the entire arg as consumed so it doesn't fall through to
    * the positional path and try to open a file. */
   driver_errf(LD_TOOL, "ignoring unsupported MS-style flag: %.*s",
               KIT_SLICE_ARG(kit_slice_cstr(a)));
   return 1;
 }
 
 static int ld_parse(int argc, char** argv, LdOptions* o) {
   int i;
   if (ld_alloc_arrays(o, argc) != 0) return 1;
 
   o->target = driver_host_target();
 
   /* First pass: detect --ms-link-driver up front so the option can
    * appear anywhere on the command line and still affect earlier
    * `/...` tokens. Also capture --sysroot before resolving any -l
    * entries; GNU ld treats the sysroot as a global search-prefix
    * setting, not positional state. Also detect -lc so the hosted lib
    * dirs can be pre-populated before -lm / -lpthread etc. are resolved. */
   {
     int has_lc = 0;
     for (i = 1; i < argc; ++i) {
       if (driver_streq(argv[i], "--ms-link-driver")) {
         o->ms_link_driver = 1;
         continue;
       }
       if (driver_streq(argv[i], "-nostdlib")) {
         o->no_default_libs = 1;
         o->nostdlib = 1;
         o->nostartfiles = 1;
         continue;
       }
       if (driver_streq(argv[i], "-nostartfiles")) {
         o->nostartfiles = 1;
         continue;
       }
       if (driver_streq(argv[i], "--no-default-libs") ||
           driver_streq(argv[i], "-nodefaultlibs")) {
         o->no_default_libs = 1;
         continue;
       }
       if (driver_strneq(argv[i], "-Wl,", 4)) {
         const char* wl = argv[i] + 4;
         if (strstr(wl, "-nostdlib")) {
           o->no_default_libs = 1;
           o->nostdlib = 1;
           o->nostartfiles = 1;
           continue;
         }
         if (strstr(wl, "-nostartfiles")) {
           o->nostartfiles = 1;
           continue;
         }
         if (strstr(wl, "--no-default-libs") ||
             strstr(wl, "-nodefaultlibs")) {
           o->no_default_libs = 1;
           continue;
         }
         continue;
       }
       if (driver_streq(argv[i], "-target") ||
           driver_streq(argv[i], "--target")) {
         if (i + 1 < argc) {
           if (ld_set_target_triple(o, argv[i + 1]) != 0) return 1;
           i++;
         }
         continue;
       }
       if (driver_strneq(argv[i], "--target=", 9)) {
         if (ld_set_target_triple(o, argv[i] + 9) != 0) return 1;
         continue;
       }
       {
         int dr = driver_darwin_platform_try_consume(
             LD_TOOL, argc, argv, &i, &o->target, o->pic_explicit);
         if (dr < 0) return 1;
         if (dr > 0) continue;
       }
       if (ld_is_cc_driver_noop(argv[i], driver_strlen(argv[i]))) {
         continue;
       }
       if (driver_streq(argv[i], "-m")) {
         if (i + 1 < argc) {
           if (ld_set_gnu_emulation(o, argv[i + 1]) != 0) return 1;
           i++;
         }
         continue;
       }
       if (driver_strneq(argv[i], "-m", 2) && argv[i][2] != '\0') {
         if (ld_set_gnu_emulation(o, argv[i] + 2) != 0) return 1;
         continue;
       }
       if (driver_streq(argv[i], "--sysroot") ||
           driver_streq(argv[i], "-syslibroot")) {
         if (i + 1 < argc) {
           o->sysroot = argv[i + 1];
           i++;
         }
         continue;
       }
       if (driver_strneq(argv[i], "--sysroot=", 10)) {
         o->sysroot = argv[i] + 10;
         continue;
       }
       if (argv[i][0] != '-' && ld_is_crt_start_object(argv[i])) {
         o->explicit_crt_start = 1;
         continue;
       }
       /* Detect -lc / -l c so hosted lib dirs are available for later -l
        * flags regardless of where -lc appears on the command line. */
       if (driver_streq(argv[i], "-lc")) {
         has_lc = 1;
         continue;
       }
       if ((driver_streq(argv[i], "-l") || driver_streq(argv[i], "--library")) &&
           i + 1 < argc && driver_streq(argv[i + 1], "c")) {
         has_lc = 1;
         i++;
         continue;
       }
     }
     if (!o->sysroot || !o->sysroot[0]) {
       const char* env_sysroot = driver_getenv("KIT_SYSROOT");
       if (env_sysroot && env_sysroot[0]) o->sysroot = env_sysroot;
     }
     /* GNU ld treats -L / --library-path as global library-search state, not
      * as a positional option that only affects later -l flags. Pre-collect
      * those directories now so Rust-style invocations can put self-contained
      * runtime libdirs after an earlier -l. */
     for (i = 1; i < argc; ++i) {
       const char* a = argv[i];
       const char* val;
       if (driver_strneq(a, "-L", 2)) {
         const char* dir = a[2] ? a + 2 : (++i < argc ? argv[i] : NULL);
         const char* rewritten;
         if (!dir) {
           driver_errf(LD_TOOL, "-L requires an argument");
           return 1;
         }
         if (ld_sysroot_rewrite_path(o, dir, &rewritten) != 0) return 1;
         if (ld_add_lib_dir(o, rewritten) != 0) return 1;
         continue;
       }
       if ((val = arg_eq_value(a, "--library-path")) != NULL) {
         const char* rewritten;
         if (ld_sysroot_rewrite_path(o, val, &rewritten) != 0) return 1;
         if (ld_add_lib_dir(o, rewritten) != 0) return 1;
         continue;
       }
       if (driver_streq(a, "--library-path")) {
         const char* rewritten;
         if (++i >= argc) {
           driver_errf(LD_TOOL, "--library-path requires an argument");
           return 1;
         }
         if (ld_sysroot_rewrite_path(o, argv[i], &rewritten) != 0) return 1;
         if (ld_add_lib_dir(o, rewritten) != 0) return 1;
         continue;
       }
       if (driver_strneq(a, "-F", 2)) {
         const char* dir = a[2] ? a + 2 : (++i < argc ? argv[i] : NULL);
         const char* rewritten;
         if (!dir) {
           driver_errf(LD_TOOL, "-F requires an argument");
           return 1;
         }
         if (ld_sysroot_rewrite_path(o, dir, &rewritten) != 0) return 1;
         if (ld_add_framework_dir(o, rewritten) != 0) return 1;
         continue;
       }
     }
     o->lib_dirs_precollected = 1;
     if (ld_add_sysroot_libdir(o) != 0) return 1;
     if (ld_add_sysroot_framework_dirs(o) != 0) return 1;
     /* Pre-populate the hosted lib dirs so user -l flags are resolved
      * against the correct sysroot even when they appear before -lc. */
     if (has_lc && !o->explicit_crt_start) {
       DriverHostedRequest req;
       DriverHostedDirs dirs;
       uint32_t j;
       memset(&req, 0, sizeof req);
       req.env = o->env;
       req.tool = LD_TOOL;
       req.target = o->target;
       req.sysroot = o->sysroot;
       if (driver_hosted_dirs_resolve(&req, &dirs) == 0) {
         for (j = 0; j < dirs.nlibdirs; ++j) {
           /* Transfer ownership of each dir string to o->owned_paths so
            * it is freed in ld_options_release; then point lib_dirs at it. */
           const char* p;
           if (ld_own_path(o, dirs.libdirs[j], dirs.libdir_sizes[j], &p) == 0) {
             dirs.libdirs[j] = NULL;
             dirs.libdir_sizes[j] = 0;
             if (ld_add_lib_dir(o, p) != 0) {
               driver_hosted_dirs_fini(&dirs);
               return 1;
             }
           }
         }
         driver_hosted_dirs_fini(&dirs);
       }
     }
   }
 
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
     const char* val;
     int ms_rc;
 
     if (driver_streq(a, "--ms-link-driver")) {
       o->ms_link_driver = 1;
       continue;
     }
     ms_rc = ld_try_ms_flag(o, a);
     if (ms_rc < 0) return 1;
     if (ms_rc > 0) continue;
 
     if (driver_strneq(a, "-Wl,", 4)) {
       if (ld_parse_wl(o, a + 4) != 0) return 1;
       continue;
     }
 
     if (driver_streq(a, "-o")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "-o requires an argument");
         return 1;
       }
       if (o->output_seen) {
         driver_errf(LD_TOOL, "-o specified more than once");
         return 1;
       }
       o->output_path = argv[i];
       o->output_seen = 1;
       continue;
     }
     if ((val = arg_eq_value(a, "--output")) != NULL) {
       if (o->output_seen) {
         driver_errf(LD_TOOL, "-o specified more than once");
         return 1;
       }
       o->output_path = val;
       o->output_seen = 1;
       continue;
     }
     if (driver_streq(a, "--output")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "--output requires an argument");
         return 1;
       }
       if (o->output_seen) {
         driver_errf(LD_TOOL, "-o specified more than once");
         return 1;
       }
       o->output_path = argv[i];
       o->output_seen = 1;
       continue;
     }
     if (driver_streq(a, "-e")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "-e requires an argument");
         return 1;
       }
       o->lf.entry = argv[i];
       continue;
     }
     if ((val = arg_eq_value(a, "--entry")) != NULL) {
       o->lf.entry = val;
       continue;
     }
     if (driver_streq(a, "--entry")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "--entry requires an argument");
         return 1;
       }
       o->lf.entry = argv[i];
       continue;
     }
     if ((val = arg_eq_value(a, "--subsystem")) != NULL) {
       if (driver_link_flags_record_pe_subsystem(&o->lf, val,
                                                 driver_strlen(val)) != 0)
         return 1;
       continue;
     }
     if (driver_streq(a, "--subsystem")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "--subsystem requires an argument");
         return 1;
       }
       if (driver_link_flags_record_pe_subsystem(&o->lf, argv[i],
                                                 driver_strlen(argv[i])) != 0)
         return 1;
       continue;
     }
     {
       int dr = driver_darwin_platform_try_consume(
           LD_TOOL, argc, argv, &i, &o->target, o->pic_explicit);
       if (dr < 0) return 1;
       if (dr > 0) continue;
     }
     if (driver_streq(a, "-target") || driver_streq(a, "--target")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "%s requires an argument", a);
         return 1;
       }
       if (ld_set_target_triple(o, argv[i]) != 0) return 1;
       continue;
     }
     if (driver_strneq(a, "--target=", 9)) {
       if (ld_set_target_triple(o, a + 9) != 0) return 1;
       continue;
     }
     if (driver_streq(a, "-flavor")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "-flavor requires an argument");
         return 1;
       }
       if (!driver_streq(argv[i], "gnu")) {
         driver_errf(LD_TOOL, "unsupported linker flavor: %s", argv[i]);
         return 1;
       }
       continue;
     }
     if (ld_is_cc_driver_noop(a, driver_strlen(a))) {
       continue;
     }
     if (driver_streq(a, "-m")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "-m requires an argument");
         return 1;
       }
       if (ld_set_gnu_emulation(o, argv[i]) != 0) return 1;
       continue;
     }
     if (driver_strneq(a, "-m", 2) && a[2] != '\0') {
       if (ld_set_gnu_emulation(o, a + 2) != 0) return 1;
       continue;
     }
 
     if (driver_streq(a, "-T")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "-T requires an argument");
         return 1;
       }
       o->script_path = argv[i];
       continue;
     }
     if ((val = arg_eq_value(a, "--script")) != NULL) {
       o->script_path = val;
       continue;
     }
     if (driver_streq(a, "--script")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "--script requires an argument");
         return 1;
       }
       o->script_path = argv[i];
       continue;
     }
     /* -Ttext ADDR / -Ttext=ADDR: set the static ET_EXEC image (text) base, for
      * freestanding images that must load at a fixed address (e.g. the qemu
      * `virt` RAM base 0x80000000). Matched here; the bare "-T" above is an
      * exact match, so it never swallows -Ttext. No effect on PIE/scripted
      * layouts. */
     {
       const char* tval = NULL;
       if (driver_streq(a, "-Ttext")) {
         if (++i >= argc) {
           driver_errf(LD_TOOL, "-Ttext requires an argument");
           return 1;
         }
         tval = argv[i];
       } else if ((tval = arg_eq_value(a, "-Ttext")) != NULL) {
         /* -Ttext=ADDR */
       }
       if (tval) {
         if (driver_link_flags_record_text_base(&o->lf, tval) != 0) return 1;
         continue;
       }
     }
     /* -Tdata / -Tbss ADDR (or =ADDR): per-section address override. Folded
      * into the section_starts table as `.data` / `.bss`. */
     {
       const char* secname = NULL;
       const char* addr = NULL;
       if (driver_streq(a, "-Tdata") || driver_streq(a, "-Tbss")) {
         secname = driver_streq(a, "-Tdata") ? ".data" : ".bss";
         if (++i >= argc) {
           driver_errf(LD_TOOL, "%s requires an address", a);
           return 1;
         }
         addr = argv[i];
       } else if ((addr = arg_eq_value(a, "-Tdata")) != NULL) {
         secname = ".data";
       } else if ((addr = arg_eq_value(a, "-Tbss")) != NULL) {
         secname = ".bss";
       }
       if (secname) {
         if (driver_link_flags_record_section_addr(&o->lf, secname, addr) != 0)
           return 1;
         continue;
       }
     }
     if (driver_streq(a, "--defsym")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "--defsym requires NAME=EXPR");
         return 1;
       }
       if (driver_link_flags_record_defsym(&o->lf, argv[i],
                                           driver_strlen(argv[i])) != 0)
         return 1;
       continue;
     }
     if ((val = arg_eq_value(a, "--defsym")) != NULL) {
       if (driver_link_flags_record_defsym(&o->lf, val, driver_strlen(val)) != 0)
         return 1;
       continue;
     }
     if (driver_streq(a, "--section-start")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "--section-start requires .NAME=ADDR");
         return 1;
       }
       if (driver_link_flags_record_section_start(
               &o->lf, argv[i], driver_strlen(argv[i])) != 0)
         return 1;
       continue;
     }
     if ((val = arg_eq_value(a, "--section-start")) != NULL) {
       if (driver_link_flags_record_section_start(&o->lf, val,
                                                  driver_strlen(val)) != 0)
         return 1;
       continue;
     }
     if (driver_streq(a, "--orphan-handling")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "--orphan-handling requires a mode");
         return 1;
       }
       if (driver_link_flags_record_orphan_handling(
               &o->lf, argv[i], driver_strlen(argv[i])) != 0)
         return 1;
       continue;
     }
     if ((val = arg_eq_value(a, "--orphan-handling")) != NULL) {
       if (driver_link_flags_record_orphan_handling(&o->lf, val,
                                                    driver_strlen(val)) != 0)
         return 1;
       continue;
     }
     if (driver_streq(a, "--fatal-warnings")) {
       o->lf.fatal_warnings = 1;
       continue;
     }
     if (driver_streq(a, "--no-fatal-warnings")) {
       o->lf.fatal_warnings = 0;
       continue;
     }
     if (driver_streq(a, "--print-memory-usage")) {
       o->lf.print_memory_usage = 1;
       continue;
     }
     if (driver_streq(a, "--cref")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "--cref requires a path");
         return 1;
       }
       if (driver_link_flags_record_cref(&o->lf, argv[i],
                                         driver_strlen(argv[i])) != 0)
         return 1;
       continue;
     }
     if ((val = arg_eq_value(a, "--cref")) != NULL) {
       if (driver_link_flags_record_cref(&o->lf, val, driver_strlen(val)) != 0)
         return 1;
       continue;
     }
     /* -nostdlib / --no-default-libs: do not auto-resolve and link kit's
      * compiler runtime. A freestanding image (e.g. riscv32-none-elf) supplies
      * its own libkit_rt.a on the command line, and a pure-linker invocation
      * should not require a per-target runtime archive to exist. */
     if (driver_streq(a, "-nostdlib")) {
       o->no_default_libs = 1;
       o->nostdlib = 1;
       o->nostartfiles = 1;
       continue;
     }
     if (driver_streq(a, "-nostartfiles")) {
       o->nostartfiles = 1;
       continue;
     }
     if (driver_streq(a, "--no-default-libs") ||
         driver_streq(a, "-nodefaultlibs")) {
       o->no_default_libs = 1;
       continue;
     }
     if (driver_streq(a, "--support-dir")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "--support-dir requires an argument");
         return 1;
       }
       o->support_dir = argv[i];
       continue;
     }
     if (driver_strneq(a, "--support-dir=", 14)) {
       o->support_dir = a + 14;
       continue;
     }
     /* --sysroot is authoritative in the first pass (GNU ld treats it as a
      * global search-prefix that must be known before any -l / "=" rewrite), so
      * o->sysroot is already set. Here we only consume the tokens so they are
      * not misread as input files; do not re-apply the value. */
     if (driver_streq(a, "--sysroot") || driver_streq(a, "-syslibroot")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "%s requires an argument", a);
         return 1;
       }
       continue;
     }
     if (driver_strneq(a, "--sysroot=", 10)) {
       continue;
     }
 
     if (driver_strneq(a, "-L", 2)) {
       const char* dir = a[2] ? a + 2 : (++i < argc ? argv[i] : NULL);
       const char* rewritten;
       if (!dir) {
         driver_errf(LD_TOOL, "-L requires an argument");
         return 1;
       }
       if (!o->lib_dirs_precollected) {
         if (ld_sysroot_rewrite_path(o, dir, &rewritten) != 0) return 1;
         if (ld_add_lib_dir(o, rewritten) != 0) return 1;
       }
       continue;
     }
     if ((val = arg_eq_value(a, "--library-path")) != NULL) {
       const char* rewritten;
       if (!o->lib_dirs_precollected) {
         if (ld_sysroot_rewrite_path(o, val, &rewritten) != 0) return 1;
         if (ld_add_lib_dir(o, rewritten) != 0) return 1;
       }
       continue;
     }
     if (driver_streq(a, "--library-path")) {
       const char* rewritten;
       if (++i >= argc) {
         driver_errf(LD_TOOL, "--library-path requires an argument");
         return 1;
       }
       if (!o->lib_dirs_precollected) {
         if (ld_sysroot_rewrite_path(o, argv[i], &rewritten) != 0) return 1;
         if (ld_add_lib_dir(o, rewritten) != 0) return 1;
       }
       continue;
     }
     if (driver_strneq(a, "-F", 2)) {
       const char* dir = a[2] ? a + 2 : (++i < argc ? argv[i] : NULL);
       const char* rewritten;
       if (!dir) {
         driver_errf(LD_TOOL, "-F requires an argument");
         return 1;
       }
       if (!o->lib_dirs_precollected) {
         if (ld_sysroot_rewrite_path(o, dir, &rewritten) != 0) return 1;
         if (ld_add_framework_dir(o, rewritten) != 0) return 1;
       }
       continue;
     }
 
     if (driver_strneq(a, "-l", 2)) {
       const char* name = a[2] ? a + 2 : (++i < argc ? argv[i] : NULL);
       char* resolved;
       size_t resolved_size;
       LibResolveKind kind;
       LibResolveMode mode;
       LibResolveOS resolve_os;
       if (!name) {
         driver_errf(LD_TOOL, "-l requires an argument");
         return 1;
       }
       if (ld_note_library_request(o, name)) continue;
       /* -Bstatic forces .a only; everything else (default,
        * -Bdynamic, --as-needed) prefers .so but falls back to .a. */
       mode = (o->inputs.cur_link_mode == KIT_LM_STATIC) ? LIB_RESOLVE_STATIC_ONLY
                                                  : LIB_RESOLVE_DYNAMIC_PREFER;
       resolve_os = (o->target.os == KIT_OS_WINDOWS) ? LIB_RESOLVE_OS_WINDOWS
                                                     : LIB_RESOLVE_OS_POSIX;
       if (ld_resolve_library(o, name, mode, resolve_os, &resolved,
                              &resolved_size, &kind) != 0) {
         driver_errf(LD_TOOL, "cannot find -l%.*s",
                     KIT_SLICE_ARG(kit_slice_cstr(name)));
         return 1;
       }
       if (kind == LIB_RESOLVE_KIND_SHARED || kind == LIB_RESOLVE_KIND_TBD) {
         ld_push_dso(o, resolved, 1, resolved_size);
       } else {
         ld_push_archive(o, resolved, 1, resolved_size);
       }
       continue;
     }
     if ((val = arg_eq_value(a, "--library")) != NULL) {
       char* resolved;
       size_t resolved_size;
       LibResolveKind kind;
       LibResolveMode mode = (o->inputs.cur_link_mode == KIT_LM_STATIC)
                                 ? LIB_RESOLVE_STATIC_ONLY
                                 : LIB_RESOLVE_DYNAMIC_PREFER;
       LibResolveOS resolve_os = (o->target.os == KIT_OS_WINDOWS)
                                     ? LIB_RESOLVE_OS_WINDOWS
                                     : LIB_RESOLVE_OS_POSIX;
       if (ld_note_library_request(o, val)) continue;
       if (ld_resolve_library(o, val, mode, resolve_os, &resolved,
                              &resolved_size, &kind) != 0) {
         driver_errf(LD_TOOL, "cannot find -l%.*s",
                     KIT_SLICE_ARG(kit_slice_cstr(val)));
         return 1;
       }
       if (kind == LIB_RESOLVE_KIND_SHARED || kind == LIB_RESOLVE_KIND_TBD) {
         ld_push_dso(o, resolved, 1, resolved_size);
       } else {
         ld_push_archive(o, resolved, 1, resolved_size);
       }
       continue;
     }
     if (driver_streq(a, "--library")) {
       char* resolved;
       size_t resolved_size;
       LibResolveKind kind;
       LibResolveMode mode;
       LibResolveOS resolve_os;
       if (++i >= argc) {
         driver_errf(LD_TOOL, "--library requires an argument");
         return 1;
       }
       if (ld_note_library_request(o, argv[i])) continue;
       mode = (o->inputs.cur_link_mode == KIT_LM_STATIC) ? LIB_RESOLVE_STATIC_ONLY
                                                  : LIB_RESOLVE_DYNAMIC_PREFER;
       resolve_os = (o->target.os == KIT_OS_WINDOWS) ? LIB_RESOLVE_OS_WINDOWS
                                                     : LIB_RESOLVE_OS_POSIX;
       if (ld_resolve_library(o, argv[i], mode, resolve_os, &resolved,
                              &resolved_size, &kind) != 0) {
         driver_errf(LD_TOOL, "cannot find -l%.*s",
                     KIT_SLICE_ARG(kit_slice_cstr(argv[i])));
         return 1;
       }
       if (kind == LIB_RESOLVE_KIND_SHARED || kind == LIB_RESOLVE_KIND_TBD) {
         ld_push_dso(o, resolved, 1, resolved_size);
       } else {
         ld_push_archive(o, resolved, 1, resolved_size);
       }
       continue;
     }
     if (driver_streq(a, "-framework")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "-framework requires an argument");
         return 1;
       }
       if (ld_push_framework(o, argv[i]) != 0) return 1;
       continue;
     }
 
     if (driver_streq(a, "-static")) {
       o->target.pic = KIT_PIC_NONE;
       o->static_link = 1;
       o->inputs.cur_link_mode = KIT_LM_STATIC;
       o->pic_explicit = 1;
       continue;
     }
     if (driver_streq(a, "-static-pie")) {
       o->target.pic = KIT_PIC_PIE;
       o->pie = 1;
       o->static_link = 1;
       o->inputs.cur_link_mode = KIT_LM_STATIC;
       o->pic_explicit = 1;
       continue;
     }
     if (driver_streq(a, "-pie")) {
       o->target.pic = KIT_PIC_PIE;
       o->pie = 1;
       o->pic_explicit = 1;
       continue;
     }
     if (driver_streq(a, "-dynamic-linker") ||
         driver_streq(a, "--dynamic-linker")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "-dynamic-linker requires an argument");
         return 1;
       }
       o->lf.interp_path = argv[i];
       continue;
     }
     if (driver_streq(a, "--no-dynamic-linker")) {
       o->lf.interp_path = "";
       continue;
     }
     if ((val = arg_eq_value(a, "--dynamic-linker")) != NULL) {
       o->lf.interp_path = val;
       continue;
     }
     if (driver_streq(a, "-no-pie")) {
       o->target.pic = KIT_PIC_NONE;
       o->pie = 0;
       o->pic_explicit = 1;
       continue;
     }
 
     if (driver_streq(a, "-shared")) {
       o->shared = 1;
       /* Shared objects must be position-independent. Force PIC unless
        * the caller has explicitly chosen PIE (which is also fine). */
       if (o->target.pic == KIT_PIC_NONE) o->target.pic = KIT_PIC_PIC;
       o->pic_explicit = 1;
       continue;
     }
     if (driver_streq(a, "-r") || driver_streq(a, "--relocatable")) {
       o->relocatable = 1;
       continue;
     }
     if (driver_streq(a, "-soname")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "-soname requires an argument");
         return 1;
       }
       o->lf.soname = argv[i];
       continue;
     }
     if ((val = arg_eq_value(a, "-soname")) != NULL) {
       o->lf.soname = val;
       continue;
     }
     if (driver_streq(a, "-rpath")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "-rpath requires an argument");
         return 1;
       }
       o->lf.rpaths[o->lf.nrpaths++] = argv[i];
       continue;
     }
     if ((val = arg_eq_value(a, "-rpath")) != NULL) {
       o->lf.rpaths[o->lf.nrpaths++] = val;
       continue;
     }
     if (driver_streq(a, "-rpath-link")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "-rpath-link requires an argument");
         return 1;
       }
       o->rpath_links[o->nrpath_links++] = argv[i];
       continue;
     }
     if ((val = arg_eq_value(a, "-rpath-link")) != NULL) {
       o->rpath_links[o->nrpath_links++] = val;
       continue;
     }
     if (driver_streq(a, "--enable-new-dtags")) {
       o->lf.new_dtags = 1;
       continue;
     }
     if (driver_streq(a, "--disable-new-dtags")) {
       o->lf.new_dtags = 0;
       continue;
     }
     if (driver_streq(a, "--gc-sections")) {
       o->lf.gc_sections = 1;
       continue;
     }
     if (driver_streq(a, "-dead_strip")) {
       o->lf.gc_sections = 1;
       continue;
     }
     if (driver_streq(a, "--no-gc-sections")) {
       o->lf.gc_sections = 0;
       continue;
     }
     if (driver_streq(a, "--map") || driver_streq(a, "-Map")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "%s requires an argument", a);
         return 1;
       }
       if (!argv[i][0]) {
         driver_errf(LD_TOOL, "%s requires a non-empty path", a);
         return 1;
       }
       o->lf.map_path = argv[i];
       continue;
     }
     if ((val = arg_eq_value(a, "--map")) != NULL) {
       if (!val[0]) {
         driver_errf(LD_TOOL, "--map requires a non-empty path");
         return 1;
       }
       o->lf.map_path = val;
       continue;
     }
     if ((val = arg_eq_value(a, "-Map")) != NULL) {
       if (!val[0]) {
         driver_errf(LD_TOOL, "-Map requires a non-empty path");
         return 1;
       }
       o->lf.map_path = val;
       continue;
     }
     if (driver_streq(a, "--symbols")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "--symbols requires an argument");
         return 1;
       }
       if (!argv[i][0]) {
         driver_errf(LD_TOOL, "--symbols requires a non-empty path");
         return 1;
       }
       o->lf.symbols_path = argv[i];
       continue;
     }
     if ((val = arg_eq_value(a, "--symbols")) != NULL) {
       if (!val[0]) {
         driver_errf(LD_TOOL, "--symbols requires a non-empty path");
         return 1;
       }
       o->lf.symbols_path = val;
       continue;
     }
     if ((val = arg_eq_value(a, "--symbols-format")) != NULL) {
       if (driver_link_flags_record_symbols_format(&o->lf, val,
                                                   driver_strlen(val)) != 0)
         return 1;
       continue;
     }
     if (driver_streq(a, "-S") || driver_streq(a, "--strip-debug")) {
       o->lf.strip_debug = 1;
       continue;
     }
     if (driver_streq(a, "-E") || driver_streq(a, "--export-dynamic")) {
       o->export_dynamic = 1;
       continue;
     }
     if (driver_streq(a, "--eh-frame-hdr")) {
       /* Rust/GNU drivers request this for unwind-table acceleration. Kit's
        * ELF writer does not currently synthesize PT_GNU_EH_FRAME, so accept it
        * as advisory until that feature is implemented. */
       continue;
     }
     if (driver_streq(a, "--fix-cortex-a53-843419")) {
       /* AArch64 GNU/LLD compatibility. Kit does not currently implement this
        * erratum-rewrite pass, so accept the request as advisory. */
       continue;
     }
     if (ld_is_pe_gnu_noop(a, driver_strlen(a))) {
       continue;
     }
     if (driver_streq(a, "--no-undefined")) {
       o->lf.allow_undefined = 0;
       continue;
     }
     if (driver_streq(a, "--allow-undefined") ||
         driver_streq(a, "--allow-shlib-undefined")) {
       o->lf.allow_undefined = 1;
       continue;
     }
     if (driver_streq(a, "-z")) {
       if (++i >= argc) {
         driver_errf(LD_TOOL, "-z requires an argument");
         return 1;
       }
       if (driver_link_flags_record_z(&o->lf, argv[i], driver_strlen(argv[i])) !=
           0)
         return 1;
       continue;
     }
     if (a[0] == '-' && a[1] == 'z' && a[2] != '\0') {
       if (driver_link_flags_record_z(&o->lf, a + 2, driver_strlen(a + 2)) != 0)
         return 1;
       continue;
     }
 
     if (driver_streq(a, "--whole-archive")) {
       o->inputs.cur_whole_archive = 1;
       continue;
     }
     if (driver_streq(a, "--no-whole-archive")) {
       o->inputs.cur_whole_archive = 0;
       continue;
     }
     if (driver_streq(a, "-Bstatic")) {
       o->inputs.cur_link_mode = KIT_LM_STATIC;
       continue;
     }
     if (driver_streq(a, "-Bdynamic")) {
       o->inputs.cur_link_mode = KIT_LM_DYNAMIC;
       continue;
     }
     if (driver_streq(a, "--as-needed")) {
       o->inputs.cur_link_mode = KIT_LM_AS_NEEDED;
       continue;
     }
     if (driver_streq(a, "--no-as-needed")) {
       o->inputs.cur_link_mode = KIT_LM_DYNAMIC;
       continue;
     }
     if (driver_streq(a, "--start-group")) {
       if (o->inputs.cur_group_id != 0) {
         driver_errf(LD_TOOL, "nested --start-group is not supported");
         return 1;
       }
       if (o->next_group_id == UINT8_MAX) {
         driver_errf(LD_TOOL, "too many --start-group occurrences");
         return 1;
       }
       o->next_group_id++;
       o->inputs.cur_group_id = o->next_group_id;
       continue;
     }
     if (driver_streq(a, "--end-group")) {
       if (o->inputs.cur_group_id == 0) {
         driver_errf(LD_TOOL, "--end-group without --start-group");
         return 1;
       }
       o->inputs.cur_group_id = 0;
       continue;
     }
 
     if ((val = arg_eq_value(a, "--build-id")) != NULL) {
       if (driver_link_flags_record_build_id(&o->lf, val) != 0) return 1;
       continue;
     }
     if (driver_streq(a, "--build-id")) {
       /* Bareword form defaults to sha256, matching GNU ld. */
       o->lf.build_id_mode = KIT_BUILDID_SHA256;
       continue;
     }
 
     if (a[0] == '-' && a[1] != '\0') {
       driver_errf(LD_TOOL, "unknown flag: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(a)));
       return 1;
     }
 
     {
       const char* path;
       if (ld_sysroot_rewrite_path(o, a, &path) != 0) return 1;
       if (driver_has_suffix(path, ".a") || driver_has_suffix(path, ".rlib")) {
         ld_push_archive(o, path, 0, 0);
       } else if (driver_is_so_filename(path)) {
         ld_push_dso(o, path, 0, 0);
       } else {
         ld_push_object(o, path);
       }
     }
   }
 
   if (!o->output_path) {
     driver_errf(LD_TOOL, "-o is required");
     return 1;
   }
   if (o->inputs.cur_group_id != 0) {
     driver_errf(LD_TOOL, "missing --end-group");
     return 1;
   }
   if (o->inputs.nobject_files == 0 && o->inputs.narchives == 0 &&
       o->inputs.ndsos == 0) {
     driver_errf(LD_TOOL, "no input files");
     ld_usage();
     return 1;
   }
   if (o->wants_hosted_libc && (o->nostdlib || o->nostartfiles)) {
     driver_errf(LD_TOOL,
                 "-lc hosted expansion is disabled by -nostdlib/"
                 "-nostartfiles");
     return 1;
   }
   if (o->shared && o->target.obj != KIT_OBJ_ELF) {
     driver_errf(LD_TOOL,
                 "-shared output is supported only for ELF targets in v1");
     return 1;
   }
   if (o->relocatable) {
     if (o->shared) {
       driver_errf(LD_TOOL, "-r and -shared are incompatible");
       return 1;
     }
     if (o->wants_hosted_libc) {
       driver_errf(LD_TOOL, "-lc hosted expansion requires executable output");
       return 1;
     }
     /* Only an explicit -pie conflicts; a default PIE target.pic is simply
      * overridden by -r (driver_link_pie suppresses pie when relocatable). */
     if (o->pie) {
       driver_errf(LD_TOOL, "-r and -pie are incompatible");
       return 1;
     }
     if (o->lf.interp_path) {
       driver_errf(LD_TOOL, "-dynamic-linker requires executable output");
       return 1;
     }
     if (o->lf.soname || o->lf.nrpaths || o->nrpath_links) {
       driver_errf(LD_TOOL, "-soname/-rpath/-rpath-link require -shared");
       return 1;
     }
     if (o->inputs.ndsos) {
       driver_errf(LD_TOOL, "-r does not support shared-object inputs");
       return 1;
     }
     if (o->script_path) {
       driver_errf(LD_TOOL, "-r does not support linker scripts yet");
       return 1;
     }
     if (o->lf.map_path || o->lf.symbols_path) {
       driver_errf(LD_TOOL, "--map/--symbols require executable output");
       return 1;
     }
   }
   return 0;
 }
 
 /* ---------- options teardown ---------- */
 
 static void ld_options_release(LdOptions* o) {
   size_t bound = o->argv_bound;
   uint32_t i;
   for (i = 0; i < o->nowned_paths; ++i) {
     if (o->owned_paths[i])
       driver_free(o->env, o->owned_paths[i], o->owned_path_sizes[i]);
   }
   /* The shared flag model owns its FLAG strings (defsym/section/map/...), the
    * build-id bytes, and the rpath/defsym/section-start vectors. The shared
    * input set owns the resolved archive/dso paths and its parallel arrays. */
   driver_link_flags_fini(&o->lf);
   driver_link_inputs_fini(&o->inputs);
   driver_cflags_fini(&o->cf, o->env);
   driver_hosted_plan_fini(o->env, &o->hosted);
   /* owned_paths/owned_path_sizes grow independently of argv_bound. */
   driver_free(o->env, o->owned_paths,
               o->cap_owned_paths * sizeof(*o->owned_paths));
   driver_free(o->env, o->owned_path_sizes,
               o->cap_owned_paths * sizeof(*o->owned_path_sizes));
   driver_free(o->env, o->rpath_links, bound * sizeof(*o->rpath_links));
 }
 
 /* ---------- input loading ---------- */
 
 typedef struct LoadedFile {
   const KitFileIO* io;
   KitFileData data;
   int loaded;
 } LoadedFile;
 
 static int load_file(const KitFileIO* io, const char* path, LoadedFile* out) {
   out->io = io;
   out->loaded = 0;
   out->data.data = NULL;
   out->data.size = 0;
   out->data.token = NULL;
   if (io->read_all(io->user, path, &out->data) != KIT_OK) return 1;
   out->loaded = 1;
   return 0;
 }
 
 static void release_file(LoadedFile* lf) {
   if (lf->loaded && lf->io && lf->io->release) {
     lf->io->release(lf->io->user, &lf->data);
   }
   lf->loaded = 0;
 }
 
 static void release_all(LoadedFile* arr, uint32_t n) {
   uint32_t i;
   if (!arr) return;
   for (i = 0; i < n; ++i) release_file(&arr[i]);
 }
 
 static KitStatus ld_write_link_report(const LdOptions* o, const KitFileIO* io,
                                       KitLinkSession* link, const char* path,
                                       int symbols) {
   KitWriter* w = NULL;
   KitStatus st;
   if (!path) return KIT_OK;
   if (io->open_writer(io->user, path, &w) != KIT_OK) {
     driver_errf(LD_TOOL, "failed to open %s output: %.*s",
                 symbols ? "symbols" : "map",
                 KIT_SLICE_ARG(kit_slice_cstr(path)));
     return KIT_IO;
   }
   st = symbols ? kit_link_session_write_symbols(link, o->lf.symbols_format, w)
                : kit_link_session_write_map(link, w);
   if (st == KIT_OK) st = kit_writer_status(w);
   kit_writer_close(w);
   if (st != KIT_OK) {
     driver_errf(LD_TOOL, "failed to write %s: %.*s",
                 symbols ? "symbols" : "map",
                 KIT_SLICE_ARG(kit_slice_cstr(path)));
   }
   return st;
 }
 
 /* --cref FILE: cross-reference table side file. */
 static KitStatus ld_write_cref(const LdOptions* o, const KitFileIO* io,
                                KitLinkSession* link) {
   KitWriter* w = NULL;
   KitStatus st;
   if (!o->lf.cref_path) return KIT_OK;
   if (io->open_writer(io->user, o->lf.cref_path, &w) != KIT_OK) {
     driver_errf(LD_TOOL, "failed to open cref output: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(o->lf.cref_path)));
     return KIT_IO;
   }
   st = kit_link_session_write_cref(link, w);
   if (st == KIT_OK) st = kit_writer_status(w);
   kit_writer_close(w);
   if (st != KIT_OK)
     driver_errf(LD_TOOL, "failed to write cref: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(o->lf.cref_path)));
   return st;
 }
 
 /* --print-memory-usage: GNU-ld-style per-region summary to stdout. */
 static KitStatus ld_print_memory_usage(LdOptions* o, KitLinkSession* link) {
   KitWriter* w;
   KitStatus st;
   if (!o->lf.print_memory_usage) return KIT_OK;
   w = driver_stdout_writer(o->env);
   if (!w) {
     driver_errf(LD_TOOL, "failed to print memory usage");
     return KIT_IO;
   }
   st = kit_link_session_write_memory_usage(link, w);
   if (st == KIT_OK) st = kit_writer_status(w);
   kit_writer_close(w);
   if (st != KIT_OK) driver_errf(LD_TOOL, "failed to print memory usage");
   return st;
 }
 
 /* Resolve and apply the hosted libc profile: hosted lib-search dirs (so user
  * -l flags resolve against the sysroot), the before/after/final crt inputs in
  * link order, and the interpreter. The shared helper folds all of this (plus
  * the system includes/defines that ld discards) into one call; the runtime
  * archive is later inserted before the final group via
  * driver_link_inputs_insert_runtime_archives. The wants-hosted / -shared guard
  * stays here. */
 static int ld_apply_hosted(LdOptions* o) {
   int shared_hosted = o->shared && driver_target_shared_uses_hosted(o->target);
   if (!o->wants_hosted_libc || (o->shared && !shared_hosted)) return 0;
   return driver_link_inputs_apply_hosted(&o->inputs, &o->hosted, &o->cf, &o->lf,
                                          o->target, o->sysroot, o->static_link,
                                          o->shared, o->nostartfiles,
                                          /*link_action=*/1);
 }
 
 /* ---------- link execution ---------- */
 
 /* Run the link. Returns 0 on success, nonzero on error. The caller owns
  * `o` and any allocations within; this function only owns transient
  * loaded-file buffers and the writer/compiler it constructs. */
 static int ld_run_link(LdOptions* o) {
   KitContext ctx = driver_env_to_context(o->env);
   const KitFileIO* io = ctx.file_io;
   KitTarget* target = NULL;
   KitCompiler* compiler = NULL;
   KitWriter* writer = NULL;
   LoadedFile* obj_lf = NULL;
   LoadedFile* arch_lf = NULL;
   LoadedFile* dso_lf = NULL;
   LoadedFile script_lf = {0};
   KitSlice* obj_in = NULL;
   KitLinkArchiveInput* arch_in = NULL;
   KitSlice* dso_in = NULL;
   KitLinkInputOrder* order = NULL;
   KitLinkScript* script = NULL;
   KitLinkSession* link = NULL;
   DriverRuntimeSupport runtime = {0};
   DriverRuntimeArchive rt_archive = {0};
   uint32_t i;
   uint32_t norder = 0;
   uint32_t initial_nobject_files;
   int runtime_resolved = 0;
   int rc = 1;
 
   if (!io || !io->read_all || !io->open_writer) {
     driver_errf(LD_TOOL, "host file I/O unavailable");
     return 1;
   }
 
   /* Load the caller's object files first so the final target is known before
    * deciding which hosted CRT/libc profile and compiler-runtime archive to
    * add. The arrays are sized to the argv bound because hosted expansion may
    * append start files after target detection. */
   initial_nobject_files = o->inputs.nobject_files;
   if (o->argv_bound) {
     obj_lf = driver_alloc_zeroed(o->env, o->argv_bound * sizeof(*obj_lf));
     obj_in = driver_alloc_zeroed(o->env, o->argv_bound * sizeof(*obj_in));
     if (!obj_lf || !obj_in) {
       driver_errf(LD_TOOL, "out of memory");
       goto out;
     }
   }
   for (i = 0; i < initial_nobject_files; ++i) {
     const char* path = o->inputs.object_files[i];
     if (load_file(io, path, &obj_lf[i]) != 0) {
       driver_errf(LD_TOOL, "failed to read: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(path)));
       goto out;
     }
     obj_in[i].data = obj_lf[i].data.data;
     obj_in[i].len = obj_lf[i].data.size;
   }
 
   /* Auto-detect target from the object inputs, falling back to the host target.
    * The PIC default is a property of the *target*, not the host: hosted targets
    * default to PIE, freestanding ones to no-PIE (driver_default_pic). The
    * host's default PIC must never leak onto a detected cross target; only an
    * EXPLICIT -static/-pie/-no-pie/-shared wins.
    *
    * Detection takes the arch from the first object, but the OS from any object:
    * a freestanding (`*-none-elf`, EI_OSABI=STANDALONE) object means a
    * freestanding link even if a foreign object (e.g. a clang-assembled startup
    * stub, which stamps EI_OSABI=SysV and so decodes as Linux) appears first. */
   if (!o->target_explicit && initial_nobject_files > 0) {
     KitTargetSpec detected;
     if (kit_detect_target(obj_lf[0].data.data, obj_lf[0].data.size,
                           &detected) == KIT_OK) {
       uint8_t pic = o->target.pic;
       uint32_t oi;
       for (oi = 1; oi < initial_nobject_files; ++oi) {
         KitTargetSpec t;
         if (kit_detect_target(obj_lf[oi].data.data, obj_lf[oi].data.size, &t) ==
             KIT_OK) {
           if (t.os == KIT_OS_FREESTANDING) detected.os = KIT_OS_FREESTANDING;
           /* Reconcile the float ABI across inputs. A foreign startup stub (e.g.
            * a clang-assembled .S) may not carry the float-ABI e_flags that the
            * kit-compiled objects do, so prefer any object's hardware ABI
            * (single/double) over a soft/unset reading. This picks the runtime
            * variant (rv32 ilp32 vs ilp32f) the real code was compiled for even
            * when obj[0] is the stub. */
           if (detected.float_abi != KIT_FLOAT_ABI_SINGLE &&
               detected.float_abi != KIT_FLOAT_ABI_DOUBLE &&
               (t.float_abi == KIT_FLOAT_ABI_SINGLE ||
                t.float_abi == KIT_FLOAT_ABI_DOUBLE))
             detected.float_abi = t.float_abi;
         }
       }
       o->target = detected;
       if (o->pic_explicit)
         o->target.pic = pic;
       else
         o->target.pic = driver_default_pic(o->target.obj, o->target.os);
     }
   }
 
   if (!o->relocatable && o->target.os == KIT_OS_FREESTANDING &&
       o->inputs.ndsos) {
     driver_errf(LD_TOOL,
                 "freestanding executable links do not accept DSO inputs");
     goto out;
   }
 
   /* Strict freestanding policy: every input object must agree with the link
    * target's arch and object format. A `*-none-*` link silently mis-linking a
    * foreign-arch object (the default detection trusts obj[0]'s arch) is a hard
    * error here. */
   if (!o->relocatable && o->target.os == KIT_OS_FREESTANDING) {
     uint32_t oi;
     for (oi = 0; oi < initial_nobject_files; ++oi) {
       KitTargetSpec t;
       if (kit_detect_target(obj_lf[oi].data.data, obj_lf[oi].data.size, &t) !=
           KIT_OK)
         continue;
       if (t.arch != o->target.arch || t.obj != o->target.obj) {
         driver_errf(LD_TOOL,
                     "freestanding link: input '%s' arch/format does not match "
                     "the link target",
                     o->inputs.object_files[oi]);
         goto out;
       }
     }
   }
 
   if (ld_apply_hosted(o) != 0) goto out;
 
   /* Hosted dynamic link: default to PIE, matching what `kit cc` does.
    * Without PIE the link_dyn path (PLT/GOT/.rela.plt) is not entered and
    * any CALL26/PLT32 reloc against an imported symbol faults at apply time.
    * Only override when the user has not made an explicit PIC choice.
    * Non-PIE (ET_EXEC) dynamic linking is not yet supported; reject early. */
   if (o->wants_hosted_libc && !o->static_link && !o->shared &&
       !o->relocatable) {
     if (o->pic_explicit && !o->pie) {
       driver_errf(LD_TOOL,
                   "-lc with -no-pie is not supported; use -pie (default) "
                   "or -static for a static link");
       goto out;
     }
     if (!o->pic_explicit) o->pie = 1;
   }
 
   /* Auto-link kit's compiler runtime for any target that has a variant unless
    * the caller has already supplied compiler builtins (Rust's
    * libcompiler_builtins*.rlib, libgcc.a, clang_rt.builtins, ...). This keeps
    * `kit ld object.o` useful while letting `kit ld` behave like a system
    * linker under external compiler drivers. A target with no variant is
    * implicitly -nostdlib and supplies its own libkit_rt.a on the command line,
    * so skip resolution rather than erroring. -nostdlib forces the skip for any
    * target.
    */
   if (!o->relocatable && !o->no_default_libs && !o->has_compiler_runtime &&
       driver_runtime_has_variant(o->target)) {
     if (driver_runtime_resolve(o->env, o->support_dir, o->driver_path,
                                &runtime) != 0) {
       driver_errf(LD_TOOL, "support dir not found");
       goto out;
     }
     runtime_resolved = 1;
     if (driver_runtime_prepare_archive(o->env, LD_TOOL, &runtime, o->target, 0,
                                        &rt_archive) != 0)
       goto out;
     /* Insert before the hosted plan's `final` (crt-end) group — the shared
      * helper also does the Windows two-position insert that the old single
      * append lacked. ld's runtime is never whole-archive, matching cc/build. */
     driver_link_inputs_insert_runtime_archives(
         &o->inputs, &rt_archive, o->target, o->hosted.nfinal, o->hosted.nafter);
   }
 
   if (ld_expand_dso_scripts(o) != 0) goto out;
 
   for (i = initial_nobject_files; i < o->inputs.nobject_files; ++i) {
     const char* path = o->inputs.object_files[i];
     if (load_file(io, path, &obj_lf[i]) != 0) {
       driver_errf(LD_TOOL, "failed to read: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(path)));
       goto out;
     }
     obj_in[i].data = obj_lf[i].data.data;
     obj_in[i].len = obj_lf[i].data.size;
   }
 
   if (o->inputs.narchives) {
     arch_lf =
         driver_alloc_zeroed(o->env, o->inputs.narchives * sizeof(*arch_lf));
     arch_in =
         driver_alloc_zeroed(o->env, o->inputs.narchives * sizeof(*arch_in));
     if (!arch_lf || !arch_in) {
       driver_errf(LD_TOOL, "out of memory");
       goto out;
     }
   }
   if (o->inputs.ndsos) {
     dso_lf = driver_alloc_zeroed(o->env, o->inputs.ndsos * sizeof(*dso_lf));
     dso_in = driver_alloc_zeroed(o->env, o->inputs.ndsos * sizeof(*dso_in));
     if (!dso_lf || !dso_in) {
       driver_errf(LD_TOOL, "out of memory");
       goto out;
     }
   }
 
   /* Load archives. */
   for (i = 0; i < o->inputs.narchives; ++i) {
     const DriverArchiveInput* a = &o->inputs.archives[i];
     if (load_file(io, a->path, &arch_lf[i]) != 0) {
       driver_errf(LD_TOOL, "failed to read: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(a->path)));
       goto out;
     }
     arch_in[i].name = kit_slice_cstr(a->path);
     arch_in[i].bytes.data = arch_lf[i].data.data;
     arch_in[i].bytes.len = arch_lf[i].data.size;
     arch_in[i].whole_archive = a->whole_archive;
     arch_in[i].link_mode = a->link_mode;
     arch_in[i].group_id = a->group_id;
   }
   /* Load shared objects. */
   for (i = 0; i < o->inputs.ndsos; ++i) {
     const DriverDsoInput* d = &o->inputs.dsos[i];
     if (load_file(io, d->path, &dso_lf[i]) != 0) {
       driver_errf(LD_TOOL, "failed to read: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(d->path)));
       goto out;
     }
     dso_in[i].data = dso_lf[i].data.data;
     dso_in[i].len = dso_lf[i].data.size;
   }
 
   /* Load and parse the linker script (if any). The structured script is
    * arena-owned by the compiler; we free it explicitly before the
    * compiler is destroyed. */
   if (o->script_path) {
     if (load_file(io, o->script_path, &script_lf) != 0) {
       driver_errf(LD_TOOL, "failed to read: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(o->script_path)));
       goto out;
     }
   }
 
   {
     KitTargetOptions topts;
     memset(&topts, 0, sizeof topts);
     topts.spec = o->target;
     /* A linker target auto-detected from RISC-V ELF inputs already carries
      * the psABI in spec.float_abi.  kit_target_new normally derives that
      * field from -march/-mabi, so reproduce the detected profile here rather
      * than letting the rv32 default (ilp32 soft-float) overwrite ilp32f/d.
      * The ISA matters for rv32 hardware ABIs because its conservative default
      * deliberately omits F/D; rv64's default already includes both. */
     if (o->target.arch == KIT_ARCH_RV32) {
       if (o->target.float_abi == KIT_FLOAT_ABI_SINGLE) {
         topts.isa = kit_slice_cstr("rv32imafc_zicsr_zifencei");
         topts.abi = kit_slice_cstr("ilp32f");
       } else if (o->target.float_abi == KIT_FLOAT_ABI_DOUBLE) {
         topts.isa = kit_slice_cstr("rv32imafdc_zicsr_zifencei");
         topts.abi = kit_slice_cstr("ilp32d");
       } else if (o->target.float_abi == KIT_FLOAT_ABI_SOFT) {
         topts.abi = kit_slice_cstr("ilp32");
       }
     } else if (o->target.arch == KIT_ARCH_RV64) {
       if (o->target.float_abi == KIT_FLOAT_ABI_SINGLE)
         topts.abi = kit_slice_cstr("lp64f");
       else if (o->target.float_abi == KIT_FLOAT_ABI_DOUBLE)
         topts.abi = kit_slice_cstr("lp64d");
       else if (o->target.float_abi == KIT_FLOAT_ABI_SOFT)
         topts.abi = kit_slice_cstr("lp64");
     }
     if (kit_target_new(&ctx, &topts, &target) != KIT_OK ||
         driver_compiler_new(target, &ctx, &compiler) != KIT_OK) {
       driver_errf(LD_TOOL, "failed to initialize compiler");
       goto out;
     }
   }
 
   if (script_lf.loaded) {
     KitSlice script_text = {.s = (const char*)script_lf.data.data,
                             .len = script_lf.data.size};
     if (kit_link_script_parse(&ctx, script_text, &script) != KIT_OK) {
       /* The parser reports a diagnostic via env.diag. */
       goto out;
     }
   }
 
   /* Translate the recorded link-item order into the engine's KitLinkInputOrder
    * list. ld records no compiled-source items, so the source args are NULL. */
   if (o->inputs.nlink_items) {
     order =
         driver_alloc_zeroed(o->env, o->inputs.nlink_items * sizeof(*order));
     if (!order) {
       driver_errf(LD_TOOL, "out of memory");
       goto out;
     }
   }
   norder = driver_link_inputs_build_order(&o->inputs, NULL, NULL, 0, order);
 
   if (o->lf.soname || o->lf.nrpaths || o->nrpath_links) {
     if (!o->shared) {
       driver_errf(LD_TOOL, "-soname/-rpath/-rpath-link require -shared");
       goto out;
     }
   }
 
   {
     KitLinkSessionOptions lopts;
     KitStatus st;
     KitSlice* rpath_slices = NULL;
     uint8_t output_kind = o->relocatable ? KIT_LINK_OUTPUT_RELOCATABLE
                           : o->shared    ? KIT_LINK_OUTPUT_SHARED
                                          : KIT_LINK_OUTPUT_EXE;
     /* The shared flag model fills entry/text-base/defsym/section-start/orphan/
      * fatal-warnings/build-id/gc/strip/pe-subsystem/interp/soname/rpath. It also
      * derives lopts.pie via driver_link_pie, but ld overrides that below. */
     if (driver_link_flags_fill_options(&o->lf, o->target, o->pie, o->shared,
                                        o->relocatable, output_kind, script,
                                        &lopts, &rpath_slices) != 0)
       goto out;
     /* GNU ld and lld default to a non-PIE ET_EXEC; PIE is opt-in via -pie. The
      * linker imposes no hosted-PIE default the way a compiler driver does (kit
      * cc still defaults hosted executables to PIE through the link API) — a
      * freestanding or static link has no dynamic loader to apply a PIE image's
      * relocations or choose its base, so a PIE default produces a binary that
      * faults under a direct/qemu loader (its writable segments sit below
      * mmap_min_addr at the vaddr-0 PIE base). -shared/-r never PIE. Callers that
      * want a hosted PIE executable pass -pie explicitly (as the musl dynamic
      * lane and real compiler drivers do); the hosted-libc dynamic lane forces
      * o->pie = 1 above. So override the shared driver_link_pie decision (which
      * would default hosted target.pic == KIT_PIC_PIE targets to PIE) back to
      * ld's policy. */
     lopts.pie = o->pie && !o->shared && !o->relocatable;
     /* Strict freestanding policy: a `*-none-*` (FREESTANDING) static non-PIE
      * executable must reject dynamic-link artifacts and cross-input
      * target/format mismatches. Only the EXE lane imposes it; -r/-shared do
      * not. --allow-undefined still relaxes undef references but not these
      * structural rejections. Set after fill_options, which derives lopts.pie. */
     if (lopts.output_kind == KIT_LINK_OUTPUT_EXE && !lopts.pie &&
         o->target.os == KIT_OS_FREESTANDING)
       lopts.freestanding_strict = true;
     (void)o->export_dynamic;
 
     st = kit_link_session_new(compiler, &lopts, &link);
     for (i = 0; i < norder && st == KIT_OK; ++i) {
       const KitLinkInputOrder* ord = &order[i];
       switch ((KitLinkInputOrderKind)ord->kind) {
         case KIT_LINK_INPUT_OBJ:
         case KIT_LINK_INPUT_OBJ_BYTES:
           st = kit_link_session_add_obj_bytes(
               link, kit_slice_cstr(o->inputs.object_files[ord->index]),
               &obj_in[ord->index]);
           break;
         case KIT_LINK_INPUT_ARCHIVE:
           st = kit_link_session_add_archive_bytes(link, &arch_in[ord->index]);
           break;
         case KIT_LINK_INPUT_DSO:
           st = kit_link_session_add_dso_bytes(
               link, kit_slice_cstr(o->inputs.dsos[ord->index].path),
               &dso_in[ord->index]);
           break;
       }
     }
     /* Parse and validate the complete input set before an output writer is
      * opened.  Apart from preserving the primary named-input diagnostic, this
      * means a malformed object/archive/DSO or a link-resolution failure cannot
      * create even a temporary output artifact. */
     if (st == KIT_OK) st = kit_link_session_resolve(link);
     if (st == KIT_OK &&
         io->open_writer(io->user, o->output_path, &writer) != KIT_OK) {
       driver_errf(LD_TOOL, "failed to open output: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(o->output_path)));
       st = KIT_IO;
     }
     if (st == KIT_OK) st = kit_link_session_emit(link, writer);
     if (st == KIT_OK) st = ld_write_link_report(o, io, link, o->lf.map_path, 0);
     if (st == KIT_OK)
       st = ld_write_link_report(o, io, link, o->lf.symbols_path, 1);
     if (st == KIT_OK) st = ld_write_cref(o, io, link);
     if (st == KIT_OK) st = ld_print_memory_usage(o, link);
     rc = st == KIT_OK ? 0 : 1;
     driver_link_flags_free_rpath_slices(&o->lf, rpath_slices);
   }
 
 out:
   if (writer) {
     if (rc != 0) driver_writer_abort(writer);
     kit_writer_close(writer);
   }
   kit_link_session_free(link);
   /* Match compiler/linker drivers: successful link outputs get executable
    * file modes while still respecting the process umask. Done after closing
    * the writer so the bits are stable on disk. */
   if (rc == 0 && o->output_path && !o->relocatable) {
     if (driver_mark_executable_output(o->output_path) != 0) {
       driver_errf(LD_TOOL, "failed to set executable mode: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(o->output_path)));
       rc = 1;
     }
   }
   if (script) kit_link_script_free(&ctx, script);
   if (compiler) driver_compiler_free(compiler);
   kit_target_free(target);
   driver_runtime_archive_fini(o->env, &rt_archive);
   if (runtime_resolved) driver_runtime_support_fini(o->env, &runtime);
   release_file(&script_lf);
   release_all(arch_lf, o->inputs.narchives);
   release_all(obj_lf, o->inputs.nobject_files);
   release_all(dso_lf, o->inputs.ndsos);
   if (arch_in)
     driver_free(o->env, arch_in, o->inputs.narchives * sizeof(*arch_in));
   if (arch_lf)
     driver_free(o->env, arch_lf, o->inputs.narchives * sizeof(*arch_lf));
   if (obj_in) driver_free(o->env, obj_in, o->argv_bound * sizeof(*obj_in));
   if (obj_lf) driver_free(o->env, obj_lf, o->argv_bound * sizeof(*obj_lf));
   if (dso_in) driver_free(o->env, dso_in, o->inputs.ndsos * sizeof(*dso_in));
   if (dso_lf) driver_free(o->env, dso_lf, o->inputs.ndsos * sizeof(*dso_lf));
   if (order)
     driver_free(o->env, order, o->inputs.nlink_items * sizeof(*order));
   return rc;
 }
 
 int driver_ld(int argc, char** argv) {
   DriverEnv env;
   LdOptions lo = {0};
   int rc;
 
   if (argc < 2 || driver_argv_wants_help(argc, argv, 1)) {
     driver_help_ld();
     return 0;
   }
 
   driver_env_init(&env);
   lo.env = &env;
   lo.driver_path = argv[0];
 
   if (ld_parse(argc, argv, &lo) != 0) {
     ld_options_release(&lo);
     driver_env_fini(&env);
     return 2;
   }
 
   rc = ld_run_link(&lo);
 
   ld_options_release(&lo);
   driver_env_fini(&env);
   return rc;
 }