kit

groupiter.c (7552B)

---

 /* Hand-built object with a COMDAT group, exercised through the public
  * object builder and kit_obj_groupiter APIs.
  *
  * Steps:
  *   1. Build an ELF with two sections wired into one COMDAT group.
  *   2. Emit ELF, reopen via kit_obj_open, walk the public iter; verify
  *      group survives the on-disk roundtrip and section IDs are
  *      remapped to the public 0-based space. */
 
 #include <kit/core.h>
 #include <kit/object.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "lib/kit_test_target.h"
 
 static void* heap_alloc(KitHeap* h, size_t n, size_t a) {
   (void)h;
   (void)a;
   return n ? malloc(n) : NULL;
 }
 static void* heap_realloc(KitHeap* h, void* p, size_t o, size_t n, size_t a) {
   (void)h;
   (void)o;
   (void)a;
   return realloc(p, n);
 }
 static void heap_free(KitHeap* h, void* p, size_t n) {
   (void)h;
   (void)n;
   free(p);
 }
 static KitHeap g_heap = {heap_alloc, heap_realloc, heap_free, NULL};
 
 static void diag_emit(KitDiagSink* s, KitDiagKind k, KitSrcLoc loc,
                       const char* fmt, va_list ap) {
   static const char* names[] = {"note", "warning", "error", "fatal"};
   (void)s;
   (void)loc;
   fprintf(stderr, "%s: ", names[k]);
   vfprintf(stderr, fmt, ap);
   fputc('\n', stderr);
 }
 static KitDiagSink g_diag = {diag_emit, NULL, 0, 0};
 
 static int g_failures;
 #define CHECK(cond, ...)                                   \
   do {                                                     \
     if (!(cond)) {                                         \
       fprintf(stderr, "FAIL %s:%d: ", __FILE__, __LINE__); \
       fprintf(stderr, __VA_ARGS__);                        \
       fputc('\n', stderr);                                 \
       g_failures++;                                        \
     }                                                      \
   } while (0)
 
 /* mov w0, #1 ; ret */
 static const uint8_t TEXT_BYTES[8] = {
     0x20, 0x00, 0x80, 0x52, 0xc0, 0x03, 0x5f, 0xd6,
 };
 
 static int name_eq(KitSlice s, const char* want) {
   return s.s && kit_slice_eq_cstr(s, want);
 }
 
 int main(void) {
   KitTargetSpec target;
   if (kit_test_target_init(&target) != 0) {
     fprintf(stderr, "FAIL: kit_test_target_init\n");
     return 1;
   }
 
   KitContext ctx = {.heap = &g_heap,
                     .file_io = NULL,
                     .diag = &g_diag,
                     .metrics = NULL,
                     .now = -1};
   KitTargetOptions target_opts;
   memset(&target_opts, 0, sizeof target_opts);
   target_opts.spec = target;
   KitTarget* kt = NULL;
   if (kit_target_new(&ctx, &target_opts, &kt) != KIT_OK || !kt) {
     fprintf(stderr, "FAIL: kit_target_new\n");
     return 1;
   }
   KitCompiler* cc = NULL;
   if (kit_compiler_new(kt, &ctx, &cc) != KIT_OK || !cc) {
     fprintf(stderr, "FAIL: kit_compiler_new\n");
     kit_target_free(kt);
     return 1;
   }
   /* ---- build ---- */
   KitObjBuilder* in = NULL;
   CHECK(kit_obj_builder_new(cc, &in) == KIT_OK && in, "kit_obj_builder_new");
 
   KitSym sig_nm = kit_sym_intern(cc, KIT_SLICE_LIT("comdat_sig"));
   KitObjSection sec_text = KIT_SECTION_NONE;
   KitObjSection sec_data = KIT_SECTION_NONE;
   KitObjSectionDesc text_desc = {
       .name = kit_sym_intern(cc, KIT_SLICE_LIT(".text.comdat_fn")),
       .kind = KIT_SEC_TEXT,
       .flags = KIT_SF_ALLOC | KIT_SF_EXEC,
       .align = 4,
       .entsize = 0,
   };
   KitObjSectionDesc data_desc = {
       .name = kit_sym_intern(cc, KIT_SLICE_LIT(".data.comdat_fn")),
       .kind = KIT_SEC_DATA,
       .flags = KIT_SF_ALLOC | KIT_SF_WRITE,
       .align = 8,
       .entsize = 0,
   };
   CHECK(kit_obj_builder_section(in, &text_desc, &sec_text) == KIT_OK,
         "section .text.comdat_fn");
   CHECK(kit_obj_builder_section(in, &data_desc, &sec_data) == KIT_OK,
         "section .data.comdat_fn");
   CHECK(kit_obj_builder_write(in, sec_text, TEXT_BYTES, sizeof TEXT_BYTES) ==
             KIT_OK,
         "write .text.comdat_fn");
   static const uint8_t zero8[8] = {0};
   CHECK(kit_obj_builder_write(in, sec_data, zero8, sizeof zero8) == KIT_OK,
         "write .data.comdat_fn");
 
   KitObjSymbol sig_sym = KIT_OBJ_SYMBOL_NONE;
   KitObjSymbolDesc sig_desc = {
       .name = sig_nm,
       .bind = KIT_SB_WEAK,
       .kind = KIT_SK_FUNC,
       .section = sec_text,
       .value = 0,
       .size = sizeof TEXT_BYTES,
   };
   CHECK(kit_obj_builder_symbol(in, &sig_desc, &sig_sym) == KIT_OK,
         "symbol comdat_sig");
 
   KitObjGroup gid = KIT_OBJ_GROUP_NONE;
   CHECK(kit_obj_builder_group(in, sig_nm, sig_sym, KIT_OBJ_GROUP_COMDAT,
                               &gid) == KIT_OK,
         "group comdat_sig");
   CHECK(kit_obj_builder_group_add_section(in, gid, sec_text) == KIT_OK,
         "group add text");
   CHECK(kit_obj_builder_group_add_section(in, gid, sec_data) == KIT_OK,
         "group add data");
   CHECK(kit_obj_builder_finalize(in) == KIT_OK, "finalize");
 
   /* ---- emit + public-iter readback ---- */
   KitWriter* w = NULL;
   (void)kit_writer_mem(&g_heap, &w);
   CHECK(kit_obj_builder_emit(in, w) == KIT_OK, "emit");
   size_t out_len = 0;
   const uint8_t* out_data = kit_writer_mem_bytes(w, &out_len);
   uint8_t* roundtrip = (uint8_t*)malloc(out_len ? out_len : 1);
   memcpy(roundtrip, out_data, out_len);
   kit_writer_close(w);
 
   KitSlice input = {.data = roundtrip, .len = out_len};
   KitObjFile* f = NULL;
   CHECK(
       kit_obj_open(&ctx, KIT_SLICE_LIT("groupiter"), &input, &f) == KIT_OK && f,
       "kit_obj_open failed");
 
   if (f) {
     /* Resolve section IDs by name so the test isn't coupled to ordering. */
     KitObjSection text_pub = KIT_SECTION_NONE;
     KitObjSection data_pub = KIT_SECTION_NONE;
     CHECK(kit_obj_section_by_name(f, KIT_SLICE_LIT(".text.comdat_fn"),
                                   &text_pub) == KIT_OK,
           "section_by_name .text.comdat_fn");
     CHECK(kit_obj_section_by_name(f, KIT_SLICE_LIT(".data.comdat_fn"),
                                   &data_pub) == KIT_OK,
           "section_by_name .data.comdat_fn");
 
     KitObjGroupIter* git = NULL;
     CHECK(kit_obj_groupiter_new(f, &git) == KIT_OK, "kit_obj_groupiter_new");
     int seen = 0;
     KitObjGroupInfo gi;
     while (kit_obj_groupiter_next(git, &gi) == KIT_ITER_ITEM) {
       ++seen;
       CHECK(name_eq(gi.name, "comdat_sig"), "public iter: name=%.*s",
             KIT_SLICE_ARG(gi.name));
       CHECK((gi.flags & KIT_OBJ_GROUP_COMDAT) != 0,
             "public iter: missing COMDAT flag (flags=0x%x)", gi.flags);
       CHECK(gi.nsections == 2, "public iter: nsections=%u, want 2",
             gi.nsections);
       CHECK(gi.sections != NULL, "public iter: NULL sections");
       if (gi.sections && gi.nsections == 2) {
         /* Order is preserved by ELF SHT_GROUP, so members[0] should be
          * sec_text and members[1] sec_data. */
         CHECK(gi.sections[0] == text_pub,
               "public iter: sections[0]=%u, want %u (text)", gi.sections[0],
               text_pub);
         CHECK(gi.sections[1] == data_pub,
               "public iter: sections[1]=%u, want %u (data)", gi.sections[1],
               data_pub);
       }
       /* Signature should be a valid public symbol id, not NONE. */
       CHECK(gi.signature != KIT_OBJ_SYMBOL_NONE,
             "public iter: signature is NONE");
     }
     CHECK(seen == 1, "public iter: saw %d groups, want 1", seen);
     kit_obj_groupiter_free(git);
     kit_obj_free(f);
   }
 
   free(roundtrip);
   kit_obj_builder_free(in);
   kit_compiler_free(cc);
   kit_target_free(kt);
 
   if (g_failures) {
     fprintf(stderr, "%d failure(s)\n", g_failures);
     return 1;
   }
   fputs("groupiter: OK\n", stderr);
   return 0;
 }