kit

align_4k.c (4926B)

---

 /* Hand-built KitObjBuilder roundtrip — verifies large sh_addralign.
  *
  * Builds an ELF with a .text section aligned to 4096 (page size),
  * emits and reads it back, asserts the align field round-trips.
  * Clang doesn't emit such large alignments naturally for .o files,
  * so this gap can only be covered by a hand-built case. */
 
 #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, #0 ; ret */
 static const uint8_t TEXT_BYTES[8] = {
     0x00, 0x00, 0x80, 0x52, 0xc0, 0x03, 0x5f, 0xd6,
 };
 
 #define WANT_ALIGN 4096u
 
 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,
                     .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;
   }
   KitObjBuilder* in = NULL;
   CHECK(kit_obj_builder_new(cc, &in) == KIT_OK && in, "kit_obj_builder_new");
 
   KitObjSection sec = KIT_SECTION_NONE;
   KitObjSectionDesc text_desc = {
       .name = kit_sym_intern(cc, KIT_SLICE_LIT(".text")),
       .kind = KIT_SEC_TEXT,
       .flags = KIT_SF_ALLOC | KIT_SF_EXEC,
       .align = WANT_ALIGN,
       .entsize = 0,
   };
   CHECK(kit_obj_builder_section(in, &text_desc, &sec) == KIT_OK,
         "section .text");
   CHECK(kit_obj_builder_write(in, sec, TEXT_BYTES, sizeof TEXT_BYTES) == KIT_OK,
         "write .text");
   KitObjSymbol sym_f = KIT_OBJ_SYMBOL_NONE;
   KitObjSymbolDesc f_desc = {
       .name = kit_sym_intern(cc, KIT_SLICE_LIT("f")),
       .bind = KIT_SB_GLOBAL,
       .kind = KIT_SK_FUNC,
       .section = sec,
       .value = 0,
       .size = sizeof TEXT_BYTES,
   };
   CHECK(kit_obj_builder_symbol(in, &f_desc, &sym_f) == KIT_OK, "symbol f");
   CHECK(kit_obj_builder_finalize(in) == KIT_OK, "finalize");
 
   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);
   memcpy(roundtrip, out_data, out_len);
   kit_writer_close(w);
 
   KitSlice input = {.data = roundtrip, .len = out_len};
   KitObjFile* back = NULL;
   CHECK(
       kit_obj_open(&ctx, KIT_SLICE_LIT("align_4k"), &input, &back) == KIT_OK &&
           back,
       "kit_obj_open failed");
 
   /* Locate .text by name. */
   int found = 0;
   if (back) {
     KitObjSection text = KIT_SECTION_NONE;
     if (kit_obj_section_by_name(back, KIT_SLICE_LIT(".text"), &text) ==
         KIT_OK) {
       KitObjSecInfo si;
       CHECK(kit_obj_section(back, text, &si) == KIT_OK, "section info .text");
       found = 1;
       CHECK(si.align == WANT_ALIGN, ".text align=%u after roundtrip, want %u",
             si.align, WANT_ALIGN);
     }
   }
   CHECK(found, ".text not present after roundtrip");
 
   if (back) kit_obj_free(back);
   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("align_4k: OK\n", stderr);
   return 0;
 }