kit

target.c (14645B)

---

 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include "driver.h"
 
 /* Pure target-triple parsing. No host I/O — just string walking — so this
  * lives outside driver/env.c (which is the syscall/host-state abstraction
  * layer). */
 
 static int triple_tok_eq(const char* s, size_t n, const char* lit) {
   size_t l = kit_slice_cstr(lit).len;
   return n == l && memcmp(s, lit, n) == 0;
 }
 
 /* Prefix match for OS tokens that carry a trailing version, e.g. clang emits
  * "freebsd15.0" / "freebsd14" rather than a bare "freebsd". */
 static int triple_tok_prefix(const char* s, size_t n, const char* lit) {
   size_t l = kit_slice_cstr(lit).len;
   return n >= l && memcmp(s, lit, l) == 0;
 }
 
 /* Recognize an architecture token, the single authority for the arch-name
  * spellings the driver accepts. Writes arch + natural pointer size on a hit.
  * Returns 0 on success, nonzero for an unrecognized token. Shared by the
  * triple parser and the public driver_arch_from_name. */
 static int arch_from_tok(const char* s, size_t n, KitArchKind* arch_out,
                          uint8_t* ptr_size_out) {
   KitArchKind arch;
   uint8_t ptr_size;
   if (triple_tok_eq(s, n, "x86_64") || triple_tok_eq(s, n, "amd64") ||
       triple_tok_eq(s, n, "x64")) {
     arch = KIT_ARCH_X86_64;
     ptr_size = 8;
   } else if (triple_tok_eq(s, n, "i386") || triple_tok_eq(s, n, "i486") ||
              triple_tok_eq(s, n, "i586") || triple_tok_eq(s, n, "i686")) {
     arch = KIT_ARCH_X86_32;
     ptr_size = 4;
   } else if (triple_tok_eq(s, n, "aarch64") || triple_tok_eq(s, n, "arm64") ||
              triple_tok_eq(s, n, "aa64")) {
     arch = KIT_ARCH_ARM_64;
     ptr_size = 8;
   } else if (triple_tok_eq(s, n, "arm") || triple_tok_eq(s, n, "armv7")) {
     arch = KIT_ARCH_ARM_32;
     ptr_size = 4;
   } else if (triple_tok_eq(s, n, "riscv64") || triple_tok_eq(s, n, "rv64")) {
     arch = KIT_ARCH_RV64;
     ptr_size = 8;
   } else if (triple_tok_eq(s, n, "riscv32") || triple_tok_eq(s, n, "rv32")) {
     arch = KIT_ARCH_RV32;
     ptr_size = 4;
   } else if (triple_tok_eq(s, n, "wasm32")) {
     arch = KIT_ARCH_WASM;
     ptr_size = 4;
   } else if (triple_tok_eq(s, n, "wasm64")) {
     arch = KIT_ARCH_WASM;
     ptr_size = 8;
   } else {
     return 1;
   }
   if (arch_out) *arch_out = arch;
   if (ptr_size_out) *ptr_size_out = ptr_size;
   return 0;
 }
 
 int driver_arch_from_name(const char* name, KitArchKind* arch_out,
                           uint8_t* ptr_size_out) {
   if (!name) return 1;
   return arch_from_tok(name, kit_slice_cstr(name).len, arch_out, ptr_size_out);
 }
 
 KitPic driver_default_pic(KitObjFmt obj, KitOSKind os) {
   /* WASM has no PIC/PIE concept; freestanding targets have no dynamic
    * loader to apply load-time relocations. Everything else is hosted and
    * defaults to PIE. */
   if (obj == KIT_OBJ_WASM) return KIT_PIC_NONE;
   if (os == KIT_OS_FREESTANDING) return KIT_PIC_NONE;
   return KIT_PIC_PIE;
 }
 
 int driver_link_pie(KitTargetSpec target, int explicit_pie, int shared,
                     int relocatable) {
   if (explicit_pie) return 1;
   if (shared || relocatable) return 0;
   return target.pic == KIT_PIC_PIE;
 }
 
 const char* driver_default_exe_name(KitTargetSpec target) {
   /* PE/COFF executables conventionally carry a `.exe` suffix; ELF/Mach-O
    * default link output is the historical `a.out`. */
   return target.os == KIT_OS_WINDOWS ? "a.exe" : "a.out";
 }
 
 void driver_default_obj_ext(KitTargetSpec target, const char** ext_out,
                             size_t* ext_len_out) {
   /* Windows targets default to a `.obj` suffix; everyone else `.o`. Drivers
    * accept both spellings as inputs, but tooling that scrapes default outputs
    * expects the canonical platform extension. */
   if (target.os == KIT_OS_WINDOWS) {
     if (ext_out) *ext_out = ".obj";
     if (ext_len_out) *ext_len_out = 4u;
   } else {
     if (ext_out) *ext_out = ".o";
     if (ext_len_out) *ext_len_out = 2u;
   }
 }
 
 int driver_target_needs_sysroot_libdir(KitTargetSpec target) {
   /* Windows targets fold `<sysroot>/lib` into the library search path (the
    * mingw import-library tree). The POSIX hosted profiles enumerate their
    * libdirs through the hosted resolver instead. */
   return target.os == KIT_OS_WINDOWS ? 1 : 0;
 }
 
 int driver_target_default_hosted_profile(KitTargetSpec target) {
   /* Windows-COFF is the one target whose hosted libc profile is engaged by
    * default (given a sysroot and no -nostdlib): the mingw/ucrt import
    * libraries are mandatory to produce a runnable PE. Other targets stay
    * freestanding unless the user opts in (-lc / explicit sysroot wiring). */
   return target.os == KIT_OS_WINDOWS && target.obj == KIT_OBJ_COFF ? 1 : 0;
 }
 
 static int target_features_grow(DriverTargetFeatures* tf) {
   DriverEnv* env = tf->env;
   uint32_t old_cap = tf->cap_features;
   uint32_t new_cap = old_cap ? old_cap * 2u : 8u;
   size_t old_sz = (size_t)old_cap * sizeof(*tf->features);
   size_t new_sz = (size_t)new_cap * sizeof(*tf->features);
   void* p = env->heap->realloc(env->heap, tf->features, old_sz, new_sz,
                                _Alignof(KitTargetFeature));
   if (!p) return 1;
   tf->features = (KitTargetFeature*)p;
   memset(tf->features + old_cap, 0, new_sz - old_sz);
   tf->cap_features = new_cap;
   return 0;
 }
 
 int driver_target_features_init(DriverTargetFeatures* tf, DriverEnv* env,
                                 int argc_bound) {
   size_t bound = argc_bound > 0 ? (size_t)argc_bound + 8u : 8u;
   if (!tf || !env || !env->heap) return 1;
   memset(tf, 0, sizeof(*tf));
   tf->env = env;
   tf->cap_features = (uint32_t)bound;
   tf->features = driver_alloc_zeroed(env, bound * sizeof(*tf->features));
   if (!tf->features) return 1;
   return 0;
 }
 
 void driver_target_features_fini(DriverTargetFeatures* tf, DriverEnv* env) {
   if (!tf || !env) return;
   driver_free(env, tf->features,
               (size_t)tf->cap_features * sizeof(*tf->features));
   memset(tf, 0, sizeof(*tf));
 }
 
 static int target_features_record_feature(DriverTargetFeatures* tf,
                                           DriverEnv* env, KitSlice name,
                                           int enabled) {
   KitTargetFeature* f;
   (void)env;
   if (!name.s || name.len == 0) return 1;
   if (tf->nfeatures >= tf->cap_features && target_features_grow(tf) != 0)
     return 1;
   f = &tf->features[tf->nfeatures++];
   f->name = name;
   f->enabled = enabled ? true : false;
   return 0;
 }
 
 static const char* target_features_pull_value(const char* tool, int argc,
                                               char** argv, int* i,
                                               size_t prefix_len,
                                               const char* flag_label) {
   const char* a = argv[*i];
   if (a[prefix_len]) return a + prefix_len;
   if (++(*i) >= argc) {
     driver_errf(tool, "%.*s requires an argument",
                 KIT_SLICE_ARG(kit_slice_cstr(flag_label)));
     return NULL;
   }
   return argv[*i];
 }
 
 static int target_features_parse_mattr(DriverTargetFeatures* tf, DriverEnv* env,
                                        const char* tool, const char* list) {
   const char* p = list;
   if (!p || !*p) {
     driver_errf(tool, "-mattr= requires a comma-separated feature list");
     return 1;
   }
   while (*p) {
     int enabled;
     const char* start;
     if (*p == '+') {
       enabled = 1;
     } else if (*p == '-') {
       enabled = 0;
     } else {
       driver_errf(tool, "-mattr entries must start with '+' or '-': %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(p)));
       return 1;
     }
     ++p;
     start = p;
     while (*p && *p != ',') ++p;
     if (p == start) {
       driver_errf(tool, "empty -mattr feature");
       return 1;
     }
     if (target_features_record_feature(
             tf, env, (KitSlice){.s = start, .len = (size_t)(p - start)},
             enabled) != 0) {
       driver_errf(tool, "out of memory");
       return 1;
     }
     if (*p == ',') ++p;
   }
   return 0;
 }
 
 int driver_target_features_try_consume(DriverTargetFeatures* tf, DriverEnv* env,
                                        const char* tool, int argc, char** argv,
                                        int* i) {
   const char* a = argv[*i];
   const char* v;
   if (!tf || !a) return 0;
 
   if (driver_strneq(a, "-mattr=", 7)) {
     return target_features_parse_mattr(tf, env, tool, a + 7) == 0 ? 1 : -1;
   }
   if (driver_streq(a, "-mattr")) {
     if (++(*i) >= argc) {
       driver_errf(tool, "-mattr requires an argument");
       return -1;
     }
     return target_features_parse_mattr(tf, env, tool, argv[*i]) == 0 ? 1 : -1;
   }
   if (driver_strneq(a, "-mfeature=", 10) ||
       driver_strneq(a, "-mno-feature=", 13)) {
     return 0;
   }
   if (driver_strneq(a, "-march=", 7)) {
     tf->isa = kit_slice_cstr(a + 7);
     return 1;
   }
   if (driver_streq(a, "-march")) {
     if (++(*i) >= argc) {
       driver_errf(tool, "-march requires an argument");
       return -1;
     }
     tf->isa = kit_slice_cstr(argv[*i]);
     return 1;
   }
   if (driver_strneq(a, "-mabi=", 6)) {
     tf->abi = kit_slice_cstr(a + 6);
     return 1;
   }
   if (driver_streq(a, "-mabi")) {
     if (++(*i) >= argc) {
       driver_errf(tool, "-mabi requires an argument");
       return -1;
     }
     tf->abi = kit_slice_cstr(argv[*i]);
     return 1;
   }
   if (driver_strneq(a, "-mcpu=", 6)) {
     tf->cpu = kit_slice_cstr(a + 6);
     return 1;
   }
   if (driver_streq(a, "-mcpu")) {
     v = target_features_pull_value(tool, argc, argv, i, 5, "-mcpu");
     if (!v) return -1;
     tf->cpu = kit_slice_cstr(v);
     return 1;
   }
   if (driver_strneq(a, "-mtune=", 7)) {
     tf->tune = kit_slice_cstr(a + 7);
     return 1;
   }
   if (driver_streq(a, "-mtune")) {
     v = target_features_pull_value(tool, argc, argv, i, 6, "-mtune");
     if (!v) return -1;
     tf->tune = kit_slice_cstr(v);
     return 1;
   }
   if (driver_strneq(a, "-mno-", 5) && a[5] != '\0') {
     if (target_features_record_feature(tf, env, kit_slice_cstr(a + 5), 0) !=
         0) {
       driver_errf(tool, "out of memory");
       return -1;
     }
     return 1;
   }
   if (driver_strneq(a, "-m", 2) && a[2] != '\0') {
     if (target_features_record_feature(tf, env, kit_slice_cstr(a + 2), 1) !=
         0) {
       driver_errf(tool, "out of memory");
       return -1;
     }
     return 1;
   }
   return 0;
 }
 
 int driver_target_options(const DriverTargetFeatures* tf, const char* tool,
                           KitTargetSpec target, KitTargetOptions* out) {
   (void)tool;
   if (!out) return 1;
   memset(out, 0, sizeof(*out));
   out->spec = target;
   if (!tf) return 0;
   out->isa = tf->isa;
   out->cpu = tf->cpu;
   out->tune = tf->tune;
   out->abi = tf->abi;
   out->features = tf->features;
   out->nfeatures = tf->nfeatures;
   return 0;
 }
 
 KitStatus driver_target_new(const KitContext* ctx, KitTargetSpec target,
                             const DriverTargetFeatures* tf, const char* tool,
                             KitTarget** out) {
   KitTargetOptions opts;
   if (driver_target_options(tf, tool, target, &opts) != 0) {
     if (out) *out = NULL;
     return KIT_INVALID;
   }
   return kit_target_new(ctx, &opts, out);
 }
 
 int driver_target_from_triple(const char* triple, KitTargetSpec* out) {
   const char* parts[4];
   size_t plen[4];
   int np = 0;
   const char* p;
   KitTargetSpec t;
   int os_set;
   int i;
 
   if (!triple || !out) return 1;
   memset(&t, 0, sizeof(t));
 
   p = triple;
   while (np < 4) {
     const char* dash = driver_strchr(p, '-');
     parts[np] = p;
     plen[np] = dash ? (size_t)(dash - p) : kit_slice_cstr(p).len;
     if (plen[np] == 0) return 1;
     np++;
     if (!dash) break;
     p = dash + 1;
   }
 
   if (arch_from_tok(parts[0], plen[0], &t.arch, &t.ptr_size) != 0) return 1;
 
   os_set = 0;
   for (i = 1; i < np; ++i) {
     if (triple_tok_eq(parts[i], plen[i], "linux")) {
       t.os = KIT_OS_LINUX;
       t.obj = KIT_OBJ_ELF;
       os_set = 1;
       break;
     }
     if (triple_tok_eq(parts[i], plen[i], "darwin") ||
         triple_tok_eq(parts[i], plen[i], "macos")) {
       t.os = KIT_OS_MACOS;
       t.obj = KIT_OBJ_MACHO;
       os_set = 1;
       break;
     }
     if (triple_tok_eq(parts[i], plen[i], "windows") ||
         triple_tok_eq(parts[i], plen[i], "win32")) {
       t.os = KIT_OS_WINDOWS;
       t.obj = KIT_OBJ_COFF;
       os_set = 1;
       break;
     }
     if (triple_tok_prefix(parts[i], plen[i], "freebsd")) {
       const char* ver = parts[i] + 7; /* skip "freebsd" */
       size_t rem = plen[i] - 7;
       unsigned v = 0;
       size_t j;
       for (j = 0; j < rem && ver[j] >= '0' && ver[j] <= '9'; ++j)
         v = v * 10 + (unsigned)(ver[j] - '0');
       t.os = KIT_OS_FREEBSD;
       t.obj = KIT_OBJ_ELF;
       t.os_version_major = (uint8_t)(v > 255 ? 0 : v);
       os_set = 1;
       break;
     }
     if (triple_tok_eq(parts[i], plen[i], "wasi")) {
       t.os = KIT_OS_WASI;
       t.obj = KIT_OBJ_WASM;
       os_set = 1;
       break;
     }
     if (triple_tok_eq(parts[i], plen[i], "none") ||
         triple_tok_eq(parts[i], plen[i], "freestanding")) {
       t.os = KIT_OS_FREESTANDING;
       t.obj = (t.arch == KIT_ARCH_WASM) ? KIT_OBJ_WASM : KIT_OBJ_ELF;
       os_set = 1;
       break;
     }
   }
   if (!os_set) {
     t.os = KIT_OS_FREESTANDING;
     t.obj = (t.arch == KIT_ARCH_WASM) ? KIT_OBJ_WASM : KIT_OBJ_ELF;
   }
 
   t.ptr_align = t.ptr_size;
   t.big_endian = 0;
   t.pic = driver_default_pic(t.obj, t.os);
   t.code_model = KIT_CM_DEFAULT;
 
   *out = t;
   return 0;
 }
 
 int driver_target_to_triple(KitTargetSpec target, char* buf, size_t cap) {
   const char* arch;
   const char* os;
   int n;
   if (!buf || cap == 0) return 1;
 
   switch (target.arch) {
     case KIT_ARCH_X86_64:
       arch = "x86_64";
       break;
     case KIT_ARCH_X86_32:
       arch = "i386";
       break;
     case KIT_ARCH_ARM_64:
       arch = "aarch64";
       break;
     case KIT_ARCH_ARM_32:
       arch = "arm";
       break;
     case KIT_ARCH_RV64:
       arch = "riscv64";
       break;
     case KIT_ARCH_RV32:
       arch = "riscv32";
       break;
     case KIT_ARCH_WASM:
       arch = target.ptr_size == 8 ? "wasm64" : "wasm32";
       break;
     default:
       arch = "unknown";
       break;
   }
 
   switch (target.os) {
     case KIT_OS_LINUX:
       os = "linux";
       break;
     case KIT_OS_MACOS:
       os = "apple-darwin";
       break;
     case KIT_OS_WINDOWS:
       os = "windows";
       break;
     case KIT_OS_FREEBSD:
       os = "freebsd";
       break;
     case KIT_OS_WASI:
       os = "wasi";
       break;
     case KIT_OS_FREESTANDING:
     default:
       os = "elf";
       break;
   }
 
   n = snprintf(buf, cap, "%.*s-%.*s", KIT_SLICE_ARG(kit_slice_cstr(arch)),
                KIT_SLICE_ARG(kit_slice_cstr(os)));
   return n < 0 || (size_t)n >= cap;
 }