kit

cc.c (90641B)

---

 #include "c/c.h"
 
 #include <kit/asm_emit.h>
 #include <kit/compile.h>
 #include <kit/core.h>
 #include <kit/link.h>
 #include <kit/preprocess.h>
 #include <stdint.h>
 #include <string.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 cc` — C compiler driver. With -c produces a single object;
  * without -c compiles all C sources, links any .o/.a inputs alongside, and
  * emits an executable. The flag surface is a GCC subset:
  *
  *   -c -E -o -O0/1/2 -g
  *   -fsyntax-only
  *   -I -isystem -D -U
  *   -M -MM -MD -MMD -MF -MT -MQ -MP
  *   -target TRIPLE
  *   -fPIC -fPIE -fpic -fpie -mcmodel=small|medium|large
  *   -Werror -fmax-errors=N
  *   --build-id=none|sha256|uuid|0xHEX
  *   -ffile-prefix-map=old=new
  *   SOURCE_DATE_EPOCH (env)
  *   -e symbol -T script.ld
  *   -static -pie -no-pie
  *   -l name -L dir
  *   -x c|asm|s|asm-cpp|S|wasm|wat
  *   - (stdin source)
  *   .c/.cc -> source; .o/.obj -> object inputs; .a -> archive inputs.
  *
  * Library resolution (-lfoo against -L paths) happens here and produces
  * concrete archive paths for libkit. */
 
 #define CC_TOOL "cc"
 
 /* Header-dependency emission mode (subset of GCC's -M family).
  *   M    — print all deps; do not compile.
  *   MM   — like M but skip <bracketed> includes.
  *   MD   — compile normally AND write all deps to a file.
  *   MMD  — like MD but skip <bracketed> includes.
  * MD/MMD currently require -c (single-source compile_obj_emit path). */
 typedef enum CcDepMode {
   CC_DEP_NONE = 0,
   CC_DEP_M,
   CC_DEP_MM,
   CC_DEP_MD,
   CC_DEP_MMD,
 } CcDepMode;
 
 typedef enum CcProbeKind {
   CC_PROBE_NONE = 0,
   CC_PROBE_PRINT_SEARCH_DIRS,
   CC_PROBE_PRINT_FILE_NAME,
   CC_PROBE_PRINT_PROG_NAME,
   CC_PROBE_PRINT_LIBGCC_FILE_NAME,
   CC_PROBE_PRINT_MULTI_OS_DIRECTORY,
   CC_PROBE_PRINT_RESOURCE_DIR,
   CC_PROBE_PRINT_SYSROOT,
   CC_PROBE_DUMPMACHINE,
   CC_PROBE_DUMPVERSION,
   CC_PROBE_DUMPSPECS,
 } CcProbeKind;
 
 typedef enum CcLinkItemKind {
   CC_LINK_SOURCE_FILE,
   CC_LINK_SOURCE_MEMORY,
   CC_LINK_OBJECT,
   CC_LINK_ARCHIVE,
   CC_LINK_DSO,
   CC_LINK_LIB,
 } CcLinkItemKind;
 
 typedef struct CcLinkItem {
   uint8_t kind; /* CcLinkItemKind */
   uint8_t pad[3];
   uint32_t index;
 } CcLinkItem;
 
 typedef struct CcArchiveInput {
   const char* path;
   int owned;
   size_t owned_size;
   uint8_t whole_archive;
   uint8_t link_mode;
   uint8_t group_id;
   uint8_t pad;
 } CcArchiveInput;
 
 typedef struct CcDsoInput {
   const char* path;
   int owned;
   size_t owned_size;
 } CcDsoInput;
 
 typedef struct CcPendingLib {
   const char* name;
   uint8_t whole_archive;
   uint8_t link_mode;
   uint8_t group_id;
   uint8_t resolved_kind; /* CcLinkItemKind: ARCHIVE or DSO */
   uint32_t resolved_index;
 } CcPendingLib;
 
 typedef struct CcOptions {
   DriverEnv* env;
   const char* driver_path;
   size_t argv_bound; /* upper bound on per-array list size */
 
   int compile_only;        /* -c               */
   int preprocess_only;     /* -E               */
   int syntax_only;         /* -fsyntax-only / check */
   int emit_c_source;       /* --emit=c         */
   int emit_ir;             /* --emit=ir        */
   int emit_asm_source;     /* -S               */
   int opt_level;           /* -O0/-O1/-O2      */
   int debug_info;          /* -g               */
   int function_sections;   /* -ffunction-sections */
   int data_sections;       /* -fdata-sections     */
   int lto;                 /* -flto/-fno-lto      */
   int warnings_are_errors; /* -Werror     */
   uint32_t max_errors;     /* -fmax-errors=N   */
   KitTargetSpec target;    /* -target / host   */
   int target_set;          /* did -target appear */
   const char* output_path; /* -o               */
   int output_path_set;
   char* owned_output_path;
   size_t owned_output_path_size;
   const char* sysroot;        /* --sysroot / -isysroot */
   int freestanding;           /* -ffreestanding (suppresses sysroot headers) */
   uint8_t default_visibility; /* KitSymVis; -fvisibility=... */
   int nostdinc;               /* -nostdinc (suppresses sysroot headers) */
   const char* support_dir;    /* --support-dir    */
   int probe_kind;             /* CcProbeKind      */
   const char* probe_arg;      /* -print-file-name= / -print-prog-name= */
 
   /* -ffile-prefix-map=old=new entries; old is heap-owned (split out), new
    * aliases argv. */
   KitPathPrefixMap* path_map;
   uint32_t npath_map;
   char** owned_path_map_olds;
   size_t* owned_path_map_old_sizes;
 
   /* Reproducibility: SOURCE_DATE_EPOCH parsed at end-of-parse. */
   uint64_t epoch;
 
   /* Cflags via shared helper. */
   DriverCflags cf;
   DriverTargetFeatures target_features;
 
   /* Positional inputs split by suffix. */
   const char** source_files; /* .c paths */
   KitLanguage* source_langs;
   uint32_t nsource_files;
   KitSourceInput* source_memory; /* "-" stdin slurp   */
   uint32_t nsource_memory;
   uint8_t* stdin_buf; /* owning storage for the one stdin */
   size_t stdin_size;
   const char** object_files; /* .o/.obj paths     */
   uint32_t nobject_files;
   CcArchiveInput* archives; /* .a paths + resolved -l names */
   uint32_t narchives;
   CcDsoInput* dsos;
   uint32_t ndsos;
   /* -L search paths (argv-borrowed; last slot may be owned, see
    * owned_sysroot_lib_dir). */
   const char** lib_search_paths;
   uint32_t nlib_search_paths;
   /* Owned `<sysroot>/lib` slot appended for Windows targets when a
    * sysroot is in effect (cmdline or KIT_SYSROOT). */
   char* owned_sysroot_lib_dir;
   size_t owned_sysroot_lib_dir_size;
   /* Pending -l names (resolved at end-of-parse). */
   CcPendingLib* pending_libs;
   uint32_t npending_libs;
   CcLinkItem* link_items;
   uint32_t nlink_items;
   uint8_t cur_whole_archive;
   uint8_t cur_link_mode;
   uint8_t cur_group_id;
   uint8_t next_group_id;
 
   /* -M family */
   int dep_mode;             /* CcDepMode */
   int dep_phony;            /* -MP       */
   const char* dep_file;     /* -MF       */
   const char** dep_targets; /* -MT/-MQ   */
   uint32_t ndep_targets;
 
   /* Link-session options and owned -Wl state. */
   DriverLinkFlags link;
   int shared; /* -shared */
   int static_link;
   int pie;
   int no_stdlib;
   int no_defaultlibs;
   int no_startfiles;
   int wants_hosted_libc;
   DriverHostedPlan hosted;
 } CcOptions;
 
 static void cc_usage(void) {
   driver_errf(CC_TOOL, "%.*s",
               KIT_SLICE_ARG(KIT_SLICE_LIT(
                   "usage: kit cc [-c|-E|-shared] [-o out] "
                   "[options...] inputs...\n"
                   "       kit cc --help    for full option reference")));
 }
 
 void driver_help_cc(void) {
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "kit cc — C compiler driver\n"
           "\n"
           "USAGE\n"
           "  kit cc [options] inputs...                   compile and link "
           "to "
           "exe\n"
           "  kit cc -c [options] input.c                  compile one source "
           "to "
           ".o\n"
           "  kit cc -E [options] input.c                  preprocess to -o\n"
           "  kit cc -fsyntax-only [options] inputs...     check only\n"
           "  kit cc -shared [options] inputs...           link a shared "
           "library\n"
           "  kit cc -M|-MM [options] input.c              print header deps; "
           "no "
           "compile\n"
           "  --sysroot DIR / -isysroot DIR                  hosted "
           "SDK/sysroot\n"
           "  --support-dir DIR                              kit support "
           "root\n"
           "  -print-search-dirs / -print-sysroot            show the dirs "
           "the\n"
           "  -print-resource-dir                            compiler will "
           "search\n"
           "  -S [options] input.c                           emit assembly "
           "(.s)\n"
           "  --emit=c [options] input.c                     emit portable C "
           "source\n"
           "  --emit=ir -O1 [options] input.c                emit semantic IR "
           "dump\n"
           "  -flto                                           link-time "
           "optimization for all source inputs\n"
           "\n"
           "(see source for the full GCC-subset flag reference)\n")));
 }
 
 void driver_help_check(void) {
   driver_printf("%.*s",
                 KIT_SLICE_ARG(KIT_SLICE_LIT(
                     "kit check — run frontend checks without emitting code\n"
                     "\n"
                     "USAGE\n"
                     "  kit check [cc-options] inputs...\n"
                     "\n"
                     "Runs the same C frontend path as `kit cc "
                     "-fsyntax-only`, including "
                     "preprocessing and diagnostics, but does not write objects "
                     "or link.\n")));
 }
 
 static int cc_alloc_arrays(CcOptions* o, int argc) {
   size_t bound = (size_t)argc + 16u;
   o->argv_bound = bound;
   o->source_files =
       driver_alloc_zeroed(o->env, bound * sizeof(*o->source_files));
   o->source_langs =
       driver_alloc_zeroed(o->env, bound * sizeof(*o->source_langs));
   o->source_memory =
       driver_alloc_zeroed(o->env, bound * sizeof(*o->source_memory));
   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));
   o->dep_targets = driver_alloc_zeroed(o->env, bound * sizeof(*o->dep_targets));
   o->path_map = driver_alloc_zeroed(o->env, bound * sizeof(*o->path_map));
   o->owned_path_map_olds =
       driver_alloc_zeroed(o->env, bound * sizeof(*o->owned_path_map_olds));
   o->owned_path_map_old_sizes =
       driver_alloc_zeroed(o->env, bound * sizeof(*o->owned_path_map_old_sizes));
   if (!o->source_files || !o->source_langs || !o->source_memory ||
       !o->object_files || !o->archives || !o->dsos || !o->lib_search_paths ||
       !o->pending_libs || !o->link_items || !o->dep_targets || !o->path_map ||
       !o->owned_path_map_olds || !o->owned_path_map_old_sizes) {
     driver_errf(CC_TOOL, "out of memory");
     return 1;
   }
   o->cur_link_mode = KIT_LM_DEFAULT;
   if (driver_link_flags_init(&o->link, o->env, CC_TOOL, (uint32_t)bound) != 0 ||
       driver_cflags_init(&o->cf, o->env,
                          (int)(bound + DRIVER_HOSTED_MAX_DEFINES +
                                DRIVER_HOSTED_MAX_INCLUDES)) != 0 ||
       driver_target_features_init(&o->target_features, o->env, argc) != 0) {
     driver_errf(CC_TOOL, "out of memory");
     return 1;
   }
   return 0;
 }
 
 static void cc_options_release(CcOptions* 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->npath_map; ++i) {
     if (o->owned_path_map_olds[i]) {
       driver_free(o->env, o->owned_path_map_olds[i],
                   o->owned_path_map_old_sizes[i]);
     }
   }
   if (o->stdin_buf) driver_free(o->env, o->stdin_buf, o->stdin_size);
   if (o->owned_output_path)
     driver_free(o->env, o->owned_output_path, o->owned_output_path_size);
   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);
   driver_cflags_fini(&o->cf, o->env);
   driver_free(o->env, o->source_files, bound * sizeof(*o->source_files));
   driver_free(o->env, o->source_langs, bound * sizeof(*o->source_langs));
   driver_free(o->env, o->source_memory, bound * sizeof(*o->source_memory));
   driver_free(o->env, o->object_files, bound * sizeof(*o->object_files));
   driver_free(o->env, o->archives, bound * sizeof(*o->archives));
   driver_free(o->env, o->dsos, bound * sizeof(*o->dsos));
   driver_free(o->env, o->lib_search_paths,
               bound * sizeof(*o->lib_search_paths));
   driver_free(o->env, o->pending_libs, bound * sizeof(*o->pending_libs));
   driver_free(o->env, o->link_items, bound * sizeof(*o->link_items));
   driver_free(o->env, o->dep_targets, bound * sizeof(*o->dep_targets));
   driver_free(o->env, o->path_map, bound * sizeof(*o->path_map));
   driver_free(o->env, o->owned_path_map_olds,
               bound * sizeof(*o->owned_path_map_olds));
   driver_free(o->env, o->owned_path_map_old_sizes,
               bound * sizeof(*o->owned_path_map_old_sizes));
 }
 
 static int cc_apply_hosted_profile(CcOptions* o);
 
 /* 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. cc still treats .h as a header, not a source — the
  * helper excludes it. */
 static int cc_is_c_source(const char* s) { return driver_path_is_source(s); }
 
 static int cc_is_dso_input(const char* s) {
   return driver_has_suffix(s, ".so") || driver_has_suffix(s, ".dylib") ||
          driver_has_suffix(s, ".tbd");
 }
 
 static void cc_push_link_item(CcOptions* o, uint8_t kind, uint32_t index) {
   CcLinkItem* it = &o->link_items[o->nlink_items++];
   it->kind = kind;
   it->index = index;
 }
 
 static void cc_insert_link_item(CcOptions* 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 cc_append_hosted_input(CcOptions* 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 = CC_LINK_OBJECT;
       break;
     case DRIVER_HOSTED_INPUT_ARCHIVE: {
       CcArchiveInput* ar = &o->archives[o->narchives++];
       ar->path = in->path;
       ar->whole_archive = 0;
       ar->link_mode = KIT_LM_DEFAULT;
       ar->group_id = 0;
       index = o->narchives - 1u;
       kind = CC_LINK_ARCHIVE;
       break;
     }
     case DRIVER_HOSTED_INPUT_DSO: {
       CcDsoInput* d = &o->dsos[o->ndsos++];
       d->path = in->path;
       index = o->ndsos - 1u;
       kind = CC_LINK_DSO;
       break;
     }
     default:
       driver_errf(CC_TOOL, "internal error: unknown hosted input kind");
       return 1;
   }
   if (insert)
     cc_insert_link_item(o, insert_pos, kind, index);
   else
     cc_push_link_item(o, kind, index);
   return 0;
 }
 
 static void cc_insert_runtime_archive(CcOptions* o, DriverRuntimeArchive* rt,
                                       uint32_t insert_pos) {
   CcArchiveInput* 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;
   cc_insert_link_item(o, insert_pos, CC_LINK_ARCHIVE, o->narchives - 1u);
 }
 
 static int cc_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 cc_record_path_map(CcOptions* o, const char* arg) {
   const char* eq = driver_strchr(arg, '=');
   KitPathPrefixMap* m = &o->path_map[o->npath_map];
   if (!eq) {
     driver_errf(CC_TOOL, "-ffile-prefix-map requires old=new");
     return 1;
   }
   {
     size_t n = (size_t)(eq - arg);
     size_t bytes = n + 1;
     char* old_ = driver_alloc(o->env, bytes);
     if (!old_) {
       driver_errf(CC_TOOL, "out of memory");
       return 1;
     }
     driver_memcpy(old_, arg, n);
     old_[n] = '\0';
     o->owned_path_map_olds[o->npath_map] = old_;
     o->owned_path_map_old_sizes[o->npath_map] = bytes;
     m->old_prefix = old_;
     m->new_prefix = eq + 1;
   }
   o->npath_map++;
   return 0;
 }
 
 static int cc_record_mcmodel(CcOptions* o, const char* val) {
   if (driver_streq(val, "small")) {
     o->target.code_model = KIT_CM_SMALL;
     return 0;
   }
   if (driver_streq(val, "medium")) {
     o->target.code_model = KIT_CM_MEDIUM;
     return 0;
   }
   if (driver_streq(val, "large")) {
     o->target.code_model = KIT_CM_LARGE;
     return 0;
   }
   if (driver_streq(val, "medlow")) {
     o->target.code_model = KIT_CM_SMALL;
     return 0;
   }
   if (driver_streq(val, "medany")) {
     o->target.code_model = KIT_CM_MEDIUM;
     return 0;
   }
   driver_errf(CC_TOOL, "unknown -mcmodel value: %.*s",
               KIT_SLICE_ARG(kit_slice_cstr(val)));
   return 1;
 }
 
 static int cc_set_probe(CcOptions* o, int kind, const char* arg) {
   if (o->probe_kind != CC_PROBE_NONE) {
     driver_errf(CC_TOOL, "only one compiler-information probe is supported");
     return 1;
   }
   o->probe_kind = kind;
   o->probe_arg = arg;
   return 0;
 }
 
 /* Emit one element of a colon-separated search path. *first tracks whether a
  * leading separator is needed; NULL/empty entries are skipped. */
 static void cc_print_path_elem(const char* dir, int* first) {
   if (!dir || !dir[0]) return;
   driver_printf("%s%.*s", *first ? "" : ":",
                 KIT_SLICE_ARG(kit_slice_cstr(dir)));
   *first = 0;
 }
 
 static int cc_run_probe(CcOptions* o) {
   char triple[64];
   if (driver_target_to_triple(o->target, triple, sizeof(triple)) != 0) {
     driver_errf(CC_TOOL, "failed to render target triple");
     return 1;
   }
 
   switch (o->probe_kind) {
     case CC_PROBE_PRINT_SEARCH_DIRS: {
       DriverRuntimeSupport rt = {0};
       int have_rt = (driver_runtime_resolve(o->env, o->support_dir,
                                             o->driver_path, &rt) == 0);
       DriverHostedDirs dirs;
       int have_dirs = 0;
       uint32_t i;
       int first;
       /* Resolve the hosted include/library dirs directly: a probe run skips the
        * parse-time hosted profile (no compile happens), so they are not yet in
        * cf. Gated on hosted libc being engaged (-lc / sysroot). */
       if (o->wants_hosted_libc) {
         DriverHostedRequest req = {0};
         req.env = o->env;
         req.tool = CC_TOOL;
         req.target = o->target;
         req.sysroot = o->sysroot;
         req.static_link = o->static_link;
         req.link_inputs = 1;
         have_dirs = (driver_hosted_dirs_resolve(&req, &dirs) == 0);
       }
       driver_printf("install: %.*s\n",
                     KIT_SLICE_ARG(kit_slice_cstr(
                         have_rt ? rt.support_root
                                 : (o->support_dir ? o->support_dir : ""))));
       driver_printf("programs: =\n");
       /* libraries: hosted crt/libc search dirs, then user -L dirs, then the kit
        * runtime dir holding libkit_rt.a. */
       driver_printf("libraries: =");
       first = 1;
       if (have_dirs)
         for (i = 0; i < dirs.nlibdirs; ++i)
           cc_print_path_elem(dirs.libdirs[i], &first);
       for (i = 0; i < o->nlib_search_paths; ++i)
         cc_print_path_elem(o->lib_search_paths[i], &first);
       if (have_rt) cc_print_path_elem(rt.rt_root, &first);
       driver_printf("\n");
       /* includes: user -I/-isystem, then the hosted system headers, then the
        * freestanding runtime headers. (kit extension to GCC's output.) */
       driver_printf("includes: =");
       first = 1;
       for (i = 0; i < o->cf.ninclude_dirs; ++i)
         cc_print_path_elem(o->cf.include_dirs[i], &first);
       for (i = 0; i < o->cf.nsystem_include_dirs; ++i)
         cc_print_path_elem(o->cf.system_include_dirs[i], &first);
       if (have_dirs)
         for (i = 0; i < dirs.nincdirs; ++i)
           cc_print_path_elem(dirs.incdirs[i], &first);
       if (have_rt) cc_print_path_elem(rt.include_dir, &first);
       driver_printf("\n");
       if (have_dirs) driver_hosted_dirs_fini(&dirs);
       if (have_rt) driver_runtime_support_fini(o->env, &rt);
       return 0;
     }
     case CC_PROBE_PRINT_FILE_NAME:
       driver_printf(
           "%.*s\n",
           KIT_SLICE_ARG(kit_slice_cstr(o->probe_arg ? o->probe_arg : "")));
       return 0;
     case CC_PROBE_PRINT_PROG_NAME:
       driver_printf(
           "%.*s\n",
           KIT_SLICE_ARG(kit_slice_cstr(o->probe_arg ? o->probe_arg : "")));
       return 0;
     case CC_PROBE_PRINT_LIBGCC_FILE_NAME:
       driver_printf("libkit_rt.a\n");
       return 0;
     case CC_PROBE_PRINT_MULTI_OS_DIRECTORY:
       driver_printf(".\n");
       return 0;
     case CC_PROBE_PRINT_RESOURCE_DIR: {
       /* clang convention: the resource-dir root, with builtin/freestanding
        * headers under <resource-dir>/include. */
       DriverRuntimeSupport rt = {0};
       if (driver_runtime_resolve(o->env, o->support_dir, o->driver_path, &rt) ==
           0) {
         driver_printf("%.*s\n", KIT_SLICE_ARG(kit_slice_cstr(rt.rt_root)));
         driver_runtime_support_fini(o->env, &rt);
       } else {
         driver_printf("%.*s\n", KIT_SLICE_ARG(kit_slice_cstr(
                                     o->support_dir ? o->support_dir : "")));
       }
       return 0;
     }
     case CC_PROBE_PRINT_SYSROOT: {
       /* The effective sysroot root: command-line --sysroot or KIT_SYSROOT, else
        * the native host probe when it resolves to a single tree (the macOS
        * SDK). Empty for a multi-dir probe (Linux/FreeBSD) or a cross target
        * with no sysroot, which have no single root. */
       DriverHostedRequest req = {0};
       DriverHostedDirs dirs;
       req.env = o->env;
       req.tool = CC_TOOL;
       req.target = o->target;
       req.sysroot = o->sysroot;
       req.static_link = o->static_link;
       req.link_inputs = 1;
       if (driver_hosted_dirs_resolve(&req, &dirs) == 0) {
         driver_printf(
             "%.*s\n",
             KIT_SLICE_ARG(kit_slice_cstr(dirs.root ? dirs.root : "")));
         driver_hosted_dirs_fini(&dirs);
       } else {
         driver_printf("\n");
       }
       return 0;
     }
     case CC_PROBE_DUMPMACHINE:
       driver_printf("%.*s\n", KIT_SLICE_ARG(kit_slice_cstr(triple)));
       return 0;
     case CC_PROBE_DUMPVERSION:
       driver_printf("0\n");
       return 0;
     case CC_PROBE_DUMPSPECS:
       driver_printf("*kit:\n");
       driver_printf("%%{!S:%%{!E:%%{!c:%%{!r:link}}}}\n");
       return 0;
     default:
       break;
   }
 
   return 0;
 }
 
 static int cc_record_stdin(CcOptions* o, int forced_lang) {
   KitSourceInput* in;
   if (o->stdin_buf) {
     driver_errf(CC_TOOL, "'-' (stdin) may appear at most once");
     return 1;
   }
   if (!driver_read_stdin(o->env, &o->stdin_buf, &o->stdin_size)) {
     driver_errf(CC_TOOL, "failed to read stdin");
     return 1;
   }
   in = &o->source_memory[o->nsource_memory++];
   in->name = KIT_SLICE_LIT("<stdin>");
   in->bytes.data = o->stdin_buf;
   in->bytes.len = o->stdin_size;
   in->lang = forced_lang >= 0 ? (KitLanguage)forced_lang : KIT_LANG_C;
   cc_push_link_item(o, CC_LINK_SOURCE_MEMORY, o->nsource_memory - 1u);
   return 0;
 }
 
 /* Stored in source_langs[] during arg parsing to mean "no -x override —
  * resolve from the path at compile time, once a compiler is around to
  * consult its frontend extension registry." */
 #define CC_LANG_AUTO ((KitLanguage)KIT_LANG_COUNT)
 
 static KitLanguage cc_resolve_lang(KitCompiler* c, const char* path,
                                    KitLanguage stored) {
   if (stored != CC_LANG_AUTO) return stored;
   return kit_language_for_path(c, path);
 }
 
 static int cc_classify_positional(CcOptions* o, const char* a,
                                   int forced_lang) {
   if (driver_streq(a, "-")) return cc_record_stdin(o, forced_lang);
   if (forced_lang >= 0 || cc_is_c_source(a)) {
     o->source_langs[o->nsource_files] =
         forced_lang >= 0 ? (KitLanguage)forced_lang : CC_LANG_AUTO;
     o->source_files[o->nsource_files++] = a;
     cc_push_link_item(o, CC_LINK_SOURCE_FILE, o->nsource_files - 1u);
     return 0;
   }
   if (driver_has_suffix(a, ".o") || driver_has_suffix(a, ".obj")) {
     o->object_files[o->nobject_files++] = a;
     cc_push_link_item(o, CC_LINK_OBJECT, o->nobject_files - 1u);
     return 0;
   }
   if (driver_has_suffix(a, ".a")) {
     CcArchiveInput* 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;
     cc_push_link_item(o, CC_LINK_ARCHIVE, o->narchives - 1u);
     return 0;
   }
   if (cc_is_dso_input(a)) {
     CcDsoInput* d = &o->dsos[o->ndsos++];
     d->path = a;
     cc_push_link_item(o, CC_LINK_DSO, o->ndsos - 1u);
     return 0;
   }
   driver_errf(CC_TOOL, "input does not have a recognized suffix: %.*s",
               KIT_SLICE_ARG(kit_slice_cstr(a)));
   return 1;
 }
 
 static int cc_resolve_pending_libs(CcOptions* o) {
   uint32_t i;
   for (i = 0; i < o->npending_libs; ++i) {
     CcPendingLib* 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(CC_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) {
       CcDsoInput* d = &o->dsos[o->ndsos++];
       d->path = p;
       d->owned = 1;
       d->owned_size = sz;
       pl->resolved_kind = CC_LINK_DSO;
       pl->resolved_index = o->ndsos - 1u;
     } else {
       CcArchiveInput* 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 = CC_LINK_ARCHIVE;
       pl->resolved_index = o->narchives - 1u;
     }
   }
   return 0;
 }
 
 static int cc_apply_hosted_profile(CcOptions* o) {
   DriverHostedRequest req;
   uint32_t i;
   uint32_t insert_pos = 0;
   int link_action = !o->compile_only && !o->preprocess_only &&
                     o->dep_mode != CC_DEP_M && o->dep_mode != CC_DEP_MM;
   if (!o->wants_hosted_libc || o->shared) return 0;
   if (o->no_stdlib || o->no_defaultlibs) {
     driver_errf(CC_TOOL,
                 "-lc hosted expansion is disabled by -nostdlib/-nodefaultlibs");
     return 1;
   }
   {
     DriverHostedRequest z = {0};
     req = z;
   }
   req.env = o->env;
   req.tool = CC_TOOL;
   req.target = o->target;
   req.sysroot = o->sysroot;
   req.static_link = o->static_link;
   req.link_inputs = link_action;
   if (driver_hosted_resolve(&req, &o->hosted) != 0) return 1;
   for (i = 0; i < o->hosted.nsystem_includes; ++i) {
     o->cf.system_include_dirs[o->cf.nsystem_include_dirs++] =
         o->hosted.system_includes[i];
   }
   for (i = 0; i < o->hosted.ndefines; ++i) {
     o->cf.defines[o->cf.ndefines++] = o->hosted.defines[i];
   }
   /* Add hosted lib search dirs so user -l flags (-lm, -lpthread, etc.) can be
    * resolved.  The strings are owned by o->hosted and outlive lib_search_paths.
    * Insert before any user -L dirs so sysroot libs take precedence. */
   for (i = 0; i < o->hosted.nlib_search_dirs; ++i)
     o->lib_search_paths[o->nlib_search_paths++] = o->hosted.lib_search_dirs[i];
   if (!link_action) return 0;
   for (i = 0; i < o->hosted.nbefore; ++i) {
     if (o->no_startfiles) break;
     if (cc_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 (cc_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 (cc_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;
 }
 
 static int cc_apply_env(CcOptions* o) {
   const char* sde = driver_getenv("SOURCE_DATE_EPOCH");
   if (sde && cc_parse_u64(sde, &o->epoch) != 0) {
     driver_errf(CC_TOOL, "invalid SOURCE_DATE_EPOCH: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(sde)));
     return 1;
   }
   return 0;
 }
 
 /* Append a default `<sysroot>/lib` to the library search path for
  * Windows targets. The llvm-mingw UCRT sysroot ships import archives
  * such as libkernel32.a, libucrt.a, and the UCRT API-set archives
  * under <sysroot>/lib; the user-supplied -L list is searched first,
  * then this appended default. Sysroot resolution order:
  *   1. -isysroot / --sysroot on the command line (already in
  *      o->sysroot at this point);
  *   2. KIT_SYSROOT env var (e.g. .../x86_64-w64-mingw32).
  *
  * No-op for non-Windows targets and for Windows when neither source
  * provides a sysroot — keeps existing tests untouched. The appended
  * path aliases the sysroot string for its lifetime; o->sysroot is
  * either argv-borrowed or env-borrowed, both stable across the
  * driver run, so the lib_search_paths slot remains valid. */
 static int cc_append_windows_lib_dirs(CcOptions* o) {
   const char* sysroot = o->sysroot;
   char* joined = NULL;
   size_t srlen;
   size_t need_slash;
   size_t bytes;
   size_t 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;
   /* "<sysroot>" + "/"? + "lib" + NUL */
   bytes = srlen + need_slash + 3u + 1u;
   joined = driver_alloc(o->env, bytes);
   if (!joined) {
     driver_errf(CC_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';
   if (o->owned_sysroot_lib_dir) {
     driver_free(o->env, o->owned_sysroot_lib_dir,
                 o->owned_sysroot_lib_dir_size);
   }
   o->owned_sysroot_lib_dir = joined;
   o->owned_sysroot_lib_dir_size = bytes;
   o->lib_search_paths[o->nlib_search_paths++] = joined;
   return 0;
 }
 
 static int cc_has_link_action(const CcOptions* o) {
   return !o->compile_only && !o->preprocess_only && o->dep_mode != CC_DEP_M &&
          o->dep_mode != CC_DEP_MM;
 }
 
 /* A sysroot on its own means "compile/link hosted against that root" — the
  * same default clang and gcc take for -isysroot/--sysroot. Engage the hosted
  * libc profile so the host headers, their feature-test defines (__GNUC__,
  * __APPLE__, __has_builtin, ...) and (for link actions) the host C runtime are
  * brought in. -ffreestanding and -nostdinc opt back out, keeping the
  * freestanding rt/include set standalone; -shared and the -nostdlib family
  * keep their existing meaning. The Windows-COFF default profile and an explicit
  * -lc already set the flag, so this is a no-op in those cases. */
 static void cc_enable_hosted_for_sysroot(CcOptions* 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 cc_apply_default_hosted_profile(CcOptions* 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;
   if (!cc_has_link_action(o) && o->nsource_files + o->nsource_memory == 0)
     return;
   o->wants_hosted_libc = 1;
 }
 
 static char* cc_dep_default_target(DriverEnv* env, const CcOptions* o,
                                    size_t* out_size);
 
 static int cc_parse(int argc, char** argv, CcOptions* o) {
   int forced_lang = -1;
   int i;
 
   if (cc_alloc_arrays(o, argc) != 0) return 1;
   o->target = driver_host_target();
 
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
 
     {
       int r =
           driver_cflags_try_consume(&o->cf, o->env, CC_TOOL, argc, argv, &i);
       if (r < 0) return 1;
       if (r > 0) continue;
     }
 
     if (driver_streq(a, "-c")) {
       o->compile_only = 1;
       continue;
     }
     if (driver_streq(a, "-v") || driver_streq(a, "-###")) {
       continue;
     }
     if (driver_streq(a, "-E")) {
       o->preprocess_only = 1;
       continue;
     }
     if (driver_streq(a, "-S")) {
       o->emit_asm_source = 1;
       o->compile_only = 1;
       continue;
     }
     if (driver_streq(a, "-fsyntax-only")) {
       o->syntax_only = 1;
       continue;
     }
     if (driver_streq(a, "--emit=c")) {
       /* C-source output instead of object bytes. Forces -c-style single-input
        * compile (no link). See doc/CBACKEND.md. */
       o->emit_c_source = 1;
       o->compile_only = 1;
       continue;
     }
     if (driver_streq(a, "--emit=ir")) {
       /* Textual semantic-IR dump instead of object bytes. The IR tape is only
        * recorded when the optimizer runs, so this requires -O1+ (validated
        * after argument parsing). Forces a single-input, no-link compile. */
       o->emit_ir = 1;
       o->compile_only = 1;
       continue;
     }
     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")) {
       o->opt_level = 2;
       continue;
     }
     if (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")) {
       o->warnings_are_errors = 1;
       continue;
     }
     if (driver_strneq(a, "-Werror=", 8)) {
       o->warnings_are_errors = 1;
       continue;
     }
     if (driver_streq(a, "-Wall") || driver_streq(a, "-Wextra") ||
         driver_streq(a, "-Wpedantic") || driver_streq(a, "-pedantic") ||
         driver_streq(a, "-pedantic-errors") || driver_streq(a, "-w") ||
         driver_strneq(a, "-Wno-", 5) ||
         (driver_strneq(a, "-W", 2) && !driver_strneq(a, "-Wl,", 4))) {
       continue;
     }
     if (driver_strneq(a, "-fmax-errors=", 13)) {
       uint64_t v;
       if (cc_parse_u64(a + 13, &v) != 0 || v > 0xFFFFFFFFu) {
         driver_errf(CC_TOOL, "-fmax-errors= requires a non-negative integer");
         return 1;
       }
       o->max_errors = (uint32_t)v;
       continue;
     }
     if (driver_strneq(a, "-std=", 5) || driver_streq(a, "-ansi")) {
       continue;
     }
     if (driver_streq(a, "-ffreestanding")) {
       o->freestanding = 1;
       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(CC_TOOL, "unsupported visibility: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(a + 13)));
       return 1;
     }
     if (driver_streq(a, "-fhosted")) {
       o->freestanding = 0;
       continue;
     }
     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, "-nostdinc")) {
       o->nostdinc = 1;
       continue;
     }
     if (driver_streq(a, "-fno-builtin") || driver_streq(a, "-pipe") ||
         driver_streq(a, "-pthread")) {
       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;
     }
     if (driver_streq(a, "-isysroot") || driver_streq(a, "--sysroot")) {
       if (++i >= argc) {
         driver_errf(CC_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(CC_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, "-print-search-dirs")) {
       if (cc_set_probe(o, CC_PROBE_PRINT_SEARCH_DIRS, NULL) != 0) return 1;
       continue;
     }
     if (driver_strneq(a, "-print-file-name=", 17)) {
       if (cc_set_probe(o, CC_PROBE_PRINT_FILE_NAME, a + 17) != 0) return 1;
       continue;
     }
     if (driver_strneq(a, "-print-prog-name=", 17)) {
       if (cc_set_probe(o, CC_PROBE_PRINT_PROG_NAME, a + 17) != 0) return 1;
       continue;
     }
     if (driver_streq(a, "-print-libgcc-file-name")) {
       if (cc_set_probe(o, CC_PROBE_PRINT_LIBGCC_FILE_NAME, NULL) != 0) return 1;
       continue;
     }
     if (driver_streq(a, "-print-multi-os-directory")) {
       if (cc_set_probe(o, CC_PROBE_PRINT_MULTI_OS_DIRECTORY, NULL) != 0)
         return 1;
       continue;
     }
     if (driver_streq(a, "-print-resource-dir")) {
       if (cc_set_probe(o, CC_PROBE_PRINT_RESOURCE_DIR, NULL) != 0) return 1;
       continue;
     }
     if (driver_streq(a, "-print-sysroot")) {
       if (cc_set_probe(o, CC_PROBE_PRINT_SYSROOT, NULL) != 0) return 1;
       continue;
     }
     if (driver_streq(a, "-dumpmachine")) {
       if (cc_set_probe(o, CC_PROBE_DUMPMACHINE, NULL) != 0) return 1;
       continue;
     }
     if (driver_streq(a, "-dumpversion")) {
       if (cc_set_probe(o, CC_PROBE_DUMPVERSION, NULL) != 0) return 1;
       continue;
     }
     if (driver_streq(a, "-dumpspecs")) {
       if (cc_set_probe(o, CC_PROBE_DUMPSPECS, NULL) != 0) return 1;
       continue;
     }
     if (driver_streq(a, "-include")) {
       if (++i >= argc) {
         driver_errf(CC_TOOL, "%.*s requires an argument",
                     KIT_SLICE_ARG(kit_slice_cstr(a)));
         return 1;
       }
       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, "-static")) {
       o->target.pic = KIT_PIC_NONE;
       o->static_link = 1;
       o->cur_link_mode = KIT_LM_STATIC;
       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;
     }
     if (driver_streq(a, "-rdynamic") || driver_streq(a, "-export-dynamic")) {
       /* GCC/clang: ask the linker to promote defined globals into .dynsym
        * (--export-dynamic). FreeBSD's HOST_ENV_LDFLAGS passes -rdynamic so a
        * dynamically linked exe re-exports symbols (e.g. `environ`) for libc.so
        * and for runtime symbolization. kit's ELF linker already exports the
        * defined symbols that the DSOs it links reference, which is what hosted
        * libc startup needs, so accept the flag for toolchain compatibility
        * rather than reject it. (The standalone `kit ld` carries the explicit
        * -E/--export-dynamic option for the full all-globals promotion.) */
       continue;
     }
     if (driver_streq(a, "-Bstatic")) {
       o->cur_link_mode = KIT_LM_STATIC;
       continue;
     }
     if (driver_streq(a, "-Bdynamic")) {
       o->cur_link_mode = KIT_LM_DYNAMIC;
       continue;
     }
     if (driver_streq(a, "--as-needed")) {
       o->cur_link_mode = KIT_LM_AS_NEEDED;
       continue;
     }
     if (driver_streq(a, "--no-as-needed")) {
       o->cur_link_mode = KIT_LM_DYNAMIC;
       continue;
     }
     if (driver_streq(a, "--whole-archive")) {
       o->cur_whole_archive = 1;
       continue;
     }
     if (driver_streq(a, "--no-whole-archive")) {
       o->cur_whole_archive = 0;
       continue;
     }
     if (driver_streq(a, "--start-group")) {
       if (o->cur_group_id != 0) {
         driver_errf(CC_TOOL, "nested --start-group is not supported");
         return 1;
       }
       if (o->next_group_id == UINT8_MAX) {
         driver_errf(CC_TOOL, "too many --start-group occurrences");
         return 1;
       }
       o->cur_group_id = ++o->next_group_id;
       continue;
     }
     if (driver_streq(a, "--end-group")) {
       if (o->cur_group_id == 0) {
         driver_errf(CC_TOOL, "--end-group without --start-group");
         return 1;
       }
       o->cur_group_id = 0;
       continue;
     }
 
     if (driver_streq(a, "-shared")) {
       o->shared = 1;
       if (o->target.pic == KIT_PIC_NONE) o->target.pic = KIT_PIC_PIC;
       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, "-Wl,", 4)) {
       if (driver_link_flags_record_wl(&o->link, a + 4) != 0) return 1;
       continue;
     }
 
     if (driver_strneq(a, "-mcmodel=", 9)) {
       if (cc_record_mcmodel(o, a + 9) != 0) return 1;
       continue;
     }
     {
       int tr = driver_target_features_try_consume(&o->target_features, o->env,
                                                   CC_TOOL, argc, argv, &i);
       if (tr < 0) return 1;
       if (tr > 0) 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_strneq(a, "-ffile-prefix-map=", 18)) {
       if (cc_record_path_map(o, a + 18) != 0) return 1;
       continue;
     }
 
     if (driver_streq(a, "-o")) {
       if (++i >= argc) {
         driver_errf(CC_TOOL, "-o requires an argument");
         return 1;
       }
       o->output_path = argv[i];
       o->output_path_set = 1;
       continue;
     }
     if (driver_strneq(a, "--output=", 9)) {
       o->output_path = a + 9;
       o->output_path_set = 1;
       continue;
     }
     if (driver_streq(a, "--output")) {
       if (++i >= argc) {
         driver_errf(CC_TOOL, "--output requires an argument");
         return 1;
       }
       o->output_path = argv[i];
       o->output_path_set = 1;
       continue;
     }
     if (driver_streq(a, "-e")) {
       if (++i >= argc) {
         driver_errf(CC_TOOL, "-e requires an argument");
         return 1;
       }
       o->link.entry = argv[i];
       continue;
     }
     if (driver_streq(a, "-T")) {
       if (++i >= argc) {
         driver_errf(CC_TOOL, "-T requires an argument");
         return 1;
       }
       o->link.linker_script = argv[i];
       continue;
     }
     if (driver_streq(a, "-target")) {
       if (++i >= argc) {
         driver_errf(CC_TOOL, "-target requires an argument");
         return 1;
       }
       if (driver_target_from_triple(argv[i], &o->target) != 0) {
         driver_errf(CC_TOOL, "unrecognized target triple: %.*s",
                     KIT_SLICE_ARG(kit_slice_cstr(argv[i])));
         return 1;
       }
       o->target_set = 1;
       continue;
     }
     if (driver_strneq(a, "--target=", 9)) {
       if (driver_target_from_triple(a + 9, &o->target) != 0) {
         driver_errf(CC_TOOL, "unrecognized target triple: %.*s",
                     KIT_SLICE_ARG(kit_slice_cstr(a + 9)));
         return 1;
       }
       o->target_set = 1;
       continue;
     }
     if (driver_streq(a, "--target")) {
       if (++i >= argc) {
         driver_errf(CC_TOOL, "--target requires an argument");
         return 1;
       }
       if (driver_target_from_triple(argv[i], &o->target) != 0) {
         driver_errf(CC_TOOL, "unrecognized target triple: %.*s",
                     KIT_SLICE_ARG(kit_slice_cstr(argv[i])));
         return 1;
       }
       o->target_set = 1;
       continue;
     }
     if (driver_streq(a, "-Xlinker")) {
       if (++i >= argc) {
         driver_errf(CC_TOOL, "-Xlinker requires an argument");
         return 1;
       }
       if (driver_link_flags_record_wl(&o->link, argv[i]) != 0) return 1;
       continue;
     }
     if (driver_streq(a, "-x")) {
       if (++i >= argc) {
         driver_errf(CC_TOOL, "-x requires an argument");
         return 1;
       }
       if (driver_streq(argv[i], "none")) {
         forced_lang = -1;
         continue;
       }
       /* cc-only CLI aliases that have no frontend `-x` name: GCC's "asm-cpp"
        * and the case-sensitive "S" (distinct from "s") both select asm. */
       if (driver_streq(argv[i], "asm-cpp") || driver_streq(argv[i], "S")) {
         forced_lang = KIT_LANG_ASM;
         continue;
       }
       {
         KitLanguage lang = kit_language_for_name(NULL, argv[i]);
         if (lang == KIT_LANG_UNKNOWN) {
           driver_errf(CC_TOOL, "unsupported -x language: %.*s",
                       KIT_SLICE_ARG(kit_slice_cstr(argv[i])));
           return 1;
         }
         forced_lang = lang;
         continue;
       }
     }
     if (driver_strneq(a, "-L", 2)) {
       const char* dir = a[2] ? a + 2 : (++i < argc ? argv[i] : NULL);
       if (!dir) {
         driver_errf(CC_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(CC_TOOL, "-l requires an argument");
         return 1;
       }
       if (driver_streq(name, "c") && !o->no_stdlib && !o->no_defaultlibs) {
         o->wants_hosted_libc = 1;
         continue;
       }
       {
         CcPendingLib* 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;
         cc_push_link_item(o, CC_LINK_LIB, o->npending_libs - 1u);
       }
       continue;
     }
 
     if (driver_streq(a, "-M")) {
       o->dep_mode = CC_DEP_M;
       continue;
     }
     if (driver_streq(a, "-MM")) {
       o->dep_mode = CC_DEP_MM;
       continue;
     }
     if (driver_streq(a, "-MD")) {
       o->dep_mode = CC_DEP_MD;
       continue;
     }
     if (driver_streq(a, "-MMD")) {
       o->dep_mode = CC_DEP_MMD;
       continue;
     }
     if (driver_streq(a, "-MP")) {
       o->dep_phony = 1;
       continue;
     }
     if (driver_streq(a, "-MF")) {
       if (++i >= argc) {
         driver_errf(CC_TOOL, "-MF requires an argument");
         return 1;
       }
       o->dep_file = argv[i];
       continue;
     }
     if (driver_streq(a, "-MT") || driver_streq(a, "-MQ")) {
       if (++i >= argc) {
         driver_errf(CC_TOOL, "%.*s requires an argument",
                     KIT_SLICE_ARG(kit_slice_cstr(a)));
         return 1;
       }
       o->dep_targets[o->ndep_targets++] = argv[i];
       continue;
     }
 
     if (driver_streq(a, "--")) {
       for (++i; i < argc; ++i) {
         if (cc_classify_positional(o, argv[i], forced_lang) != 0) return 1;
       }
       break;
     }
     if (driver_streq(a, "-")) {
       if (cc_classify_positional(o, a, forced_lang) != 0) return 1;
       continue;
     }
     if (a[0] == '-' && a[1] != '\0') {
       driver_errf(CC_TOOL, "unknown flag: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(a)));
       return 1;
     }
 
     if (cc_classify_positional(o, a, forced_lang) != 0) return 1;
   }
 
   if (o->probe_kind != CC_PROBE_NONE) return 0;
 
   if (cc_apply_env(o) != 0) return 1;
   if (cc_append_windows_lib_dirs(o) != 0) return 1;
 
   {
     uint32_t total_sources = o->nsource_files + o->nsource_memory;
     uint32_t total_link =
         o->nobject_files + o->narchives + o->ndsos + o->npending_libs;
 
     if (total_sources == 0 && total_link == 0) {
       driver_errf(CC_TOOL, "no input files");
       cc_usage();
       return 1;
     }
     if ((o->compile_only && o->preprocess_only) ||
         (o->emit_asm_source && o->preprocess_only) ||
         (o->syntax_only &&
          (o->compile_only || o->preprocess_only || o->emit_asm_source))) {
       driver_errf(CC_TOOL,
                   "-c, -S, -E, and -fsyntax-only are mutually exclusive");
       return 1;
     }
     if (o->shared && (o->compile_only || o->emit_asm_source ||
                       o->preprocess_only || o->syntax_only)) {
       driver_errf(CC_TOOL,
                   "-shared is incompatible with -c/-S/-E/-fsyntax-only");
       return 1;
     }
     if (o->shared && o->lto) {
       driver_errf(CC_TOOL,
                   "-shared -flto is not supported yet "
                   "(shared-library LTO output is not exercised)");
       return 1;
     }
     if (o->shared) {
       driver_errf(CC_TOOL,
                   "creating dynamic/shared libraries is not yet supported");
       return 1;
     }
     if (o->emit_ir && o->opt_level < 1) {
       driver_errf(CC_TOOL,
                   "--emit=ir requires -O1 or higher "
                   "(the IR tape is only recorded when the optimizer runs)");
       return 1;
     }
     if (o->syntax_only) {
       if (total_sources == 0 || total_link != 0) {
         driver_errf(CC_TOOL,
                     "-fsyntax-only requires source inputs and no link inputs");
         return 1;
       }
       if (o->output_path) {
         driver_errf(CC_TOOL, "-o is incompatible with -fsyntax-only");
         return 1;
       }
       if (o->dep_mode != CC_DEP_NONE) {
         driver_errf(CC_TOOL, "-M* is incompatible with -fsyntax-only");
         return 1;
       }
     }
     if (!o->shared && o->link.soname) {
       driver_errf(CC_TOOL, "-Wl,-soname requires -shared");
       return 1;
     }
     if (o->cur_group_id != 0) {
       driver_errf(CC_TOOL, "missing --end-group");
       return 1;
     }
     if (o->compile_only) {
       if (total_sources == 0 || total_link != 0) {
         driver_errf(CC_TOOL, "-c requires source inputs and no link inputs");
         return 1;
       }
       if (o->output_path && total_sources > 1) {
         driver_errf(CC_TOOL, "-o cannot be used with -c and multiple sources");
         return 1;
       }
     }
     if (o->preprocess_only) {
       if (total_sources != 1 || total_link != 0) {
         driver_errf(CC_TOOL,
                     "-E requires exactly one C source and no .o/.a inputs");
         return 1;
       }
     }
     {
       int dep_only = (o->dep_mode == CC_DEP_M || o->dep_mode == CC_DEP_MM);
       int dep_with_compile =
           (o->dep_mode == CC_DEP_MD || o->dep_mode == CC_DEP_MMD);
       if (o->dep_mode != CC_DEP_NONE && o->preprocess_only) {
         driver_errf(CC_TOOL, "-M* is incompatible with -E");
         return 1;
       }
       if (dep_only && total_sources != 1) {
         driver_errf(CC_TOOL, "-M/-MM requires exactly one input");
         return 1;
       }
       if (dep_with_compile && !o->compile_only) {
         driver_errf(CC_TOOL, "-MD/-MMD currently requires -c");
         return 1;
       }
       if (dep_with_compile && total_sources != 1) {
         driver_errf(CC_TOOL, "-MD/-MMD currently requires exactly one source");
         return 1;
       }
       if (!o->output_path && !dep_only) {
         if (o->syntax_only) {
           /* no output */
         } else if (o->compile_only) {
           if (total_sources == 1) {
             o->owned_output_path =
                 cc_dep_default_target(o->env, o, &o->owned_output_path_size);
             if (!o->owned_output_path) {
               driver_errf(CC_TOOL, "out of memory");
               return 1;
             }
             o->output_path = o->owned_output_path;
           }
         } else if (o->preprocess_only) {
           /* stdout */
         } else {
           o->output_path = driver_default_exe_name(o->target);
         }
       }
     }
   }
   cc_enable_hosted_for_sysroot(o);
   cc_apply_default_hosted_profile(o);
   if (cc_apply_hosted_profile(o) != 0) return 1;
   if (!o->syntax_only && cc_resolve_pending_libs(o) != 0) return 1;
   return 0;
 }
 
 static const char* cc_primary_source_name(const CcOptions* o);
 
 /* Borrow the single source as a KitSlice. `*loaded` is set nonzero only
  * when the file was opened via file_io and must be released. */
 static int cc_load_single_source(const KitContext* ctx, const CcOptions* o,
                                  KitSlice* in, KitFileData* fd, int* loaded) {
   *loaded = 0;
   if (o->nsource_memory == 1) {
     *in = o->source_memory[0].bytes;
     return 0;
   }
   if (ctx->file_io->read_all(ctx->file_io->user, o->source_files[0], fd) !=
       KIT_OK) {
     driver_errf(CC_TOOL, "failed to read: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(o->source_files[0])));
     return 1;
   }
   *loaded = 1;
   in->data = fd->data;
   in->len = fd->size;
   return 0;
 }
 
 static KitStatus cc_compiler_new(const CcOptions* o, const KitContext* ctx,
                                  KitTarget** target_out,
                                  KitCompiler** compiler_out) {
   KitStatus st;
   if (target_out) *target_out = NULL;
   if (compiler_out) *compiler_out = NULL;
   if (!o || !ctx || !target_out || !compiler_out) return KIT_INVALID;
   st = driver_target_new(ctx, o->target, &o->target_features, CC_TOOL,
                          target_out);
   if (st != KIT_OK) return st;
   st = driver_compiler_new(*target_out, ctx, compiler_out);
   if (st != KIT_OK) {
     kit_target_free(*target_out);
     *target_out = NULL;
   }
   return st;
 }
 
 static int cc_preprocess(DriverEnv* env, const CcOptions* o,
                          const KitPreprocessOptions* pp_opts) {
   KitContext ctx = driver_env_to_context(env);
   KitTarget* target = NULL;
   KitCompiler* compiler = NULL;
   KitWriter* writer = NULL;
   KitFileData fd = {0};
   KitSlice input = {0};
   int rc = 1;
   int loaded = 0;
 
   if (cc_load_single_source(&ctx, o, &input, &fd, &loaded) != 0) goto out;
 
   if (o->output_path) {
     if (ctx.file_io->open_writer(ctx.file_io->user, o->output_path, &writer) !=
         KIT_OK) {
       driver_errf(CC_TOOL, "failed to open output: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(o->output_path)));
       goto out;
     }
   } else {
     writer = driver_stdout_writer(env);
     if (!writer) {
       driver_errf(CC_TOOL, "out of memory");
       goto out;
     }
   }
 
   if (cc_compiler_new(o, &ctx, &target, &compiler) != KIT_OK) {
     driver_errf(CC_TOOL, "failed to initialize compiler");
     goto out;
   }
 
   rc = kit_cpp_preprocess(compiler, pp_opts,
                           kit_slice_cstr(cc_primary_source_name(o)), &input,
                           writer) == KIT_OK
            ? 0
            : 1;
 
 out:
   if (compiler) driver_compiler_free(compiler);
   kit_target_free(target);
   if (writer) kit_writer_close(writer);
   if (loaded) ctx.file_io->release(ctx.file_io->user, &fd);
   return rc;
 }
 
 /* ---- header-dependency output (-M family) ---- */
 
 typedef struct CcDepList {
   const char** items;
   uint32_t n;
   uint32_t cap;
 } CcDepList;
 
 typedef struct CcDiscardWriter {
   KitWriter base;
   DriverEnv* env;
   uint64_t pos;
 } CcDiscardWriter;
 
 static KitStatus cc_disc_write(KitWriter* w, const void* d, size_t n) {
   (void)d;
   ((CcDiscardWriter*)w)->pos += (uint64_t)n;
   return KIT_OK;
 }
 static KitStatus cc_disc_seek(KitWriter* w, uint64_t off) {
   ((CcDiscardWriter*)w)->pos = off;
   return KIT_OK;
 }
 static uint64_t cc_disc_tell(KitWriter* w) {
   return ((CcDiscardWriter*)w)->pos;
 }
 static KitStatus cc_disc_status(KitWriter* w) {
   (void)w;
   return KIT_OK;
 }
 static void cc_disc_close(KitWriter* w) {
   CcDiscardWriter* dw = (CcDiscardWriter*)w;
   driver_free(dw->env, dw, sizeof(*dw));
 }
 
 static KitWriter* cc_discard_writer_new(DriverEnv* env) {
   CcDiscardWriter* dw = (CcDiscardWriter*)driver_alloc_zeroed(env, sizeof(*dw));
   if (!dw) return NULL;
   dw->base.write = cc_disc_write;
   dw->base.seek = cc_disc_seek;
   dw->base.tell = cc_disc_tell;
   dw->base.status = cc_disc_status;
   dw->base.close = cc_disc_close;
   dw->env = env;
   return &dw->base;
 }
 
 static void cc_write_str(KitWriter* w, const char* s) {
   kit_writer_write(w, s, driver_strlen(s));
 }
 
 static int cc_dep_filters_system(int mode) {
   return mode == CC_DEP_MM || mode == CC_DEP_MMD;
 }
 
 static int cc_dep_list_push(DriverEnv* env, CcDepList* l, const char* s) {
   uint32_t i;
   for (i = 0; i < l->n; ++i) {
     if (driver_streq(l->items[i], s)) return 0;
   }
   if (l->n == l->cap) {
     uint32_t newcap = l->cap ? l->cap * 2 : 16;
     const char** ni = driver_alloc_zeroed(env, newcap * sizeof(*ni));
     if (!ni) return 1;
     if (l->items) {
       driver_memcpy(ni, l->items, l->n * sizeof(*l->items));
       driver_free(env, l->items, l->cap * sizeof(*l->items));
     }
     l->items = ni;
     l->cap = newcap;
   }
   l->items[l->n++] = s;
   return 0;
 }
 
 static void cc_dep_list_free(DriverEnv* env, CcDepList* l) {
   if (l->items) driver_free(env, l->items, l->cap * sizeof(*l->items));
   l->items = NULL;
   l->n = 0;
   l->cap = 0;
 }
 
 static char* cc_dep_default_target(DriverEnv* env, const CcOptions* o,
                                    size_t* out_size) {
   const char* base = o->output_path;
   size_t len;
   char* buf;
   if (base) {
     len = driver_strlen(base);
     buf = driver_alloc(env, len + 1);
     if (!buf) return NULL;
     driver_memcpy(buf, base, len);
     buf[len] = '\0';
     *out_size = len + 1;
     return buf;
   }
   if (o->nsource_memory == 1) {
     const char* fallback = "<stdin>.o";
     size_t flen = driver_strlen(fallback);
     buf = driver_alloc(env, flen + 1);
     if (!buf) return NULL;
     driver_memcpy(buf, fallback, flen);
     buf[flen] = '\0';
     *out_size = flen + 1;
     return buf;
   }
   {
     const char* src = o->source_files[0];
     size_t srclen = driver_strlen(src);
     size_t dot = srclen;
     size_t slash = 0;
     size_t k;
     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;
       }
     }
     {
       const char* ext;
       size_t ext_len;
       size_t name_len = dot - slash;
       size_t bufsz;
       driver_default_obj_ext(o->target, &ext, &ext_len);
       bufsz = name_len + ext_len + 1u;
       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;
     }
   }
 }
 
 static char* cc_default_obj_path_for_name(DriverEnv* env, const CcOptions* o,
                                           const char* src, size_t* out_size) {
   /* -S/--emit override the object suffix; otherwise the canonical
    * platform object extension (Windows `.obj`, else `.o`) via the shared
    * per-target helper. */
   const char* ext;
   size_t ext_len;
   if (o && o->emit_asm_source) {
     ext = ".s";
     ext_len = 2u;
   } else if (o && o->emit_ir) {
     ext = ".ir";
     ext_len = 3u;
   } else {
     driver_default_obj_ext(o->target, &ext, &ext_len);
   }
   size_t srclen = driver_strlen(src);
   size_t dot = srclen;
   size_t slash = 0;
   size_t k;
   char* buf;
   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;
     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;
   }
 }
 
 static char* cc_dep_default_path(DriverEnv* env, const char* out_path,
                                  size_t* out_size) {
   size_t len = driver_strlen(out_path);
   size_t dot = len;
   size_t k;
   for (k = len; k > 0; --k) {
     if (out_path[k - 1] == '.') {
       dot = k - 1;
       break;
     }
     if (out_path[k - 1] == '/') break;
   }
   {
     size_t bufsz = dot + 3;
     char* buf = driver_alloc(env, bufsz);
     if (!buf) return NULL;
     driver_memcpy(buf, out_path, dot);
     buf[dot] = '.';
     buf[dot + 1] = 'd';
     buf[dot + 2] = '\0';
     *out_size = bufsz;
     return buf;
   }
 }
 
 static int cc_dep_collect(DriverEnv* env, KitCompiler* compiler,
                           int system_filter, CcDepList* list) {
   KitDepIter* it = NULL;
   KitDepEdge e;
   if (kit_dep_iter_new(compiler, &it) != KIT_OK) return 1;
   for (;;) {
     KitIterResult r = kit_dep_iter_next(it, &e);
     if (r != KIT_ITER_ITEM) break;
     if (system_filter && e.from_system_path) continue;
     if (cc_dep_list_push(env, list, e.included_name.s) != 0) {
       kit_dep_iter_free(it);
       return 1;
     }
   }
   kit_dep_iter_free(it);
   return 0;
 }
 
 static void cc_dep_emit_rule(KitWriter* w, const char* const* targets,
                              uint32_t ntargets, const char* primary_src,
                              const CcDepList* deps, int phony) {
   uint32_t i;
   for (i = 0; i < ntargets; ++i) {
     if (i) cc_write_str(w, " ");
     cc_write_str(w, targets[i]);
   }
   cc_write_str(w, ":");
   if (primary_src) {
     cc_write_str(w, " ");
     cc_write_str(w, primary_src);
   }
   for (i = 0; i < deps->n; ++i) {
     cc_write_str(w, " \\\n  ");
     cc_write_str(w, deps->items[i]);
   }
   cc_write_str(w, "\n");
   if (phony) {
     for (i = 0; i < deps->n; ++i) {
       cc_write_str(w, "\n");
       cc_write_str(w, deps->items[i]);
       cc_write_str(w, ":\n");
     }
   }
 }
 
 static KitWriter* cc_dep_open_writer(DriverEnv* env, const KitContext* ctx,
                                      const CcOptions* o, char** owned_path,
                                      size_t* owned_path_size) {
   KitWriter* w = NULL;
   *owned_path = NULL;
   *owned_path_size = 0;
   if (o->dep_file) {
     if (ctx->file_io->open_writer(ctx->file_io->user, o->dep_file, &w) !=
         KIT_OK)
       return NULL;
     return w;
   }
   if (o->dep_mode == CC_DEP_M || o->dep_mode == CC_DEP_MM) {
     return driver_stdout_writer(env);
   }
   {
     char* p = cc_dep_default_path(env, o->output_path, owned_path_size);
     if (!p) return NULL;
     *owned_path = p;
     if (ctx->file_io->open_writer(ctx->file_io->user, p, &w) != KIT_OK)
       return NULL;
     return w;
   }
 }
 
 static const char* cc_primary_source_name(const CcOptions* o) {
   if (o->nsource_memory == 1) return o->source_memory[0].name.s;
   return o->source_files[0];
 }
 
 static int cc_dep_finish(DriverEnv* env, const KitContext* ctx,
                          KitCompiler* compiler, const CcOptions* o) {
   CcDepList deps = {0};
   KitWriter* dep_w = NULL;
   char* owned_path = NULL;
   size_t owned_size = 0;
   char* owned_target = NULL;
   size_t owned_target_size = 0;
   const char* one_target[1];
   const char* const* targets;
   uint32_t ntargets;
   int rc = 1;
 
   if (cc_dep_collect(env, compiler, cc_dep_filters_system(o->dep_mode),
                      &deps) != 0) {
     driver_errf(CC_TOOL, "out of memory");
     goto out;
   }
 
   targets = o->dep_targets;
   ntargets = o->ndep_targets;
   if (ntargets == 0) {
     owned_target = cc_dep_default_target(env, o, &owned_target_size);
     if (!owned_target) {
       driver_errf(CC_TOOL, "out of memory");
       goto out;
     }
     one_target[0] = owned_target;
     targets = one_target;
     ntargets = 1;
   }
 
   dep_w = cc_dep_open_writer(env, ctx, o, &owned_path, &owned_size);
   if (!dep_w) {
     driver_errf(CC_TOOL, "failed to open dep output: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(
                     o->dep_file ? o->dep_file
                                 : (owned_path ? owned_path : "<stdout>"))));
     goto out;
   }
 
   cc_dep_emit_rule(dep_w, targets, ntargets, cc_primary_source_name(o), &deps,
                    o->dep_phony);
   rc = kit_writer_status(dep_w) == KIT_OK ? 0 : 1;
 
 out:
   if (dep_w) kit_writer_close(dep_w);
   if (owned_path) driver_free(env, owned_path, owned_size);
   if (owned_target) driver_free(env, owned_target, owned_target_size);
   cc_dep_list_free(env, &deps);
   return rc;
 }
 
 static void cc_fill_c_opts(const CcOptions* o, KitCCompileOptions* copts) {
   KitCCompileOptions zero = {0};
   *copts = zero;
   copts->code.opt_level = o->syntax_only ? 0 : o->opt_level;
   copts->code.debug_info = o->debug_info;
   copts->code.check_only = o->syntax_only ? true : false;
   copts->code.default_visibility = o->default_visibility;
   copts->code.emit_c_source = o->emit_c_source ? true : false;
   copts->code.emit_ir = o->emit_ir ? true : false;
   copts->code.emit_asm_source = o->emit_asm_source ? true : false;
   copts->code.function_sections = o->function_sections ? true : false;
   copts->code.data_sections = o->data_sections ? true : false;
   copts->code.lto = o->lto ? true : false;
   copts->code.epoch = o->epoch;
   copts->code.path_map = o->npath_map ? o->path_map : NULL;
   copts->code.npath_map = o->npath_map;
   copts->diagnostics.warnings_are_errors = o->warnings_are_errors;
   copts->diagnostics.max_errors = o->max_errors;
 }
 
 static int cc_run_deps_only(DriverEnv* env, const CcOptions* o,
                             const KitPreprocessOptions* pp) {
   KitContext ctx = driver_env_to_context(env);
   KitTarget* target = NULL;
   KitCompiler* compiler = NULL;
   KitWriter* discard = NULL;
   KitFileData fd = {0};
   KitSlice input = {0};
   int loaded = 0;
   int rc = 1;
 
   if (cc_load_single_source(&ctx, o, &input, &fd, &loaded) != 0) goto out;
 
   discard = cc_discard_writer_new(env);
   if (!discard) {
     driver_errf(CC_TOOL, "out of memory");
     goto out;
   }
 
   if (cc_compiler_new(o, &ctx, &target, &compiler) != KIT_OK) {
     driver_errf(CC_TOOL, "failed to initialize compiler");
     goto out;
   }
 
   if (kit_cpp_preprocess(compiler, pp,
                          kit_slice_cstr(cc_primary_source_name(o)), &input,
                          discard) != KIT_OK)
     goto out;
 
   rc = cc_dep_finish(env, &ctx, compiler, o);
 
 out:
   if (compiler) driver_compiler_free(compiler);
   kit_target_free(target);
   if (discard) kit_writer_close(discard);
   if (loaded) ctx.file_io->release(ctx.file_io->user, &fd);
   return rc;
 }
 
 /* Compile one source to an object builder via the shared engine. cc never
  * passes frontend-specific language_options (it has no flag surface for them);
  * those are the `compile` tool's domain. */
 static KitStatus cc_compile_source_obj(KitCompiler* compiler, KitLanguage lang,
                                        const KitCCompileOptions* copts,
                                        const KitPreprocessOptions* pp,
                                        KitSlice name, const KitSlice* input,
                                        KitObjBuilder** out) {
   return driver_compile_run(compiler, lang, &copts->code, &copts->diagnostics,
                             pp, NULL, name, input, NULL, out);
 }
 
 static KitStatus cc_compile_source_emit(KitCompiler* compiler, KitLanguage lang,
                                         const KitCCompileOptions* copts,
                                         const KitPreprocessOptions* pp,
                                         KitSlice name, const KitSlice* input,
                                         KitWriter* out) {
   return driver_compile_run(compiler, lang, &copts->code, &copts->diagnostics,
                             pp, NULL, name, input, out, NULL);
 }
 
 static int cc_run_compile_one(DriverEnv* env, const CcOptions* o,
                               const KitPreprocessOptions* pp, int is_memory,
                               uint32_t index, const char* out_path) {
   KitContext ctx = driver_env_to_context(env);
   KitTarget* target = NULL;
   KitCompiler* compiler = NULL;
   KitWriter* obj_w = NULL;
   KitFileData fd = {0};
   KitSlice input = {0};
   KitCCompileOptions copts;
   int loaded = 0;
   int rc = 1;
 
   if (is_memory) {
     input = o->source_memory[index].bytes;
   } else {
     if (ctx.file_io->read_all(ctx.file_io->user, o->source_files[index], &fd) !=
         KIT_OK) {
       driver_errf(CC_TOOL, "failed to read: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(o->source_files[index])));
       goto out;
     }
     loaded = 1;
     input.data = fd.data;
     input.len = fd.size;
   }
 
   if (ctx.file_io->open_writer(ctx.file_io->user, out_path, &obj_w) != KIT_OK) {
     driver_errf(CC_TOOL, "failed to open output: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(out_path)));
     goto out;
   }
 
   if (cc_compiler_new(o, &ctx, &target, &compiler) != KIT_OK) {
     driver_errf(CC_TOOL, "failed to initialize compiler");
     goto out;
   }
 
   cc_fill_c_opts(o, &copts);
   if (copts.code.emit_c_source) {
     /* --emit=c routes the output writer to the C-source CGTarget instead of
      * the object emitter. The downstream `kit_compile_*_emit` path will
      * skip the object-serialize step when this is set. */
     copts.code.c_source_writer = obj_w;
   }
   if (copts.code.emit_ir) {
     /* --emit=ir routes the output writer to the semantic-IR dumper in the opt
      * recorder instead of the object emitter. The downstream emit path skips
      * the object-serialize step when this is set. */
     copts.code.ir_dump_writer = obj_w;
   }
   {
     KitLanguage lang = is_memory
                            ? o->source_memory[index].lang
                            : cc_resolve_lang(compiler, o->source_files[index],
                                              o->source_langs[index]);
     KitSlice in_name = is_memory ? o->source_memory[index].name
                                  : kit_slice_cstr(o->source_files[index]);
     KitStatus st;
     st = cc_compile_source_emit(compiler, lang, &copts, pp, in_name, &input,
                                 obj_w);
     if (st != KIT_OK) goto out;
   }
 
   rc = (o->dep_mode == CC_DEP_MD || o->dep_mode == CC_DEP_MMD)
            ? cc_dep_finish(env, &ctx, compiler, o)
            : 0;
 
 out:
   if (compiler) driver_compiler_free(compiler);
   kit_target_free(target);
   if (obj_w) kit_writer_close(obj_w);
   if (loaded) ctx.file_io->release(ctx.file_io->user, &fd);
   return rc;
 }
 
 static int cc_run_compile_obj(DriverEnv* env, const CcOptions* o,
                               const KitPreprocessOptions* pp) {
   return cc_run_compile_one(env, o, pp, o->nsource_memory == 1, 0,
                             o->output_path);
 }
 
 static int cc_run_compile_objs(DriverEnv* env, const CcOptions* o,
                                const KitPreprocessOptions* pp) {
   uint32_t i;
   if (o->output_path) return cc_run_compile_obj(env, o, pp);
   for (i = 0; i < o->nsource_files; ++i) {
     size_t out_size = 0;
     char* out =
         cc_default_obj_path_for_name(env, o, o->source_files[i], &out_size);
     int rc;
     if (!out) {
       driver_errf(CC_TOOL, "out of memory");
       return 1;
     }
     rc = cc_run_compile_one(env, o, pp, 0, i, out);
     driver_free(env, out, out_size);
     if (rc != 0) return rc;
   }
   for (i = 0; i < o->nsource_memory; ++i) {
     const char* out = o->emit_asm_source ? "<stdin>.s"
                       : o->emit_ir       ? "<stdin>.ir"
                                          : "<stdin>.o";
     if (cc_run_compile_one(env, o, pp, 1, i, out) != 0) return 1;
   }
   return 0;
 }
 
 static int cc_run_check(DriverEnv* env, const CcOptions* o,
                         const KitPreprocessOptions* pp) {
   KitContext ctx = driver_env_to_context(env);
   const KitFileIO* io = ctx.file_io;
   KitTarget* target = NULL;
   KitCompiler* compiler = NULL;
   DriverLoad* src_lf = NULL;
   KitSlice* src_bytes = NULL;
   KitCCompileOptions copts;
   uint32_t i;
   int rc = 1;
 
   if (!io || !io->read_all) {
     driver_errf(CC_TOOL, "host file I/O unavailable");
     return 1;
   }
 
   if (o->nsource_files) {
     src_lf = driver_alloc_zeroed(env, o->nsource_files * sizeof(*src_lf));
     src_bytes = driver_alloc_zeroed(env, o->nsource_files * sizeof(*src_bytes));
     if (!src_lf || !src_bytes) {
       driver_errf(CC_TOOL, "out of memory");
       goto out;
     }
   }
 
   for (i = 0; i < o->nsource_files; ++i) {
     if (driver_load_bytes(io, CC_TOOL, o->source_files[i], &src_lf[i],
                           &src_bytes[i]) != 0)
       goto out;
   }
 
   if (cc_compiler_new(o, &ctx, &target, &compiler) != KIT_OK) {
     driver_errf(CC_TOOL, "failed to initialize compiler");
     goto out;
   }
 
   cc_fill_c_opts(o, &copts);
   for (i = 0; i < o->nsource_files; ++i) {
     KitObjBuilder* ob = NULL;
     KitLanguage lang =
         cc_resolve_lang(compiler, o->source_files[i], o->source_langs[i]);
     KitStatus st = cc_compile_source_obj(compiler, lang, &copts, pp,
                                          kit_slice_cstr(o->source_files[i]),
                                          &src_bytes[i], &ob);
     kit_obj_builder_free(ob);
     if (st != KIT_OK) goto out;
   }
   for (i = 0; i < o->nsource_memory; ++i) {
     KitObjBuilder* ob = NULL;
     KitStatus st = cc_compile_source_obj(compiler, o->source_memory[i].lang,
                                          &copts, pp, o->source_memory[i].name,
                                          &o->source_memory[i].bytes, &ob);
     kit_obj_builder_free(ob);
     if (st != KIT_OK) goto out;
   }
 
   rc = 0;
 
 out:
   if (compiler) driver_compiler_free(compiler);
   kit_target_free(target);
   if (src_lf) {
     for (i = 0; i < o->nsource_files; ++i) driver_release_bytes(io, &src_lf[i]);
   }
   if (src_bytes)
     driver_free(env, src_bytes, o->nsource_files * sizeof(*src_bytes));
   if (src_lf) driver_free(env, src_lf, o->nsource_files * sizeof(*src_lf));
   return rc;
 }
 
 /* exe/shared path: compile every source via a single KitCompiler, load
  * .o/.a/script inputs, and link. The link session borrows the per-source
  * KitObjBuilders; this function keeps ownership and frees them after the
  * session is done. */
 static int cc_run_link_exe(DriverEnv* env, const CcOptions* o,
                            const KitPreprocessOptions* pp) {
   KitContext ctx = driver_env_to_context(env);
   const KitFileIO* io = ctx.file_io;
   KitTarget* target = NULL;
   KitCompiler* compiler = NULL;
   KitWriter* out_w = NULL;
   DriverLoad* src_lf = NULL;
   DriverLoad* obj_lf = NULL;
   DriverLoad* arch_lf = NULL;
   DriverLoad script_lf = {0};
   DriverLoad* dso_lf = NULL;
   KitSlice* src_bytes = NULL;
   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;
   DriverCompileSource* sources = NULL;
   DriverCompilePendingLto pending_lto = {0};
   uint32_t* source_obj_index = NULL;
   uint8_t* source_order_keep = NULL;
   KitLinkScript* script = NULL;
   KitSlice* rpath_slices = NULL;
   KitCCompileOptions copts;
   DriverCompileBatchOptions lto_batch;
   uint32_t nsrc = o->nsource_files + o->nsource_memory;
   uint32_t i;
   uint32_t nobjs = 0;
   uint32_t norder = 0;
   int rc = 1;
 
   if (!io || !io->read_all || !io->open_writer) {
     driver_errf(CC_TOOL, "host file I/O unavailable");
     return 1;
   }
 
   if (o->nsource_files) {
     src_bytes = driver_alloc_zeroed(env, o->nsource_files * sizeof(*src_bytes));
     src_lf = driver_alloc_zeroed(env, o->nsource_files * sizeof(*src_lf));
     if (!src_bytes || !src_lf) {
       driver_errf(CC_TOOL, "out of memory");
       goto out;
     }
   }
   if (nsrc) {
     objs = driver_alloc_zeroed(env, nsrc * sizeof(*objs));
     sources = driver_alloc_zeroed(env, nsrc * sizeof(*sources));
     source_obj_index =
         driver_alloc_zeroed(env, nsrc * sizeof(*source_obj_index));
     source_order_keep =
         driver_alloc_zeroed(env, nsrc * sizeof(*source_order_keep));
     if (!objs || !sources || !source_obj_index || !source_order_keep) {
       driver_errf(CC_TOOL, "out of memory");
       goto out;
     }
   }
   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) {
       driver_errf(CC_TOOL, "out of memory");
       goto out;
     }
   }
   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) {
       driver_errf(CC_TOOL, "out of memory");
       goto out;
     }
   }
   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) {
       driver_errf(CC_TOOL, "out of memory");
       goto out;
     }
   }
   if (o->nlink_items) {
     order = driver_alloc_zeroed(env, o->nlink_items * sizeof(*order));
     if (!order) {
       driver_errf(CC_TOOL, "out of memory");
       goto out;
     }
   }
 
   for (i = 0; i < o->nsource_files; ++i) {
     if (driver_load_bytes(io, CC_TOOL, o->source_files[i], &src_lf[i],
                           &src_bytes[i]) != 0)
       goto out;
   }
 
   for (i = 0; i < o->nobject_files; ++i) {
     if (driver_load_bytes(io, CC_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, CC_TOOL, o->archives[i].path, &arch_lf[i],
                           &arch_in[i].bytes) != 0)
       goto out;
     arch_in[i].link_mode = o->archives[i].link_mode;
     arch_in[i].whole_archive = o->archives[i].whole_archive;
     arch_in[i].group_id = o->archives[i].group_id;
   }
   for (i = 0; i < o->ndsos; ++i) {
     if (driver_load_bytes(io, CC_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, CC_TOOL, o->link.linker_script, &script_lf,
                           &dummy) != 0)
       goto out;
   }
 
   if (cc_compiler_new(o, &ctx, &target, &compiler) != KIT_OK) {
     driver_errf(CC_TOOL, "failed to initialize compiler");
     goto out;
   }
 
   if (script_lf.loaded) {
     KitSlice script_text = {.s = (const char*)script_lf.fd.data,
                             .len = script_lf.fd.size};
     if (kit_link_script_parse(&ctx, script_text, &script) != KIT_OK) goto out;
   }
 
   cc_fill_c_opts(o, &copts);
   memset(&lto_batch, 0, sizeof lto_batch);
   lto_batch.output_kind =
       o->shared ? KIT_CG_OUTPUT_SHARED : KIT_CG_OUTPUT_EXECUTABLE;
   lto_batch.interposition_policy = o->shared
                                        ? KIT_CG_INTERPOSITION_DEFAULT_VISIBILITY
                                        : KIT_CG_INTERPOSITION_DEFAULT;
   lto_batch.defer_lto_finish = 1;
   for (i = 0; i < o->nsource_files; ++i) {
     KitLanguage lang =
         cc_resolve_lang(compiler, o->source_files[i], o->source_langs[i]);
     if (lang == KIT_LANG_UNKNOWN) {
       driver_errf(CC_TOOL, "cannot determine language for %.*s (use -x LANG)",
                   KIT_SLICE_ARG(kit_slice_cstr(o->source_files[i])));
       goto out;
     }
     sources[i].lang = lang;
     sources[i].name = kit_slice_cstr(o->source_files[i]);
     sources[i].bytes = src_bytes[i];
     sources[i].pp = pp;
   }
   for (i = 0; i < o->nsource_memory; ++i) {
     uint32_t si = o->nsource_files + i;
     if (o->source_memory[i].lang == KIT_LANG_UNKNOWN) {
       driver_errf(CC_TOOL, "cannot determine language for %.*s (use -x LANG)",
                   KIT_SLICE_ARG(o->source_memory[i].name));
       goto out;
     }
     sources[si].lang = o->source_memory[i].lang;
     sources[si].name = o->source_memory[i].name;
     sources[si].bytes = o->source_memory[i].bytes;
     sources[si].pp = pp;
   }
   if (nsrc) {
     DriverCompileObjects cout;
     KitStatus st;
     memset(&cout, 0, sizeof cout);
     cout.objs = objs;
     cout.source_obj_index = source_obj_index;
     cout.source_order_keep = source_order_keep;
     cout.pending_lto = &pending_lto;
     st = driver_compile_sources_run(compiler, &copts.code, &copts.diagnostics,
                                     sources, nsrc, &lto_batch, &cout);
     nobjs = cout.nobjs;
     if (st != KIT_OK) goto out;
   }
 
   if (io->open_writer(io->user, o->output_path, &out_w) != KIT_OK) {
     driver_errf(CC_TOOL, "failed to open output: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(o->output_path)));
     goto out;
   }
 
   {
     KitLinkSessionOptions lopts;
     KitStatus st;
     if (driver_link_flags_fill_options(
             &o->link, o->target, o->pie, o->shared, /*relocatable=*/0,
             o->shared ? KIT_LINK_OUTPUT_SHARED : KIT_LINK_OUTPUT_EXE, script,
             &lopts, &rpath_slices) != 0)
       goto out;
 
     /* Translate the command-line link order into the engine's public
      * KitLinkInputOrder list. The dead-simple fallback for o->nlink_items == 0
      * never fires (a link action always has at least one input), so every add
      * flows through the ordered path. */
     {
       uint32_t oi;
       DriverLinkInputs li;
       for (oi = 0; oi < o->nlink_items; ++oi) {
         const CcLinkItem* item = &o->link_items[oi];
         KitLinkInputOrder* ord;
         switch ((CcLinkItemKind)item->kind) {
           case CC_LINK_SOURCE_FILE:
             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 CC_LINK_SOURCE_MEMORY: {
             uint32_t si = o->nsource_files + item->index;
             if (!source_order_keep[si]) continue;
             ord = &order[norder++];
             ord->kind = KIT_LINK_INPUT_OBJ;
             ord->index = source_obj_index[si];
             break;
           }
           case CC_LINK_OBJECT:
             ord = &order[norder++];
             ord->kind = KIT_LINK_INPUT_OBJ_BYTES;
             ord->index = item->index;
             break;
           case CC_LINK_ARCHIVE:
             ord = &order[norder++];
             ord->kind = KIT_LINK_INPUT_ARCHIVE;
             ord->index = item->index;
             break;
           case CC_LINK_DSO:
             ord = &order[norder++];
             ord->kind = KIT_LINK_INPUT_DSO;
             ord->index = item->index;
             break;
           case CC_LINK_LIB: {
             const CcPendingLib* pl = &o->pending_libs[item->index];
             ord = &order[norder++];
             if (pl->resolved_kind == CC_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;
           }
         }
       }
       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 && o->output_path) {
     if (driver_mark_executable_output(o->output_path) != 0) {
       driver_errf(CC_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);
   if (compiler) driver_compiler_free(compiler);
   kit_target_free(target);
   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 (src_lf) {
     for (i = 0; i < o->nsource_files; ++i) driver_release_bytes(io, &src_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));
   if (src_lf) driver_free(env, src_lf, o->nsource_files * sizeof(*src_lf));
   if (src_bytes)
     driver_free(env, src_bytes, o->nsource_files * sizeof(*src_bytes));
   if (objs) {
     for (i = 0; i < nobjs; ++i) kit_obj_builder_free(objs[i]);
     driver_free(env, objs, nsrc * sizeof(*objs));
   }
   if (source_order_keep)
     driver_free(env, source_order_keep, nsrc * sizeof(*source_order_keep));
   if (source_obj_index)
     driver_free(env, source_obj_index, nsrc * sizeof(*source_obj_index));
   if (sources) driver_free(env, sources, nsrc * sizeof(*sources));
   return rc;
 }
 
 static int driver_cc_main(int argc, char** argv, int force_check) {
   DriverEnv env;
   CcOptions co = {0};
   DriverRuntimeSupport runtime = {0};
   KitPreprocessOptions pp;
   int rc;
   int runtime_resolved = 0;
   int link_action;
 
   if (argc < 2 || driver_argv_wants_help(argc, argv, 1)) {
     if (force_check) {
       driver_help_check();
       return 0;
     }
     driver_help_cc();
     return 0;
   }
 
   driver_env_init(&env);
   co.env = &env;
   co.driver_path = argv[0];
   co.syntax_only = force_check ? 1 : 0;
 
   if (cc_parse(argc, argv, &co) != 0) {
     cc_options_release(&co);
     driver_env_fini(&env);
     return 2;
   }
   if (co.probe_kind != CC_PROBE_NONE) {
     rc = cc_run_probe(&co);
     cc_options_release(&co);
     driver_env_fini(&env);
     return rc;
   }
 
   link_action = !co.compile_only && !co.preprocess_only && !co.syntax_only &&
                 co.dep_mode != CC_DEP_M && co.dep_mode != CC_DEP_MM;
   if (driver_runtime_resolve(&env, co.support_dir, co.driver_path, &runtime) ==
       0) {
     runtime_resolved = 1;
     if (co.nsource_files || co.nsource_memory) {
       int add_headers;
       if (co.hosted.profile_name) {
         add_headers =
             driver_runtime_append_freestanding_headers(&runtime, &co.cf);
       } else {
         add_headers = driver_runtime_add_freestanding_headers(&runtime, &co.cf);
       }
       if (add_headers != 0) {
         driver_errf(CC_TOOL, "failed to add freestanding headers");
         driver_runtime_support_fini(&env, &runtime);
         cc_options_release(&co);
         driver_env_fini(&env);
         return 1;
       }
     }
   } else if (co.support_dir || link_action || co.nsource_files ||
              co.nsource_memory) {
     driver_errf(CC_TOOL, "support dir not found");
     cc_options_release(&co);
     driver_env_fini(&env);
     return 1;
   }
 
   if (link_action && !co.no_stdlib && !co.no_defaultlibs) {
     DriverRuntimeArchive rt_archive = {0};
     uint32_t insert_pos;
     if (!runtime_resolved) {
       driver_errf(CC_TOOL, "support dir not found");
       cc_options_release(&co);
       driver_env_fini(&env);
       return 1;
     }
     if (driver_runtime_prepare_archive(&env, CC_TOOL, &runtime, co.target,
                                        co.epoch, &rt_archive) != 0) {
       driver_runtime_archive_fini(&env, &rt_archive);
       driver_runtime_support_fini(&env, &runtime);
       cc_options_release(&co);
       driver_env_fini(&env);
       return 1;
     }
     insert_pos = co.nlink_items;
     if (co.hosted.nfinal <= insert_pos) insert_pos -= co.hosted.nfinal;
     cc_insert_runtime_archive(&co, &rt_archive, insert_pos);
     driver_runtime_archive_fini(&env, &rt_archive);
   }
 
   driver_cflags_fill_pp(&co.cf, &pp);
 
   if (co.preprocess_only) {
     rc = cc_preprocess(&env, &co, &pp);
   } else if (co.dep_mode == CC_DEP_M || co.dep_mode == CC_DEP_MM) {
     rc = cc_run_deps_only(&env, &co, &pp);
   } else if (co.syntax_only) {
     rc = cc_run_check(&env, &co, &pp);
   } else if (co.compile_only) {
     rc = cc_run_compile_objs(&env, &co, &pp);
   } else {
     rc = cc_run_link_exe(&env, &co, &pp);
   }
 
   cc_options_release(&co);
   if (runtime_resolved) driver_runtime_support_fini(&env, &runtime);
   driver_env_fini(&env);
   return rc;
 }
 
 int driver_cc(int argc, char** argv) { return driver_cc_main(argc, argv, 0); }
 
 int driver_check(int argc, char** argv) {
   return driver_cc_main(argc, argv, 1);
 }