kit

kit
git clone https://git.ryansepassi.com/git/kit.git
Log | Files | Refs | README

target_test.c (4322B)

      1 /* target_test - public <kit/core.h> target creation and feature API. */
      2 
      3 #include <kit/core.h>
      4 #include <string.h>
      5 
      6 #include "lib/kit_unit.h"
      7 
      8 static KitUnit g_u;
      9 #define EXPECT(c, ...) CU_EXPECT(&g_u, c, __VA_ARGS__)
     10 
     11 static KitTargetSpec target_spec(KitArchKind arch, KitOSKind os,
     12                                  KitObjFmt obj) {
     13   KitTargetSpec t = kit_unit_target(arch, os, obj);
     14   if (arch == KIT_ARCH_WASM) {
     15     t.ptr_size = 4;
     16     t.ptr_align = 4;
     17   }
     18   return t;
     19 }
     20 
     21 static KitStatus make_target(KitTargetSpec spec, KitSlice isa,
     22                              const KitTargetFeature* features,
     23                              uint32_t nfeatures, KitTarget** out) {
     24   KitTargetOptions opts;
     25   memset(&opts, 0, sizeof opts);
     26   opts.spec = spec;
     27   opts.isa = isa;
     28   opts.features = features;
     29   opts.nfeatures = nfeatures;
     30   return kit_target_new(&g_u.ctx, &opts, out);
     31 }
     32 
     33 static int has(KitTarget* t, const char* name) {
     34   return kit_target_has_feature(t, kit_slice_cstr(name));
     35 }
     36 
     37 static void check_x64_defaults_and_isa(void) {
     38   KitTargetSpec spec = target_spec(KIT_ARCH_X86_64, KIT_OS_LINUX, KIT_OBJ_ELF);
     39   KitTargetFeature disable_avx2[] = {
     40       {KIT_SLICE_LIT("avx2"), false},
     41   };
     42   KitTarget* t = NULL;
     43 
     44   EXPECT(make_target(spec, KIT_SLICE_NULL, NULL, 0, &t) == KIT_OK,
     45          "x64 default target");
     46   EXPECT(has(t, "sse"), "x64 default has sse");
     47   EXPECT(has(t, "sse2"), "x64 default has sse2");
     48   EXPECT(!has(t, "avx"), "x64 default lacks avx");
     49   kit_target_free(t);
     50 
     51   t = NULL;
     52   EXPECT(make_target(spec, KIT_SLICE_LIT("x86-64-v3"), disable_avx2, 1, &t) ==
     53              KIT_OK,
     54          "x64 isa profile plus feature override");
     55   EXPECT(has(t, "avx"), "x86-64-v3 enables avx");
     56   EXPECT(!has(t, "avx2"), "explicit feature override disables avx2");
     57   kit_target_free(t);
     58 }
     59 
     60 static void check_rv64_isa_and_overrides(void) {
     61   KitTargetSpec spec = target_spec(KIT_ARCH_RV64, KIT_OS_LINUX, KIT_OBJ_ELF);
     62   KitTargetFeature enable_c[] = {
     63       {KIT_SLICE_LIT("c"), true},
     64   };
     65   KitTarget* t = NULL;
     66 
     67   EXPECT(make_target(spec, KIT_SLICE_LIT("rv64im"), enable_c, 1, &t) == KIT_OK,
     68          "rv64 isa plus feature override");
     69   EXPECT(has(t, "i"), "rv64im has i");
     70   EXPECT(has(t, "m"), "rv64im has m");
     71   EXPECT(!has(t, "a"), "rv64im lacks a");
     72   EXPECT(has(t, "c"), "explicit feature override enables c");
     73   EXPECT(!has(t, "zicsr"), "rv64im lacks zicsr");
     74   kit_target_free(t);
     75 }
     76 
     77 static void check_wasm_features(void) {
     78   KitTargetSpec spec = target_spec(KIT_ARCH_WASM, KIT_OS_WASI, KIT_OBJ_WASM);
     79   KitTargetFeature disable_tail_calls[] = {
     80       {KIT_SLICE_LIT("tail-calls"), false},
     81   };
     82   KitTarget* t = NULL;
     83   KitTargetSpec resolved;
     84 
     85   EXPECT(make_target(spec, KIT_SLICE_LIT("wasm32"), disable_tail_calls, 1,
     86                      &t) == KIT_OK,
     87          "wasm32 target with disabled tail-calls");
     88   resolved = kit_target_spec(t);
     89   EXPECT(resolved.arch == KIT_ARCH_WASM && resolved.ptr_size == 4,
     90          "kit_target_spec preserves wasm32 shape");
     91   EXPECT(!has(t, "tail-calls"),
     92          "explicit feature override disables tail-calls");
     93   EXPECT(has(t, "bulk-memory"), "wasm default still has bulk-memory");
     94   EXPECT(!has(t, "not-a-feature"), "unknown queried feature is absent");
     95   kit_target_free(t);
     96 }
     97 
     98 static void check_errors(void) {
     99   KitTargetSpec spec = target_spec(KIT_ARCH_X86_64, KIT_OS_LINUX, KIT_OBJ_ELF);
    100   KitTargetFeature bad_feature[] = {
    101       {KIT_SLICE_LIT("nope"), true},
    102   };
    103   KitTarget* t = NULL;
    104 
    105   g_u.last_diag[0] = '\0';
    106   EXPECT(make_target(spec, KIT_SLICE_NULL, bad_feature, 1, &t) == KIT_INVALID,
    107          "unknown feature rejected");
    108   EXPECT(t == NULL, "unknown feature leaves target NULL");
    109   EXPECT(strstr(g_u.last_diag, "unknown target feature") != NULL,
    110          "unknown feature diagnostic");
    111 
    112   g_u.last_diag[0] = '\0';
    113   EXPECT(
    114       make_target(spec, KIT_SLICE_LIT("x86-64-v9"), NULL, 0, &t) == KIT_INVALID,
    115       "unknown ISA/profile rejected");
    116   EXPECT(t == NULL, "unknown ISA/profile leaves target NULL");
    117   EXPECT(strstr(g_u.last_diag, "unsupported ISA/profile") != NULL,
    118          "unknown ISA/profile diagnostic");
    119 }
    120 
    121 int main(void) {
    122   kit_unit_init(&g_u);
    123   check_x64_defaults_and_isa();
    124   check_rv64_isa_and_overrides();
    125   check_wasm_features();
    126   check_errors();
    127   kit_unit_summary(&g_u, "target_test");
    128   return kit_unit_status(&g_u);
    129 }