kit

build.c (84376B)

---

 #include <kit/compile.h>
 #include <kit/core.h>
 #include <kit/link.h>
 #include <kit/preprocess.h>
 #include <stdint.h>
 #include <string.h>
 
 #include "archive_engine.h"
 #include "cflags.h"
 #include "compile_engine.h"
 #include "driver.h"
 #include "hosted.h"
 #include "lib_resolve.h"
 #include "link_engine.h"
 #include "link_flags.h"
 #include "runtime.h"
 
 /* `kit build-exe` / `build-lib` / `build-obj` — the kit-native build verbs.
  *
  * Each command is polyglot (C / asm / toy / wasm resolved per file), compiles
  * entirely in memory, and writes no intermediate files. They share one
  * parse+run parameterized by output kind:
  *
  *   build-exe   link an executable           (link session, OUTPUT_EXE)
  *   build-lib   static .a                    (archive of compiled objects;
  *                                             dynamic/shared not yet supported)
  *   build-obj   one object; or a relocatable  (compile each source / link
  *               combine of N sources; or       session, OUTPUT_RELOCATABLE)
  *               --emit=asm|c|ir; -fsyntax-only
  *
  * build-obj fully replaces the retired `compile` tool. Two flag tiers:
  *   - global / per-output flags apply to the whole build (target, -O/-g, link
  *     flags, output flags); they may appear anywhere outside a --group.
  *   - scopable flags (-I/-isystem/-D/-U, -x, -X<lang>) form a global baseline
  *     and may be overridden inside a `--group [flags] -- sources...` block.
  *
  * Per-language frontend flags route through `-X<lang> FLAG` (e.g.
  * `-Xwasm -mfeature=simd128`). */
 
 /* Stand-in for "no -x; resolve language from the path suffix at compile time."
  */
 #define BUILD_LANG_AUTO ((KitLanguage)KIT_LANG_COUNT)
 
 typedef enum BuildOutputKind {
   BUILD_OUT_EXE,
   BUILD_OUT_LIB,
   BUILD_OUT_OBJ,
 } BuildOutputKind;
 
 typedef enum BuildEmit {
   BUILD_EMIT_OBJ = 0,
   BUILD_EMIT_ASM,
   BUILD_EMIT_C,
   BUILD_EMIT_IR,
 } BuildEmit;
 
 typedef enum BuildLinkKind {
   BUILD_LINK_SOURCE,
   BUILD_LINK_OBJECT,
   BUILD_LINK_ARCHIVE,
   BUILD_LINK_DSO,
   BUILD_LINK_LIB,
 } BuildLinkKind;
 
 typedef struct BuildLinkItem {
   uint8_t kind; /* BuildLinkKind */
   uint8_t pad[3];
   uint32_t index;
 } BuildLinkItem;
 
 typedef struct BuildSource {
   const char* path; /* argv-borrowed */
   uint32_t group;   /* index into o->groups[]; 0 = global/bare baseline */
 } BuildSource;
 
 typedef struct BuildArchiveInput {
   const char* path;
   int owned;
   size_t owned_size;
   uint8_t whole_archive;
   uint8_t link_mode;
   uint8_t group_id;
   uint8_t pad;
 } BuildArchiveInput;
 
 typedef struct BuildDsoInput {
   const char* path;
   int owned;
   size_t owned_size;
 } BuildDsoInput;
 
 typedef struct BuildPendingLib {
   const char* name;
   uint8_t whole_archive;
   uint8_t link_mode;
   uint8_t group_id;
   uint8_t resolved_kind; /* BuildLinkKind: ARCHIVE or DSO */
   uint32_t resolved_index;
 } BuildPendingLib;
 
 /* One -X<lang> frontend flag token, scoped to a language. */
 typedef struct BuildFeFlag {
   uint8_t lang; /* KitLanguage */
   uint8_t pad[3];
   char* tok; /* argv-borrowed */
 } BuildFeFlag;
 
 /* A compile-flag scope: the global baseline (groups[0]) plus one entry per
  * `--group`. Each carries its own preprocessor delta, language override, and
  * per-language frontend flags. */
 typedef struct BuildGroup {
   DriverCflags cf;
   int cf_inited;
   KitLanguage forced_lang; /* BUILD_LANG_AUTO if -x not set */
   BuildFeFlag* fe;
   uint32_t nfe;
   /* Merged preprocessor view (group delta over the global baseline), filled
    * after parsing. For groups[0] this borrows cf directly; for real groups it
    * points at the m_* arrays below. */
   KitPreprocessOptions pp;
   const char** m_inc;
   uint32_t m_ninc;
   const char** m_sys;
   uint32_t m_nsys;
   KitDefine* m_def;
   uint32_t m_ndef;
   uint32_t
       m_def_cap; /* allocation size; m_ndef <= cap once globals are shadowed */
   KitSlice* m_und;
   uint32_t m_nund;
 } BuildGroup;
 
 typedef struct BuildOptions {
   DriverEnv* env;
   const char* tool;        /* "build-exe" | "build-lib" | "build-obj" */
   int kind;                /* BuildOutputKind */
   const char* driver_path; /* argv[0] */
   size_t argv_bound;
 
   /* Output / per-output state. */
   int emit; /* BuildEmit (build-obj) */
   int syntax_only;
   int opt_level;
   int debug_info;
   int dynamic;                /* -dynamic / -shared */
   int shared_requested;       /* -shared spelling, for build-exe diagnostics */
   int shared;                 /* computed: kind==lib && dynamic */
   int static_link;            /* -static */
   int pie;                    /* -pie */
   int function_sections;      /* -ffunction-sections */
   int data_sections;          /* -fdata-sections */
   int lto;                    /* -flto/-fno-lto */
   uint8_t default_visibility; /* KitSymVis */
   int warnings_are_errors;
   uint32_t max_errors;
   const char* output_path;
 
   KitTargetSpec target;
   DriverTargetFeatures target_features;
 
   /* Link-session options and owned -Wl state. */
   DriverLinkFlags link;
   uint64_t epoch;
 
   /* Hosted libc / sysroot state. */
   const char* sysroot;
   const char* support_dir;
   int freestanding;
   int nostdinc;
   int no_stdlib;
   int no_defaultlibs;
   int no_startfiles;
   int wants_hosted_libc;
   DriverHostedPlan hosted;
   char* owned_sysroot_lib_dir;
   size_t owned_sysroot_lib_dir_size;
 
   /* Sources + compile-flag scopes. */
   BuildSource* sources;
   uint32_t nsources;
   BuildGroup* groups;
   uint32_t ngroups;
   uint32_t cur_group; /* scope for newly seen sources */
 
   /* Link inputs (build-exe). */
   const char** object_files;
   uint32_t nobject_files;
   BuildArchiveInput* archives;
   uint32_t narchives;
   BuildDsoInput* dsos;
   uint32_t ndsos;
   const char** lib_search_paths;
   uint32_t nlib_search_paths;
   BuildPendingLib* pending_libs;
   uint32_t npending_libs;
   BuildLinkItem* link_items;
   uint32_t nlink_items;
   uint8_t cur_whole_archive;
   uint8_t cur_link_mode;
   uint8_t cur_group_id;
 } BuildOptions;
 
 /* ===================================================================== */
 /* small parse helpers                                                    */
 /* ===================================================================== */
 
 static int build_parse_u64(const char* s, uint64_t* out) {
   uint64_t v = 0;
   int any = 0;
   if (!s) return 1;
   while (*s) {
     unsigned d;
     if (*s < '0' || *s > '9') return 1;
     d = (unsigned)(*s - '0');
     if (v > (UINT64_MAX - d) / 10u) return 1;
     v = v * 10u + d;
     any = 1;
     s++;
   }
   if (!any) return 1;
   *out = v;
   return 0;
 }
 
 static int build_record_mcmodel(BuildOptions* o, const char* val) {
   if (driver_streq(val, "small") || driver_streq(val, "medlow")) {
     o->target.code_model = KIT_CM_SMALL;
     return 0;
   }
   if (driver_streq(val, "medium") || driver_streq(val, "medany")) {
     o->target.code_model = KIT_CM_MEDIUM;
     return 0;
   }
   if (driver_streq(val, "large")) {
     o->target.code_model = KIT_CM_LARGE;
     return 0;
   }
   driver_errf(o->tool, "unknown -mcmodel value: %.*s",
               KIT_SLICE_ARG(kit_slice_cstr(val)));
   return 1;
 }
 
 static int build_lang_from_name(const char* name, KitLanguage* out) {
   /* Resolve off the compile-time default frontend set (no compiler exists at
    * arg-parse time). Value-equivalent to the former explicit map:
    * c->C, asm/s->ASM, toy->TOY, wasm/wat->WASM. */
   KitLanguage lang = kit_language_for_name(NULL, name);
   if (lang == KIT_LANG_UNKNOWN) return 1;
   *out = lang;
   return 0;
 }
 
 /* ===================================================================== */
 /* allocation / lifetime                                                  */
 /* ===================================================================== */
 
 static int build_group_cf_init(BuildOptions* o, BuildGroup* g) {
   if (g->cf_inited) return 0;
   if (driver_cflags_init(&g->cf, o->env,
                          (int)(o->argv_bound + DRIVER_HOSTED_MAX_DEFINES +
                                DRIVER_HOSTED_MAX_INCLUDES)) != 0)
     return 1;
   g->cf_inited = 1;
   g->forced_lang = BUILD_LANG_AUTO;
   g->fe = driver_alloc_zeroed(o->env, o->argv_bound * sizeof(*g->fe));
   return g->fe ? 0 : 1;
 }
 
 static int build_alloc(BuildOptions* o, int argc) {
   size_t bound = (size_t)argc + 16u;
   o->argv_bound = bound;
   o->sources = driver_alloc_zeroed(o->env, bound * sizeof(*o->sources));
   o->groups = driver_alloc_zeroed(o->env, bound * sizeof(*o->groups));
   o->object_files =
       driver_alloc_zeroed(o->env, bound * sizeof(*o->object_files));
   o->archives = driver_alloc_zeroed(o->env, bound * sizeof(*o->archives));
   o->dsos = driver_alloc_zeroed(o->env, bound * sizeof(*o->dsos));
   o->lib_search_paths =
       driver_alloc_zeroed(o->env, bound * sizeof(*o->lib_search_paths));
   o->pending_libs =
       driver_alloc_zeroed(o->env, bound * sizeof(*o->pending_libs));
   o->link_items = driver_alloc_zeroed(o->env, bound * sizeof(*o->link_items));
   if (!o->sources || !o->groups || !o->object_files || !o->archives ||
       !o->dsos || !o->lib_search_paths || !o->pending_libs || !o->link_items) {
     driver_errf(o->tool, "out of memory");
     return 1;
   }
   o->cur_link_mode = KIT_LM_DEFAULT;
   /* groups[0] is the global / bare baseline. */
   o->ngroups = 1;
   if (driver_link_flags_init(&o->link, o->env, o->tool, (uint32_t)bound) != 0 ||
       build_group_cf_init(o, &o->groups[0]) != 0 ||
       driver_target_features_init(&o->target_features, o->env, argc) != 0) {
     driver_errf(o->tool, "out of memory");
     return 1;
   }
   return 0;
 }
 
 static void build_release(BuildOptions* o) {
   uint32_t i;
   size_t bound = o->argv_bound;
   for (i = 0; i < o->narchives; ++i)
     if (o->archives[i].owned)
       driver_free(o->env, (void*)o->archives[i].path,
                   o->archives[i].owned_size);
   for (i = 0; i < o->ndsos; ++i)
     if (o->dsos[i].owned)
       driver_free(o->env, (void*)o->dsos[i].path, o->dsos[i].owned_size);
   for (i = 0; i < o->ngroups; ++i) {
     BuildGroup* g = &o->groups[i];
     if (g->cf_inited) driver_cflags_fini(&g->cf, o->env);
     if (g->fe) driver_free(o->env, g->fe, bound * sizeof(*g->fe));
     if (g->m_inc) driver_free(o->env, g->m_inc, g->m_ninc * sizeof(*g->m_inc));
     if (g->m_sys) driver_free(o->env, g->m_sys, g->m_nsys * sizeof(*g->m_sys));
     if (g->m_def)
       driver_free(o->env, g->m_def, g->m_def_cap * sizeof(*g->m_def));
     if (g->m_und) driver_free(o->env, g->m_und, g->m_nund * sizeof(*g->m_und));
   }
   if (o->owned_sysroot_lib_dir)
     driver_free(o->env, o->owned_sysroot_lib_dir,
                 o->owned_sysroot_lib_dir_size);
   driver_hosted_plan_fini(o->env, &o->hosted);
   driver_link_flags_fini(&o->link);
   driver_target_features_fini(&o->target_features, o->env);
   if (o->sources) driver_free(o->env, o->sources, bound * sizeof(*o->sources));
   if (o->groups) driver_free(o->env, o->groups, bound * sizeof(*o->groups));
   if (o->object_files)
     driver_free(o->env, o->object_files, bound * sizeof(*o->object_files));
   if (o->archives)
     driver_free(o->env, o->archives, bound * sizeof(*o->archives));
   if (o->dsos) driver_free(o->env, o->dsos, bound * sizeof(*o->dsos));
   if (o->lib_search_paths)
     driver_free(o->env, o->lib_search_paths,
                 bound * sizeof(*o->lib_search_paths));
   if (o->pending_libs)
     driver_free(o->env, o->pending_libs, bound * sizeof(*o->pending_libs));
   if (o->link_items)
     driver_free(o->env, o->link_items, bound * sizeof(*o->link_items));
 }
 
 /* ===================================================================== */
 /* link-item bookkeeping (build-exe)                                      */
 /* ===================================================================== */
 
 static void build_push_link_item(BuildOptions* o, uint8_t kind,
                                  uint32_t index) {
   BuildLinkItem* it = &o->link_items[o->nlink_items++];
   it->kind = kind;
   it->index = index;
 }
 
 static void build_insert_link_item(BuildOptions* o, uint32_t pos, uint8_t kind,
                                    uint32_t index) {
   uint32_t i;
   if (pos > o->nlink_items) pos = o->nlink_items;
   for (i = o->nlink_items; i > pos; --i)
     o->link_items[i] = o->link_items[i - 1u];
   o->link_items[pos].kind = kind;
   o->link_items[pos].index = index;
   o->nlink_items++;
 }
 
 static int build_append_hosted_input(BuildOptions* o,
                                      const DriverHostedInput* in,
                                      uint32_t insert_pos, int insert) {
   uint32_t index;
   uint8_t kind;
   switch ((DriverHostedInputKind)in->kind) {
     case DRIVER_HOSTED_INPUT_OBJECT:
       index = o->nobject_files++;
       o->object_files[index] = in->path;
       kind = BUILD_LINK_OBJECT;
       break;
     case DRIVER_HOSTED_INPUT_ARCHIVE: {
       BuildArchiveInput* ar = &o->archives[o->narchives++];
       ar->path = in->path;
       ar->link_mode = KIT_LM_DEFAULT;
       index = o->narchives - 1u;
       kind = BUILD_LINK_ARCHIVE;
       break;
     }
     case DRIVER_HOSTED_INPUT_DSO: {
       BuildDsoInput* d = &o->dsos[o->ndsos++];
       d->path = in->path;
       index = o->ndsos - 1u;
       kind = BUILD_LINK_DSO;
       break;
     }
     default:
       driver_errf(o->tool, "internal error: unknown hosted input kind");
       return 1;
   }
   if (insert)
     build_insert_link_item(o, insert_pos, kind, index);
   else
     build_push_link_item(o, kind, index);
   return 0;
 }
 
 static void build_insert_runtime_archive(BuildOptions* o,
                                          DriverRuntimeArchive* rt,
                                          uint32_t insert_pos) {
   BuildArchiveInput* ar = &o->archives[o->narchives++];
   ar->path = rt->path;
   ar->owned = 1;
   ar->owned_size = rt->path_size;
   ar->whole_archive = rt->whole_archive;
   ar->link_mode = rt->link_mode;
   ar->group_id = rt->group_id;
   rt->path = NULL;
   rt->path_size = 0;
   build_insert_link_item(o, insert_pos, BUILD_LINK_ARCHIVE, o->narchives - 1u);
 }
 
 /* ===================================================================== */
 /* positional classification                                              */
 /* ===================================================================== */
 
 /* Routed through the shared driver_path_is_source authority (canonical
  * extension registry, headers excluded), so adding a frontend extension reaches
  * cc/build/run/dbg at once. build still treats .h as a header, not a source —
  * the helper excludes it. */
 static int build_is_source(const char* s) { return driver_path_is_source(s); }
 
 static int build_is_dso(const char* s) {
   return driver_has_suffix(s, ".so") || driver_has_suffix(s, ".dylib") ||
          driver_has_suffix(s, ".tbd");
 }
 
 /* The language forced (via -x) for sources in group `gi`: the group's own -x,
  * else the global baseline's, else -1 (resolve by suffix). */
 static int build_scope_forced_lang(const BuildOptions* o, uint32_t gi) {
   if (gi != 0 && o->groups[gi].forced_lang != BUILD_LANG_AUTO)
     return (int)o->groups[gi].forced_lang;
   if (o->groups[0].forced_lang != BUILD_LANG_AUTO)
     return (int)o->groups[0].forced_lang;
   return -1;
 }
 
 static int build_classify_positional(BuildOptions* o, const char* a) {
   if (driver_streq(a, "-")) {
     driver_errf(o->tool, "stdin ('-') is not supported; pass a source file");
     return 1;
   }
   /* Explicit link-input suffixes are always link inputs — never reinterpreted
    * as sources, even when -x forces a language. */
   if (driver_has_suffix(a, ".o") || driver_has_suffix(a, ".obj")) {
     o->object_files[o->nobject_files++] = a;
     build_push_link_item(o, BUILD_LINK_OBJECT, o->nobject_files - 1u);
     return 0;
   }
   if (driver_has_suffix(a, ".a")) {
     BuildArchiveInput* ar = &o->archives[o->narchives++];
     ar->path = a;
     ar->whole_archive = o->cur_whole_archive;
     ar->link_mode = o->cur_link_mode;
     ar->group_id = o->cur_group_id;
     build_push_link_item(o, BUILD_LINK_ARCHIVE, o->narchives - 1u);
     return 0;
   }
   if (build_is_dso(a)) {
     BuildDsoInput* d = &o->dsos[o->ndsos++];
     d->path = a;
     build_push_link_item(o, BUILD_LINK_DSO, o->ndsos - 1u);
     return 0;
   }
   /* Otherwise a source: a recognized source suffix, or any file at all when a
    * language is forced in scope (so `-x toy mykernel` compiles an extensionless
    * or odd-suffix file). */
   if (build_is_source(a) || build_scope_forced_lang(o, o->cur_group) >= 0) {
     BuildSource* s = &o->sources[o->nsources];
     s->path = a;
     s->group = o->cur_group;
     build_push_link_item(o, BUILD_LINK_SOURCE, o->nsources);
     o->nsources++;
     return 0;
   }
   driver_errf(o->tool,
               "input does not have a recognized suffix: %.*s (use -x LANG)",
               KIT_SLICE_ARG(kit_slice_cstr(a)));
   return 1;
 }
 
 /* ===================================================================== */
 /* scopable-flag parsing (shared by global context and --group blocks)    */
 /* ===================================================================== */
 
 /* Try to consume a scopable flag (-I/-isystem/-D/-U, -x, -X<lang>) at argv[*i]
  * into group `g`. Returns 1 consumed, 0 not a scopable flag, -1 on error. */
 static int build_try_scopable(BuildOptions* o, BuildGroup* g, int argc,
                               char** argv, int* i) {
   const char* a = argv[*i];
   int r = driver_cflags_try_consume(&g->cf, o->env, o->tool, argc, argv, i);
   if (r != 0) return r;
 
   if (driver_streq(a, "-x")) {
     KitLanguage lang;
     if (++(*i) >= argc) {
       driver_errf(o->tool, "-x requires an argument");
       return -1;
     }
     if (driver_streq(argv[*i], "--")) {
       driver_errf(o->tool, "-x requires an argument before `--`");
       return -1;
     }
     if (build_lang_from_name(argv[*i], &lang) != 0) {
       driver_errf(o->tool, "unsupported -x language: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(argv[*i])));
       return -1;
     }
     g->forced_lang = lang;
     return 1;
   }
   if (driver_strneq(a, "-X", 2) && a[2] != '\0') {
     KitLanguage lang;
     BuildFeFlag* f;
     if (build_lang_from_name(a + 2, &lang) != 0) {
       driver_errf(o->tool, "unsupported -X language: %.*s (use c|asm|toy|wasm)",
                   KIT_SLICE_ARG(kit_slice_cstr(a + 2)));
       return -1;
     }
     if (++(*i) >= argc) {
       driver_errf(o->tool, "%.*s requires a following flag",
                   KIT_SLICE_ARG(kit_slice_cstr(a)));
       return -1;
     }
     if (driver_streq(argv[*i], "--")) {
       driver_errf(o->tool, "%.*s requires a following flag before `--`",
                   KIT_SLICE_ARG(kit_slice_cstr(a)));
       return -1;
     }
     f = &g->fe[g->nfe++];
     f->lang = (uint8_t)lang;
     f->tok = argv[*i];
     return 1;
   }
   return 0;
 }
 
 /* Recognize the global / per-output flags, so a --group block can flag them as
  * misplaced with a pointed diagnostic. */
 static int build_is_global_flag(const char* a) {
   return driver_streq(a, "-o") || driver_strneq(a, "--output", 8) ||
          driver_strneq(a, "-O", 2) || driver_streq(a, "-g") ||
          driver_streq(a, "-S") || driver_strneq(a, "--emit=", 7) ||
          driver_streq(a, "-fsyntax-only") || driver_strneq(a, "-fPIC", 5) ||
          driver_strneq(a, "-fpic", 5) || driver_strneq(a, "-fPIE", 5) ||
          driver_strneq(a, "-fpie", 5) ||
          driver_strneq(a, "-fvisibility=", 13) ||
          driver_streq(a, "-ffunction-sections") ||
          driver_streq(a, "-fdata-sections") || driver_streq(a, "-flto") ||
          driver_streq(a, "-fno-lto") || driver_streq(a, "-static") ||
          driver_streq(a, "-dynamic") || driver_streq(a, "-shared") ||
          driver_streq(a, "-pie") || driver_streq(a, "-no-pie") ||
          driver_streq(a, "-target") || driver_strneq(a, "--target", 8) ||
          driver_strneq(a, "-l", 2) || driver_strneq(a, "-L", 2) ||
          driver_streq(a, "-e") || driver_streq(a, "-T") ||
          driver_strneq(a, "-Wl,", 4) || driver_strneq(a, "--build-id", 10) ||
          driver_streq(a, "-Werror") || driver_strneq(a, "-fmax-errors=", 13) ||
          driver_strneq(a, "-m", 2);
 }
 
 /* ===================================================================== */
 /* main parser                                                            */
 /* ===================================================================== */
 
 static int build_parse_group(BuildOptions* o, int argc, char** argv, int* i) {
   BuildGroup* g;
   uint32_t gid = o->ngroups++;
   g = &o->groups[gid];
   if (build_group_cf_init(o, g) != 0) {
     driver_errf(o->tool, "out of memory");
     return 1;
   }
   ++(*i); /* past --group */
   /* scopable flag section, terminated by `--` */
   for (; *i < argc && !driver_streq(argv[*i], "--"); ++(*i)) {
     int r = build_try_scopable(o, g, argc, argv, i);
     if (r < 0) return 1;
     if (r > 0) continue;
     if (build_is_global_flag(argv[*i])) {
       driver_errf(o->tool,
                   "%.*s is a per-output flag; place it before any --group",
                   KIT_SLICE_ARG(kit_slice_cstr(argv[*i])));
       return 1;
     }
     driver_errf(o->tool, "unsupported flag in --group: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(argv[*i])));
     return 1;
   }
   if (*i >= argc) {
     driver_errf(o->tool, "--group requires `--` before its sources");
     return 1;
   }
   ++(*i);             /* past `--` */
   o->cur_group = gid; /* subsequent sources belong to this group */
   return 0;
 }
 
 static int build_parse(int argc, char** argv, BuildOptions* o) {
   int i;
   o->target = driver_host_target();
 
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
 
     if (driver_streq(a, "--group")) {
       if (build_parse_group(o, argc, argv, &i) != 0) return 1;
       --i; /* parse_group leaves i at the next token; loop's ++i re-reads it */
       continue;
     }
 
     /* Scopable flags in the global context feed the baseline (groups[0]). */
     {
       int r = build_try_scopable(o, &o->groups[0], argc, argv, &i);
       if (r < 0) return 1;
       if (r > 0) continue;
     }
 
     /* Output form. */
     if (driver_streq(a, "-c")) {
       o->emit = BUILD_EMIT_OBJ;
       continue;
     }
     if (driver_streq(a, "-S") || driver_streq(a, "--emit=asm")) {
       o->emit = BUILD_EMIT_ASM;
       continue;
     }
     if (driver_streq(a, "--emit=obj")) {
       o->emit = BUILD_EMIT_OBJ;
       continue;
     }
     if (driver_streq(a, "--emit=c")) {
       o->emit = BUILD_EMIT_C;
       continue;
     }
     if (driver_streq(a, "--emit=ir")) {
       o->emit = BUILD_EMIT_IR;
       continue;
     }
     if (driver_streq(a, "-fsyntax-only")) {
       o->syntax_only = 1;
       continue;
     }
     if (driver_streq(a, "-o")) {
       if (++i >= argc) {
         driver_errf(o->tool, "-o requires an argument");
         return 1;
       }
       o->output_path = argv[i];
       continue;
     }
     if (driver_strneq(a, "-o", 2)) {
       o->output_path = a + 2;
       continue;
     }
     if (driver_strneq(a, "--output=", 9)) {
       o->output_path = a + 9;
       continue;
     }
     if (driver_streq(a, "--output")) {
       if (++i >= argc) {
         driver_errf(o->tool, "--output requires an argument");
         return 1;
       }
       o->output_path = argv[i];
       continue;
     }
 
     /* Optimization / debug / codegen knobs. */
     if (driver_streq(a, "-g")) {
       o->debug_info = 1;
       continue;
     }
     if (driver_streq(a, "-O0")) {
       o->opt_level = 0;
       continue;
     }
     if (driver_streq(a, "-O1")) {
       o->opt_level = 1;
       continue;
     }
     if (driver_streq(a, "-O2") || driver_streq(a, "-O") ||
         driver_streq(a, "-O3") || driver_streq(a, "-Os") ||
         driver_streq(a, "-Oz") || driver_streq(a, "-Ofast")) {
       o->opt_level = 2;
       continue;
     }
     if (driver_streq(a, "-Werror") || driver_strneq(a, "-Werror=", 8)) {
       o->warnings_are_errors = 1;
       continue;
     }
     if (driver_strneq(a, "-fmax-errors=", 13)) {
       uint64_t v;
       if (build_parse_u64(a + 13, &v) != 0 || v > 0xFFFFFFFFu) {
         driver_errf(o->tool, "-fmax-errors= requires a non-negative integer");
         return 1;
       }
       o->max_errors = (uint32_t)v;
       continue;
     }
     if (driver_streq(a, "-fPIC") || driver_streq(a, "-fpic")) {
       o->target.pic = KIT_PIC_PIC;
       continue;
     }
     if (driver_streq(a, "-fPIE") || driver_streq(a, "-fpie")) {
       o->target.pic = KIT_PIC_PIE;
       continue;
     }
     if (driver_streq(a, "-fno-PIC") || driver_streq(a, "-fno-pic") ||
         driver_streq(a, "-fno-PIE") || driver_streq(a, "-fno-pie")) {
       o->target.pic = KIT_PIC_NONE;
       continue;
     }
     if (driver_streq(a, "-fvisibility=hidden")) {
       o->default_visibility = KIT_SV_HIDDEN;
       continue;
     }
     if (driver_streq(a, "-fvisibility=default")) {
       o->default_visibility = KIT_SV_DEFAULT;
       continue;
     }
     if (driver_strneq(a, "-fvisibility=", 13)) {
       driver_errf(o->tool, "unsupported visibility: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(a + 13)));
       return 1;
     }
     if (driver_streq(a, "-ffunction-sections")) {
       o->function_sections = 1;
       continue;
     }
     if (driver_streq(a, "-fno-function-sections")) {
       o->function_sections = 0;
       continue;
     }
     if (driver_streq(a, "-fdata-sections")) {
       o->data_sections = 1;
       continue;
     }
     if (driver_streq(a, "-fno-data-sections")) {
       o->data_sections = 0;
       continue;
     }
     if (driver_streq(a, "-flto")) {
       o->lto = 1;
       continue;
     }
     if (driver_streq(a, "-fno-lto")) {
       o->lto = 0;
       continue;
     }
     if (driver_streq(a, "-ffreestanding")) {
       o->freestanding = 1;
       continue;
     }
     if (driver_streq(a, "-fhosted")) {
       o->freestanding = 0;
       continue;
     }
     if (driver_streq(a, "-nostdinc")) {
       o->nostdinc = 1;
       continue;
     }
     if (driver_streq(a, "-nostdlib")) {
       o->no_stdlib = 1;
       continue;
     }
     if (driver_streq(a, "-nodefaultlibs")) {
       o->no_defaultlibs = 1;
       continue;
     }
     if (driver_streq(a, "-nostartfiles")) {
       o->no_startfiles = 1;
       continue;
     }
 
     /* Link kind. */
     if (driver_streq(a, "-static")) {
       o->static_link = 1;
       o->target.pic = KIT_PIC_NONE;
       o->cur_link_mode = KIT_LM_STATIC;
       continue;
     }
     if (driver_streq(a, "-dynamic")) {
       o->dynamic = 1;
       continue;
     }
     if (driver_streq(a, "-shared")) {
       o->dynamic = 1;
       o->shared_requested = 1;
       continue;
     }
     if (driver_streq(a, "-pie")) {
       o->target.pic = KIT_PIC_PIE;
       o->pie = 1;
       continue;
     }
     if (driver_streq(a, "-no-pie")) {
       o->target.pic = KIT_PIC_NONE;
       o->pie = 0;
       continue;
     }
 
     /* Link inputs / flags. */
     if (driver_strneq(a, "-L", 2)) {
       const char* dir = a[2] ? a + 2 : (++i < argc ? argv[i] : NULL);
       if (!dir) {
         driver_errf(o->tool, "-L requires an argument");
         return 1;
       }
       o->lib_search_paths[o->nlib_search_paths++] = dir;
       continue;
     }
     if (driver_strneq(a, "-l", 2)) {
       const char* name = a[2] ? a + 2 : (++i < argc ? argv[i] : NULL);
       if (!name) {
         driver_errf(o->tool, "-l requires an argument");
         return 1;
       }
       if (driver_streq(name, "c") && !o->no_stdlib && !o->no_defaultlibs) {
         o->wants_hosted_libc = 1;
         continue;
       }
       {
         BuildPendingLib* pl = &o->pending_libs[o->npending_libs++];
         pl->name = name;
         pl->whole_archive = o->cur_whole_archive;
         pl->link_mode = o->cur_link_mode;
         pl->group_id = o->cur_group_id;
         build_push_link_item(o, BUILD_LINK_LIB, o->npending_libs - 1u);
       }
       continue;
     }
     if (driver_streq(a, "-e")) {
       if (++i >= argc) {
         driver_errf(o->tool, "-e requires an argument");
         return 1;
       }
       o->link.entry = argv[i];
       continue;
     }
     if (driver_streq(a, "-T")) {
       if (++i >= argc) {
         driver_errf(o->tool, "-T requires an argument");
         return 1;
       }
       o->link.linker_script = argv[i];
       continue;
     }
     if (driver_strneq(a, "-Wl,", 4)) {
       if (driver_link_flags_record_wl(&o->link, a + 4) != 0) return 1;
       continue;
     }
     if (driver_streq(a, "-Xlinker")) {
       if (++i >= argc) {
         driver_errf(o->tool, "-Xlinker requires an argument");
         return 1;
       }
       if (driver_link_flags_record_wl(&o->link, argv[i]) != 0) return 1;
       continue;
     }
     if (driver_strneq(a, "--build-id=", 11)) {
       if (driver_link_flags_record_build_id(&o->link, a + 11) != 0) return 1;
       continue;
     }
     if (driver_streq(a, "-mwindows")) {
       o->link.pe_subsystem = KIT_PE_SUBSYSTEM_WINDOWS_GUI;
       continue;
     }
     if (driver_streq(a, "-mconsole")) {
       o->link.pe_subsystem = KIT_PE_SUBSYSTEM_WINDOWS_CUI;
       continue;
     }
     if (driver_strneq(a, "-mcmodel=", 9)) {
       if (build_record_mcmodel(o, a + 9) != 0) return 1;
       continue;
     }
 
     /* Target. */
     if (driver_streq(a, "-target") || driver_streq(a, "--target")) {
       if (++i >= argc) {
         driver_errf(o->tool, "%.*s requires an argument",
                     KIT_SLICE_ARG(kit_slice_cstr(a)));
         return 1;
       }
       if (driver_target_from_triple(argv[i], &o->target) != 0) {
         driver_errf(o->tool, "unrecognized target triple: %.*s",
                     KIT_SLICE_ARG(kit_slice_cstr(argv[i])));
         return 1;
       }
       continue;
     }
     if (driver_strneq(a, "--target=", 9)) {
       if (driver_target_from_triple(a + 9, &o->target) != 0) {
         driver_errf(o->tool, "unrecognized target triple: %.*s",
                     KIT_SLICE_ARG(kit_slice_cstr(a + 9)));
         return 1;
       }
       continue;
     }
     {
       int tr = driver_target_features_try_consume(&o->target_features, o->env,
                                                   o->tool, argc, argv, &i);
       if (tr < 0) return 1;
       if (tr > 0) continue;
     }
 
     /* Support dir / sysroot. */
     if (driver_streq(a, "-isysroot") || driver_streq(a, "--sysroot")) {
       if (++i >= argc) {
         driver_errf(o->tool, "%.*s requires an argument",
                     KIT_SLICE_ARG(kit_slice_cstr(a)));
         return 1;
       }
       o->sysroot = argv[i];
       continue;
     }
     if (driver_strneq(a, "--sysroot=", 10)) {
       o->sysroot = a + 10;
       continue;
     }
     if (driver_streq(a, "--support-dir")) {
       if (++i >= argc) {
         driver_errf(o->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;
     }
 
     if (driver_streq(a, "--")) {
       for (++i; i < argc; ++i)
         if (build_classify_positional(o, argv[i]) != 0) return 1;
       break;
     }
     if (a[0] == '-' && a[1] != '\0') {
       driver_errf(o->tool, "unknown flag: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(a)));
       return 1;
     }
     if (build_classify_positional(o, a) != 0) return 1;
   }
   return 0;
 }
 
 /* ===================================================================== */
 /* hosted libc / runtime orchestration (build-exe; shared build-lib)      */
 /* ===================================================================== */
 
 static int build_is_link_output(const BuildOptions* o) {
   if (o->kind == BUILD_OUT_EXE && o->target.obj == KIT_OBJ_WASM) return 0;
   return o->kind == BUILD_OUT_EXE || (o->kind == BUILD_OUT_LIB && o->dynamic);
 }
 
 static int build_resolve_pending_libs(BuildOptions* o) {
   uint32_t i;
   for (i = 0; i < o->npending_libs; ++i) {
     BuildPendingLib* pl = &o->pending_libs[i];
     char* p;
     size_t sz;
     LibResolveKind kind;
     LibResolveMode mode = (o->static_link || pl->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 (driver_lib_resolve_for_os(o->env, pl->name, mode, resolve_os,
                                   o->lib_search_paths, o->nlib_search_paths, &p,
                                   &sz, &kind) != 0) {
       driver_errf(o->tool, "library not found: -l%.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(pl->name)));
       return 1;
     }
     if (kind == LIB_RESOLVE_KIND_SHARED || kind == LIB_RESOLVE_KIND_TBD) {
       BuildDsoInput* d = &o->dsos[o->ndsos++];
       d->path = p;
       d->owned = 1;
       d->owned_size = sz;
       pl->resolved_kind = BUILD_LINK_DSO;
       pl->resolved_index = o->ndsos - 1u;
     } else {
       BuildArchiveInput* ar = &o->archives[o->narchives++];
       ar->path = p;
       ar->owned = 1;
       ar->owned_size = sz;
       ar->whole_archive = pl->whole_archive;
       ar->link_mode = pl->link_mode;
       ar->group_id = pl->group_id;
       pl->resolved_kind = BUILD_LINK_ARCHIVE;
       pl->resolved_index = o->narchives - 1u;
     }
   }
   return 0;
 }
 
 /* A sysroot on its own engages the hosted libc profile (matching clang/gcc).
  * -ffreestanding / -nostdinc / -nostdlib opt back out; -dynamic (shared) keeps
  * its standalone meaning. */
 static void build_enable_hosted_for_sysroot(BuildOptions* o) {
   if (o->wants_hosted_libc || o->shared) return;
   if (!o->sysroot || !o->sysroot[0]) return;
   if (o->freestanding || o->nostdinc) return;
   if (o->no_stdlib || o->no_defaultlibs) return;
   o->wants_hosted_libc = 1;
 }
 
 static void build_apply_default_hosted_profile(BuildOptions* o) {
   if (!driver_target_default_hosted_profile(o->target)) return;
   if (o->no_stdlib || o->no_defaultlibs || o->wants_hosted_libc) return;
   if (!o->sysroot || !o->sysroot[0]) return;
   o->wants_hosted_libc = 1;
 }
 
 static int build_apply_hosted_profile(BuildOptions* o) {
   DriverHostedRequest req;
   uint32_t i;
   uint32_t insert_pos = 0;
   if (!o->wants_hosted_libc || o->shared) return 0;
   if (o->no_stdlib || o->no_defaultlibs) {
     driver_errf(o->tool,
                 "-lc hosted expansion is disabled by -nostdlib/-nodefaultlibs");
     return 1;
   }
   {
     DriverHostedRequest z = {0};
     req = z;
   }
   req.env = o->env;
   req.tool = o->tool;
   req.target = o->target;
   req.sysroot = o->sysroot;
   req.static_link = o->static_link;
   req.link_inputs = 1;
   if (driver_hosted_resolve(&req, &o->hosted) != 0) return 1;
   for (i = 0; i < o->hosted.nsystem_includes; ++i)
     o->groups[0]
         .cf.system_include_dirs[o->groups[0].cf.nsystem_include_dirs++] =
         o->hosted.system_includes[i];
   for (i = 0; i < o->hosted.ndefines; ++i)
     o->groups[0].cf.defines[o->groups[0].cf.ndefines++] = o->hosted.defines[i];
   for (i = 0; i < o->hosted.nbefore; ++i) {
     if (o->no_startfiles) break;
     if (build_append_hosted_input(o, &o->hosted.before[i], insert_pos, 1) != 0)
       return 1;
     insert_pos++;
   }
   for (i = 0; i < o->hosted.nafter; ++i)
     if (build_append_hosted_input(o, &o->hosted.after[i], 0, 0) != 0) return 1;
   for (i = 0; i < o->hosted.nfinal; ++i) {
     if (o->no_startfiles) break;
     if (build_append_hosted_input(o, &o->hosted.final[i], 0, 0) != 0) return 1;
   }
   if (!o->link.interp_path && o->hosted.interp_path)
     o->link.interp_path = o->hosted.interp_path;
   return 0;
 }
 
 /* Append `<sysroot>/lib` to the search path for Windows targets (mirrors cc).
  */
 static int build_append_windows_lib_dirs(BuildOptions* o) {
   const char* sysroot = o->sysroot;
   char* joined;
   size_t srlen, need_slash, bytes, off = 0;
   if (!driver_target_needs_sysroot_libdir(o->target)) return 0;
   if (!sysroot || !sysroot[0]) {
     sysroot = driver_getenv("KIT_SYSROOT");
     if (!sysroot || !sysroot[0]) return 0;
     o->sysroot = sysroot;
   }
   srlen = driver_strlen(sysroot);
   need_slash = (srlen > 0 && sysroot[srlen - 1] != '/') ? 1u : 0u;
   bytes = srlen + need_slash + 3u + 1u;
   joined = driver_alloc(o->env, bytes);
   if (!joined) {
     driver_errf(o->tool, "out of memory");
     return 1;
   }
   driver_memcpy(joined + off, sysroot, srlen);
   off += srlen;
   if (need_slash) joined[off++] = '/';
   driver_memcpy(joined + off, "lib", 3);
   off += 3;
   joined[off] = '\0';
   o->owned_sysroot_lib_dir = joined;
   o->owned_sysroot_lib_dir_size = bytes;
   o->lib_search_paths[o->nlib_search_paths++] = joined;
   return 0;
 }
 
 /* ===================================================================== */
 /* merged preprocessor view per group                                     */
 /* ===================================================================== */
 
 static int build_group_build_pp(BuildOptions* o, uint32_t gi) {
   BuildGroup* g = &o->groups[gi];
   BuildGroup* gl = &o->groups[0];
   uint32_t k;
   if (gi == 0) {
     driver_cflags_fill_pp(&gl->cf, &g->pp);
     return 0;
   }
   /* include = group then global (group searched first). */
   g->m_ninc = g->cf.ninclude_dirs + gl->cf.ninclude_dirs;
   g->m_nsys = g->cf.nsystem_include_dirs + gl->cf.nsystem_include_dirs;
   g->m_def_cap = gl->cf.ndefines + g->cf.ndefines;
   g->m_nund = gl->cf.nundefines + g->cf.nundefines;
   if (g->m_ninc)
     g->m_inc = driver_alloc_zeroed(o->env, g->m_ninc * sizeof(*g->m_inc));
   if (g->m_nsys)
     g->m_sys = driver_alloc_zeroed(o->env, g->m_nsys * sizeof(*g->m_sys));
   if (g->m_def_cap)
     g->m_def = driver_alloc_zeroed(o->env, g->m_def_cap * sizeof(*g->m_def));
   if (g->m_nund)
     g->m_und = driver_alloc_zeroed(o->env, g->m_nund * sizeof(*g->m_und));
   if ((g->m_ninc && !g->m_inc) || (g->m_nsys && !g->m_sys) ||
       (g->m_def_cap && !g->m_def) || (g->m_nund && !g->m_und)) {
     driver_errf(o->tool, "out of memory");
     return 1;
   }
   {
     uint32_t p = 0, j;
     for (k = 0; k < g->cf.ninclude_dirs; ++k)
       g->m_inc[p++] = g->cf.include_dirs[k];
     for (k = 0; k < gl->cf.ninclude_dirs; ++k)
       g->m_inc[p++] = gl->cf.include_dirs[k];
     p = 0;
     for (k = 0; k < g->cf.nsystem_include_dirs; ++k)
       g->m_sys[p++] = g->cf.system_include_dirs[k];
     for (k = 0; k < gl->cf.nsystem_include_dirs; ++k)
       g->m_sys[p++] = gl->cf.system_include_dirs[k];
     /* defines: each global define survives only if the group does not redefine
      * the same name; the group's defines then follow. This realizes "a group
      * -D of an already-defined name overrides it for that group" without
      * emitting a duplicate (which the preprocessor rejects as a conflicting
      * redefinition). */
     p = 0;
     for (k = 0; k < gl->cf.ndefines; ++k) {
       int shadowed = 0;
       for (j = 0; j < g->cf.ndefines; ++j) {
         if (kit_slice_eq(gl->cf.defines[k].name, g->cf.defines[j].name)) {
           shadowed = 1;
           break;
         }
       }
       if (!shadowed) g->m_def[p++] = gl->cf.defines[k];
     }
     for (k = 0; k < g->cf.ndefines; ++k) g->m_def[p++] = g->cf.defines[k];
     g->m_ndef = p;
     p = 0;
     for (k = 0; k < gl->cf.nundefines; ++k) g->m_und[p++] = gl->cf.undefines[k];
     for (k = 0; k < g->cf.nundefines; ++k) g->m_und[p++] = g->cf.undefines[k];
   }
   {
     KitPreprocessOptions z = {0};
     g->pp = z;
     g->pp.include_dirs = g->m_inc;
     g->pp.ninclude_dirs = g->m_ninc;
     g->pp.system_include_dirs = g->m_sys;
     g->pp.nsystem_include_dirs = g->m_nsys;
     g->pp.defines = g->m_def;
     g->pp.ndefines = g->m_ndef;
     g->pp.undefines = g->m_und;
     g->pp.nundefines = g->m_nund;
   }
   return 0;
 }
 
 /* ===================================================================== */
 /* compile one source                                                     */
 /* ===================================================================== */
 
 static KitLanguage build_resolve_lang(BuildOptions* o, KitCompiler* compiler,
                                       uint32_t si) {
   uint32_t gi = o->sources[si].group;
   if (gi != 0 && o->groups[gi].forced_lang != BUILD_LANG_AUTO)
     return o->groups[gi].forced_lang;
   if (o->groups[0].forced_lang != BUILD_LANG_AUTO)
     return o->groups[0].forced_lang;
   return kit_language_for_path(compiler, o->sources[si].path);
 }
 
 /* Collect the -X<lang> frontend tokens for a source into a fresh argv:
  * global (groups[0]) tokens first, then the source's group's. */
 static int build_collect_fe_argv(BuildOptions* o, uint32_t si, KitLanguage lang,
                                  char*** out_argv, uint32_t* out_n) {
   uint32_t gi = o->sources[si].group;
   uint32_t n = 0, k, p = 0;
   char** argv;
   for (k = 0; k < o->groups[0].nfe; ++k)
     if (o->groups[0].fe[k].lang == (uint8_t)lang) n++;
   if (gi != 0)
     for (k = 0; k < o->groups[gi].nfe; ++k)
       if (o->groups[gi].fe[k].lang == (uint8_t)lang) n++;
   *out_argv = NULL;
   *out_n = 0;
   if (n == 0) return 0;
   argv = driver_alloc_zeroed(o->env, n * sizeof(*argv));
   if (!argv) {
     driver_errf(o->tool, "out of memory");
     return 1;
   }
   for (k = 0; k < o->groups[0].nfe; ++k)
     if (o->groups[0].fe[k].lang == (uint8_t)lang)
       argv[p++] = o->groups[0].fe[k].tok;
   if (gi != 0)
     for (k = 0; k < o->groups[gi].nfe; ++k)
       if (o->groups[gi].fe[k].lang == (uint8_t)lang)
         argv[p++] = o->groups[gi].fe[k].tok;
   *out_argv = argv;
   *out_n = n;
   return 0;
 }
 
 /* Compile source[si]; emit to `emit_out` (per-source output) or return a
  * builder via `obj_out` (link/archive). Exactly one of the two is non-NULL. */
 static int build_compile_source(BuildOptions* o, KitCompiler* compiler,
                                 const KitContext* ctx, uint32_t si,
                                 const KitCodeOptions* code,
                                 const KitDiagnosticOptions* diag,
                                 KitWriter* emit_out, KitObjBuilder** obj_out) {
   const char* path = o->sources[si].path;
   uint32_t gi = o->sources[si].group;
   DriverLoad load = {0};
   KitSlice bytes = {0};
   KitLanguage lang;
   char** fe_argv = NULL;
   uint32_t fe_n = 0;
   void* lang_extra = NULL;
   KitStatus st;
   int rc = 1;
 
   if (driver_load_bytes(ctx->file_io, o->tool, path, &load, &bytes) != 0)
     return 1;
 
   lang = build_resolve_lang(o, compiler, si);
   if (lang == KIT_LANG_UNKNOWN) {
     driver_errf(o->tool, "cannot determine language for %.*s (use -x LANG)",
                 KIT_SLICE_ARG(kit_slice_cstr(path)));
     goto out;
   }
   if (build_collect_fe_argv(o, si, lang, &fe_argv, &fe_n) != 0) goto out;
   if (fe_n) {
     if (kit_frontend_parse_options(compiler, lang, (int)fe_n, fe_argv,
                                    &lang_extra) != KIT_OK) {
       driver_errf(o->tool, "unsupported -X%.*s frontend flag: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(kit_language_name(compiler, lang))),
                   KIT_SLICE_ARG(kit_slice_cstr(fe_argv[0])));
       goto out;
     }
   }
 
   st = driver_compile_run(compiler, lang, code, diag, &o->groups[gi].pp,
                           lang_extra, kit_slice_cstr(path), &bytes, emit_out,
                           obj_out);
   rc = (st == KIT_OK) ? 0 : 1;
 
 out:
   if (lang_extra) kit_frontend_free_options(compiler, lang, lang_extra);
   if (fe_argv) driver_free(o->env, fe_argv, fe_n * sizeof(*fe_argv));
   driver_release_bytes(ctx->file_io, &load);
   return rc;
 }
 
 static void build_fill_code(const BuildOptions* o, KitCodeOptions* code) {
   KitCodeOptions z = {0};
   *code = z;
   code->opt_level = o->syntax_only ? 0 : o->opt_level;
   code->debug_info = o->debug_info ? true : false;
   code->check_only = o->syntax_only ? true : false;
   code->default_visibility = o->default_visibility;
   code->function_sections = o->function_sections ? true : false;
   code->data_sections = o->data_sections ? true : false;
   code->lto = o->lto ? true : false;
   code->epoch = o->epoch;
 }
 
 /* ===================================================================== */
 /* default output naming                                                  */
 /* ===================================================================== */
 
 static char* build_default_obj_name(DriverEnv* env, const BuildOptions* o,
                                     const char* src, size_t* out_size) {
   const char* ext;
   size_t ext_len, srclen = driver_strlen(src), dot = driver_strlen(src),
                   slash = 0, k;
   switch ((BuildEmit)o->emit) {
     case BUILD_EMIT_ASM:
       ext = ".s";
       ext_len = 2u;
       break;
     case BUILD_EMIT_IR:
       ext = ".ir";
       ext_len = 3u;
       break;
     case BUILD_EMIT_C:
       ext = ".c";
       ext_len = 2u;
       break;
     default:
       driver_default_obj_ext(o->target, &ext, &ext_len);
       break;
   }
   for (k = srclen; k > 0; --k) {
     if (src[k - 1] == '.') {
       dot = k - 1;
       break;
     }
     if (src[k - 1] == '/') break;
   }
   for (k = dot; k > 0; --k) {
     if (src[k - 1] == '/') {
       slash = k;
       break;
     }
   }
   {
     size_t name_len = dot - slash;
     size_t bufsz = name_len + ext_len + 1u;
     char* buf = driver_alloc(env, bufsz);
     if (!buf) return NULL;
     driver_memcpy(buf, src + slash, name_len);
     driver_memcpy(buf + name_len, ext, ext_len);
     buf[name_len + ext_len] = '\0';
     *out_size = bufsz;
     return buf;
   }
 }
 
 /* Open the output: a file, or stdout for "-". */
 static int build_open_output(const KitContext* ctx, DriverEnv* env,
                              const char* tool, const char* path,
                              KitWriter** out) {
   if (driver_streq(path, "-")) {
     *out = driver_stdout_writer(env);
     if (!*out) {
       driver_errf(tool, "out of memory");
       return 1;
     }
     return 0;
   }
   if (ctx->file_io->open_writer(ctx->file_io->user, path, out) != KIT_OK) {
     driver_errf(tool, "failed to open output: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(path)));
     return 1;
   }
   return 0;
 }
 
 /* Compile every source to an in-memory builder; objs[] is caller-owned. */
 static int build_compile_all(BuildOptions* o, KitCompiler* compiler,
                              const KitContext* ctx, const KitCodeOptions* code,
                              const KitDiagnosticOptions* diag,
                              KitObjBuilder** objs, uint32_t* source_obj_index,
                              uint8_t* source_order_keep,
                              const DriverCompileBatchOptions* batch,
                              DriverCompilePendingLto* pending_lto,
                              uint32_t* nobjs_out) {
   DriverLoad* loads = NULL;
   DriverCompileSource* sources = NULL;
   void** lang_extras = NULL;
   DriverCompileObjects out;
   uint32_t i;
   KitStatus st;
   int rc = 1;
 
   if (nobjs_out) *nobjs_out = 0;
   if (o->nsources == 0) return 0;
 
   loads = driver_alloc_zeroed(o->env, o->nsources * sizeof(*loads));
   sources = driver_alloc_zeroed(o->env, o->nsources * sizeof(*sources));
   lang_extras = driver_alloc_zeroed(o->env, o->nsources * sizeof(*lang_extras));
   if (!loads || !sources || !lang_extras) {
     driver_errf(o->tool, "out of memory");
     goto out;
   }
 
   for (i = 0; i < o->nsources; ++i) {
     const char* path = o->sources[i].path;
     uint32_t gi = o->sources[i].group;
     KitLanguage lang;
     char** fe_argv = NULL;
     uint32_t fe_n = 0;
 
     if (driver_load_bytes(ctx->file_io, o->tool, path, &loads[i],
                           &sources[i].bytes) != 0)
       goto out;
     lang = build_resolve_lang(o, compiler, i);
     if (lang == KIT_LANG_UNKNOWN) {
       driver_errf(o->tool, "cannot determine language for %.*s (use -x LANG)",
                   KIT_SLICE_ARG(kit_slice_cstr(path)));
       goto out;
     }
     if (build_collect_fe_argv(o, i, lang, &fe_argv, &fe_n) != 0) {
       if (fe_argv) driver_free(o->env, fe_argv, fe_n * sizeof(*fe_argv));
       goto out;
     }
     if (fe_n) {
       if (kit_frontend_parse_options(compiler, lang, (int)fe_n, fe_argv,
                                      &lang_extras[i]) != KIT_OK) {
         driver_errf(
             o->tool, "unsupported -X%.*s frontend flag: %.*s",
             KIT_SLICE_ARG(kit_slice_cstr(kit_language_name(compiler, lang))),
             KIT_SLICE_ARG(kit_slice_cstr(fe_argv[0])));
         if (fe_argv) driver_free(o->env, fe_argv, fe_n * sizeof(*fe_argv));
         goto out;
       }
     }
     if (fe_argv) driver_free(o->env, fe_argv, fe_n * sizeof(*fe_argv));
     sources[i].lang = lang;
     sources[i].name = kit_slice_cstr(path);
     sources[i].pp = &o->groups[gi].pp;
     sources[i].lang_extra = lang_extras[i];
   }
 
   memset(&out, 0, sizeof out);
   out.objs = objs;
   out.source_obj_index = source_obj_index;
   out.source_order_keep = source_order_keep;
   out.pending_lto = pending_lto;
   st = driver_compile_sources_run(compiler, code, diag, sources, o->nsources,
                                   batch, &out);
   if (nobjs_out) *nobjs_out = out.nobjs;
   if (st != KIT_OK) goto out;
   rc = 0;
 
 out:
   if (lang_extras && sources) {
     for (i = 0; i < o->nsources; ++i)
       if (lang_extras[i])
         kit_frontend_free_options(compiler, sources[i].lang, lang_extras[i]);
   }
   if (loads)
     for (i = 0; i < o->nsources; ++i)
       driver_release_bytes(ctx->file_io, &loads[i]);
   if (lang_extras)
     driver_free(o->env, lang_extras, o->nsources * sizeof(*lang_extras));
   if (sources) driver_free(o->env, sources, o->nsources * sizeof(*sources));
   if (loads) driver_free(o->env, loads, o->nsources * sizeof(*loads));
   return rc;
 }
 
 /* build-exe / shared build-lib: compile sources, load link inputs, link. */
 static int build_run_link(BuildOptions* o, KitCompiler* compiler,
                           const KitContext* ctx, const KitCodeOptions* code,
                           const KitDiagnosticOptions* diag,
                           uint8_t output_kind) {
   DriverEnv* env = o->env;
   const KitFileIO* io = ctx->file_io;
   KitWriter* out_w = NULL;
   DriverLoad* obj_lf = NULL;
   DriverLoad* arch_lf = NULL;
   DriverLoad* dso_lf = NULL;
   DriverLoad script_lf = {0};
   KitSlice* obj_in = NULL;
   KitSlice* obj_names = NULL;
   KitLinkArchiveInput* arch_in = NULL;
   KitSlice* dso_in = NULL;
   KitSlice* dso_names = NULL;
   KitLinkInputOrder* order = NULL;
   KitObjBuilder** objs = NULL;
   DriverCompilePendingLto pending_lto = {0};
   uint32_t* source_obj_index = NULL;
   uint8_t* source_order_keep = NULL;
   KitLinkScript* script = NULL;
   KitSlice* rpath_slices = NULL;
   DriverCompileBatchOptions lto_batch;
   uint32_t nobjs = 0;
   uint32_t i;
   uint32_t norder = 0;
   int rc = 1;
 
   if (o->nsources) {
     objs = driver_alloc_zeroed(env, o->nsources * sizeof(*objs));
     source_obj_index =
         driver_alloc_zeroed(env, o->nsources * sizeof(*source_obj_index));
     source_order_keep =
         driver_alloc_zeroed(env, o->nsources * sizeof(*source_order_keep));
     if (!objs || !source_obj_index || !source_order_keep) goto oom;
   }
   if (o->nobject_files) {
     obj_lf = driver_alloc_zeroed(env, o->nobject_files * sizeof(*obj_lf));
     obj_in = driver_alloc_zeroed(env, o->nobject_files * sizeof(*obj_in));
     obj_names = driver_alloc_zeroed(env, o->nobject_files * sizeof(*obj_names));
     if (!obj_lf || !obj_in || !obj_names) goto oom;
   }
   if (o->narchives) {
     arch_lf = driver_alloc_zeroed(env, o->narchives * sizeof(*arch_lf));
     arch_in = driver_alloc_zeroed(env, o->narchives * sizeof(*arch_in));
     if (!arch_lf || !arch_in) goto oom;
   }
   if (o->ndsos) {
     dso_lf = driver_alloc_zeroed(env, o->ndsos * sizeof(*dso_lf));
     dso_in = driver_alloc_zeroed(env, o->ndsos * sizeof(*dso_in));
     dso_names = driver_alloc_zeroed(env, o->ndsos * sizeof(*dso_names));
     if (!dso_lf || !dso_in || !dso_names) goto oom;
   }
   if (o->nlink_items) {
     order = driver_alloc_zeroed(env, o->nlink_items * sizeof(*order));
     if (!order) goto oom;
   }
 
   for (i = 0; i < o->nobject_files; ++i) {
     if (driver_load_bytes(io, o->tool, o->object_files[i], &obj_lf[i],
                           &obj_in[i]) != 0)
       goto out;
     obj_names[i] = kit_slice_cstr(o->object_files[i]);
   }
   for (i = 0; i < o->narchives; ++i) {
     if (driver_load_bytes(io, o->tool, o->archives[i].path, &arch_lf[i],
                           &arch_in[i].bytes) != 0)
       goto out;
     arch_in[i].name = kit_slice_cstr(o->archives[i].path);
     arch_in[i].link_mode = o->archives[i].link_mode;
     arch_in[i].whole_archive = o->archives[i].whole_archive ? true : false;
     arch_in[i].group_id = o->archives[i].group_id;
   }
   for (i = 0; i < o->ndsos; ++i) {
     if (driver_load_bytes(io, o->tool, o->dsos[i].path, &dso_lf[i],
                           &dso_in[i]) != 0)
       goto out;
     dso_names[i] = kit_slice_cstr(o->dsos[i].path);
   }
   if (o->link.linker_script) {
     KitSlice dummy;
     if (driver_load_bytes(io, o->tool, o->link.linker_script, &script_lf,
                           &dummy) != 0)
       goto out;
   }
 
   if (script_lf.loaded) {
     KitSlice text = {.s = (const char*)script_lf.fd.data,
                      .len = script_lf.fd.size};
     if (kit_link_script_parse(ctx, text, &script) != KIT_OK) goto out;
   }
 
   {
     memset(&lto_batch, 0, sizeof lto_batch);
     lto_batch.output_kind = output_kind == KIT_LINK_OUTPUT_SHARED
                                 ? KIT_CG_OUTPUT_SHARED
                                 : KIT_CG_OUTPUT_EXECUTABLE;
     lto_batch.interposition_policy =
         output_kind == KIT_LINK_OUTPUT_SHARED
             ? KIT_CG_INTERPOSITION_DEFAULT_VISIBILITY
             : KIT_CG_INTERPOSITION_DEFAULT;
     lto_batch.defer_lto_finish = 1;
     if (build_compile_all(o, compiler, ctx, code, diag, objs, source_obj_index,
                           source_order_keep, &lto_batch, &pending_lto,
                           &nobjs) != 0)
       goto out;
   }
 
   if (build_open_output(ctx, env, o->tool, o->output_path, &out_w) != 0)
     goto out;
 
   /* Translate the recorded link order into KitLinkInputOrder. */
   for (i = 0; i < o->nlink_items; ++i) {
     const BuildLinkItem* item = &o->link_items[i];
     KitLinkInputOrder* ord;
     switch ((BuildLinkKind)item->kind) {
       case BUILD_LINK_SOURCE:
         if (!source_order_keep[item->index]) continue;
         ord = &order[norder++];
         ord->kind = KIT_LINK_INPUT_OBJ;
         ord->index = source_obj_index[item->index];
         break;
       case BUILD_LINK_OBJECT:
         ord = &order[norder++];
         ord->kind = KIT_LINK_INPUT_OBJ_BYTES;
         ord->index = item->index;
         break;
       case BUILD_LINK_ARCHIVE:
         ord = &order[norder++];
         ord->kind = KIT_LINK_INPUT_ARCHIVE;
         ord->index = item->index;
         break;
       case BUILD_LINK_DSO:
         ord = &order[norder++];
         ord->kind = KIT_LINK_INPUT_DSO;
         ord->index = item->index;
         break;
       case BUILD_LINK_LIB: {
         const BuildPendingLib* pl = &o->pending_libs[item->index];
         ord = &order[norder++];
         if (pl->resolved_kind == BUILD_LINK_DSO) {
           ord->kind = KIT_LINK_INPUT_DSO;
           ord->index = pl->resolved_index;
         } else {
           ord->kind = KIT_LINK_INPUT_ARCHIVE;
           ord->index = pl->resolved_index;
         }
         break;
       }
     }
   }
 
   {
     KitLinkSessionOptions lopts;
     DriverLinkInputs li;
     KitStatus st;
     if (driver_link_flags_fill_options(
             &o->link, o->target, o->pie, o->shared,
             output_kind == KIT_LINK_OUTPUT_RELOCATABLE, output_kind, script,
             &lopts, &rpath_slices) != 0)
       goto out;
     memset(&li, 0, sizeof(li));
     li.objs = objs;
     li.nobjs = nobjs;
     li.obj_names = obj_names;
     li.obj_bytes = obj_in;
     li.nobj_bytes = o->nobject_files;
     li.archives = arch_in;
     li.narchives = o->narchives;
     li.dso_names = dso_names;
     li.dso_bytes = dso_in;
     li.ndsos = o->ndsos;
     li.order = order;
     li.norder = norder;
     st = driver_link_engine_emit_with_lto(compiler, &lopts, &li, &pending_lto,
                                           &lto_batch, out_w);
     rc = (st == KIT_OK) ? 0 : 1;
   }
 
 out:
   if (out_w) kit_writer_close(out_w);
   if (rc == 0 && output_kind == KIT_LINK_OUTPUT_EXE &&
       !driver_streq(o->output_path, "-")) {
     if (driver_mark_executable_output(o->output_path) != 0) {
       driver_errf(o->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);
   driver_compile_pending_lto_abort(&pending_lto);
   driver_link_flags_free_rpath_slices(&o->link, rpath_slices);
   driver_release_bytes(io, &script_lf);
   if (arch_lf)
     for (i = 0; i < o->narchives; ++i) driver_release_bytes(io, &arch_lf[i]);
   if (dso_lf)
     for (i = 0; i < o->ndsos; ++i) driver_release_bytes(io, &dso_lf[i]);
   if (obj_lf)
     for (i = 0; i < o->nobject_files; ++i) driver_release_bytes(io, &obj_lf[i]);
   if (arch_in) driver_free(env, arch_in, o->narchives * sizeof(*arch_in));
   if (arch_lf) driver_free(env, arch_lf, o->narchives * sizeof(*arch_lf));
   if (dso_in) driver_free(env, dso_in, o->ndsos * sizeof(*dso_in));
   if (dso_names) driver_free(env, dso_names, o->ndsos * sizeof(*dso_names));
   if (dso_lf) driver_free(env, dso_lf, o->ndsos * sizeof(*dso_lf));
   if (order) driver_free(env, order, o->nlink_items * sizeof(*order));
   if (obj_in) driver_free(env, obj_in, o->nobject_files * sizeof(*obj_in));
   if (obj_names)
     driver_free(env, obj_names, o->nobject_files * sizeof(*obj_names));
   if (obj_lf) driver_free(env, obj_lf, o->nobject_files * sizeof(*obj_lf));
   /* The link session borrows the per-source builders (it frees only its own
    * pointer array), so the caller still owns and must release them. */
   if (objs) {
     for (i = 0; i < nobjs; ++i) kit_obj_builder_free(objs[i]);
     driver_free(env, objs, o->nsources * sizeof(*objs));
   }
   if (source_order_keep)
     driver_free(env, source_order_keep,
                 o->nsources * sizeof(*source_order_keep));
   if (source_obj_index)
     driver_free(env, source_obj_index, o->nsources * sizeof(*source_obj_index));
   return rc;
 
 oom:
   driver_errf(o->tool, "out of memory");
   goto out;
 }
 
 /* build-obj multi-source: combine into one relocatable object (ld -r). */
 static int build_run_relocatable(BuildOptions* o, KitCompiler* compiler,
                                  const KitContext* ctx,
                                  const KitCodeOptions* code,
                                  const KitDiagnosticOptions* diag) {
   DriverEnv* env = o->env;
   KitObjBuilder** objs = NULL;
   uint32_t* source_obj_index = NULL;
   uint8_t* source_order_keep = NULL;
   KitLinkInputOrder* order = NULL;
   DriverCompilePendingLto pending_lto = {0};
   KitWriter* out_w = NULL;
   DriverCompileBatchOptions lto_batch;
   uint32_t nobjs = 0;
   uint32_t norder = 0;
   uint32_t i;
   int rc = 1;
 
   objs = driver_alloc_zeroed(env, o->nsources * sizeof(*objs));
   source_obj_index =
       driver_alloc_zeroed(env, o->nsources * sizeof(*source_obj_index));
   source_order_keep =
       driver_alloc_zeroed(env, o->nsources * sizeof(*source_order_keep));
   order = driver_alloc_zeroed(env, o->nsources * sizeof(*order));
   if (!objs || !source_obj_index || !source_order_keep || !order) {
     driver_errf(o->tool, "out of memory");
     goto out;
   }
   {
     memset(&lto_batch, 0, sizeof lto_batch);
     lto_batch.output_kind = KIT_CG_OUTPUT_RELOCATABLE;
     lto_batch.interposition_policy = KIT_CG_INTERPOSITION_DEFAULT;
     lto_batch.defer_lto_finish = 1;
     if (build_compile_all(o, compiler, ctx, code, diag, objs, source_obj_index,
                           source_order_keep, &lto_batch, &pending_lto,
                           &nobjs) != 0)
       goto out;
   }
   for (i = 0; i < o->nsources; ++i) {
     if (!source_order_keep[i]) continue;
     order[norder].kind = KIT_LINK_INPUT_OBJ;
     order[norder].index = source_obj_index[i];
     ++norder;
   }
   if (build_open_output(ctx, env, o->tool, o->output_path, &out_w) != 0)
     goto out;
   {
     KitLinkSessionOptions lopts;
     DriverLinkInputs li;
     KitStatus st;
     memset(&lopts, 0, sizeof(lopts));
     lopts.output_kind = KIT_LINK_OUTPUT_RELOCATABLE;
     lopts.allow_undefined = 1;
     lopts.strip_debug = o->link.strip_debug ? true : false;
     memset(&li, 0, sizeof(li));
     li.objs = objs;
     li.nobjs = nobjs;
     li.order = order;
     li.norder = norder;
     st = driver_link_engine_emit_with_lto(compiler, &lopts, &li, &pending_lto,
                                           &lto_batch, out_w);
     rc = (st == KIT_OK) ? 0 : 1;
   }
 
 out:
   if (out_w) kit_writer_close(out_w);
   driver_compile_pending_lto_abort(&pending_lto);
   if (order) driver_free(env, order, o->nsources * sizeof(*order));
   /* The link session borrows the builders; release them here (see
    * build_run_link). */
   if (objs) {
     for (i = 0; i < nobjs; ++i) kit_obj_builder_free(objs[i]);
     driver_free(env, objs, o->nsources * sizeof(*objs));
   }
   if (source_order_keep)
     driver_free(env, source_order_keep,
                 o->nsources * sizeof(*source_order_keep));
   if (source_obj_index)
     driver_free(env, source_obj_index, o->nsources * sizeof(*source_obj_index));
   return rc;
 }
 
 /* build-obj wasm multi-source: merge all inputs into one .wasm via CG merge. */
 static int build_run_wasm_module(BuildOptions* o, KitCompiler* compiler,
                                  const KitContext* ctx,
                                  const KitCodeOptions* code,
                                  const KitDiagnosticOptions* diag) {
   DriverEnv* env = o->env;
   KitObjBuilder** objs = NULL;
   uint32_t* source_obj_index = NULL;
   uint8_t* source_order_keep = NULL;
   KitWriter* out_w = NULL;
   KitCodeOptions code2 = *code;
   uint32_t nobjs = 0;
   uint32_t i;
   int rc = 1;
 
   code2.lto = true;
 
   objs = driver_alloc_zeroed(env, o->nsources * sizeof(*objs));
   source_obj_index =
       driver_alloc_zeroed(env, o->nsources * sizeof(*source_obj_index));
   source_order_keep =
       driver_alloc_zeroed(env, o->nsources * sizeof(*source_order_keep));
   if (!objs || !source_obj_index || !source_order_keep) {
     driver_errf(o->tool, "out of memory");
     goto out;
   }
   {
     DriverCompileBatchOptions batch;
     memset(&batch, 0, sizeof batch);
     batch.output_kind = KIT_CG_OUTPUT_RELOCATABLE;
     batch.interposition_policy = KIT_CG_INTERPOSITION_DEFAULT;
     if (build_compile_all(o, compiler, ctx, &code2, diag, objs, source_obj_index,
                           source_order_keep, &batch, NULL, &nobjs) != 0)
       goto out;
   }
   if (nobjs != 1) {
     driver_errf(o->tool,
                 "build-obj: wasm multi-input expects a single merged module");
     goto out;
   }
   if (build_open_output(ctx, env, o->tool, o->output_path, &out_w) != 0)
     goto out;
   rc = (kit_obj_builder_emit(objs[0], out_w) == KIT_OK) ? 0 : 1;
 
 out:
   if (out_w) kit_writer_close(out_w);
   if (objs) {
     for (i = 0; i < nobjs; ++i) kit_obj_builder_free(objs[i]);
     driver_free(env, objs, o->nsources * sizeof(*objs));
   }
   if (source_order_keep)
     driver_free(env, source_order_keep,
                 o->nsources * sizeof(*source_order_keep));
   if (source_obj_index)
     driver_free(env, source_obj_index, o->nsources * sizeof(*source_obj_index));
   return rc;
 }
 
 /* build-exe wasm: merge all sources into one .wasm with DCE/internalization. */
 static int build_run_wasm_exe(BuildOptions* o, KitCompiler* compiler,
                               const KitContext* ctx,
                               const KitCodeOptions* code,
                               const KitDiagnosticOptions* diag) {
   DriverEnv* env = o->env;
   KitObjBuilder** objs = NULL;
   uint32_t* source_obj_index = NULL;
   uint8_t* source_order_keep = NULL;
   DriverCompilePendingLto pending_lto = {0};
   KitWriter* out_w = NULL;
   KitCodeOptions code2 = *code;
   uint32_t nobjs = 0;
   uint32_t i;
   int rc = 1;
 
   code2.lto = true;
 
   objs = driver_alloc_zeroed(env, o->nsources * sizeof(*objs));
   source_obj_index =
       driver_alloc_zeroed(env, o->nsources * sizeof(*source_obj_index));
   source_order_keep =
       driver_alloc_zeroed(env, o->nsources * sizeof(*source_order_keep));
   if (!objs || !source_obj_index || !source_order_keep) {
     driver_errf(o->tool, "out of memory");
     goto out;
   }
   {
     DriverCompileBatchOptions batch;
     memset(&batch, 0, sizeof batch);
     batch.output_kind = KIT_CG_OUTPUT_EXECUTABLE;
     batch.interposition_policy = KIT_CG_INTERPOSITION_NONE;
     batch.defer_lto_finish = 1;
     if (build_compile_all(o, compiler, ctx, &code2, diag, objs,
                           source_obj_index, source_order_keep,
                           &batch, &pending_lto, &nobjs) != 0)
       goto out;
   }
   if (nobjs != 1) {
     driver_errf(o->tool, "build-exe: wasm expects a single merged module");
     goto out;
   }
   {
     const char* entry_name = o->link.entry ? o->link.entry : "main";
     KitSym entry_interned =
         kit_sym_intern(compiler, kit_slice_cstr(entry_name));
     KitObjSymbol entry_sym = KIT_OBJ_SYMBOL_NONE;
     DriverCompileBatchOptions batch2;
     KitCgSym csym;
 
     if (!entry_interned ||
         kit_obj_builder_find_symbol(pending_lto.obj, entry_interned,
                                     &entry_sym) != KIT_OK) {
       driver_errf(o->tool,
                   "build-exe: entry symbol '%s' not found in module",
                   entry_name);
       goto out;
     }
     csym = (KitCgSym)entry_sym;
     memset(&batch2, 0, sizeof batch2);
     batch2.output_kind = KIT_CG_OUTPUT_EXECUTABLE;
     batch2.interposition_policy = KIT_CG_INTERPOSITION_NONE;
     if (driver_compile_pending_lto_finish(&pending_lto, &batch2,
                                           &csym, 1) != KIT_OK) {
       driver_errf(o->tool, "build-exe: LTO finish failed");
       goto out;
     }
     kit_obj_builder_wasm_add_custom(objs[0], KIT_SLICE_LIT("kit-entry"),
                                     kit_slice_cstr(entry_name));
   }
   if (build_open_output(ctx, env, o->tool, o->output_path, &out_w) != 0)
     goto out;
   rc = (kit_obj_builder_emit(objs[0], out_w) == KIT_OK) ? 0 : 1;
 
 out:
   if (out_w) kit_writer_close(out_w);
   if (pending_lto.active) driver_compile_pending_lto_abort(&pending_lto);
   if (objs) {
     for (i = 0; i < nobjs; ++i) kit_obj_builder_free(objs[i]);
     driver_free(env, objs, o->nsources * sizeof(*objs));
   }
   if (source_order_keep)
     driver_free(env, source_order_keep,
                 o->nsources * sizeof(*source_order_keep));
   if (source_obj_index)
     driver_free(env, source_obj_index, o->nsources * sizeof(*source_obj_index));
   return rc;
 }
 
 /* build-lib static: archive every compiled source object. */
 static int build_run_archive(BuildOptions* o, KitCompiler* compiler,
                              const KitContext* ctx, const KitCodeOptions* code,
                              const KitDiagnosticOptions* diag) {
   DriverEnv* env = o->env;
   KitObjBuilder** objs = NULL;
   uint32_t* source_obj_index = NULL;
   uint8_t* source_order_keep = NULL;
   KitSlice* names = NULL;
   char** owned_names = NULL;
   size_t* owned_name_sizes = NULL;
   KitWriter* out_w = NULL;
   uint32_t nobjs = 0;
   uint32_t i;
   int rc = 1;
 
   objs = driver_alloc_zeroed(env, o->nsources * sizeof(*objs));
   source_obj_index =
       driver_alloc_zeroed(env, o->nsources * sizeof(*source_obj_index));
   source_order_keep =
       driver_alloc_zeroed(env, o->nsources * sizeof(*source_order_keep));
   names = driver_alloc_zeroed(env, o->nsources * sizeof(*names));
   owned_names = driver_alloc_zeroed(env, o->nsources * sizeof(*owned_names));
   owned_name_sizes =
       driver_alloc_zeroed(env, o->nsources * sizeof(*owned_name_sizes));
   if (!objs || !source_obj_index || !source_order_keep || !names ||
       !owned_names || !owned_name_sizes) {
     driver_errf(o->tool, "out of memory");
     goto out;
   }
   {
     DriverCompileBatchOptions batch;
     memset(&batch, 0, sizeof batch);
     batch.output_kind = KIT_CG_OUTPUT_ARCHIVE_MEMBER;
     batch.interposition_policy = KIT_CG_INTERPOSITION_DEFAULT;
     if (build_compile_all(o, compiler, ctx, code, diag, objs, source_obj_index,
                           source_order_keep, &batch, NULL, &nobjs) != 0)
       goto out;
   }
   /* build-lib always emits objects (validated), so build_default_obj_name
    * yields the right `.o`/`.obj` member name. */
   for (i = 0; i < o->nsources; ++i) {
     uint32_t oi;
     if (!source_order_keep[i]) continue;
     oi = source_obj_index[i];
     owned_names[oi] = build_default_obj_name(env, o, o->sources[i].path,
                                              &owned_name_sizes[oi]);
     if (!owned_names[oi]) {
       driver_errf(o->tool, "out of memory");
       goto out;
     }
     names[oi] = kit_slice_cstr(owned_names[oi]);
   }
   if (build_open_output(ctx, env, o->tool, o->output_path, &out_w) != 0)
     goto out;
   rc = driver_archive_emit(env, ctx, o->tool, objs, names, nobjs, o->epoch,
                            out_w);
 
 out:
   if (out_w) kit_writer_close(out_w);
   if (objs)
     for (i = 0; i < nobjs; ++i) kit_obj_builder_free(objs[i]);
   if (owned_names) {
     for (i = 0; i < o->nsources; ++i)
       if (owned_names[i]) driver_free(env, owned_names[i], owned_name_sizes[i]);
   }
   if (objs) driver_free(env, objs, o->nsources * sizeof(*objs));
   if (source_order_keep)
     driver_free(env, source_order_keep,
                 o->nsources * sizeof(*source_order_keep));
   if (source_obj_index)
     driver_free(env, source_obj_index, o->nsources * sizeof(*source_obj_index));
   if (names) driver_free(env, names, o->nsources * sizeof(*names));
   if (owned_names)
     driver_free(env, owned_names, o->nsources * sizeof(*owned_names));
   if (owned_name_sizes)
     driver_free(env, owned_name_sizes, o->nsources * sizeof(*owned_name_sizes));
   return rc;
 }
 
 /* build-obj per-source: check-only, or one output per source (obj/asm/c/ir). */
 static int build_run_per_source(BuildOptions* o, KitCompiler* compiler,
                                 const KitContext* ctx,
                                 const KitCodeOptions* code_in,
                                 const KitDiagnosticOptions* diag) {
   DriverEnv* env = o->env;
   KitCodeOptions code = *code_in;
   uint32_t i;
 
   code.emit_asm_source = (o->emit == BUILD_EMIT_ASM) ? true : false;
   code.emit_c_source = (o->emit == BUILD_EMIT_C) ? true : false;
   code.emit_ir = (o->emit == BUILD_EMIT_IR) ? true : false;
 
   for (i = 0; i < o->nsources; ++i) {
     if (o->syntax_only) {
       KitObjBuilder* ob = NULL;
       int rc =
           build_compile_source(o, compiler, ctx, i, &code, diag, NULL, &ob);
       kit_obj_builder_free(ob);
       if (rc != 0) return rc;
       continue;
     }
     {
       const char* out_path = o->output_path;
       char* owned = NULL;
       size_t owned_size = 0;
       KitWriter* w = NULL;
       int rc;
       if (!out_path) {
         owned = build_default_obj_name(env, o, o->sources[i].path, &owned_size);
         if (!owned) {
           driver_errf(o->tool, "out of memory");
           return 1;
         }
         out_path = owned;
       }
       if (build_open_output(ctx, env, o->tool, out_path, &w) != 0) {
         if (owned) driver_free(env, owned, owned_size);
         return 1;
       }
       rc = build_compile_source(o, compiler, ctx, i, &code, diag, w, NULL);
       kit_writer_close(w);
       if (owned) driver_free(env, owned, owned_size);
       if (rc != 0) return rc;
     }
   }
   return 0;
 }
 
 /* ===================================================================== */
 /* validation                                                             */
 /* ===================================================================== */
 
 static int build_validate(BuildOptions* o) {
   uint32_t total_link =
       o->nobject_files + o->narchives + o->ndsos + o->npending_libs;
 
   if (o->nsources == 0 && total_link == 0) {
     driver_errf(o->tool, "no input files");
     return 1;
   }
 
   /* -dynamic selects the default executable link mode for build-exe and the
    * not-yet-supported shared-library mode for build-lib. -shared is the GCC
    * spelling for producing a shared library, so build-exe rejects it. */
 
   if (o->kind == BUILD_OUT_EXE) {
     if (o->shared_requested) {
       driver_errf(o->tool, "-shared is not valid for build-exe");
       return 1;
     }
     if (o->emit != BUILD_EMIT_OBJ || o->syntax_only) {
       driver_errf(o->tool, "--emit/-S/-fsyntax-only are build-obj options");
       return 1;
     }
     if (!o->output_path) {
       o->output_path = (o->target.obj == KIT_OBJ_WASM)
                            ? "a.wasm"
                            : driver_default_exe_name(o->target);
     }
     if (o->target.obj == KIT_OBJ_WASM) {
       uint32_t total_link =
           o->nobject_files + o->narchives + o->ndsos + o->npending_libs;
       if (total_link) {
         driver_errf(o->tool,
                     "build-exe -target wasm32-none accepts only source files "
                     "(no .o / .a / -l inputs)");
         return 1;
       }
     }
     return 0;
   }
 
   if (o->kind == BUILD_OUT_LIB) {
     if (o->dynamic) {
       driver_errf(o->tool,
                   "creating dynamic/shared libraries is not yet supported; "
                   "build-lib produces a static .a");
       return 1;
     }
     if (o->emit != BUILD_EMIT_OBJ || o->syntax_only) {
       driver_errf(o->tool, "--emit/-S/-fsyntax-only are build-obj options");
       return 1;
     }
     if (total_link != 0) {
       driver_errf(o->tool,
                   "build-lib takes only sources; pass .o/.a/-l to build-exe");
       return 1;
     }
     if (o->nsources == 0) {
       driver_errf(o->tool, "no source files");
       return 1;
     }
     if (!o->output_path) {
       driver_errf(o->tool, "-o is required (no default library name)");
       return 1;
     }
     return 0;
   }
 
   /* build-obj */
   if (total_link != 0) {
     driver_errf(o->tool,
                 "build-obj takes only sources; pass .o/.a/-l to build-exe");
     return 1;
   }
   if (o->nsources == 0) {
     driver_errf(o->tool, "no source files");
     return 1;
   }
   if (o->dynamic) {
     driver_errf(o->tool, "-dynamic/-shared is only valid for build-lib");
     return 1;
   }
   if (o->syntax_only) {
     if (o->output_path) {
       driver_errf(o->tool, "-o is incompatible with -fsyntax-only");
       return 1;
     }
     return 0;
   }
   if (o->emit == BUILD_EMIT_IR && o->opt_level < 1) {
     driver_errf(o->tool,
                 "--emit=ir requires -O1 or higher (the IR tape is only "
                 "recorded when the optimizer runs)");
     return 1;
   }
   if (o->emit == BUILD_EMIT_OBJ && o->nsources > 1) {
     /* relocatable combine */
     if (!o->output_path) {
       driver_errf(o->tool,
                   "-o is required to combine multiple sources into one object");
       return 1;
     }
     return 0;
   }
   /* per-source emit (single obj, or asm/c/ir) */
   if (o->output_path && o->nsources > 1) {
     driver_errf(o->tool, "-o cannot be used with multiple sources");
     return 1;
   }
   if (o->emit == BUILD_EMIT_C && !o->output_path) {
     driver_errf(o->tool, "--emit=c requires -o");
     return 1;
   }
   return 0;
 }
 
 /* ===================================================================== */
 /* driver                                                                 */
 /* ===================================================================== */
 
 static int build_apply_env(BuildOptions* o) {
   const char* sde = driver_getenv("SOURCE_DATE_EPOCH");
   if (sde && build_parse_u64(sde, &o->epoch) != 0) {
     driver_errf(o->tool, "invalid SOURCE_DATE_EPOCH: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(sde)));
     return 1;
   }
   return 0;
 }
 
 static int build_main(int argc, char** argv, int kind, const char* tool) {
   DriverEnv env;
   BuildOptions o = {0};
   DriverRuntimeSupport runtime = {0};
   int runtime_resolved = 0;
   KitContext ctx;
   KitTarget* target = NULL;
   KitCompiler* compiler = NULL;
   KitCodeOptions code;
   KitDiagnosticOptions diag = {0};
   uint32_t gi;
   int rc = 2;
 
   driver_env_init(&env);
   o.env = &env;
   o.tool = tool;
   o.kind = kind;
   o.driver_path = argv[0];
 
   if (build_alloc(&o, argc) != 0) {
     rc = 2;
     goto done;
   }
   if (build_parse(argc, argv, &o) != 0) goto done;
   if (build_apply_env(&o) != 0) goto done;
 
   o.shared = (o.kind == BUILD_OUT_LIB && o.dynamic);
   if (o.shared && o.target.pic == KIT_PIC_NONE) o.target.pic = KIT_PIC_PIC;
 
   if (build_validate(&o) != 0) goto done;
 
   /* Freestanding runtime headers so C/asm #includes resolve (mirrors compile);
    * for link outputs, also the runtime archive + hosted libc wiring. */
   if (driver_runtime_resolve(&env, o.support_dir, o.driver_path, &runtime) ==
       0) {
     runtime_resolved = 1;
     if (driver_runtime_add_freestanding_headers(&runtime, &o.groups[0].cf) !=
         0) {
       driver_errf(tool, "failed to add freestanding headers");
       rc = 1;
       goto done;
     }
   } else {
     driver_errf(tool, "support dir not found");
     rc = 1;
     goto done;
   }
 
   if (build_is_link_output(&o)) {
     if (build_append_windows_lib_dirs(&o) != 0) {
       rc = 1;
       goto done;
     }
     build_enable_hosted_for_sysroot(&o);
     build_apply_default_hosted_profile(&o);
     if (build_apply_hosted_profile(&o) != 0) {
       rc = 1;
       goto done;
     }
     if (build_resolve_pending_libs(&o) != 0) {
       rc = 1;
       goto done;
     }
     if (!o.no_stdlib && !o.no_defaultlibs) {
       DriverRuntimeArchive rt = {0};
       uint32_t insert_pos;
       if (driver_runtime_prepare_archive(&env, tool, &runtime, o.target,
                                          o.epoch, &rt) != 0) {
         driver_runtime_archive_fini(&env, &rt);
         rc = 1;
         goto done;
       }
       insert_pos = o.nlink_items;
       if (o.hosted.nfinal <= insert_pos) insert_pos -= o.hosted.nfinal;
       build_insert_runtime_archive(&o, &rt, insert_pos);
       driver_runtime_archive_fini(&env, &rt);
     }
   } else if (o.npending_libs) {
     driver_errf(tool, "-l is only valid for build-exe");
     rc = 1;
     goto done;
   }
 
   /* Build per-group merged preprocessor views now that the global baseline
    * (groups[0]) holds the runtime/hosted includes and defines. */
   for (gi = 0; gi < o.ngroups; ++gi) {
     if (build_group_build_pp(&o, gi) != 0) {
       rc = 1;
       goto done;
     }
   }
 
   ctx = driver_env_to_context(&env);
   if (driver_target_new(&ctx, o.target, &o.target_features, tool, &target) !=
           KIT_OK ||
       driver_compiler_new(target, &ctx, &compiler) != KIT_OK) {
     driver_errf(tool, "failed to initialize compiler");
     rc = 1;
     goto done;
   }
 
   build_fill_code(&o, &code);
   diag.warnings_are_errors = o.warnings_are_errors ? true : false;
   diag.max_errors = o.max_errors;
 
   if (o.kind == BUILD_OUT_EXE) {
     if (o.target.obj == KIT_OBJ_WASM)
       rc = build_run_wasm_exe(&o, compiler, &ctx, &code, &diag);
     else
       rc = build_run_link(&o, compiler, &ctx, &code, &diag, KIT_LINK_OUTPUT_EXE);
   } else if (o.kind == BUILD_OUT_LIB) {
     rc = o.shared ? build_run_link(&o, compiler, &ctx, &code, &diag,
                                    KIT_LINK_OUTPUT_SHARED)
                   : build_run_archive(&o, compiler, &ctx, &code, &diag);
   } else if (o.syntax_only) {
     rc = build_run_per_source(&o, compiler, &ctx, &code, &diag);
   } else if (o.emit == BUILD_EMIT_OBJ && o.nsources > 1 &&
              o.target.obj == KIT_OBJ_WASM) {
     rc = build_run_wasm_module(&o, compiler, &ctx, &code, &diag);
   } else if (o.emit == BUILD_EMIT_OBJ && o.nsources > 1) {
     rc = build_run_relocatable(&o, compiler, &ctx, &code, &diag);
   } else {
     rc = build_run_per_source(&o, compiler, &ctx, &code, &diag);
   }
 
 done:
   if (compiler) driver_compiler_free(compiler);
   kit_target_free(target);
   if (runtime_resolved) driver_runtime_support_fini(&env, &runtime);
   build_release(&o);
   driver_env_fini(&env);
   return rc;
 }
 
 /* ===================================================================== */
 /* help + entry points                                                    */
 /* ===================================================================== */
 
 void driver_help_build_exe(void) {
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "kit build-exe — link a polyglot source set into an executable\n"
           "\n"
           "USAGE\n"
           "  kit build-exe [options] inputs...\n"
           "\n"
           "DESCRIPTION\n"
           "  Compiles C / asm / toy / wasm sources (language per file) in\n"
           "  memory and links them with any .o/.a/.so inputs into one\n"
           "  executable. No intermediate files.\n"
           "\n"
           "OPTIONS (selection)\n"
           "  -o PATH               Output (default a.out / a.exe)\n"
           "  -O0 -O1 -O2  -g       Optimization / debug info\n"
           "  -target TRIPLE        Cross-compile target\n"
           "  -flto                 Link-time optimization for source inputs\n"
           "  -static               Fully static executable\n"
           "  -l NAME  -L DIR       Link a library / add a search dir\n"
           "  -e SYM  -T script.ld  Entry symbol / linker script\n"
           "  -Wl,...               Linker pass-through\n"
           "  --group [flags] -- sources...   Scope compile flags to sources\n"
           "  -X<lang> FLAG         Per-language frontend flag "
           "(c|asm|toy|wasm)\n"
           "  -h, --help            Show this help\n")));
 }
 
 void driver_help_build_lib(void) {
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "kit build-lib — build a static library (.a)\n"
           "\n"
           "USAGE\n"
           "  kit build-lib -o LIB.a [options] sources...\n"
           "\n"
           "DESCRIPTION\n"
           "  Compiles a polyglot source set in memory and archives the "
           "objects\n"
           "  into a static library (.a) with a symbol index. Dynamic/shared\n"
           "  libraries are not yet supported.\n"
           "\n"
           "OPTIONS (selection)\n"
           "  -o PATH               Output archive (required)\n"
           "  -fPIC                 Position-independent code\n"
           "  -O0 -O1 -O2  -g       Optimization / debug info\n"
           "  -flto                 Link-time optimization for source inputs\n"
           "  -target TRIPLE        Cross-compile target\n"
           "  --group [flags] -- sources...   Scope compile flags to sources\n"
           "  -X<lang> FLAG         Per-language frontend flag "
           "(c|asm|toy|wasm)\n"
           "  -h, --help            Show this help\n")));
 }
 
 void driver_help_build_obj(void) {
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "kit build-obj — compile sources to an object (or asm / C / IR)\n"
           "\n"
           "USAGE\n"
           "  kit build-obj [options] sources...\n"
           "\n"
           "DESCRIPTION\n"
           "  Compiles each source (C / asm / toy / wasm by suffix or -x) to "
           "an\n"
           "  object. Multiple sources with --emit=obj combine into one\n"
           "  relocatable object (ld -r). The kit-native replacement for the\n"
           "  retired `compile` tool.\n"
           "\n"
           "OPTIONS\n"
           "  -o PATH               Output (default <base>.o; required for a\n"
           "                        multi-source combine and for --emit=c)\n"
           "  --emit=obj|asm|c|ir   Output form (ir requires -O1+)\n"
           "  -S                    Alias for --emit=asm\n"
           "  -fsyntax-only         Check only; write no output\n"
           "  -O0 -O1 -O2  -g       Optimization / debug info\n"
           "  -flto                 Link-time optimization for multi-source "
           "obj\n"
           "  -target TRIPLE        Cross-compile target\n"
           "  -I/-isystem/-D/-U     Preprocessor flags (C/asm frontends)\n"
           "  -x LANG               Force language: c | asm | toy | wasm\n"
           "  --group [flags] -- sources...   Scope compile flags to sources\n"
           "  -X<lang> FLAG         Per-language frontend flag "
           "(c|asm|toy|wasm)\n"
           "  -o -                  Write the emit to stdout\n"
           "  -h, --help            Show this help\n")));
 }
 
 int driver_build_exe(int argc, char** argv) {
   if (argc < 2 || driver_argv_wants_help(argc, argv, 1)) {
     driver_help_build_exe();
     return 0;
   }
   return build_main(argc, argv, BUILD_OUT_EXE, "build-exe");
 }
 
 int driver_build_lib(int argc, char** argv) {
   if (argc < 2 || driver_argv_wants_help(argc, argv, 1)) {
     driver_help_build_lib();
     return 0;
   }
   return build_main(argc, argv, BUILD_OUT_LIB, "build-lib");
 }
 
 int driver_build_obj(int argc, char** argv) {
   if (argc < 2 || driver_argv_wants_help(argc, argv, 1)) {
     driver_help_build_obj();
     return 0;
   }
   return build_main(argc, argv, BUILD_OUT_OBJ, "build-obj");
 }