kit

compile.c (18160B)

---

 #include <kit/compile.h>
 #include <kit/core.h>
 #include <kit/preprocess.h>
 #include <stdint.h>
 #include <string.h>
 
 #include "cflags.h"
 #include "compile_engine.h"
 #include "driver.h"
 #include "runtime.h"
 
 /* `kit compile` — kit-native, single-language source compiler.
  *
  * Unlike `cc` (the GCC-compatible C driver + linker), `compile` resolves
  * exactly one frontend per invocation — from `-x` or the source suffix — and
  * does NOT link: it produces objects (or `-S`/`--emit=c`/`--emit=ir`) and can
  * check. The active frontend dictates which extra flags are accepted: it
  * declares whether the preprocessor family (-I/-isystem/-D/-U) applies, and
  * any flag `compile` does not own itself is handed to the frontend's own
  * option parser (e.g. wasm `-mfeature=...`). `.o`/`.a` inputs are rejected —
  * use `cc`, `ld`, or `run` to link. */
 
 #define COMPILE_TOOL "compile"
 
 typedef enum CompileEmit {
   COMPILE_EMIT_OBJ = 0,
   COMPILE_EMIT_ASM,
   COMPILE_EMIT_C,
   COMPILE_EMIT_IR,
 } CompileEmit;
 
 typedef struct CompileOptions {
   DriverEnv* env;
   const char* driver_path;
   DriverCflags cf;
   int cpp_flags_used;
 
   const char** sources; /* source paths (argv-borrowed) */
   uint32_t nsources;
 
   char** fe_args; /* leftover frontend flags (argv-borrowed) */
   uint32_t nfe_args;
 
   int forced_lang; /* -1 = resolve by suffix; else KitLanguage */
   int opt_level;
   int debug_info;
   int check_only;
   int emit; /* CompileEmit */
   const char* output_path;
   int warnings_are_errors;
   uint32_t max_errors;
   KitTargetSpec target;
   DriverTargetFeatures target_features;
 } CompileOptions;
 
 static void compile_usage(void) {
   driver_errf(COMPILE_TOOL, "%.*s",
               KIT_SLICE_ARG(KIT_SLICE_LIT(
                   "usage: kit compile [options] source...\n"
                   "       kit compile --help    for full option reference")));
 }
 
 void driver_help_compile(void) {
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "kit compile — compile one frontend's sources (no link)\n"
           "\n"
           "USAGE\n"
           "  kit compile [options] source...\n"
           "\n"
           "DESCRIPTION\n"
           "  Compiles each source to an object (default) or to assembly / C /\n"
           "  semantic IR. Every source must belong to ONE language, chosen by\n"
           "  -x or by file suffix (.c .s .toy .wat .wasm). `compile` does not\n"
           "  link: pass .o/.a to `cc`, `ld`, or `run` instead.\n"
           "\n"
           "  The resolved frontend decides which extra flags apply. Only a\n"
           "  preprocessor-enabled frontend (C) accepts -I/-isystem/-D/-U; any\n"
           "  other unrecognized flag is handed to the frontend's own parser\n"
           "  (e.g. wasm: -mfeature=NAME / -mno-feature=NAME).\n"
           "\n"
           "OPTIONS\n"
           "  -c                Compile to object (the default; accepted for "
           "parity)\n"
           "  -S                Emit assembly (.s)\n"
           "  --emit=obj|asm|c|ir   Select output form (ir requires -O1+)\n"
           "  -fsyntax-only     Check only; write no output\n"
           "  -o PATH           Output path (required with multiple sources or\n"
           "                    --emit=c; otherwise a default name is derived)\n"
           "  -O0 -O1 -O2       Optimization level (default -O0)\n"
           "  -g                Emit DWARF debug info\n"
           "  -x LANG           Force language: c | asm | toy | wasm\n"
           "  -I/-isystem/-D/-U Preprocessor flags (preprocessor frontends "
           "only)\n"
           "  -target TRIPLE    Cross-compile target (see `kit cc --help`)\n"
           "  -Werror           Treat warnings as errors\n"
           "  -fmax-errors=N    Stop after N errors (0 = unlimited)\n"
           "  -h, --help        Show this help and exit\n"
           "\n"
           "EXIT CODES\n"
           "  0   success           1   compile error           2   bad "
           "usage\n")));
 }
 
 static int compile_parse_u64(const char* s, uint64_t* out) {
   uint64_t v = 0;
   int any = 0;
   if (!s) return 1;
   while (*s) {
     unsigned d;
     if (*s < '0' || *s > '9') return 1;
     d = (unsigned)(*s - '0');
     if (v > (UINT64_MAX - d) / 10u) return 1;
     v = v * 10u + d;
     any = 1;
     s++;
   }
   if (!any) return 1;
   *out = v;
   return 0;
 }
 
 static int compile_set_lang(CompileOptions* o, const char* name) {
   if (driver_streq(name, "c")) {
     o->forced_lang = KIT_LANG_C;
   } else if (driver_streq(name, "asm") || driver_streq(name, "s")) {
     o->forced_lang = KIT_LANG_ASM;
   } else if (driver_streq(name, "toy")) {
     o->forced_lang = KIT_LANG_TOY;
   } else if (driver_streq(name, "wasm") || driver_streq(name, "wat")) {
     o->forced_lang = KIT_LANG_WASM;
   } else {
     driver_errf(COMPILE_TOOL, "unsupported -x language: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(name)));
     return 1;
   }
   return 0;
 }
 
 /* Reject obvious link inputs with a clear pointer to the right tool. */
 static int compile_is_link_input(const char* a) {
   return driver_has_suffix(a, ".o") || driver_has_suffix(a, ".obj") ||
          driver_has_suffix(a, ".a") || driver_has_suffix(a, ".so") ||
          driver_has_suffix(a, ".dylib") || driver_has_suffix(a, ".tbd");
 }
 
 static int compile_classify_positional(CompileOptions* o, const char* a) {
   if (driver_streq(a, "-")) {
     driver_errf(COMPILE_TOOL,
                 "stdin ('-') is not supported; pass a source file");
     return 1;
   }
   if (compile_is_link_input(a)) {
     driver_errf(COMPILE_TOOL,
                 "compile does not link; pass %.*s to `cc`, `ld`, or `run`",
                 KIT_SLICE_ARG(kit_slice_cstr(a)));
     return 1;
   }
   o->sources[o->nsources++] = a;
   return 0;
 }
 
 static int compile_parse(int argc, char** argv, CompileOptions* o) {
   int i;
   o->forced_lang = -1;
   o->target = driver_host_target();
 
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
     int r;
 
     r = driver_cflags_try_consume(&o->cf, o->env, COMPILE_TOOL, argc, argv, &i);
     if (r < 0) return 1;
     if (r > 0) {
       o->cpp_flags_used = 1;
       continue;
     }
 
     if (driver_streq(a, "-c")) {
       o->emit = COMPILE_EMIT_OBJ;
       continue;
     }
     if (driver_streq(a, "-S")) {
       o->emit = COMPILE_EMIT_ASM;
       continue;
     }
     if (driver_streq(a, "--emit=obj")) {
       o->emit = COMPILE_EMIT_OBJ;
       continue;
     }
     if (driver_streq(a, "--emit=asm")) {
       o->emit = COMPILE_EMIT_ASM;
       continue;
     }
     if (driver_streq(a, "--emit=c")) {
       o->emit = COMPILE_EMIT_C;
       continue;
     }
     if (driver_streq(a, "--emit=ir")) {
       o->emit = COMPILE_EMIT_IR;
       continue;
     }
     if (driver_streq(a, "-fsyntax-only") || driver_streq(a, "--check")) {
       o->check_only = 1;
       continue;
     }
     if (driver_streq(a, "-g")) {
       o->debug_info = 1;
       continue;
     }
     if (driver_streq(a, "-O0")) {
       o->opt_level = 0;
       continue;
     }
     if (driver_streq(a, "-O1")) {
       o->opt_level = 1;
       continue;
     }
     if (driver_streq(a, "-O2")) {
       o->opt_level = 2;
       continue;
     }
     if (driver_streq(a, "-Werror")) {
       o->warnings_are_errors = 1;
       continue;
     }
     if (driver_strneq(a, "-fmax-errors=", 13)) {
       uint64_t v;
       if (compile_parse_u64(a + 13, &v) != 0 || v > 0xFFFFFFFFu) {
         driver_errf(COMPILE_TOOL,
                     "-fmax-errors= requires a non-negative integer");
         return 1;
       }
       o->max_errors = (uint32_t)v;
       continue;
     }
     if (driver_streq(a, "-o")) {
       if (++i >= argc) {
         driver_errf(COMPILE_TOOL, "-o requires an argument");
         return 1;
       }
       o->output_path = argv[i];
       continue;
     }
     if (driver_strneq(a, "-o", 2)) {
       o->output_path = a + 2;
       continue;
     }
     if (driver_streq(a, "-x")) {
       if (++i >= argc) {
         driver_errf(COMPILE_TOOL, "-x requires an argument");
         return 1;
       }
       if (compile_set_lang(o, argv[i]) != 0) return 1;
       continue;
     }
     if (driver_streq(a, "-target")) {
       if (++i >= argc) {
         driver_errf(COMPILE_TOOL, "-target requires an argument");
         return 1;
       }
       if (driver_target_from_triple(argv[i], &o->target) != 0) {
         driver_errf(COMPILE_TOOL, "unrecognized target: %.*s",
                     KIT_SLICE_ARG(kit_slice_cstr(argv[i])));
         return 1;
       }
       continue;
     }
     if (driver_strneq(a, "--target=", 9)) {
       if (driver_target_from_triple(a + 9, &o->target) != 0) {
         driver_errf(COMPILE_TOOL, "unrecognized target: %.*s",
                     KIT_SLICE_ARG(kit_slice_cstr(a + 9)));
         return 1;
       }
       continue;
     }
 
     {
       int tr = driver_target_features_try_consume(&o->target_features, o->env,
                                                   COMPILE_TOOL, argc, argv, &i);
       if (tr < 0) return 1;
       if (tr > 0) continue;
     }
 
     if (driver_streq(a, "--")) {
       for (++i; i < argc; ++i)
         if (compile_classify_positional(o, argv[i]) != 0) return 1;
       break;
     }
 
     /* A leftover flag belongs to the active frontend; defer it. A bare
      * positional is a source. */
     if (a[0] == '-' && a[1] != '\0') {
       o->fe_args[o->nfe_args++] = (char*)a;
       continue;
     }
     if (compile_classify_positional(o, a) != 0) return 1;
   }
 
   if (o->nsources == 0) {
     driver_errf(COMPILE_TOOL, "no input files");
     compile_usage();
     return 1;
   }
   if (o->output_path && o->nsources > 1) {
     driver_errf(COMPILE_TOOL, "-o cannot be used with multiple sources");
     return 1;
   }
   if (o->emit == COMPILE_EMIT_C && !o->output_path && !o->check_only) {
     driver_errf(COMPILE_TOOL, "--emit=c requires -o");
     return 1;
   }
   if (o->emit == COMPILE_EMIT_IR && o->opt_level < 1) {
     driver_errf(COMPILE_TOOL,
                 "--emit=ir requires -O1 or higher (the IR tape is only "
                 "recorded when the optimizer runs)");
     return 1;
   }
   return 0;
 }
 
 /* Derive `<base>.<ext>` next to nothing (basename only), where ext follows the
  * emit mode and target. Caller frees via driver_free(env, p, *out_size). */
 static char* compile_default_out(DriverEnv* env, const CompileOptions* o,
                                  const char* src, size_t* out_size) {
   int win = (o->target.os == KIT_OS_WINDOWS);
   const char* ext;
   size_t ext_len;
   size_t srclen = driver_strlen(src);
   size_t dot = srclen;
   size_t slash = 0;
   size_t k;
   switch ((CompileEmit)o->emit) {
     case COMPILE_EMIT_ASM:
       ext = ".s";
       ext_len = 2u;
       break;
     case COMPILE_EMIT_IR:
       ext = ".ir";
       ext_len = 3u;
       break;
     case COMPILE_EMIT_C:
       ext = ".c";
       ext_len = 2u;
       break;
     default:
       ext = win ? ".obj" : ".o";
       ext_len = win ? 4u : 2u;
       break;
   }
   for (k = srclen; k > 0; --k) {
     if (src[k - 1] == '.') {
       dot = k - 1;
       break;
     }
     if (src[k - 1] == '/') break;
   }
   for (k = dot; k > 0; --k) {
     if (src[k - 1] == '/') {
       slash = k;
       break;
     }
   }
   {
     size_t name_len = dot - slash;
     size_t bufsz = name_len + ext_len + 1u;
     char* buf = driver_alloc(env, bufsz);
     if (!buf) return NULL;
     driver_memcpy(buf, src + slash, name_len);
     driver_memcpy(buf + name_len, ext, ext_len);
     buf[name_len + ext_len] = '\0';
     *out_size = bufsz;
     return buf;
   }
 }
 
 /* Compile one source. out_path is NULL for check-only. */
 static int compile_one(const KitContext* ctx, KitCompiler* compiler,
                        KitLanguage lang, const KitCodeOptions* code,
                        const KitDiagnosticOptions* diag,
                        const KitPreprocessOptions* pp, const void* lang_extra,
                        const char* src, const char* out_path) {
   KitFileData fd = {0};
   KitSlice input;
   KitWriter* w = NULL;
   KitObjBuilder* ob = NULL;
   KitStatus st;
   int rc = 1;
 
   if (ctx->file_io->read_all(ctx->file_io->user, src, &fd) != KIT_OK) {
     driver_errf(COMPILE_TOOL, "failed to read: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(src)));
     return 1;
   }
   input.data = fd.data;
   input.len = fd.size;
 
   if (out_path) {
     if (ctx->file_io->open_writer(ctx->file_io->user, out_path, &w) != KIT_OK) {
       driver_errf(COMPILE_TOOL, "failed to open output: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(out_path)));
       goto out;
     }
     st = driver_compile_run(compiler, lang, code, diag, pp, lang_extra,
                             kit_slice_cstr(src), &input, w, NULL);
   } else {
     /* check-only: build and drop the object. */
     st = driver_compile_run(compiler, lang, code, diag, pp, lang_extra,
                             kit_slice_cstr(src), &input, NULL, &ob);
     kit_obj_builder_free(ob);
   }
   rc = (st == KIT_OK) ? 0 : 1;
 
 out:
   if (w) kit_writer_close(w);
   ctx->file_io->release(ctx->file_io->user, &fd);
   return rc;
 }
 
 int driver_compile(int argc, char** argv) {
   DriverEnv env;
   CompileOptions o = {0};
   DriverRuntimeSupport runtime = {0};
   int runtime_resolved = 0;
   KitContext ctx;
   KitTarget* target = NULL;
   KitCompiler* compiler = NULL;
   KitFrontendCaps caps = {0};
   KitLanguage lang = KIT_LANG_UNKNOWN;
   KitCodeOptions code = {0};
   KitDiagnosticOptions diag = {0};
   KitPreprocessOptions pp;
   void* lang_extra = NULL;
   uint32_t i;
   int rc = 2;
 
   if (argc < 2 || driver_argv_wants_help(argc, argv, 1)) {
     driver_help_compile();
     return 0;
   }
 
   driver_env_init(&env);
   o.env = &env;
   o.driver_path = argv[0];
 
   o.sources = driver_alloc_zeroed(&env, (size_t)argc * sizeof(*o.sources));
   o.fe_args = driver_alloc_zeroed(&env, (size_t)argc * sizeof(*o.fe_args));
   if (!o.sources || !o.fe_args || driver_cflags_init(&o.cf, &env, argc) != 0 ||
       driver_target_features_init(&o.target_features, &env, argc) != 0) {
     driver_errf(COMPILE_TOOL, "out of memory");
     goto done;
   }
 
   if (compile_parse(argc, argv, &o) != 0) goto done;
 
   /* Freestanding runtime headers (mirrors `cc`): required once we have
    * sources, so C/asm `#include`s resolve; harmless for toy/wasm. */
   if (driver_runtime_resolve(&env, NULL, o.driver_path, &runtime) == 0) {
     runtime_resolved = 1;
     if (driver_runtime_add_freestanding_headers(&runtime, &o.cf) != 0) {
       driver_errf(COMPILE_TOOL, "failed to add freestanding headers");
       rc = 1;
       goto done;
     }
   } else {
     driver_errf(COMPILE_TOOL, "support dir not found");
     rc = 1;
     goto done;
   }
 
   ctx = driver_env_to_context(&env);
   if (driver_target_new(&ctx, o.target, &o.target_features, COMPILE_TOOL,
                         &target) != KIT_OK ||
       driver_compiler_new(target, &ctx, &compiler) != KIT_OK) {
     driver_errf(COMPILE_TOOL, "failed to initialize compiler");
     rc = 1;
     goto done;
   }
 
   /* Resolve the single language: -x wins, else the first source's suffix.
    * Require every source to agree. */
   if (o.forced_lang >= 0) {
     lang = (KitLanguage)o.forced_lang;
   } else {
     lang = kit_language_for_path(compiler, o.sources[0]);
     if (lang == KIT_LANG_UNKNOWN) {
       driver_errf(COMPILE_TOOL,
                   "cannot determine language for %.*s (use -x LANG)",
                   KIT_SLICE_ARG(kit_slice_cstr(o.sources[0])));
       rc = 1;
       goto done;
     }
     for (i = 1; i < o.nsources; ++i) {
       if (kit_language_for_path(compiler, o.sources[i]) != lang) {
         driver_errf(COMPILE_TOOL,
                     "all sources must be one language; %.*s differs (use -x)",
                     KIT_SLICE_ARG(kit_slice_cstr(o.sources[i])));
         rc = 1;
         goto done;
       }
     }
   }
 
   if (kit_frontend_caps(compiler, lang, &caps) != KIT_OK) {
     driver_errf(COMPILE_TOOL, "no frontend registered for the input language");
     rc = 1;
     goto done;
   }
   if (o.cpp_flags_used && !caps.preprocessor) {
     driver_errf(COMPILE_TOOL,
                 "this frontend does not accept preprocessor flags "
                 "(-I/-isystem/-D/-U)");
     rc = 1;
     goto done;
   }
   if (o.nfe_args) {
     if (kit_frontend_parse_options(compiler, lang, (int)o.nfe_args, o.fe_args,
                                    &lang_extra) != KIT_OK) {
       /* The frontend emitted a specific diagnostic when it has a parser;
        * add a generic line for frontends that accept no extra flags. */
       driver_errf(COMPILE_TOOL, "unsupported option for this frontend: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(o.fe_args[0])));
       rc = 1;
       goto done;
     }
   }
 
   code.opt_level = o.check_only ? 0 : o.opt_level;
   code.debug_info = o.debug_info;
   code.check_only = o.check_only ? true : false;
   code.emit_asm_source = (o.emit == COMPILE_EMIT_ASM);
   code.emit_c_source = (o.emit == COMPILE_EMIT_C);
   code.emit_ir = (o.emit == COMPILE_EMIT_IR);
   diag.warnings_are_errors = o.warnings_are_errors;
   diag.max_errors = o.max_errors;
   driver_cflags_fill_pp(&o.cf, &pp);
 
   rc = 0;
   for (i = 0; i < o.nsources && rc == 0; ++i) {
     const char* src = o.sources[i];
     char* owned = NULL;
     size_t owned_size = 0;
     const char* out_path = NULL;
     if (!o.check_only) {
       if (o.output_path) {
         out_path = o.output_path;
       } else {
         owned = compile_default_out(&env, &o, src, &owned_size);
         if (!owned) {
           driver_errf(COMPILE_TOOL, "out of memory");
           rc = 1;
           break;
         }
         out_path = owned;
       }
     }
     rc = compile_one(&ctx, compiler, lang, &code, &diag,
                      caps.preprocessor ? &pp : NULL, lang_extra, src, out_path);
     if (owned) driver_free(&env, owned, owned_size);
   }
 
 done:
   if (lang_extra) kit_frontend_free_options(compiler, lang, lang_extra);
   if (compiler) driver_compiler_free(compiler);
   kit_target_free(target);
   if (runtime_resolved) driver_runtime_support_fini(&env, &runtime);
   driver_target_features_fini(&o.target_features, &env);
   driver_cflags_fini(&o.cf, &env);
   if (o.sources)
     driver_free(&env, o.sources, (size_t)argc * sizeof(*o.sources));
   if (o.fe_args)
     driver_free(&env, o.fe_args, (size_t)argc * sizeof(*o.fe_args));
   driver_env_fini(&env);
   return rc;
 }