kit

target.c (16113B)

---

 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <kit/target.h>
 
 #include "driver.h"
 
 /* Target-triple parsing and the spec-derived target defaults now live in the
  * public libkit API (<kit/target.h>, src/api/target.c). The functions below are
  * thin driver-side wrappers that preserve the historical driver_* signatures
  * (and the driver's int-status / diagnostic conventions) so every CLI caller is
  * unaffected. The CLI feature-parsing policy (-march / -mattr / -mcpu / -m<feat>
  * → DriverTargetFeatures) stays here, since it consumes argv and emits
  * diagnostics. */
 
 int driver_arch_from_name(const char* name, KitArchKind* arch_out,
                           uint8_t* ptr_size_out) {
   return kit_arch_from_name(name, arch_out, ptr_size_out) ? 0 : 1;
 }
 
 void driver_err_unknown_target(const char* tool, const char* value) {
   const KitTargetProfile* profiles;
   const char* candidates[64];
   DriverSuggestion suggestions[3];
   size_t count = 0, candidate_count = 0, i, nsuggestions;
   profiles = kit_target_profiles(&count);
   for (i = 0; i < count && candidate_count < 64; ++i)
     candidates[candidate_count++] = profiles[i].triple;
   for (i = 0; i < count && candidate_count < 64; ++i)
     candidates[candidate_count++] = profiles[i].selector;
   nsuggestions = driver_suggest_values(value, candidates, candidate_count,
                                        suggestions, 3);
   if (nsuggestions)
     driver_errf(tool, "unrecognized target: %s; did you mean '%s'?", value,
                 suggestions[0].value);
   else
     driver_errf(tool, "unrecognized target: %s; run `kit targets` to list "
                       "supported profiles",
                 value);
 }
 
 KitPic driver_default_pic(KitObjFmt obj, KitOSKind os) {
   return kit_target_default_pic(obj, os);
 }
 
 int driver_link_pie(KitTargetSpec target, int explicit_pie, int shared,
                     int relocatable) {
   return kit_target_link_pie(target, explicit_pie, shared, relocatable);
 }
 
 const char* driver_default_exe_name(KitTargetSpec target) {
   return kit_target_default_exe_name(target);
 }
 
 void driver_default_obj_ext(KitTargetSpec target, const char** ext_out,
                             size_t* ext_len_out) {
   kit_target_default_obj_ext(target, ext_out, ext_len_out);
 }
 
 int driver_target_needs_sysroot_libdir(KitTargetSpec target) {
   return kit_target_needs_sysroot_libdir(target);
 }
 
 int driver_target_default_hosted_profile(KitTargetSpec target) {
   return kit_target_default_hosted_profile(target);
 }
 
 int driver_target_shared_uses_hosted(KitTargetSpec target) {
   /* Whether a `-shared` link still needs the hosted CRT/libc is an OS policy
    * (Android bionic does; ELF/Mach-O/COFF hosts otherwise do not). Read it from
    * the OS hosted-ops vtable rather than hardcoding the identity here. The obj
    * gate guards against a triple that names an OS but a mismatched object
    * format. Note: no arch coupling -- Android shared libs need the hosted CRT on
    * every arch (only aarch64 is built today, so behavior is preserved). */
   const KitOsImpl* o = kit_os_lookup(target.os);
   return o && o->hosted && o->hosted->obj == target.obj &&
          o->hosted->shared_uses_hosted;
 }
 
 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;
 }
 
 /* Map an ARM -mfpu= name onto the backend's VFP target features. `none` records
  * nothing (soft-float). `fpv4-sp-d16` (Cortex-M4F) records `vfp`; `fpv5-d16` /
  * `fpv5-sp-d16` (Cortex-M7) record `vfp`+`fpv5`. An unknown name is an error.
  * The recorded features flow through opts->features[] into kit_target_new, where
  * resolve_float_abi requires them for -mfloat-abi=hard/softfp and the
  * feature_predefines hook keys __ARM_FP/__ARM_FPV5__ on them. */
 static int target_features_record_mfpu(DriverTargetFeatures* tf, DriverEnv* env,
                                        const char* tool, const char* fpu) {
   if (driver_streq(fpu, "none")) return 0;
   if (driver_streq(fpu, "fpv4-sp-d16")) {
     return target_features_record_feature(tf, env, KIT_SLICE_LIT("vfp"), 1) == 0
                ? 0
                : 1;
   }
   if (driver_streq(fpu, "fpv5-d16") || driver_streq(fpu, "fpv5-sp-d16")) {
     if (target_features_record_feature(tf, env, KIT_SLICE_LIT("vfp"), 1) != 0)
       return 1;
     return target_features_record_feature(tf, env, KIT_SLICE_LIT("fpv5"), 1) == 0
                ? 0
                : 1;
   }
   driver_errf(tool, "-mfpu=%s is unsupported (none, fpv4-sp-d16, fpv5-d16, "
                     "fpv5-sp-d16)",
               fpu);
   return 1;
 }
 
 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;
   }
   /* -mfloat-abi / -mfpu: ARM float-ABI selection. v1 supports soft-float only
    * (FP via the AEABI helpers); the arch's resolve_float_abi pins float_abi to
    * SOFT. Consume the flag here so it does not fall through to the generic
    * -m<feature> recorder (which would reject "float-abi=soft" as an unknown
    * feature). hard/softfp are a follow-on. -mfpu records the VFP target
    * features so the FP-feature machinery (resolve_float_abi requiring vfp/fpv5,
    * the __ARM_FP/__ARM_FPV5__ macros) is exercisable at the kit_target_new
    * level, even though -mfloat-abi=hard/softfp is still rejected below. */
   if (driver_strneq(a, "-mfloat-abi=", 12)) {
     if (!driver_streq(a + 12, "soft")) {
       driver_errf(tool,
                   "-mfloat-abi=%s is unsupported (soft-float only; hard/softfp "
                   "are a follow-on)",
                   a + 12);
       return -1;
     }
     return 1;
   }
   if (driver_streq(a, "-mfloat-abi")) {
     v = target_features_pull_value(tool, argc, argv, i, 11, "-mfloat-abi");
     if (!v) return -1;
     if (!driver_streq(v, "soft")) {
       driver_errf(tool,
                   "-mfloat-abi %s is unsupported (soft-float only; hard/softfp "
                   "are a follow-on)",
                   v);
       return -1;
     }
     return 1;
   }
   if (driver_strneq(a, "-mfpu=", 6))
     return target_features_record_mfpu(tf, env, tool, a + 6) == 0 ? 1 : -1;
   if (driver_streq(a, "-mfpu")) {
     v = target_features_pull_value(tool, argc, argv, i, 5, "-mfpu");
     if (!v) return -1;
     return target_features_record_mfpu(tf, env, tool, v) == 0 ? 1 : -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;
 }
 
 static int darwin_platform_set_arch(const char* tool, KitTargetSpec* target,
                                     const char* arch) {
   KitArchKind k;
   uint8_t ptr_size;
   if (!arch) {
     driver_errf(tool, "-arch requires an argument");
     return 1;
   }
   if (driver_streq(arch, "arm64e")) arch = "arm64";
   if (driver_arch_from_name(arch, &k, &ptr_size) != 0) {
     driver_errf(tool, "unsupported -arch value: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(arch)));
     return 1;
   }
   target->arch = k;
   target->ptr_size = ptr_size;
   target->ptr_align = ptr_size;
   return 0;
 }
 
 static void darwin_platform_set_os(KitTargetSpec* target, const char* platform,
                                    int pic_explicit) {
   if (!platform) return;
   if (driver_streq(platform, "macos")) {
     target->os = KIT_OS_MACOS;
     target->obj = KIT_OBJ_MACHO;
   } else if (driver_streq(platform, "ios")) {
     target->os = KIT_OS_IOS;
     target->obj = KIT_OBJ_MACHO;
   } else if (driver_streq(platform, "ios-simulator") ||
              driver_streq(platform, "iossimulator")) {
     target->os = KIT_OS_IOS_SIMULATOR;
     target->obj = KIT_OBJ_MACHO;
   } else if (driver_streq(platform, "linux")) {
     target->os = KIT_OS_LINUX;
     target->obj = KIT_OBJ_ELF;
   } else {
     return;
   }
   if (!pic_explicit) target->pic = driver_default_pic(target->obj, target->os);
 }
 
 int driver_darwin_platform_try_consume(const char* tool, int argc, char** argv,
                                        int* i, KitTargetSpec* target,
                                        int pic_explicit) {
   const char* a;
   if (!argv || !i || !target || *i < 0 || *i >= argc) return 0;
   a = argv[*i];
   if (driver_streq(a, "-arch")) {
     if (++(*i) >= argc) {
       driver_errf(tool, "-arch requires an argument");
       return -1;
     }
     return darwin_platform_set_arch(tool, target, argv[*i]) == 0 ? 1 : -1;
   }
   if (driver_streq(a, "-platform_version")) {
     if (*i + 3 >= argc) {
       driver_errf(tool, "-platform_version requires three arguments");
       return -1;
     }
     darwin_platform_set_os(target, argv[*i + 1], pic_explicit);
     *i += 3;
     return 1;
   }
   if (driver_streq(a, "-macosx_version_min")) {
     if (++(*i) >= argc) {
       driver_errf(tool, "-macosx_version_min requires an argument");
       return -1;
     }
     darwin_platform_set_os(target, "macos", pic_explicit);
     return 1;
   }
   if (driver_streq(a, "-ios_version_min") ||
       driver_streq(a, "-iphoneos_version_min")) {
     if (++(*i) >= argc) {
       driver_errf(tool, "%s requires an argument", a);
       return -1;
     }
     darwin_platform_set_os(target, "ios", pic_explicit);
     return 1;
   }
   if (driver_streq(a, "-ios_simulator_version_min") ||
       driver_streq(a, "-iphonesimulator_version_min")) {
     if (++(*i) >= argc) {
       driver_errf(tool, "%s requires an argument", a);
       return -1;
     }
     darwin_platform_set_os(target, "ios-simulator", pic_explicit);
     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) {
   return kit_target_from_triple(triple, out) ? 0 : 1;
 }
 
 int driver_target_to_triple(KitTargetSpec target, char* buf, size_t cap) {
   return kit_target_to_triple(target, buf, cap) ? 0 : 1;
 }
 
 int driver_record_mcmodel(KitTargetSpec* target, const char* tool,
                           const char* val) {
   KitCodeModel cm;
   if (!kit_target_code_model_from_name(val, &cm)) {
     driver_errf(tool, "unknown -mcmodel value: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(val)));
     return 1;
   }
   if (target) target->code_model = cm;
   return 0;
 }