kit

cc.c (113272B)

---

 #include <kit/asm_emit.h>
 #include <kit/build.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 "driver.h"
 #include "hosted.h"
 #include "lib_resolve.h"
 #include "link_flags.h"
 #include "link_inputs.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 (-O2 aliases -O1 for v1) -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|kernel
  *   -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 -framework name -F 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 headers resolved via system (-isystem) dirs.
  *   MD   — compile normally AND write all deps to a file.
  *   MMD  — like MD but skip headers resolved via system (-isystem) dirs.
  * The MM/MMD filter keys on the resolved include directory (GCC semantics),
  * not the <...>-vs-"..." spelling, so a <foo.h> found via a plain -I dir is
  * still reported. Multi-source modes keep one rule and output path per source. */
 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;
 
 /* Link-input model (link items + object/archive/dso/lib arrays) is shared with
  * the build-* drivers; see driver/lib/link_inputs.h. */
 
 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 aliases -O1 */
   int debug_info;          /* -g               */
   int function_sections;   /* -ffunction-sections */
   int data_sections;       /* -fdata-sections     */
   int auto_var_init;       /* -ftrivial-auto-var-init= (KitAutoVarInit) */
   int stack_protector;     /* KitStackProtectorMode */
   int lto;                 /* -flto/-fno-lto      */
   uint64_t disabled_backend_features;
   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               */
   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;
   /* Shared link-input model: object/archive/dso/lib arrays, the ordered link
    * item list, -L search paths, and the owned `<sysroot>/lib` Windows slot. */
   DriverLinkInputSet inputs;
   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   */
   char** owned_dep_targets; /* quoted -MQ storage */
   size_t* owned_dep_target_sizes;
   uint32_t ndep_targets;
 
   /* Link-session options and owned -Wl state. */
   DriverLinkFlags link;
   int shared; /* -shared */
   int static_link;
   int pie;
   int pic_explicit;
   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] INPUT...                  compile and link\n"
           "  kit cc -c [options] INPUT.c               emit an object\n"
           "  kit cc -S [options] INPUT.c               emit assembly\n"
           "  kit cc -E [options] INPUT.c               preprocess only\n"
           "  kit cc -M|-MM [options] INPUT.c           print dependencies\n"
           "  kit cc --emit=c|ir [options] INPUT.c      emit C or IR\n"
           "  kit cc -fsyntax-only [options] INPUT...   check only\n"
           "\n"
           "DESCRIPTION\n"
           "  Compiles C and assembly sources, optionally linking compatible\n"
           "  objects, archives, and shared libraries into a program. It can\n"
           "  also stop after preprocessing, dependency generation, semantic\n"
           "  checks, assembly, object, portable C, or semantic IR output.\n"
           "\n"
           "  .c is C source; .S is preprocessed assembly; .s is assembly.\n"
           "  Target-compatible .o, .a, and ELF .so files are accepted by the\n"
           "  link stage. A single `-` input reads stdin; use `-x c -` when an\n"
           "  input suffix is unavailable. This release does not accept `--`\n"
           "  before compiler operands; spell a leading-dash path as ./-name.c.\n"
           "\n"
           "  Linking defaults to a.out (a.exe for Windows). -c and -S derive\n"
           "  <base>.o and <base>.s for one source. -E, -M, and -MM write stdout\n"
           "  when -o is absent. Use -o for --emit=c/ir and combined outputs.\n"
           "\n"
           "OPTIONS\n"
           "  -I DIR, -isystem DIR       Add user/system include directories\n"
           "  -D NAME[=BODY], -U NAME    Define or undefine a macro\n"
           "  -E                         Preprocess without compiling\n"
           "  -M, -MM                    Dependencies with/without system headers\n"
           "  -MD, -MMD, -MF FILE        Side-effect dependencies/output file\n"
           "  -MT TARGET, -MQ TARGET     Dependency target spelling\n"
           "\n"
           "  -M/-MM emit one rule per source in input order. -MD/-MMD write\n"
           "  per-source dependency files during compile and compile-link.\n"
           "\n"
           "COMPILATION\n"
           "  -std=c11                    Select the supported C language level\n"
           "  -fsyntax-only               Diagnose only; write no output\n"
           "  -c, -S                      Stop after object or assembly emission\n"
           "  --emit=c                    Portable C output (-O1/-O2 normalize to -O0)\n"
           "  --emit=ir                   Semantic IR dump; requires -O1 or -O2\n"
           "  -O0, -O1, -O2              Optimize (-O2 aliases -O1)\n"
           "  -g                          Emit debug information\n"
           "  -flto                       Record source inputs for LTO at link\n"
           "  -fPIC/-fpic, -fPIE/-fpie   Position-independent code/executable\n"
           "  -Werror, -fmax-errors=N     Diagnostic policy\n"
           "  -ffreestanding              Freestanding language/runtime mode\n"
           "  -fstack-protector[-strong|-all]\n"
           "                              Select conventional stack canaries\n"
           "  -fno-stack-protector       Disable stack canaries\n"
           "  -x c|assembler|assembler-with-cpp\n"
           "                              Override suffix classification\n"
           "\n"
           "LINKING\n"
           "  -o PATH                     Output path\n"
           "  -L DIR, -l NAME             Library search/input\n"
           "  -static, -shared            Static executable / ELF shared library\n"
           "  -nostdlib, -nodefaultlibs, -nostartfiles\n"
           "                              Suppress default link components\n"
           "  -T SCRIPT, -e SYMBOL        Linker script and entry symbol\n"
           "  -Wl,...                     Forward supported linker tokens\n"
           "  -framework NAME, -F DIR     Darwin framework/search directory\n"
           "\n"
           "  Linker scripts and entries accept direct joined/equal forms,\n"
           "  -Wl comma lists, and equivalent -Xlinker sequences. Static/shared\n"
           "  availability follows the target\n"
           "  platform; non-ELF shared-library output is not provided here.\n")));
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "\n"
           "TARGET AND SEARCH PATHS\n"
           "  -target TRIPLE              Select a canonical target below\n"
           "  -arch ARCH                  Darwin-style architecture selection\n"
           "  -march=ISA, -mabi=ABI       Architecture/ABI selection when supported\n"
           "  --sysroot DIR, -isysroot DIR\n"
           "                              Hosted SDK/sysroot supplied by the user\n"
           "  --support-dir DIR           Kit distribution support root\n"
           "  -print-search-dirs          Print compiler/library search paths\n"
           "  -print-sysroot              Print the native SDK Kit can discover\n"
           "  -print-resource-dir         Print the current compiler resource path\n"
           "\n"
           "  Hosted: aarch64-linux-gnu, x86_64-linux-gnu, riscv64-linux-gnu;\n"
           "    aarch64-linux-musl, x86_64-linux-musl, riscv64-linux-musl;\n"
           "    aarch64-freebsd, x86_64-freebsd, riscv64-freebsd;\n"
           "    aarch64-windows, x86_64-windows; aarch64-linux-android21;\n"
           "    aarch64-apple-darwin, x86_64-apple-darwin.\n"
           "  Freestanding: aarch64-none-elf, x86_64-none-elf,\n"
           "    riscv64-none-elf, riscv32-none-elf, arm-none-eabi.\n"
           "  WebAssembly source target: wasm32-none (source-batch module; this\n"
           "    release does not link separate Wasm .o/.a inputs).\n"
           "\n"
           "DISCOVERY AND LIMITS\n"
           "  Kit resolves support relative to its canonical executable path;\n"
           "  --support-dir is an authoritative override. Native macOS applies\n"
           "  the discovered SDK automatically. Cross-hosted compilation still\n"
           "  requires an explicit user-supplied sysroot.\n"
           "\n"
           "  Portable-C output currently uses the -O0 semantic pipeline; explicit\n"
           "  -O1/-O2 requests are accepted and normalized before code generation.\n"
           "\n"
           "GETTING HELP\n"
           "  -h, --help                  Show this help and exit\n"
           "  --version                   Show Kit version and exit\n"
           "\n"
           "EXAMPLES\n"
           "  # Native compile.\n"
           "  printf 'int main(void) { return 0; }\\n' > hello.c\n"
           "  kit cc hello.c -o hello\n"
           "  ./hello\n"
           "\n"
           "  # Replace SYSROOT with a supplied hosted cross sysroot.\n"
           "  SYSROOT=/replace/with/aarch64-linux-sysroot\n"
           "  kit cc -target aarch64-linux-gnu --sysroot \"$SYSROOT\" \\\n"
           "    hello.c -o hello.aa64\n"
           "\n"
           "  # Freestanding final link; provide startup object and linker script.\n"
           "  kit cc -target aarch64-none-elf \\\n"
           "    -ffreestanding -c kernel.c -o kernel.o\n"
           "  kit cc -target aarch64-none-elf \\\n"
           "    -ffreestanding -T link.ld -e _start start.o kernel.o -o kernel.elf\n"
           "\n"
           "  kit cc -E -DVALUE=42 input.c\n"
           "  kit cc -MM input.c -MF input.d\n"
           "  kit cc --emit=c -O0 input.c -o input.out.c\n"
           "  kit cc --emit=ir -O1 input.c -o input.ir\n"
           "\n"
           "EXIT CODES\n"
           "  0   success    1   compile/link/I/O error    2   bad usage\n")));
 }
 
 void driver_help_check(void) {
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "kit check — run C frontend checks without emitting code\n"
           "\n"
           "USAGE\n"
           "  kit check [options] INPUT.c...\n"
           "\n"
           "DESCRIPTION\n"
           "  Equivalent to the preprocessing and semantic-check portion of\n"
           "  `kit cc -fsyntax-only`. It writes diagnostics only: no object,\n"
           "  assembly, executable, or dependency output is produced.\n"
           "\n"
           "OPTIONS\n"
           "  Accepts the cc preprocessing, target, sysroot, diagnostic, and\n"
           "  language options described by `kit cc --help`, including -I,\n"
           "  -isystem, -D, -U, -std=c11, -Werror, -fmax-errors=N,\n"
           "  -target, --sysroot/-isysroot, and --support-dir. Inputs are C\n"
           "  sources; each is preprocessed and checked independently.\n"
           "\n"
           "  Relocated distributions discover their sibling support tree. Native\n"
           "  macOS discovers SDK headers automatically; cross-hosted checks use\n"
           "  an explicit --sysroot/-isysroot as described by `kit cc --help`.\n"
           "\n"
           "GETTING HELP\n"
           "  -h, --help        Show this help and exit\n"
           "  --version         Show Kit version and exit\n"
           "\n"
           "EXAMPLES\n"
           "  kit check \\\n"
           "    -I include -DDEBUG=1 src/main.c src/util.c\n"
           "\n"
           "EXIT CODES\n"
           "  0   checks passed    1   frontend/I/O error    2   bad usage\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->dep_targets = driver_alloc_zeroed(o->env, bound * sizeof(*o->dep_targets));
   o->owned_dep_targets =
       driver_alloc_zeroed(o->env, bound * sizeof(*o->owned_dep_targets));
   o->owned_dep_target_sizes = driver_alloc_zeroed(
       o->env, bound * sizeof(*o->owned_dep_target_sizes));
   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->dep_targets || !o->owned_dep_targets ||
       !o->owned_dep_target_sizes || !o->path_map || !o->owned_path_map_olds ||
       !o->owned_path_map_old_sizes) {
     driver_errf(CC_TOOL, "out of memory");
     return 1;
   }
   if (driver_link_inputs_init(&o->inputs, o->env, CC_TOOL, bound) != 0)
     return 1;
   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->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]);
     }
   }
   for (i = 0; i < o->ndep_targets; ++i) {
     if (o->owned_dep_targets[i]) {
       driver_free(o->env, o->owned_dep_targets[i],
                   o->owned_dep_target_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);
   driver_link_inputs_fini(&o->inputs);
   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->dep_targets, bound * sizeof(*o->dep_targets));
   driver_free(o->env, o->owned_dep_targets,
               bound * sizeof(*o->owned_dep_targets));
   driver_free(o->env, o->owned_dep_target_sizes,
               bound * sizeof(*o->owned_dep_target_sizes));
   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);
 static int cc_record_framework(CcOptions* o, const char* name) {
   DriverPendingFramework* pf;
   if (!name || !name[0]) {
     driver_errf(CC_TOOL, "-framework requires an argument");
     return 1;
   }
   pf = &o->inputs.pending_frameworks[o->inputs.npending_frameworks++];
   pf->name = name;
   driver_link_inputs_push(&o->inputs, DRIVER_LINK_FRAMEWORK,
                           o->inputs.npending_frameworks - 1u);
   return 0;
 }
 
 /* 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_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_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->inputs.nlib_search_paths; ++i)
         cc_print_path_elem(o->inputs.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 {
         /* An explicitly selected (argv or KIT_SYSROOT) path is authoritative.
          * The resolver has already diagnosed an invalid one; do not turn that
          * failure into a successful empty probe.  A cross target with no
          * supplied sysroot still resolves successfully with dirs.root == NULL
          * and prints the conventional empty line above. */
         return 1;
       }
       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;
   driver_link_inputs_push(&o->inputs, DRIVER_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 KIT_LANG_AUTO
 
 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;
     driver_link_inputs_push(&o->inputs, DRIVER_LINK_SOURCE,
                             o->nsource_files - 1u);
     return 0;
   }
   if (driver_has_suffix(a, ".o") || driver_has_suffix(a, ".obj")) {
     o->inputs.object_files[o->inputs.nobject_files++] = a;
     driver_link_inputs_push(&o->inputs, DRIVER_LINK_OBJECT,
                             o->inputs.nobject_files - 1u);
     return 0;
   }
   if (driver_has_suffix(a, ".a")) {
     DriverArchiveInput* ar = &o->inputs.archives[o->inputs.narchives++];
     ar->path = a;
     ar->whole_archive = o->inputs.cur_whole_archive;
     ar->link_mode = o->inputs.cur_link_mode;
     ar->group_id = o->inputs.cur_group_id;
     driver_link_inputs_push(&o->inputs, DRIVER_LINK_ARCHIVE,
                             o->inputs.narchives - 1u);
     return 0;
   }
   if (driver_is_dso_path(a)) {
     DriverDsoInput* d = &o->inputs.dsos[o->inputs.ndsos++];
     d->path = a;
     driver_link_inputs_push(&o->inputs, DRIVER_LINK_DSO, o->inputs.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_apply_hosted_profile(CcOptions* o) {
   /* A link action (not -c/-E/-M/-MM) gets crt files + interpreter; the include
    * + define + lib-search-dir parts apply regardless. */
   int link_action = !o->syntax_only && !o->compile_only &&
                     !o->preprocess_only &&
                     o->dep_mode != CC_DEP_M && o->dep_mode != CC_DEP_MM;
   int shared_hosted = o->shared && driver_target_shared_uses_hosted(o->target);
   if (!o->wants_hosted_libc || (o->shared && !shared_hosted)) return 0;
   /* -nostdlib/-nodefaultlibs suppress the link-time CRT/libc additions, not
    * the hosted compiler profile.  Native compilation still needs the SDK's
    * defines and headers (matching clang/gcc). */
   if (o->no_stdlib || o->no_defaultlibs) link_action = 0;
   return driver_link_inputs_apply_hosted(
       &o->inputs, &o->hosted, &o->cf, &o->link, o->target, o->sysroot,
       o->static_link, o->shared, o->no_startfiles, link_action);
 }
 
 static int cc_apply_env(CcOptions* o) {
   const char* sde = driver_getenv("SOURCE_DATE_EPOCH");
   if (sde && driver_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;
 }
 
 static int cc_has_link_action(const CcOptions* o) {
   return !o->syntax_only && !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 keeps its existing meaning.
  * -nostdlib/-nodefaultlibs only suppress link additions. 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) return;
   if (o->shared && !driver_target_shared_uses_hosted(o->target)) return;
   if (!o->sysroot || !o->sysroot[0]) return;
   if (o->freestanding || o->nostdinc) return;
   o->wants_hosted_libc = 1;
 }
 
 static void cc_apply_default_hosted_profile(CcOptions* o) {
   KitTargetSpec host;
   int native_macos;
   if (!driver_target_default_hosted_profile(o->target)) return;
   if (o->wants_hosted_libc) return;
   if (o->freestanding || o->nostdinc) return;
   host = driver_host_target();
   native_macos = host.os == KIT_OS_MACOS && o->target.os == KIT_OS_MACOS;
   if ((!o->sysroot || !o->sysroot[0]) && !native_macos) 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);
 
 /* GNU make quoting used by -MQ and by driver-derived dependency paths. -MT is
  * intentionally left verbatim. */
 static char* cc_dep_quote_make_alloc(DriverEnv* env, const char* s,
                                      size_t* out_size) {
   size_t n = driver_strlen(s);
   size_t i;
   size_t pos = 0;
   char* out = driver_alloc(env, n * 2u + 1u);
   if (!out) return NULL;
   for (i = 0; i < n; ++i) {
     char c = s[i];
     if (c == '$') {
       out[pos++] = '$';
       out[pos++] = '$';
     } else if (c == ' ' || c == '\t' || c == '#' || c == '\\') {
       out[pos++] = '\\';
       out[pos++] = c;
     } else {
       out[pos++] = c;
     }
   }
   out[pos] = '\0';
   if (out_size) *out_size = n * 2u + 1u;
   return out;
 }
 
 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 = 1;
       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 = 1;
       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 (driver_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_strneq(a, "-ftrivial-auto-var-init=", 24)) {
       const char* mode = a + 24;
       if (driver_streq(mode, "zero")) {
         o->auto_var_init = KIT_AUTOVAR_ZERO;
       } else if (driver_streq(mode, "uninitialized")) {
         o->auto_var_init = KIT_AUTOVAR_UNINIT;
       } else if (driver_streq(mode, "pattern")) {
         driver_errf(CC_TOOL,
                     "-ftrivial-auto-var-init=pattern is not yet supported; "
                     "use =zero");
         return 1;
       } else {
         driver_errf(CC_TOOL,
                     "-ftrivial-auto-var-init=: unknown mode '%s' "
                     "(expected zero, pattern, or uninitialized)",
                     mode);
         return 1;
       }
       continue;
     }
     if (driver_streq(a, "-fno-data-sections")) {
       o->data_sections = 0;
       continue;
     }
     if (driver_streq(a, "-fno-stack-protector")) {
       o->stack_protector = KIT_STACK_PROTECTOR_NONE;
       continue;
     }
     if (driver_streq(a, "-fstack-protector")) {
       o->stack_protector = KIT_STACK_PROTECTOR_BASIC;
       continue;
     }
     if (driver_streq(a, "-fstack-protector-strong")) {
       o->stack_protector = KIT_STACK_PROTECTOR_STRONG;
       continue;
     }
     if (driver_streq(a, "-fstack-protector-all")) {
       o->stack_protector = KIT_STACK_PROTECTOR_ALL;
       continue;
     }
     if (driver_strneq(a, "-fstack-protector", 17)) {
       driver_errf(CC_TOOL, "unsupported stack protector mode: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(a)));
       return 1;
     }
     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_strneq(a, "-fno-builtin-", 13) || 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;
       }
       /* The preprocessor has no force-include hook yet (KitPreprocessOptions
        * carries no prefix-include list), so honoring this would silently drop
        * the file and miscompile. Fail loudly rather than ignore it. */
       driver_errf(CC_TOOL, "-include is unimplemented: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(argv[i])));
       return 1;
     }
 
     if (driver_streq(a, "-fPIC") || driver_streq(a, "-fpic")) {
       o->target.pic = KIT_PIC_PIC;
       o->pic_explicit = 1;
       continue;
     }
     if (driver_streq(a, "-fPIE") || driver_streq(a, "-fpie")) {
       o->target.pic = KIT_PIC_PIE;
       o->pic_explicit = 1;
       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;
       o->pic_explicit = 1;
       continue;
     }
     if (driver_streq(a, "-static")) {
       o->target.pic = KIT_PIC_NONE;
       o->static_link = 1;
       o->pic_explicit = 1;
       o->inputs.cur_link_mode = KIT_LM_STATIC;
       continue;
     }
     if (driver_streq(a, "-pie")) {
       o->target.pic = KIT_PIC_PIE;
       o->pie = 1;
       o->pic_explicit = 1;
       continue;
     }
     if (driver_streq(a, "-no-pie")) {
       o->target.pic = KIT_PIC_NONE;
       o->pie = 0;
       o->pic_explicit = 1;
       continue;
     }
     if (driver_streq(a, "-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->inputs.cur_link_mode = KIT_LM_STATIC;
       continue;
     }
     if (driver_streq(a, "-Bdynamic")) {
       o->inputs.cur_link_mode = KIT_LM_DYNAMIC;
       continue;
     }
     if (driver_streq(a, "--as-needed")) {
       o->inputs.cur_link_mode = KIT_LM_AS_NEEDED;
       continue;
     }
     if (driver_streq(a, "--no-as-needed")) {
       o->inputs.cur_link_mode = KIT_LM_DYNAMIC;
       continue;
     }
     if (driver_streq(a, "--whole-archive")) {
       o->inputs.cur_whole_archive = 1;
       continue;
     }
     if (driver_streq(a, "--no-whole-archive")) {
       o->inputs.cur_whole_archive = 0;
       continue;
     }
     if (driver_streq(a, "--start-group")) {
       if (o->inputs.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->inputs.cur_group_id = ++o->next_group_id;
       continue;
     }
     if (driver_streq(a, "--end-group")) {
       if (o->inputs.cur_group_id == 0) {
         driver_errf(CC_TOOL, "--end-group without --start-group");
         return 1;
       }
       o->inputs.cur_group_id = 0;
       continue;
     }
 
     if (driver_streq(a, "-shared")) {
       o->shared = 1;
       continue;
     }
     if (driver_streq(a, "-mwindows")) {
       o->link.pe_subsystem = KIT_PE_SUBSYSTEM_WINDOWS_GUI;
       continue;
     }
     if (driver_streq(a, "-mconsole")) {
       o->link.pe_subsystem = KIT_PE_SUBSYSTEM_WINDOWS_CUI;
       continue;
     }
     if (driver_strneq(a, "-Wl,", 4)) {
       if (driver_strneq(a, "-Wl,-framework,", 15)) {
         if (cc_record_framework(o, a + 15) != 0) return 1;
         continue;
       }
       if (driver_link_flags_record_wl(&o->link, a + 4) != 0) return 1;
       continue;
     }
 
     if (driver_strneq(a, "-mcmodel=", 9)) {
       if (driver_record_mcmodel(&o->target, CC_TOOL, a + 9) != 0) return 1;
       continue;
     }
     if (driver_streq(a, "-mno-red-zone")) {
       o->disabled_backend_features |= KIT_CG_BACKEND_RED_ZONE;
       continue;
     }
     if (driver_streq(a, "-mred-zone")) {
       o->disabled_backend_features &= ~KIT_CG_BACKEND_RED_ZONE;
       continue;
     }
     if (driver_streq(a, "-mgeneral-regs-only")) {
       o->disabled_backend_features |= KIT_CG_BACKEND_SIMD;
       continue;
     }
     if (driver_streq(a, "-mno-general-regs-only")) {
       o->disabled_backend_features &= ~KIT_CG_BACKEND_SIMD;
       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];
       continue;
     }
     if (driver_strneq(a, "--output=", 9)) {
       o->output_path = a + 9;
       continue;
     }
     if (driver_streq(a, "--output")) {
       if (++i >= argc) {
         driver_errf(CC_TOOL, "--output requires an argument");
         return 1;
       }
       o->output_path = argv[i];
       continue;
     }
     if (driver_streq(a, "-e")) {
       if (++i >= argc) {
         driver_errf(CC_TOOL, "-e requires an argument");
         return 1;
       }
       if (driver_link_flags_record_entry(&o->link, argv[i],
                                          driver_strlen(argv[i])) != 0)
         return 1;
       continue;
     }
     if (driver_strneq(a, "--entry=", 8)) {
       if (driver_link_flags_record_entry(&o->link, a + 8,
                                          driver_strlen(a + 8)) != 0)
         return 1;
       continue;
     }
     if (driver_streq(a, "--entry")) {
       if (++i >= argc) {
         driver_errf(CC_TOOL, "--entry requires an argument");
         return 1;
       }
       if (driver_link_flags_record_entry(&o->link, argv[i],
                                          driver_strlen(argv[i])) != 0)
         return 1;
       continue;
     }
     if (a[0] == '-' && a[1] == 'e' && a[2] != '\0') {
       if (driver_link_flags_record_entry(&o->link, a + 2,
                                          driver_strlen(a + 2)) != 0)
         return 1;
       continue;
     }
     if (driver_streq(a, "-T")) {
       if (++i >= argc) {
         driver_errf(CC_TOOL, "-T requires an argument");
         return 1;
       }
       if (driver_link_flags_record_script(&o->link, argv[i],
                                           driver_strlen(argv[i])) != 0)
         return 1;
       continue;
     }
     if (driver_strneq(a, "--script=", 9)) {
       if (driver_link_flags_record_script(&o->link, a + 9,
                                           driver_strlen(a + 9)) != 0)
         return 1;
       continue;
     }
     if (driver_streq(a, "--script")) {
       if (++i >= argc) {
         driver_errf(CC_TOOL, "--script requires an argument");
         return 1;
       }
       if (driver_link_flags_record_script(&o->link, argv[i],
                                           driver_strlen(argv[i])) != 0)
         return 1;
       continue;
     }
     if (a[0] == '-' && a[1] == 'T' && a[2] != '\0' &&
         !driver_strneq(a, "-Ttext", 6) &&
         !driver_strneq(a, "-Tdata", 6) &&
         !driver_strneq(a, "-Tbss", 5)) {
       if (driver_link_flags_record_script(&o->link, a + 2,
                                           driver_strlen(a + 2)) != 0)
         return 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_err_unknown_target(CC_TOOL, 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_err_unknown_target(CC_TOOL, 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_err_unknown_target(CC_TOOL, argv[i]);
         return 1;
       }
       o->target_set = 1;
       continue;
     }
     if (driver_streq(a, "-Xlinker")) {
       const char* xarg;
       if (++i >= argc) {
         driver_errf(CC_TOOL, "-Xlinker requires an argument");
         return 1;
       }
       xarg = argv[i];
       if (driver_streq(argv[i], "-framework")) {
         if (++i >= argc) {
           driver_errf(CC_TOOL, "-framework requires an argument");
           return 1;
         }
         if (driver_streq(argv[i], "-Xlinker")) {
           if (++i >= argc) {
             driver_errf(CC_TOOL, "-framework requires an argument");
             return 1;
           }
         }
         if (cc_record_framework(o, argv[i]) != 0) return 1;
         continue;
       }
       if (driver_streq(xarg, "-T") || driver_streq(xarg, "--script") ||
           driver_streq(xarg, "-e") || driver_streq(xarg, "--entry")) {
         const char* value;
         if (++i >= argc) {
           driver_errf(CC_TOOL, "%s passed via -Xlinker requires an argument",
                       xarg);
           return 1;
         }
         if (driver_streq(argv[i], "-Xlinker")) {
           if (++i >= argc) {
             driver_errf(CC_TOOL,
                         "%s passed via -Xlinker requires an argument", xarg);
             return 1;
           }
         }
         value = argv[i];
         if ((xarg[1] == 'T' || driver_streq(xarg, "--script"))
                 ? driver_link_flags_record_script(&o->link, value,
                                                   driver_strlen(value))
                 : driver_link_flags_record_entry(&o->link, value,
                                                  driver_strlen(value)))
           return 1;
         continue;
       }
       if (driver_link_flags_record_wl(&o->link, xarg) != 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) {
           const char* const known[] = {"c",   "asm",  "assembler",
                                        "s",   "toy",  "wasm",
                                        "wat", "none", "asm-cpp"};
           const char* candidates[sizeof known / sizeof known[0]];
           DriverSuggestion suggestions[3];
           size_t k, count = 0, n;
           for (k = 0; k < sizeof known / sizeof known[0]; ++k) {
             if (driver_streq(known[k], "none") ||
                 driver_streq(known[k], "asm-cpp") ||
                 kit_language_for_name(NULL, known[k]) != KIT_LANG_UNKNOWN)
               candidates[count++] = known[k];
           }
           n = driver_suggest_values(argv[i], candidates, count, suggestions, 3);
           if (n)
             driver_errf(CC_TOOL,
                         "unsupported -x language: %s; did you mean '%s'?",
                         argv[i], suggestions[0].value);
           else
             driver_errf(CC_TOOL, "unsupported -x language: %s", 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->inputs.lib_search_paths[o->inputs.nlib_search_paths++] = dir;
       continue;
     }
     if (driver_strneq(a, "-F", 2)) {
       const char* dir = a[2] ? a + 2 : (++i < argc ? argv[i] : NULL);
       if (!dir) {
         driver_errf(CC_TOOL, "-F requires an argument");
         return 1;
       }
       o->inputs.framework_search_paths[o->inputs.nframework_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;
       }
       {
         DriverPendingLib* pl =
             &o->inputs.pending_libs[o->inputs.npending_libs++];
         pl->name = name;
         pl->whole_archive = o->inputs.cur_whole_archive;
         pl->link_mode = o->inputs.cur_link_mode;
         pl->group_id = o->inputs.cur_group_id;
         driver_link_inputs_push(&o->inputs, DRIVER_LINK_LIB,
                                 o->inputs.npending_libs - 1u);
       }
       continue;
     }
     if (driver_streq(a, "-framework")) {
       if (++i >= argc) {
         driver_errf(CC_TOOL, "-framework requires an argument");
         return 1;
       }
       if (cc_record_framework(o, argv[i]) != 0) return 1;
       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")) {
       int quote = driver_streq(a, "-MQ");
       uint32_t slot = o->ndep_targets;
       if (++i >= argc) {
         driver_errf(CC_TOOL, "%.*s requires an argument",
                     KIT_SLICE_ARG(kit_slice_cstr(a)));
         return 1;
       }
       if (quote) {
         o->owned_dep_targets[slot] = cc_dep_quote_make_alloc(
             o->env, argv[i], &o->owned_dep_target_sizes[slot]);
         if (!o->owned_dep_targets[slot]) {
           driver_errf(CC_TOOL, "out of memory");
           return 1;
         }
         o->dep_targets[slot] = o->owned_dep_targets[slot];
       } else {
         o->dep_targets[slot] = argv[i];
       }
       o->ndep_targets++;
       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') {
       const char* const valid[] = {
           "--help",     "-h",          "--version", "-target",
           "--target",   "-o",          "--output",  "-T",
           "--script",   "-e",          "--entry",   "-x",
           "-c",         "-S",          "-E",        "-shared",
           "-static",    "-nostdlib",   "-isysroot", "--sysroot",
           "--start-group", "--end-group"};
       DriverSuggestion suggestions[3];
       size_t n = driver_suggest_values(a, valid,
                                        sizeof valid / sizeof valid[0],
                                        suggestions, 3);
       if (n)
         driver_errf(CC_TOOL, "unknown flag: %s; did you mean '%s'?", a,
                     suggestions[0].value);
       else
         driver_errf(CC_TOOL, "unknown flag: %s", 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 (driver_link_inputs_append_windows_lib_dirs(&o->inputs, &o->sysroot,
                                                  o->target) != 0)
     return 1;
   if (driver_link_inputs_append_sysroot_framework_dirs(&o->inputs, &o->sysroot,
                                                        o->target) != 0)
     return 1;
   if (o->shared && !o->pic_explicit) o->target.pic = KIT_PIC_PIC;
 
   {
     uint32_t total_sources = o->nsource_files + o->nsource_memory;
     uint32_t total_link = o->inputs.nobject_files + o->inputs.narchives +
                           o->inputs.ndsos + o->inputs.npending_libs +
                           o->inputs.npending_frameworks;
 
     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 && o->target.obj != KIT_OBJ_ELF) {
       driver_errf(CC_TOOL,
                   "-shared output is supported only for ELF targets in v1");
       return 1;
     }
     if (o->shared && o->target.pic == KIT_PIC_NONE) {
       driver_errf(CC_TOOL, "-shared requires PIC input; remove -fno-pic/-static");
       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->inputs.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);
       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 == 0 || total_link != 0)) {
         driver_errf(CC_TOOL,
                     "-M/-MM requires source inputs and no link inputs");
         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);
         }
       }
       /* Windows PE/COFF executables conventionally carry a `.exe` suffix;
        * GCC/clang on a mingw target append it to an -o output that has no
        * extension. Mirror that so `kit cc -o foo` for a windows target
        * produces foo.exe, matching the rest of the toolchain. Only for
        * executable links (the default name already carries .exe; shared
        * libraries use the .dll convention; non-link actions are skipped). */
       if (o->output_path && o->target.os == KIT_OS_WINDOWS && !o->shared &&
           !o->syntax_only && !o->compile_only && !o->preprocess_only &&
           !dep_only) {
         const char* base = o->output_path;
         for (const char* q = o->output_path; *q; q++)
           if (*q == '/' || *q == '\\') base = q + 1;
         int has_ext = 0;
         for (const char* q = base; *q; q++)
           if (*q == '.') {
             has_ext = 1;
             break;
           }
         if (*base && !has_ext) {
           size_t len = strlen(o->output_path);
           size_t nsize = len + 5; /* ".exe" + NUL */
           char* buf = driver_alloc(o->env, nsize);
           if (!buf) {
             driver_errf(CC_TOOL, "out of memory");
             return 1;
           }
           memcpy(buf, o->output_path, len);
           memcpy(buf + len, ".exe", 4);
           buf[len + 4] = '\0';
           o->owned_output_path = buf;
           o->owned_output_path_size = nsize;
           o->output_path = o->owned_output_path;
         }
       }
     }
   }
   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 && driver_link_inputs_resolve_pending(
                              &o->inputs, o->target, o->static_link) != 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 void cc_close_output(KitWriter** writer, const char* output_path,
                             int* rc) {
   if (writer && *writer && rc && kit_writer_status(*writer) != KIT_OK) *rc = 1;
   if (writer && *writer && rc && *rc != 0 && output_path)
     driver_writer_abort(*writer);
   if (writer && *writer) {
     kit_writer_close(*writer);
     *writer = NULL;
   }
 }
 
 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);
   cc_close_output(&writer, o->output_path, &rc);
   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;
   }
 }
 
 /* Collect the include-dependency edges into `list`. Returns 0 on success,
  * CC_DEP_COLLECT_OOM on allocation failure (caller reports it generically), or
  * CC_DEP_COLLECT_DIAGNOSED when the iterator faulted mid-scan -- in that case a
  * specific diagnostic naming the offending dependency has already been emitted,
  * so the caller must not overwrite it with a generic message. */
 #define CC_DEP_COLLECT_OOM 1
 #define CC_DEP_COLLECT_DIAGNOSED 2
 
 static int cc_dep_collect(DriverEnv* env, KitCompiler* compiler,
                           int system_filter, CcDepList* list) {
   KitDepIter* it = NULL;
   KitDepEdge e = {0};
   if (kit_dep_iter_new(compiler, &it) != KIT_OK) return CC_DEP_COLLECT_OOM;
   for (;;) {
     KitIterResult r = kit_dep_iter_next(it, &e);
     if (r == KIT_ITER_ERROR) {
       /* Name the most recently scanned dependency so the failure is actionable
        * instead of a silent short read of the dep list. `e` is zero-initialized
        * and only ever written by kit_dep_iter_next, so it is never garbage: on
        * an error before any edge it is empty (-> generic message), otherwise it
        * holds the last edge we saw. */
       if (e.included_name.len)
         driver_errf(CC_TOOL, "failed while scanning dependency: %.*s",
                     KIT_SLICE_ARG(e.included_name));
       else
         driver_errf(CC_TOOL, "failed to scan include dependencies");
       kit_dep_iter_free(it);
       return CC_DEP_COLLECT_DIAGNOSED;
     }
     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 CC_DEP_COLLECT_OOM;
     }
   }
   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,
                              int quote_default_target) {
   uint32_t i;
   for (i = 0; i < ntargets; ++i) {
     const char* s;
     if (i) cc_write_str(w, " ");
     s = targets[i];
     if (!quote_default_target) {
       cc_write_str(w, s);
     } else {
       for (; *s; ++s) {
         char c = *s;
         if (c == '$') {
           cc_write_str(w, "$$");
         } else if (c == ' ' || c == '\t' || c == '#' || c == '\\') {
           kit_writer_write(w, "\\", 1);
           kit_writer_write(w, &c, 1);
         } else {
           kit_writer_write(w, &c, 1);
         }
       }
     }
   }
   cc_write_str(w, ":");
   if (primary_src) {
     const char* s = primary_src;
     cc_write_str(w, " ");
     for (; *s; ++s) {
       char c = *s;
       if (c == '$') {
         cc_write_str(w, "$$");
       } else if (c == ' ' || c == '\t' || c == '#' || c == '\\') {
         kit_writer_write(w, "\\", 1);
         kit_writer_write(w, &c, 1);
       } else {
         kit_writer_write(w, &c, 1);
       }
     }
   }
   for (i = 0; i < deps->n; ++i) {
     const char* s = deps->items[i];
     cc_write_str(w, " \\\n  ");
     for (; *s; ++s) {
       char c = *s;
       if (c == '$') {
         cc_write_str(w, "$$");
       } else if (c == ' ' || c == '\t' || c == '#' || c == '\\') {
         kit_writer_write(w, "\\", 1);
         kit_writer_write(w, &c, 1);
       } else {
         kit_writer_write(w, &c, 1);
       }
     }
   }
   cc_write_str(w, "\n");
   if (phony) {
     for (i = 0; i < deps->n; ++i) {
       const char* s = deps->items[i];
       cc_write_str(w, "\n");
       for (; *s; ++s) {
         char c = *s;
         if (c == '$') {
           cc_write_str(w, "$$");
         } else if (c == ' ' || c == '\t' || c == '#' || c == '\\') {
           kit_writer_write(w, "\\", 1);
           kit_writer_write(w, &c, 1);
         } else {
           kit_writer_write(w, &c, 1);
         }
       }
       cc_write_str(w, ":\n");
     }
   }
 }
 
 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 char* cc_dep_default_target_for(DriverEnv* env, const CcOptions* o,
                                        const char* source_name,
                                        const char* output_path,
                                        size_t* out_size) {
   CcOptions view = *o;
   const char* one_file[1];
   KitSourceInput one_memory[1];
   view.output_path = output_path;
   view.nsource_files = 0;
   view.nsource_memory = 0;
   if (driver_streq(source_name, "<stdin>")) {
     memset(one_memory, 0, sizeof(one_memory));
     one_memory[0].name = kit_slice_cstr(source_name);
     view.source_memory = one_memory;
     view.nsource_memory = 1;
   } else {
     one_file[0] = source_name;
     view.source_files = one_file;
     view.nsource_files = 1;
   }
   return cc_dep_default_target(env, &view, out_size);
 }
 
 static int cc_dep_finish_to(DriverEnv* env, KitCompiler* compiler,
                             const CcOptions* o, const char* source_name,
                             const char* output_path, KitWriter* dep_w) {
   CcDepList deps = {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;
 
   {
     int cr = cc_dep_collect(env, compiler, cc_dep_filters_system(o->dep_mode),
                             &deps);
     if (cr == CC_DEP_COLLECT_OOM) {
       driver_errf(CC_TOOL, "out of memory");
       goto out;
     }
     if (cr != 0) goto out; /* CC_DEP_COLLECT_DIAGNOSED: already reported */
   }
 
   targets = o->dep_targets;
   ntargets = o->ndep_targets;
   if (ntargets == 0) {
     owned_target = cc_dep_default_target_for(
         env, o, source_name, output_path, &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;
   }
 
   cc_dep_emit_rule(dep_w, targets, ntargets, source_name, &deps, o->dep_phony,
                    o->ndep_targets == 0);
   rc = kit_writer_status(dep_w) == KIT_OK ? 0 : 1;
 
 out:
   if (owned_target) driver_free(env, owned_target, owned_target_size);
   cc_dep_list_free(env, &deps);
   return rc;
 }
 
 static KitWriter* cc_dep_buffer_new(const KitContext* ctx) {
   KitWriter* w = NULL;
   if (!ctx || !ctx->heap || kit_writer_mem(ctx->heap, &w) != KIT_OK) return NULL;
   return w;
 }
 
 static int cc_dep_commit_buffer(DriverEnv* env, const KitContext* ctx,
                                 KitWriter* mem, const char* path) {
   KitWriter* out = NULL;
   const uint8_t* bytes;
   size_t len = 0;
   int rc = 1;
   bytes = kit_writer_mem_bytes(mem, &len);
   if (path) {
     if (ctx->file_io->open_writer(ctx->file_io->user, path, &out) != KIT_OK) {
       driver_errf(CC_TOOL, "failed to open dep output: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(path)));
       return 1;
     }
   } else {
     out = driver_stdout_writer(env);
     if (!out) {
       driver_errf(CC_TOOL, "out of memory");
       return 1;
     }
   }
   if (kit_writer_write(out, bytes, len) == KIT_OK &&
       kit_writer_status(out) == KIT_OK)
     rc = 0;
   if (rc != 0 && path) driver_writer_abort(out);
   kit_writer_close(out);
   return rc;
 }
 
 static int cc_dep_finish_default_file(DriverEnv* env, const KitContext* ctx,
                                       KitCompiler* compiler,
                                       const CcOptions* o,
                                       const char* source_name,
                                       const char* output_path) {
   KitWriter* mem = NULL;
   char* dep_path = NULL;
   size_t dep_path_size = 0;
   int rc = 1;
   mem = cc_dep_buffer_new(ctx);
   if (!mem) {
     driver_errf(CC_TOOL, "out of memory");
     goto out;
   }
   if (cc_dep_finish_to(env, compiler, o, source_name, output_path, mem) != 0)
     goto out;
   dep_path = cc_dep_default_path(env, output_path, &dep_path_size);
   if (!dep_path) {
     driver_errf(CC_TOOL, "out of memory");
     goto out;
   }
   rc = cc_dep_commit_buffer(env, ctx, mem, dep_path);
 out:
   if (dep_path) driver_free(env, dep_path, dep_path_size);
   if (mem) kit_writer_close(mem);
   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.disabled_backend_features = o->disabled_backend_features;
   copts->code.trivial_auto_var_init = (uint8_t)o->auto_var_init;
   copts->code.stack_protector = (uint8_t)o->stack_protector;
   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 const char* cc_source_name(const CcOptions* o, int is_memory,
                                   uint32_t index) {
   return is_memory ? o->source_memory[index].name.s : o->source_files[index];
 }
 
 static int cc_dep_scan_one(DriverEnv* env, const CcOptions* o,
                            const KitPreprocessOptions* pp, int is_memory,
                            uint32_t index, const char* output_path,
                            KitWriter* rules) {
   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;
   const char* source_name = cc_source_name(o, is_memory, index);
 
   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;
   }
 
   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(source_name), &input,
                          discard) != KIT_OK)
     goto out;
 
   rc = cc_dep_finish_to(env, compiler, o, source_name, output_path, rules);
 
 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;
 }
 
 static int cc_run_deps_only(DriverEnv* env, const CcOptions* o,
                             const KitPreprocessOptions* pp) {
   KitContext ctx = driver_env_to_context(env);
   KitWriter* rules = NULL;
   uint32_t i;
   int rc = 1;
   rules = cc_dep_buffer_new(&ctx);
   if (!rules) {
     driver_errf(CC_TOOL, "out of memory");
     return 1;
   }
   for (i = 0; i < o->inputs.nlink_items; ++i) {
     const DriverLinkItem* item = &o->inputs.link_items[i];
     if (item->kind == DRIVER_LINK_SOURCE) {
       if (cc_dep_scan_one(env, o, pp, 0, item->index, NULL, rules) != 0)
         goto out;
     } else if (item->kind == DRIVER_LINK_SOURCE_MEMORY) {
       if (cc_dep_scan_one(env, o, pp, 1, item->index, NULL, rules) != 0)
         goto out;
     }
   }
   rc = cc_dep_commit_buffer(env, &ctx, rules, o->dep_file);
 out:
   kit_writer_close(rules);
   return rc;
 }
 
 static int cc_dep_scan_default_file(DriverEnv* env, const CcOptions* o,
                                     const KitPreprocessOptions* pp,
                                     int is_memory, uint32_t index,
                                     const char* output_path) {
   KitContext ctx = driver_env_to_context(env);
   KitWriter* rules = NULL;
   char* dep_path = NULL;
   size_t dep_path_size = 0;
   int rc = 1;
   rules = cc_dep_buffer_new(&ctx);
   if (!rules) {
     driver_errf(CC_TOOL, "out of memory");
     goto out;
   }
   if (cc_dep_scan_one(env, o, pp, is_memory, index, output_path, rules) != 0)
     goto out;
   dep_path = cc_dep_default_path(env, output_path, &dep_path_size);
   if (!dep_path) {
     driver_errf(CC_TOOL, "out of memory");
     goto out;
   }
   rc = cc_dep_commit_buffer(env, &ctx, rules, dep_path);
 out:
   if (dep_path) driver_free(env, dep_path, dep_path_size);
   if (rules) kit_writer_close(rules);
   return rc;
 }
 
 static int cc_run_link_dependencies(DriverEnv* env, const CcOptions* o,
                                     const KitPreprocessOptions* pp) {
   KitContext ctx = driver_env_to_context(env);
   KitWriter* shared = NULL;
   uint32_t i;
   int rc = 1;
   if (o->dep_file) {
     shared = cc_dep_buffer_new(&ctx);
     if (!shared) {
       driver_errf(CC_TOOL, "out of memory");
       return 1;
     }
   }
   for (i = 0; i < o->inputs.nlink_items; ++i) {
     const DriverLinkItem* item = &o->inputs.link_items[i];
     int is_memory;
     const char* source_name;
     const char* obj_path;
     char* owned_obj = NULL;
     size_t owned_obj_size = 0;
     if (item->kind != DRIVER_LINK_SOURCE &&
         item->kind != DRIVER_LINK_SOURCE_MEMORY)
       continue;
     is_memory = item->kind == DRIVER_LINK_SOURCE_MEMORY;
     source_name = cc_source_name(o, is_memory, item->index);
     if (is_memory) {
       obj_path = "<stdin>.o";
     } else {
       owned_obj =
           cc_default_obj_path_for_name(env, o, source_name, &owned_obj_size);
       if (!owned_obj) {
         driver_errf(CC_TOOL, "out of memory");
         goto out;
       }
       obj_path = owned_obj;
     }
     if (shared) {
       rc = cc_dep_scan_one(env, o, pp, is_memory, item->index, obj_path,
                            shared);
     } else {
       rc = cc_dep_scan_default_file(env, o, pp, is_memory, item->index,
                                     obj_path);
     }
     if (owned_obj) driver_free(env, owned_obj, owned_obj_size);
     if (rc != 0) goto out;
   }
   if (shared) rc = cc_dep_commit_buffer(env, &ctx, shared, o->dep_file);
   else rc = 0;
 out:
   if (shared) kit_writer_close(shared);
   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 kit_build_compile_one(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 kit_build_compile_one(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,
                               KitWriter* dep_rules) {
   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;
   const char* source_name = cc_source_name(o, is_memory, index);
 
   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 = kit_slice_cstr(source_name);
     KitStatus st;
     st = cc_compile_source_emit(compiler, lang, &copts, pp, in_name, &input,
                                 obj_w);
     if (st != KIT_OK) goto out;
   }
 
   if (o->dep_mode == CC_DEP_MD || o->dep_mode == CC_DEP_MMD) {
     rc = dep_rules ? cc_dep_finish_to(env, compiler, o, source_name, out_path,
                                       dep_rules)
                    : cc_dep_finish_default_file(env, &ctx, compiler, o,
                                                 source_name, out_path);
   } else {
     rc = 0;
   }
 
 out:
   if (compiler) driver_compiler_free(compiler);
   kit_target_free(target);
   cc_close_output(&obj_w, out_path, &rc);
   if (loaded) ctx.file_io->release(ctx.file_io->user, &fd);
   return rc;
 }
 
 static int cc_run_compile_objs(DriverEnv* env, const CcOptions* o,
                                const KitPreprocessOptions* pp) {
   KitContext ctx = driver_env_to_context(env);
   KitWriter* dep_rules = NULL;
   uint32_t i;
   int rc = 1;
   if ((o->dep_mode == CC_DEP_MD || o->dep_mode == CC_DEP_MMD) &&
       o->dep_file) {
     dep_rules = cc_dep_buffer_new(&ctx);
     if (!dep_rules) {
       driver_errf(CC_TOOL, "out of memory");
       return 1;
     }
   }
   for (i = 0; i < o->inputs.nlink_items; ++i) {
     const DriverLinkItem* item = &o->inputs.link_items[i];
     int is_memory;
     const char* source_name;
     const char* out;
     char* owned_out = NULL;
     size_t owned_out_size = 0;
     if (item->kind != DRIVER_LINK_SOURCE &&
         item->kind != DRIVER_LINK_SOURCE_MEMORY)
       continue;
     is_memory = item->kind == DRIVER_LINK_SOURCE_MEMORY;
     source_name = cc_source_name(o, is_memory, item->index);
     if (o->output_path) {
       out = o->output_path;
     } else if (is_memory) {
       out = o->emit_asm_source ? "<stdin>.s"
             : o->emit_ir       ? "<stdin>.ir"
                                : "<stdin>.o";
     } else {
       owned_out = cc_default_obj_path_for_name(env, o, source_name,
                                                &owned_out_size);
       if (!owned_out) {
         driver_errf(CC_TOOL, "out of memory");
         goto out;
       }
       out = owned_out;
     }
     rc = cc_run_compile_one(env, o, pp, is_memory, item->index, out,
                             dep_rules);
     if (owned_out) driver_free(env, owned_out, owned_out_size);
     if (rc != 0) goto out;
   }
   if (dep_rules) rc = cc_dep_commit_buffer(env, &ctx, dep_rules, o->dep_file);
   else rc = 0;
 out:
   if (dep_rules) kit_writer_close(dep_rules);
   return rc;
 }
 
 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;
 }
 
 /* Side-report writer for the link session: -Wl,-Map / --symbols / --cref FILE
  * and --print-memory-usage. cc routes these through driver_link_flags but the
  * link runs inside kit_build_link_with_lto_report, which hands back the live
  * session here so the reports actually get written (rather than being silently
  * dropped). Kept parallel to ld and build-exe's report writers. */
 typedef struct CcLinkReports {
   DriverEnv* env;
   const KitFileIO* io;
   const CcOptions* o;
 } CcLinkReports;
 
 static KitStatus cc_write_link_report(const CcLinkReports* r,
                                       KitLinkSession* link, const char* path,
                                       int symbols) {
   KitWriter* w = NULL;
   KitStatus st;
   if (!path) return KIT_OK;
   if (r->io->open_writer(r->io->user, path, &w) != KIT_OK) {
     driver_errf(CC_TOOL, "failed to open %s output: %.*s",
                 symbols ? "symbols" : "map",
                 KIT_SLICE_ARG(kit_slice_cstr(path)));
     return KIT_IO;
   }
   st = symbols
            ? kit_link_session_write_symbols(link, r->o->link.symbols_format, w)
            : kit_link_session_write_map(link, w);
   if (st == KIT_OK) st = kit_writer_status(w);
   kit_writer_close(w);
   if (st != KIT_OK)
     driver_errf(CC_TOOL, "failed to write %s: %.*s", symbols ? "symbols" : "map",
                 KIT_SLICE_ARG(kit_slice_cstr(path)));
   return st;
 }
 
 static KitStatus cc_link_write_reports(void* user, KitLinkSession* link) {
   const CcLinkReports* r = (const CcLinkReports*)user;
   KitStatus st;
   st = cc_write_link_report(r, link, r->o->link.map_path, 0);
   if (st == KIT_OK)
     st = cc_write_link_report(r, link, r->o->link.symbols_path, 1);
   if (st == KIT_OK && r->o->link.cref_path) {
     KitWriter* w = NULL;
     if (r->io->open_writer(r->io->user, r->o->link.cref_path, &w) != KIT_OK) {
       driver_errf(CC_TOOL, "failed to open cref output: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(r->o->link.cref_path)));
       st = KIT_IO;
     } else {
       st = kit_link_session_write_cref(link, w);
       if (st == KIT_OK) st = kit_writer_status(w);
       kit_writer_close(w);
       if (st != KIT_OK)
         driver_errf(CC_TOOL, "failed to write cref: %.*s",
                     KIT_SLICE_ARG(kit_slice_cstr(r->o->link.cref_path)));
     }
   }
   if (st == KIT_OK && r->o->link.print_memory_usage) {
     KitWriter* w = driver_stdout_writer(r->env);
     if (!w) {
       driver_errf(CC_TOOL, "failed to print memory usage");
       st = KIT_IO;
     } else {
       st = kit_link_session_write_memory_usage(link, w);
       if (st == KIT_OK) st = kit_writer_status(w);
       kit_writer_close(w);
       if (st != KIT_OK) driver_errf(CC_TOOL, "failed to print memory usage");
     }
   }
   return st;
 }
 
 /* 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;
   KitBuildSource* sources = NULL;
   KitBuildPendingLto pending_lto = {0};
   uint32_t* source_obj_index = NULL;
   uint8_t* source_order_keep = NULL;
   KitLinkScript* script = NULL;
   KitSlice* rpath_slices = NULL;
   KitCCompileOptions copts;
   KitBuildBatchOptions 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->inputs.nobject_files) {
     obj_lf =
         driver_alloc_zeroed(env, o->inputs.nobject_files * sizeof(*obj_lf));
     obj_in =
         driver_alloc_zeroed(env, o->inputs.nobject_files * sizeof(*obj_in));
     obj_names =
         driver_alloc_zeroed(env, o->inputs.nobject_files * sizeof(*obj_names));
     if (!obj_lf || !obj_in || !obj_names) {
       driver_errf(CC_TOOL, "out of memory");
       goto out;
     }
   }
   if (o->inputs.narchives) {
     arch_lf = driver_alloc_zeroed(env, o->inputs.narchives * sizeof(*arch_lf));
     arch_in = driver_alloc_zeroed(env, o->inputs.narchives * sizeof(*arch_in));
     if (!arch_lf || !arch_in) {
       driver_errf(CC_TOOL, "out of memory");
       goto out;
     }
   }
   if (o->inputs.ndsos) {
     dso_lf = driver_alloc_zeroed(env, o->inputs.ndsos * sizeof(*dso_lf));
     dso_in = driver_alloc_zeroed(env, o->inputs.ndsos * sizeof(*dso_in));
     dso_names = driver_alloc_zeroed(env, o->inputs.ndsos * sizeof(*dso_names));
     if (!dso_lf || !dso_in || !dso_names) {
       driver_errf(CC_TOOL, "out of memory");
       goto out;
     }
   }
   if (o->inputs.nlink_items) {
     order = driver_alloc_zeroed(env, o->inputs.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->inputs.nobject_files; ++i) {
     if (driver_load_bytes(io, CC_TOOL, o->inputs.object_files[i], &obj_lf[i],
                           &obj_in[i]) != 0)
       goto out;
     obj_names[i] = kit_slice_cstr(o->inputs.object_files[i]);
   }
   for (i = 0; i < o->inputs.narchives; ++i) {
     if (driver_load_bytes(io, CC_TOOL, o->inputs.archives[i].path, &arch_lf[i],
                           &arch_in[i].bytes) != 0)
       goto out;
     arch_in[i].name = kit_slice_cstr(o->inputs.archives[i].path);
     arch_in[i].link_mode = o->inputs.archives[i].link_mode;
     arch_in[i].whole_archive =
         o->inputs.archives[i].whole_archive ? true : false;
     arch_in[i].group_id = o->inputs.archives[i].group_id;
   }
   for (i = 0; i < o->inputs.ndsos; ++i) {
     if (driver_load_bytes(io, CC_TOOL, o->inputs.dsos[i].path, &dso_lf[i],
                           &dso_in[i]) != 0)
       goto out;
     dso_names[i] = kit_slice_cstr(o->inputs.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) {
     KitBuildObjects 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 = kit_build_compile(compiler, &copts.code, &copts.diagnostics, sources,
                            nsrc, &lto_batch, &cout);
     nobjs = cout.nobjs;
     if (st != KIT_OK) goto out;
   }
 
   if ((o->dep_mode == CC_DEP_MD || o->dep_mode == CC_DEP_MMD) &&
       cc_run_link_dependencies(env, o, pp) != 0)
     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->inputs.nlink_items == 0 never fires (a link action always has at least
      * one input), so every add flows through the ordered path. */
     {
       KitLinkInputs li;
       norder = driver_link_inputs_build_order(&o->inputs, source_obj_index,
                                               source_order_keep,
                                               o->nsource_files, order);
       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->inputs.nobject_files;
       li.archives = arch_in;
       li.narchives = o->inputs.narchives;
       li.dso_names = dso_names;
       li.dso_bytes = dso_in;
       li.ndsos = o->inputs.ndsos;
       li.order = order;
       li.norder = norder;
       {
         /* Honor the link side-reports (-Wl,-Map / --symbols / --cref /
          * --print-memory-usage) that flowed in via driver_link_flags by
          * writing them from the live session — matching ld and build-exe. */
         CcLinkReports reports;
         int want_reports = o->link.map_path || o->link.symbols_path ||
                            o->link.cref_path || o->link.print_memory_usage;
         reports.env = env;
         reports.io = io;
         reports.o = o;
         st = kit_build_link_with_lto_report(
             compiler, &lopts, &li, &pending_lto, &lto_batch, out_w,
             want_reports ? cc_link_write_reports : NULL,
             want_reports ? (void*)&reports : NULL);
       }
     }
     rc = st == KIT_OK ? 0 : 1;
   }
 
 out:
   cc_close_output(&out_w, o->output_path, &rc);
   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);
   kit_build_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->inputs.narchives; ++i)
       driver_release_bytes(io, &arch_lf[i]);
   }
   if (dso_lf) {
     for (i = 0; i < o->inputs.ndsos; ++i) driver_release_bytes(io, &dso_lf[i]);
   }
   if (obj_lf) {
     for (i = 0; i < o->inputs.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->inputs.narchives * sizeof(*arch_in));
   if (arch_lf)
     driver_free(env, arch_lf, o->inputs.narchives * sizeof(*arch_lf));
   if (dso_in) driver_free(env, dso_in, o->inputs.ndsos * sizeof(*dso_in));
   if (dso_names)
     driver_free(env, dso_names, o->inputs.ndsos * sizeof(*dso_names));
   if (dso_lf) driver_free(env, dso_lf, o->inputs.ndsos * sizeof(*dso_lf));
   if (order) driver_free(env, order, o->inputs.nlink_items * sizeof(*order));
   if (obj_in)
     driver_free(env, obj_in, o->inputs.nobject_files * sizeof(*obj_in));
   if (obj_names)
     driver_free(env, obj_names, o->inputs.nobject_files * sizeof(*obj_names));
   if (obj_lf)
     driver_free(env, obj_lf, o->inputs.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) && !co.nostdinc) {
       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.shared || driver_target_shared_uses_hosted(co.target)) &&
       !co.no_stdlib && !co.no_defaultlibs) {
     DriverRuntimeArchive rt_archive = {0};
     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;
     }
     driver_link_inputs_insert_runtime_archives(
         &co.inputs, &rt_archive, co.target, co.hosted.nfinal, co.hosted.nafter);
     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);
   }
 
   if (rc == 0 &&
       driver_diag_finish(&env, CC_TOOL, co.warnings_are_errors, co.max_errors))
     rc = 1;
 
   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);
 }