kit

link_script_test.c (38459B)

---

 /* Public linker-script parser coverage for the kernel-script subset. */
 
 #include <kit/core.h>
 #include <kit/link.h>
 #include <kit/object.h>
 #include <string.h>
 
 #include "lib/kit_unit.h"
 
 static KitUnit g_u;
 #define EXPECT(c, ...) CU_EXPECT(&g_u, c, __VA_ARGS__)
 
 static void check_kernel_script_subset(void) {
   static const char script_text[] =
       "OUTPUT_FORMAT(\"elf64-littleaarch64\")\n"
       "OUTPUT_ARCH(aarch64)\n"
       "ENTRY(_start)\n"
       "EXTERN(retained)\n"
       "MEMORY {\n"
       "  ROM (rx)  : ORIGIN = 0x10000, LENGTH = 64K\n"
       "  RAM (rwx) : ORIGIN = 0x80000000, LENGTH = 128K\n"
       "}\n"
       "PHDRS {\n"
       "  text PT_LOAD FILEHDR PHDRS FLAGS(5);\n"
       "  data PT_LOAD FLAGS(6);\n"
       "}\n"
       "PROVIDE_HIDDEN(__image_base = ORIGIN(ROM));\n"
       "SECTIONS {\n"
       "  . = ORIGIN(ROM) + SIZEOF_HEADERS;\n"
       "  .text : ALIGN(16) AT(ORIGIN(ROM)) {\n"
       "    KEEP(*(.text.start))\n"
       "    *(.text .text.*)\n"
       "    PROVIDE(__etext = .);\n"
       "  } > ROM :text =0x90\n"
       "  .data ORIGIN(RAM) : {\n"
       "    *(.rodata .rodata.*)\n"
       "    *(EXCLUDE_FILE (*crtend.o) .data .data.*)\n"
       "  } > RAM AT> ROM :data\n"
       "  .bss (NOLOAD) : {\n"
       "    __bss_start = .;\n"
       "    *(.bss .bss.* COMMON)\n"
       "    . = ALIGN(., 16);\n"
       "  } > RAM\n"
       "  ASSERT(LENGTH(ROM) - SIZEOF(.text), \"text too large\");\n"
       "}\n";
 
   KitLinkScript* s = NULL;
   KitSlice text = {.s = script_text, .len = sizeof(script_text) - 1u};
   EXPECT(kit_link_script_parse(&g_u.ctx, text, &s) == KIT_OK,
          "kernel linker script parses");
   EXPECT(s != NULL, "parser returns script");
   if (!s) return;
 
   EXPECT(kit_slice_eq_cstr(s->entry, "_start"), "ENTRY recorded");
   EXPECT(kit_slice_eq_cstr(s->output_format, "elf64-littleaarch64"),
          "OUTPUT_FORMAT recorded");
   EXPECT(kit_slice_eq_cstr(s->output_arch, "aarch64"),
          "OUTPUT_ARCH recorded");
   EXPECT(s->nexterns == 1 &&
              kit_slice_eq_cstr(s->externs[0], "retained"),
          "EXTERN recorded");
 
   EXPECT(s->nregions == 2, "MEMORY region count");
   EXPECT(kit_slice_eq_cstr(s->regions[0].name, "ROM"), "ROM region name");
   EXPECT(s->regions[0].origin == 0x10000u, "ROM origin");
   EXPECT(s->regions[0].length == 64u * 1024u, "ROM length suffix");
   EXPECT((s->regions[0].flags & (KIT_LRF_R | KIT_LRF_X)) ==
              (KIT_LRF_R | KIT_LRF_X),
          "ROM flags");
   EXPECT(kit_slice_eq_cstr(s->regions[1].name, "RAM"), "RAM region name");
 
   EXPECT(s->nphdrs == 2, "PHDRS count");
   EXPECT(kit_slice_eq_cstr(s->phdrs[0].name, "text"), "text PHDR name");
   EXPECT(s->phdrs[0].filehdr && s->phdrs[0].phdrs,
          "text PHDR header attrs");
   EXPECT(s->phdrs[0].flags &&
              s->phdrs[0].flags->kind == KIT_LE_INT &&
              s->phdrs[0].flags->v.int_val == 5,
          "text PHDR FLAGS");
 
   EXPECT(s->ntop_asns == 2, "top-level dot and PROVIDE_HIDDEN assignments");
   const KitLinkAssignment* provide = NULL;
   for (uint32_t i = 0; i < s->ntop_asns; ++i)
     if (s->top_asns[i].kind == KIT_LAS_PROVIDE_HIDDEN)
       provide = &s->top_asns[i];
   EXPECT(provide != NULL, "PROVIDE_HIDDEN assignment kind");
   EXPECT(provide && provide->expr &&
              provide->expr->kind == KIT_LE_REGION_ORIGIN,
          "PROVIDE_HIDDEN ORIGIN expression");
 
   EXPECT(s->nsections == 3, "output section count");
   const KitLinkOutputSection* text_sec = &s->sections[0];
   const KitLinkOutputSection* data_sec = &s->sections[1];
   const KitLinkOutputSection* bss_sec = &s->sections[2];
   EXPECT(kit_slice_eq_cstr(text_sec->name, ".text"), ".text section");
   EXPECT(kit_slice_eq_cstr(text_sec->region, "ROM"), ".text region");
   EXPECT(text_sec->lma && text_sec->lma->kind == KIT_LE_REGION_ORIGIN,
          ".text AT(ORIGIN)");
   EXPECT(text_sec->nphdrs == 1 &&
              kit_slice_eq_cstr(text_sec->phdrs[0], "text"),
          ".text PHDR reference");
   EXPECT(text_sec->fill && text_sec->fill->kind == KIT_LE_INT &&
              text_sec->fill->v.int_val == 0x90,
          ".text fill");
   EXPECT(text_sec->ninputs >= 1 && text_sec->inputs[0].keep,
          "KEEP input matcher");
 
   EXPECT(data_sec->vma && data_sec->vma->kind == KIT_LE_REGION_ORIGIN,
          ".data VMA expression");
   EXPECT(kit_slice_eq_cstr(data_sec->region, "RAM"), ".data VMA region");
   EXPECT(kit_slice_eq_cstr(data_sec->load_region, "ROM"),
          ".data load region");
   EXPECT(data_sec->nphdrs == 1 &&
              kit_slice_eq_cstr(data_sec->phdrs[0], "data"),
          ".data PHDR reference");
   EXPECT(data_sec->ninputs >= 4 &&
              data_sec->inputs[2].nexclude_file_patterns == 1 &&
              kit_slice_eq_cstr(data_sec->inputs[2].exclude_file_patterns[0],
                                "*crtend.o"),
          "EXCLUDE_FILE matcher");
 
   EXPECT(bss_sec->noload, ".bss NOLOAD");
   EXPECT(kit_slice_eq_cstr(bss_sec->region, "RAM"), ".bss region");
   EXPECT(bss_sec->nasns == 2, ".bss assignments");
   EXPECT(s->nasserts == 1 &&
              kit_slice_eq_cstr(s->asserts[0].message, "text too large"),
          "ASSERT recorded");
 
   kit_link_script_free(&g_u.ctx, s);
 }
 
 static KitObjBuilder* build_layout_input(KitCompiler* c) {
   static const uint8_t text_bytes[4] = {0xc0, 0x03, 0x5f, 0xd6};
   static const uint8_t data_bytes[4] = {1, 2, 3, 4};
   KitObjBuilder* ob = NULL;
   KitObjSection text = KIT_SECTION_NONE;
   KitObjSection data = KIT_SECTION_NONE;
   KitObjSymbol sym = KIT_OBJ_SYMBOL_NONE;
   KitObjSectionDesc text_desc;
   KitObjSectionDesc data_desc;
   KitObjSymbolDesc sym_desc;
 
   if (kit_obj_builder_new(c, &ob) != KIT_OK || !ob) {
     EXPECT(0, "obj builder allocation");
     return NULL;
   }
 
   memset(&text_desc, 0, sizeof(text_desc));
   text_desc.name = kit_sym_intern(c, KIT_SLICE_LIT(".text"));
   text_desc.kind = KIT_SEC_TEXT;
   text_desc.flags = KIT_SF_ALLOC | KIT_SF_EXEC;
   text_desc.align = 4;
   if (kit_obj_builder_section(ob, &text_desc, &text) != KIT_OK) {
     EXPECT(0, "create .text");
     goto fail;
   }
   if (kit_obj_builder_write(ob, text, text_bytes, sizeof(text_bytes)) !=
       KIT_OK) {
     EXPECT(0, "write .text");
     goto fail;
   }
 
   memset(&data_desc, 0, sizeof(data_desc));
   data_desc.name = kit_sym_intern(c, KIT_SLICE_LIT(".data"));
   data_desc.kind = KIT_SEC_DATA;
   data_desc.flags = KIT_SF_ALLOC | KIT_SF_WRITE;
   data_desc.align = 4;
   if (kit_obj_builder_section(ob, &data_desc, &data) != KIT_OK) {
     EXPECT(0, "create .data");
     goto fail;
   }
   if (kit_obj_builder_write(ob, data, data_bytes, sizeof(data_bytes)) !=
       KIT_OK) {
     EXPECT(0, "write .data");
     goto fail;
   }
 
   memset(&sym_desc, 0, sizeof(sym_desc));
   sym_desc.name = kit_sym_intern(c, KIT_SLICE_LIT("_start"));
   sym_desc.bind = KIT_SB_GLOBAL;
   sym_desc.kind = KIT_SK_FUNC;
   sym_desc.section = text;
   sym_desc.value = 0;
   sym_desc.size = sizeof(text_bytes);
   if (kit_obj_builder_symbol(ob, &sym_desc, &sym) != KIT_OK) {
     EXPECT(0, "define _start");
     goto fail;
   }
 
   sym = KIT_OBJ_SYMBOL_NONE;
   memset(&sym_desc, 0, sizeof(sym_desc));
   sym_desc.name = kit_sym_intern(c, KIT_SLICE_LIT("global_data"));
   sym_desc.bind = KIT_SB_GLOBAL;
   sym_desc.kind = KIT_SK_OBJ;
   sym_desc.section = data;
   sym_desc.value = 0;
   sym_desc.size = sizeof(data_bytes);
   if (kit_obj_builder_symbol(ob, &sym_desc, &sym) != KIT_OK) {
     EXPECT(0, "define global_data");
     goto fail;
   }
 
   if (kit_obj_builder_finalize(ob) != KIT_OK) {
     EXPECT(0, "finalize input object");
     goto fail;
   }
   return ob;
 
 fail:
   kit_obj_builder_free(ob);
   return NULL;
 }
 
 /* Parse `script_text`, link `build_layout_input()` against it, and open the
  * emitted image. On success *out_f / *out_w / *out_c / *out_s / *out_ob own
  * resources the caller must release (use emit_cleanup). Returns 1 on success,
  * 0 if any stage failed (an EXPECT already fired). */
 typedef struct EmitFixture {
   KitCompiler* c;
   KitObjBuilder* ob;
   KitLinkScript* s;
   KitLinkSession* sess;
   KitWriter* w;
   KitObjFile* f;
 } EmitFixture;
 
 static void emit_cleanup(EmitFixture* fx) {
   if (fx->f) kit_obj_free(fx->f);
   if (fx->w) kit_writer_close(fx->w);
   if (fx->sess) kit_link_session_free(fx->sess);
   if (fx->ob) kit_obj_builder_free(fx->ob);
   if (fx->s) kit_link_script_free(&g_u.ctx, fx->s);
   if (fx->c) kit_compiler_free(fx->c);
   memset(fx, 0, sizeof(*fx));
 }
 
 static int emit_layout(const char* script_text, size_t script_len,
                        EmitFixture* fx) {
   KitTargetSpec target =
       kit_unit_target(KIT_ARCH_ARM_64, KIT_OS_LINUX, KIT_OBJ_ELF);
   KitLinkSessionOptions opts;
   KitSlice script;
   KitSlice bytes;
   size_t len = 0;
 
   memset(fx, 0, sizeof(*fx));
   script.s = script_text;
   script.len = script_len;
   EXPECT(kit_link_script_parse(&g_u.ctx, script, &fx->s) == KIT_OK && fx->s,
          "layout script parses");
   if (!fx->s) return 0;
   EXPECT(kit_unit_compiler_new(&g_u, target, &fx->c) == KIT_OK && fx->c,
          "compiler allocation");
   if (!fx->c) return 0;
   fx->ob = build_layout_input(fx->c);
   if (!fx->ob) return 0;
   memset(&opts, 0, sizeof(opts));
   opts.output_kind = KIT_LINK_OUTPUT_EXE;
   opts.linker_script = fx->s;
   EXPECT(kit_link_session_new(fx->c, &opts, &fx->sess) == KIT_OK && fx->sess,
          "link session allocation");
   if (!fx->sess) return 0;
   EXPECT(kit_link_session_add_obj(fx->sess, fx->ob) == KIT_OK,
          "add input object");
   EXPECT(kit_writer_mem(&g_u.heap, &fx->w) == KIT_OK && fx->w, "memory writer");
   if (!fx->w) return 0;
   EXPECT(kit_link_session_emit(fx->sess, fx->w) == KIT_OK,
          "emit scripted image");
   bytes.data = kit_writer_mem_bytes(fx->w, &len);
   bytes.len = len;
   EXPECT(bytes.data && bytes.len > 0, "scripted image bytes");
   if (!bytes.data || bytes.len == 0) return 0;
   EXPECT(kit_obj_open(&g_u.ctx, KIT_SLICE_LIT("<scripted-layout>"), &bytes,
                       &fx->f) == KIT_OK &&
              fx->f,
          "open scripted image");
   return fx->f != NULL;
 }
 
 static void check_scripted_layout_vma_lma(void) {
   static const char script_text[] =
       "OUTPUT_FORMAT(\"elf64-littleaarch64\")\n"
       "OUTPUT_ARCH(aarch64)\n"
       "ENTRY(_start)\n"
       "MEMORY {\n"
       "  ROM (rx)  : ORIGIN = 0x10000, LENGTH = 64K\n"
       "  RAM (rwx) : ORIGIN = 0x80000000, LENGTH = 64K\n"
       "}\n"
       "PHDRS {\n"
       "  text PT_LOAD FLAGS(5);\n"
       "  data PT_LOAD FLAGS(6);\n"
       "}\n"
       "SECTIONS {\n"
       "  .text : { KEEP(*(.text .text.*)) } > ROM :text\n"
       "  .data ORIGIN(RAM) : { *(.data .data.*) } > RAM AT> ROM :data\n"
       "}\n";
   KitTargetSpec target =
       kit_unit_target(KIT_ARCH_ARM_64, KIT_OS_LINUX, KIT_OBJ_ELF);
   KitCompiler* c = NULL;
   KitObjBuilder* ob = NULL;
   KitLinkScript* s = NULL;
   KitLinkSession* sess = NULL;
   KitWriter* w = NULL;
   KitObjFile* f = NULL;
   KitObjSegIter* it = NULL;
   KitSlice script;
   KitSlice bytes;
   KitLinkSessionOptions opts;
   size_t len = 0;
   uint32_t nload = 0;
   int saw_text = 0;
   int saw_data = 0;
 
   script.s = script_text;
   script.len = sizeof(script_text) - 1u;
   EXPECT(kit_link_script_parse(&g_u.ctx, script, &s) == KIT_OK && s,
          "layout script parses");
   if (!s) goto done;
 
   EXPECT(kit_unit_compiler_new(&g_u, target, &c) == KIT_OK && c,
          "compiler allocation");
   if (!c) goto done;
 
   ob = build_layout_input(c);
   if (!ob) goto done;
 
   memset(&opts, 0, sizeof(opts));
   opts.output_kind = KIT_LINK_OUTPUT_EXE;
   opts.linker_script = s;
   EXPECT(kit_link_session_new(c, &opts, &sess) == KIT_OK && sess,
          "link session allocation");
   if (!sess) goto done;
   EXPECT(kit_link_session_add_obj(sess, ob) == KIT_OK, "add input object");
   EXPECT(kit_writer_mem(&g_u.heap, &w) == KIT_OK && w, "memory writer");
   if (!w) goto done;
   EXPECT(kit_link_session_emit(sess, w) == KIT_OK, "emit scripted image");
   bytes.data = kit_writer_mem_bytes(w, &len);
   bytes.len = len;
   EXPECT(bytes.data && bytes.len > 0, "scripted image bytes");
   if (!bytes.data || bytes.len == 0) goto done;
   EXPECT(kit_obj_open(&g_u.ctx, KIT_SLICE_LIT("<scripted-layout>"), &bytes,
                       &f) == KIT_OK &&
              f,
          "open scripted image");
   if (!f) goto done;
   EXPECT(kit_obj_kind(f) == KIT_OBJ_KIND_EXEC, "scripted image is executable");
   EXPECT(kit_obj_segiter_new(f, &it) == KIT_OK && it, "segment iterator");
   if (!it) goto done;
   for (;;) {
     KitObjSegInfo seg;
     KitIterResult r = kit_obj_segiter_next(it, &seg);
     if (r == KIT_ITER_END) break;
     EXPECT(r == KIT_ITER_ITEM, "segment iteration");
     if (r != KIT_ITER_ITEM) break;
     if (!kit_slice_eq_cstr(seg.name, "LOAD")) continue;
     ++nload;
     if (seg.vaddr == 0x10000u) {
       saw_text = 1;
       EXPECT(seg.paddr == 0x10000u, ".text LMA follows ROM origin");
       EXPECT(seg.file_size == 4u && seg.vsize == 4u, ".text segment size");
       EXPECT(seg.perms == (KIT_SEG_R | KIT_SEG_X), ".text PHDR flags");
     } else if (seg.vaddr == 0x80000000u) {
       saw_data = 1;
       EXPECT(seg.paddr == 0x10004u, ".data AT> ROM follows .text bytes");
       EXPECT(seg.file_size == 4u && seg.vsize == 4u, ".data segment size");
       EXPECT(seg.perms == (KIT_SEG_R | KIT_SEG_W), ".data PHDR flags");
     }
   }
   EXPECT(nload == 2, "scripted image LOAD segment count");
   EXPECT(saw_text, "scripted image text LOAD");
   EXPECT(saw_data, "scripted image data LOAD");
 
 done:
   if (it) kit_obj_segiter_free(it);
   if (f) kit_obj_free(f);
   if (w) kit_writer_close(w);
   if (sess) kit_link_session_free(sess);
   if (ob) kit_obj_builder_free(ob);
   if (s) kit_link_script_free(&g_u.ctx, s);
   if (c) kit_compiler_free(c);
 }
 
 /* Item 1: a PROGBITS-content output section marked (NOLOAD) must contribute
  * zero file bytes and present a NOBITS-style segment (file_size 0, vsize > 0). */
 static void check_noload_progbits(void) {
   static const char script_text[] =
       "OUTPUT_FORMAT(\"elf64-littleaarch64\")\n"
       "OUTPUT_ARCH(aarch64)\n"
       "ENTRY(_start)\n"
       "SECTIONS {\n"
       "  . = 0x10000;\n"
       "  .text : { *(.text .text.*) }\n"
       "  .shadow (NOLOAD) : { *(.data .data.*) }\n"
       "}\n";
   EmitFixture fx;
   KitObjSegIter* it = NULL;
   int saw_shadow = 0;
   uint64_t text_end = 0;
 
   if (!emit_layout(script_text, sizeof(script_text) - 1u, &fx)) goto done;
   EXPECT(kit_obj_segiter_new(fx.f, &it) == KIT_OK && it, "segment iterator");
   if (!it) goto done;
   for (;;) {
     KitObjSegInfo seg;
     KitIterResult r = kit_obj_segiter_next(it, &seg);
     if (r == KIT_ITER_END) break;
     if (r != KIT_ITER_ITEM) break;
     if (!kit_slice_eq_cstr(seg.name, "LOAD")) continue;
     if (seg.file_size == 4u && seg.perms == (KIT_SEG_R | KIT_SEG_X))
       text_end = seg.vaddr + seg.vsize;
     /* the shadow segment carries the .data bytes (4) as pure bss */
     if (seg.vsize == 4u && seg.file_size == 0u &&
         (seg.perms & KIT_SEG_X) == 0) {
       saw_shadow = 1;
       EXPECT(seg.file_size == 0u, "NOLOAD section contributes no file bytes");
       EXPECT(seg.vsize == 4u, "NOLOAD section keeps memory size");
     }
   }
   EXPECT(text_end != 0u, "saw .text LOAD before shadow");
   EXPECT(saw_shadow, "saw NOLOAD shadow segment with zero file size");
 
 done:
   if (it) kit_obj_segiter_free(it);
   emit_cleanup(&fx);
 }
 
 /* Item 2: an inter-section `. = ALIGN(0x1000)` written between two output
  * sections must advance the location counter at its textual position so the
  * following section lands at the aligned address. */
 static void check_intersection_dot_align(void) {
   static const char script_text[] =
       "OUTPUT_FORMAT(\"elf64-littleaarch64\")\n"
       "OUTPUT_ARCH(aarch64)\n"
       "ENTRY(_start)\n"
       "SECTIONS {\n"
       "  . = 0x10000;\n"
       "  .text : { *(.text .text.*) }\n"
       "  . = ALIGN(0x1000);\n"
       "  .data : { *(.data .data.*) }\n"
       "}\n";
   EmitFixture fx;
   KitObjSegIter* it = NULL;
   int saw_text = 0;
   int saw_data = 0;
 
   if (!emit_layout(script_text, sizeof(script_text) - 1u, &fx)) goto done;
   EXPECT(kit_obj_segiter_new(fx.f, &it) == KIT_OK && it, "segment iterator");
   if (!it) goto done;
   for (;;) {
     KitObjSegInfo seg;
     KitIterResult r = kit_obj_segiter_next(it, &seg);
     if (r == KIT_ITER_END) break;
     if (r != KIT_ITER_ITEM) break;
     if (!kit_slice_eq_cstr(seg.name, "LOAD")) continue;
     if (seg.vaddr == 0x10000u) saw_text = 1;
     if (seg.perms & KIT_SEG_W) {
       saw_data = 1;
       EXPECT(seg.vaddr == 0x11000u,
              ".data lands at . = ALIGN(0x1000) after .text");
     }
   }
   EXPECT(saw_text, "saw .text at 0x10000");
   EXPECT(saw_data, "saw .data aligned to 0x1000");
 
 done:
   if (it) kit_obj_segiter_free(it);
   emit_cleanup(&fx);
 }
 
 /* Item 3: a multi-byte fill value must be laid down as a repeating big-endian
  * pattern across an in-section gap rather than truncated to its low byte. */
 static void check_multibyte_fill(void) {
   /* SUBALIGN(16) forces each input to a 16-byte boundary: .text (4 bytes) at
    * offset 0, .data (4 bytes) at offset 16, leaving a 12-byte gap [4..16).
    * That gap must carry the FILL pattern (0x12345678, big-endian, repeated)
    * rather than just its low byte (0x78). */
   static const char script_text[] =
       "OUTPUT_FORMAT(\"elf64-littleaarch64\")\n"
       "OUTPUT_ARCH(aarch64)\n"
       "ENTRY(_start)\n"
       "SECTIONS {\n"
       "  . = 0x10000;\n"
       "  .text : SUBALIGN(16) {\n"
       "    *(.text .text.*)\n"
       "    *(.data .data.*)\n"
       "    FILL(0x12345678)\n"
       "  }\n"
       "}\n";
   EmitFixture fx;
   KitObjSegIter* it = NULL;
   KitSlice img;
   size_t len = 0;
   uint64_t seg_off = 0;
   int found = 0;
 
   if (!emit_layout(script_text, sizeof(script_text) - 1u, &fx)) goto done;
   EXPECT(kit_obj_segiter_new(fx.f, &it) == KIT_OK && it, "segment iterator");
   if (!it) goto done;
   for (;;) {
     KitObjSegInfo seg;
     KitIterResult r = kit_obj_segiter_next(it, &seg);
     if (r == KIT_ITER_END) break;
     if (r != KIT_ITER_ITEM) break;
     if (!kit_slice_eq_cstr(seg.name, "LOAD")) continue;
     if (seg.vaddr == 0x10000u) {
       seg_off = seg.file_off;
       found = 1;
       EXPECT(seg.file_size == 20u, ".text segment spans text+gap+data");
     }
   }
   EXPECT(found, "found .text segment");
   if (!found) goto done;
   img.data = kit_writer_mem_bytes(fx.w, &len);
   img.len = len;
   EXPECT(img.data && (size_t)(seg_off + 20) <= len, "segment bytes in range");
   if (img.data && (size_t)(seg_off + 20) <= len) {
     const uint8_t* p = (const uint8_t*)img.data + seg_off;
     /* bytes [4..16) are the 12-byte gap; the pattern is phase-aligned to the
      * start of the segment buffer, so offset 4 sees pat[4 % 4] == pat[0]:
      * 12 34 56 78 repeated. */
     static const uint8_t want[12] = {0x12, 0x34, 0x56, 0x78, 0x12, 0x34,
                                      0x56, 0x78, 0x12, 0x34, 0x56, 0x78};
     EXPECT(memcmp(p + 4, want, 12) == 0,
            "gap filled with repeated big-endian FILL pattern");
   }
 
 done:
   if (it) kit_obj_segiter_free(it);
   emit_cleanup(&fx);
 }
 
 /* Item 4: (a) two output sections naming the same :phdr coalesce into a single
  * PT_LOAD; (b) a section listing several phdrs appears under each named
  * segment. */
 static void check_phdr_coalesce_and_multi(void) {
   static const char script_text[] =
       "OUTPUT_FORMAT(\"elf64-littleaarch64\")\n"
       "OUTPUT_ARCH(aarch64)\n"
       "ENTRY(_start)\n"
       "PHDRS {\n"
       "  text PT_LOAD FLAGS(5);\n"
       "  data PT_LOAD FLAGS(6);\n"
       "}\n"
       "SECTIONS {\n"
       "  . = 0x10000;\n"
       "  .text : { *(.text .text.*) } :text\n"
       "  .also : { *(.data .data.*) } :text :data\n"
       "}\n";
   EmitFixture fx;
   KitObjSegIter* it = NULL;
   uint32_t nload = 0;
   uint32_t n_rx = 0; /* PT_LOAD with R|X (the coalesced text phdr) */
   uint32_t n_rw = 0; /* PT_LOAD with R|W (the data phdr) */
 
   if (!emit_layout(script_text, sizeof(script_text) - 1u, &fx)) goto done;
   EXPECT(kit_obj_segiter_new(fx.f, &it) == KIT_OK && it, "segment iterator");
   if (!it) goto done;
   for (;;) {
     KitObjSegInfo seg;
     KitIterResult r = kit_obj_segiter_next(it, &seg);
     if (r == KIT_ITER_END) break;
     if (r != KIT_ITER_ITEM) break;
     if (!kit_slice_eq_cstr(seg.name, "LOAD")) continue;
     ++nload;
     if (seg.perms == (KIT_SEG_R | KIT_SEG_X)) ++n_rx;
     if (seg.perms == (KIT_SEG_R | KIT_SEG_W)) ++n_rw;
   }
   /* .text and .also both name :text -> one R|X PT_LOAD; .also also names
    * :data -> a second PT_LOAD with the data flags. So exactly 2 PT_LOAD. */
   EXPECT(nload == 2, "two sections sharing :text coalesce; :data adds one");
   EXPECT(n_rx == 1, "single coalesced R|X text segment");
   EXPECT(n_rw == 1, ".also also appears under the :data segment");
 
 done:
   if (it) kit_obj_segiter_free(it);
   emit_cleanup(&fx);
 }
 
 /* Build an input object whose .data output-bound content is followed by a
  * NOBITS .bss tail, so that an output section collecting both gets a PROGBITS
  * head + NOBITS tail (mem_size > file_size). Defines _start (.text),
  * data_sym (.data), and bss_sym (.bss) so a linked image exposes their vaddrs. */
 static KitObjBuilder* build_bss_tail_input(KitCompiler* c) {
   static const uint8_t text_bytes[4] = {0xc0, 0x03, 0x5f, 0xd6};
   static const uint8_t data_bytes[4] = {1, 2, 3, 4};
   KitObjBuilder* ob = NULL;
   KitObjSection text = KIT_SECTION_NONE;
   KitObjSection data = KIT_SECTION_NONE;
   KitObjSection bss = KIT_SECTION_NONE;
   KitObjSymbol sym = KIT_OBJ_SYMBOL_NONE;
   KitObjSectionDesc desc;
   KitObjSymbolDesc sym_desc;
 
   if (kit_obj_builder_new(c, &ob) != KIT_OK || !ob) {
     EXPECT(0, "obj builder allocation");
     return NULL;
   }
 
   memset(&desc, 0, sizeof(desc));
   desc.name = kit_sym_intern(c, KIT_SLICE_LIT(".text"));
   desc.kind = KIT_SEC_TEXT;
   desc.flags = KIT_SF_ALLOC | KIT_SF_EXEC;
   desc.align = 4;
   if (kit_obj_builder_section(ob, &desc, &text) != KIT_OK ||
       kit_obj_builder_write(ob, text, text_bytes, sizeof(text_bytes)) !=
           KIT_OK) {
     EXPECT(0, "create+write .text");
     goto fail;
   }
 
   memset(&desc, 0, sizeof(desc));
   desc.name = kit_sym_intern(c, KIT_SLICE_LIT(".data"));
   desc.kind = KIT_SEC_DATA;
   desc.flags = KIT_SF_ALLOC | KIT_SF_WRITE;
   desc.align = 4;
   if (kit_obj_builder_section(ob, &desc, &data) != KIT_OK ||
       kit_obj_builder_write(ob, data, data_bytes, sizeof(data_bytes)) !=
           KIT_OK) {
     EXPECT(0, "create+write .data");
     goto fail;
   }
 
   memset(&desc, 0, sizeof(desc));
   desc.name = kit_sym_intern(c, KIT_SLICE_LIT(".bss"));
   desc.kind = KIT_SEC_BSS;
   desc.flags = KIT_SF_ALLOC | KIT_SF_WRITE;
   desc.align = 8;
   if (kit_obj_builder_section(ob, &desc, &bss) != KIT_OK ||
       kit_obj_builder_reserve_bss(ob, bss, 0x40u, 8u) != KIT_OK) {
     EXPECT(0, "create+reserve .bss");
     goto fail;
   }
 
   memset(&sym_desc, 0, sizeof(sym_desc));
   sym_desc.name = kit_sym_intern(c, KIT_SLICE_LIT("_start"));
   sym_desc.bind = KIT_SB_GLOBAL;
   sym_desc.kind = KIT_SK_FUNC;
   sym_desc.section = text;
   sym_desc.size = sizeof(text_bytes);
   if (kit_obj_builder_symbol(ob, &sym_desc, &sym) != KIT_OK) {
     EXPECT(0, "define _start");
     goto fail;
   }
 
   sym = KIT_OBJ_SYMBOL_NONE;
   memset(&sym_desc, 0, sizeof(sym_desc));
   sym_desc.name = kit_sym_intern(c, KIT_SLICE_LIT("data_sym"));
   sym_desc.bind = KIT_SB_GLOBAL;
   sym_desc.kind = KIT_SK_OBJ;
   sym_desc.section = data;
   sym_desc.size = sizeof(data_bytes);
   if (kit_obj_builder_symbol(ob, &sym_desc, &sym) != KIT_OK) {
     EXPECT(0, "define data_sym");
     goto fail;
   }
 
   sym = KIT_OBJ_SYMBOL_NONE;
   memset(&sym_desc, 0, sizeof(sym_desc));
   sym_desc.name = kit_sym_intern(c, KIT_SLICE_LIT("bss_sym"));
   sym_desc.bind = KIT_SB_GLOBAL;
   sym_desc.kind = KIT_SK_OBJ;
   sym_desc.section = bss;
   sym_desc.size = 0x40u;
   if (kit_obj_builder_symbol(ob, &sym_desc, &sym) != KIT_OK) {
     EXPECT(0, "define bss_sym");
     goto fail;
   }
 
   if (kit_obj_builder_finalize(ob) != KIT_OK) {
     EXPECT(0, "finalize bss-tail input");
     goto fail;
   }
   return ob;
 
 fail:
   kit_obj_builder_free(ob);
   return NULL;
 }
 
 /* Like emit_layout, but uses build_bss_tail_input as the link input. */
 static int emit_layout_with(const char* script_text, size_t script_len,
                             KitObjBuilder* (*build)(KitCompiler*),
                             EmitFixture* fx) {
   KitTargetSpec target =
       kit_unit_target(KIT_ARCH_ARM_64, KIT_OS_LINUX, KIT_OBJ_ELF);
   KitLinkSessionOptions opts;
   KitSlice script;
   KitSlice bytes;
   size_t len = 0;
 
   memset(fx, 0, sizeof(*fx));
   script.s = script_text;
   script.len = script_len;
   EXPECT(kit_link_script_parse(&g_u.ctx, script, &fx->s) == KIT_OK && fx->s,
          "layout script parses");
   if (!fx->s) return 0;
   EXPECT(kit_unit_compiler_new(&g_u, target, &fx->c) == KIT_OK && fx->c,
          "compiler allocation");
   if (!fx->c) return 0;
   fx->ob = build(fx->c);
   if (!fx->ob) return 0;
   memset(&opts, 0, sizeof(opts));
   opts.output_kind = KIT_LINK_OUTPUT_EXE;
   opts.linker_script = fx->s;
   EXPECT(kit_link_session_new(fx->c, &opts, &fx->sess) == KIT_OK && fx->sess,
          "link session allocation");
   if (!fx->sess) return 0;
   EXPECT(kit_link_session_add_obj(fx->sess, fx->ob) == KIT_OK,
          "add input object");
   EXPECT(kit_writer_mem(&g_u.heap, &fx->w) == KIT_OK && fx->w, "memory writer");
   if (!fx->w) return 0;
   EXPECT(kit_link_session_emit(fx->sess, fx->w) == KIT_OK,
          "emit scripted image");
   bytes.data = kit_writer_mem_bytes(fx->w, &len);
   bytes.len = len;
   EXPECT(bytes.data && bytes.len > 0, "scripted image bytes");
   if (!bytes.data || bytes.len == 0) return 0;
   EXPECT(kit_obj_open(&g_u.ctx, KIT_SLICE_LIT("<scripted-layout>"), &bytes,
                       &fx->f) == KIT_OK &&
              fx->f,
          "open scripted image");
   return fx->f != NULL;
 }
 
 /* Bug 1: an output section with a PROGBITS head + NOBITS (bss) tail must NOT
  * coalesce a following same-:phdr, vaddr-contiguous output section into the
  * same PT_LOAD by packing its file bytes file-contiguously — that would skew
  * the follower's loaded bytes down by the bss-tail size relative to its vaddr.
  *
  * .first collects .data (4 PROGBITS bytes) + .bss (0x40 NOBITS bytes) so its
  * mem_size (0x44) > file_size (4). .second collects .text and shares :ld and is
  * vaddr-contiguous. We assert no vaddr<->file-offset skew: the segment carrying
  * .second's bytes must place them so (file_off - seg_file_off) matches
  * (vaddr - seg_vaddr). The safe fix splits into two PT_LOADs. */
 static void check_bss_tail_no_coalesce_skew(void) {
   static const char script_text[] =
       "OUTPUT_FORMAT(\"elf64-littleaarch64\")\n"
       "OUTPUT_ARCH(aarch64)\n"
       "ENTRY(_start)\n"
       "PHDRS {\n"
       "  ld PT_LOAD FLAGS(6);\n"
       "}\n"
       "SECTIONS {\n"
       "  . = 0x10000;\n"
       "  .first : { *(.data .data.*) *(.bss .bss.*) } :ld\n"
       "  .second : { *(.text .text.*) } :ld\n"
       "}\n";
   EmitFixture fx;
   KitObjSegIter* it = NULL;
   KitObjSymInfo text_sym;
   uint64_t text_vaddr = 0;
   int saw_text_load = 0;
   int got_text_sym = 0;
 
   if (!emit_layout_with(script_text, sizeof(script_text) - 1u,
                         build_bss_tail_input, &fx))
     goto done;
 
   got_text_sym = kit_obj_symbol_by_name(fx.f, KIT_SLICE_LIT("_start"),
                                         &text_sym) == KIT_OK;
   EXPECT(got_text_sym, "_start resolves in linked image");
   if (!got_text_sym) goto done;
   text_vaddr = text_sym.value;
 
   EXPECT(kit_obj_segiter_new(fx.f, &it) == KIT_OK && it, "segment iterator");
   if (!it) goto done;
   for (;;) {
     KitObjSegInfo seg;
     KitIterResult r = kit_obj_segiter_next(it, &seg);
     if (r == KIT_ITER_END) break;
     if (r != KIT_ITER_ITEM) break;
     if (!kit_slice_eq_cstr(seg.name, "LOAD")) continue;
     /* Find the LOAD segment that contains _start's vaddr. */
     if (text_vaddr >= seg.vaddr && text_vaddr < seg.vaddr + seg.vsize) {
       uint64_t voff = text_vaddr - seg.vaddr;
       saw_text_load = 1;
       /* The byte for _start must be file-resident at the matching offset:
        * its file delta must equal its vaddr delta (no NOBITS-tail skew). */
       EXPECT(voff < seg.file_size,
              "_start's vaddr maps to a file-resident byte (no bss-tail skew)");
       /* And the segment's own geometry must be self-consistent: a PROGBITS
        * follower coalesced after a bss tail would have file_size < the offset
        * at which its bytes sit. The split-PT_LOAD fix keeps file_size==vsize
        * for the .text-only segment. */
       EXPECT(seg.file_size >= voff + 4u,
              "_start's 4 bytes lie within the segment file image");
     }
   }
   EXPECT(saw_text_load, "found the LOAD segment carrying _start");
 
 done:
   if (it) kit_obj_segiter_free(it);
   emit_cleanup(&fx);
 }
 
 /* Bug 2: a FLAGS-less PHDRS PT_LOAD that coalesces an RX section and an RW
  * section must emit p_flags = R|W|X (the union of mapped sections' perms),
  * matching GNU ld. Without the perms-union, the single PT_LOAD would carry only
  * the FIRST section's perms. Two order variants pin this down. */
 static void check_coalesce_perms_union(void) {
   static const char script_rx_first[] =
       "OUTPUT_FORMAT(\"elf64-littleaarch64\")\n"
       "OUTPUT_ARCH(aarch64)\n"
       "ENTRY(_start)\n"
       "PHDRS {\n"
       "  ld PT_LOAD;\n"
       "}\n"
       "SECTIONS {\n"
       "  . = 0x10000;\n"
       "  .text : { *(.text .text.*) } :ld\n"
       "  .data : { *(.data .data.*) } :ld\n"
       "}\n";
   static const char script_rw_first[] =
       "OUTPUT_FORMAT(\"elf64-littleaarch64\")\n"
       "OUTPUT_ARCH(aarch64)\n"
       "ENTRY(_start)\n"
       "PHDRS {\n"
       "  ld PT_LOAD;\n"
       "}\n"
       "SECTIONS {\n"
       "  . = 0x10000;\n"
       "  .data : { *(.data .data.*) } :ld\n"
       "  .text : { *(.text .text.*) } :ld\n"
       "}\n";
   const char* variants[2];
   size_t lens[2];
   unsigned v;
   variants[0] = script_rx_first;
   lens[0] = sizeof(script_rx_first) - 1u;
   variants[1] = script_rw_first;
   lens[1] = sizeof(script_rw_first) - 1u;
 
   for (v = 0; v < 2; ++v) {
     EmitFixture fx;
     KitObjSegIter* it = NULL;
     uint32_t nload = 0;
     int saw_rwx = 0;
 
     if (!emit_layout(variants[v], lens[v], &fx)) {
       emit_cleanup(&fx);
       continue;
     }
     EXPECT(kit_obj_segiter_new(fx.f, &it) == KIT_OK && it, "segment iterator");
     if (!it) {
       emit_cleanup(&fx);
       continue;
     }
     for (;;) {
       KitObjSegInfo seg;
       KitIterResult r = kit_obj_segiter_next(it, &seg);
       if (r == KIT_ITER_END) break;
       if (r != KIT_ITER_ITEM) break;
       if (!kit_slice_eq_cstr(seg.name, "LOAD")) continue;
       ++nload;
       if (seg.perms == (KIT_SEG_R | KIT_SEG_W | KIT_SEG_X)) ++saw_rwx;
     }
     EXPECT(nload == 1,
            v == 0 ? "RX-then-RW coalesces into one PT_LOAD"
                   : "RW-then-RX coalesces into one PT_LOAD");
     EXPECT(saw_rwx == 1,
            v == 0 ? "RX-first coalesced PT_LOAD has R|W|X perms (union)"
                   : "RW-first coalesced PT_LOAD has R|W|X perms (union)");
     if (it) kit_obj_segiter_free(it);
     emit_cleanup(&fx);
   }
 }
 
 /* Item 5: deeply nested parentheses must fail cleanly (diagnostic) rather than
  * overflow the parser/eval stack. */
 static void check_recursion_depth_guard(void) {
   /* 512 nested parens around an int — well past the 256 limit. */
   char buf[2048];
   size_t pos = 0;
   unsigned i;
   KitLinkScript* s = NULL;
   KitSlice text;
   static const char prefix[] = "SECTIONS {\n  . = ";
   static const char suffix[] = ";\n}\n";
   memcpy(buf + pos, prefix, sizeof(prefix) - 1);
   pos += sizeof(prefix) - 1;
   for (i = 0; i < 512; ++i) buf[pos++] = '(';
   buf[pos++] = '0';
   for (i = 0; i < 512; ++i) buf[pos++] = ')';
   memcpy(buf + pos, suffix, sizeof(suffix) - 1);
   pos += sizeof(suffix) - 1;
   text.s = buf;
   text.len = pos;
   /* must return an error, not crash, and not produce a script */
   EXPECT(kit_link_script_parse(&g_u.ctx, text, &s) != KIT_OK,
          "deeply nested parens rejected, no crash");
   if (s) kit_link_script_free(&g_u.ctx, s);
 }
 
 /* Build an input with two writable data sections (.data = 4 bytes, .data.more
  * = 8 bytes) plus a _start in .text, so a section body can glob each
  * separately and place interior `sym = .` markers between them. */
 static KitObjBuilder* build_two_data_input(KitCompiler* c) {
   static const uint8_t text_bytes[4] = {0xc0, 0x03, 0x5f, 0xd6};
   static const uint8_t data_bytes[4] = {1, 2, 3, 4};
   static const uint8_t data2_bytes[8] = {5, 6, 7, 8, 9, 10, 11, 12};
   KitObjBuilder* ob = NULL;
   KitObjSection text = KIT_SECTION_NONE;
   KitObjSection data = KIT_SECTION_NONE;
   KitObjSection data2 = KIT_SECTION_NONE;
   KitObjSymbol sym = KIT_OBJ_SYMBOL_NONE;
   KitObjSectionDesc d;
   KitObjSymbolDesc sd;
 
   if (kit_obj_builder_new(c, &ob) != KIT_OK || !ob) {
     EXPECT(0, "obj builder allocation");
     return NULL;
   }
   memset(&d, 0, sizeof(d));
   d.name = kit_sym_intern(c, KIT_SLICE_LIT(".text"));
   d.kind = KIT_SEC_TEXT;
   d.flags = KIT_SF_ALLOC | KIT_SF_EXEC;
   d.align = 4;
   if (kit_obj_builder_section(ob, &d, &text) != KIT_OK ||
       kit_obj_builder_write(ob, text, text_bytes, sizeof(text_bytes)) != KIT_OK)
     goto fail;
 
   memset(&d, 0, sizeof(d));
   d.name = kit_sym_intern(c, KIT_SLICE_LIT(".data"));
   d.kind = KIT_SEC_DATA;
   d.flags = KIT_SF_ALLOC | KIT_SF_WRITE;
   d.align = 4;
   if (kit_obj_builder_section(ob, &d, &data) != KIT_OK ||
       kit_obj_builder_write(ob, data, data_bytes, sizeof(data_bytes)) != KIT_OK)
     goto fail;
 
   memset(&d, 0, sizeof(d));
   d.name = kit_sym_intern(c, KIT_SLICE_LIT(".data.more"));
   d.kind = KIT_SEC_DATA;
   d.flags = KIT_SF_ALLOC | KIT_SF_WRITE;
   d.align = 4;
   if (kit_obj_builder_section(ob, &d, &data2) != KIT_OK ||
       kit_obj_builder_write(ob, data2, data2_bytes, sizeof(data2_bytes)) !=
           KIT_OK)
     goto fail;
 
   memset(&sd, 0, sizeof(sd));
   sd.name = kit_sym_intern(c, KIT_SLICE_LIT("_start"));
   sd.bind = KIT_SB_GLOBAL;
   sd.kind = KIT_SK_FUNC;
   sd.section = text;
   sd.value = 0;
   sd.size = sizeof(text_bytes);
   if (kit_obj_builder_symbol(ob, &sd, &sym) != KIT_OK) goto fail;
 
   if (kit_obj_builder_finalize(ob) != KIT_OK) goto fail;
   return ob;
 fail:
   EXPECT(0, "build two-data input");
   kit_obj_builder_free(ob);
   return NULL;
 }
 
 /* Bug fix: section-body commands execute in source order, so a `sym = .` after
  * an input-section glob captures the location counter ADVANCED past the glob's
  * content, and `. = ALIGN(N)` after the last glob extends the section. Before
  * the fix every body assignment was evaluated against the section-start dot, so
  * _sdata == _mid == _edata. This drives the exact bare-metal `.data` copy-loop
  * idiom (_sdata/_edata bracketing initialized data) plus an interior midpoint
  * marker between two globs. */
 static void check_body_symbols_after_glob(void) {
   static const char script_text[] =
       "OUTPUT_FORMAT(\"elf64-littleaarch64\")\n"
       "OUTPUT_ARCH(aarch64)\n"
       "ENTRY(_start)\n"
       "MEMORY {\n"
       "  FLASH (rx)  : ORIGIN = 0x10000, LENGTH = 64K\n"
       "  SRAM  (rwx) : ORIGIN = 0x20000000, LENGTH = 64K\n"
       "}\n"
       "SECTIONS {\n"
       "  .text : { *(.text .text.*) } > FLASH\n"
       "  .data : ALIGN(4) {\n"
       "    _sdata = .;\n"
       "    *(.data)\n"
       "    _mid = .;\n"
       "    *(.data.more)\n"
       "    . = ALIGN(16);\n"
       "    _edata = .;\n"
       "  } > SRAM AT> FLASH\n"
       "}\n";
   KitTargetSpec target =
       kit_unit_target(KIT_ARCH_ARM_64, KIT_OS_LINUX, KIT_OBJ_ELF);
   KitCompiler* c = NULL;
   KitObjBuilder* ob = NULL;
   KitLinkScript* s = NULL;
   KitLinkSession* sess = NULL;
   KitWriter* w = NULL;
   KitObjFile* f = NULL;
   KitSlice script;
   KitSlice bytes;
   KitLinkSessionOptions opts;
   KitObjSymInfo sdata, mid, edata;
   size_t len = 0;
 
   script.s = script_text;
   script.len = sizeof(script_text) - 1u;
   EXPECT(kit_link_script_parse(&g_u.ctx, script, &s) == KIT_OK && s,
          "body-symbol script parses");
   if (!s) goto done;
   EXPECT(kit_unit_compiler_new(&g_u, target, &c) == KIT_OK && c,
          "compiler allocation");
   if (!c) goto done;
   ob = build_two_data_input(c);
   if (!ob) goto done;
   memset(&opts, 0, sizeof(opts));
   opts.output_kind = KIT_LINK_OUTPUT_EXE;
   opts.linker_script = s;
   EXPECT(kit_link_session_new(c, &opts, &sess) == KIT_OK && sess,
          "link session allocation");
   if (!sess) goto done;
   EXPECT(kit_link_session_add_obj(sess, ob) == KIT_OK, "add input object");
   EXPECT(kit_writer_mem(&g_u.heap, &w) == KIT_OK && w, "memory writer");
   if (!w) goto done;
   EXPECT(kit_link_session_emit(sess, w) == KIT_OK, "emit scripted image");
   bytes.data = kit_writer_mem_bytes(w, &len);
   bytes.len = len;
   if (!bytes.data || bytes.len == 0) goto done;
   EXPECT(kit_obj_open(&g_u.ctx, KIT_SLICE_LIT("<body-symbols>"), &bytes, &f) ==
                  KIT_OK &&
              f,
          "open scripted image");
   if (!f) goto done;
 
   EXPECT(kit_obj_symbol_by_name(f, KIT_SLICE_LIT("_sdata"), &sdata) == KIT_OK,
          "_sdata defined");
   EXPECT(kit_obj_symbol_by_name(f, KIT_SLICE_LIT("_mid"), &mid) == KIT_OK,
          "_mid defined");
   EXPECT(kit_obj_symbol_by_name(f, KIT_SLICE_LIT("_edata"), &edata) == KIT_OK,
          "_edata defined");
 
   /* .data is placed at SRAM origin (4-aligned). The leading marker captures the
    * base; `.data` (4 bytes) advances to base+4; `.data.more` (8 bytes,
    * already 4-aligned) ends at base+12; `. = ALIGN(16)` rounds to base+16. */
   EXPECT(sdata.value == 0x20000000u, "_sdata == .data start (section base)");
   EXPECT(mid.value == 0x20000004u, "_mid == base + sizeof(.data) after glob");
   EXPECT(edata.value == 0x20000010u,
          "_edata == ALIGN(16) of base + .data + .data.more");
   EXPECT(sdata.value != edata.value,
          "interior symbols around globs are not collapsed to the section start");
 
 done:
   if (f) kit_obj_free(f);
   if (w) kit_writer_close(w);
   if (sess) kit_link_session_free(sess);
   if (ob) kit_obj_builder_free(ob);
   if (s) kit_link_script_free(&g_u.ctx, s);
   if (c) kit_compiler_free(c);
 }
 
 int main(void) {
   kit_unit_init(&g_u);
   check_kernel_script_subset();
   check_scripted_layout_vma_lma();
   check_noload_progbits();
   check_intersection_dot_align();
   check_body_symbols_after_glob();
   check_multibyte_fill();
   check_phdr_coalesce_and_multi();
   check_bss_tail_no_coalesce_skew();
   check_coalesce_perms_union();
   check_recursion_depth_guard();
   kit_unit_summary(&g_u, "link_script_test");
   return kit_unit_status(&g_u);
 }