kit

coff_archive_fixpoint_test.c (6273B)

---

 /* COFF archive global fixed-point regression.
  *
  * Rust/MinGW links can create demand for an earlier library from a later
  * library. ELF/Mach-O preserve positional archive semantics, but COFF linkers
  * search the library set as a fixed point. This test builds:
  *
  *   input.o       -> undef late
  *   libearly.a   -> defines early
  *   liblate.a    -> defines late, undef early
  *
  * Positional scanning leaves `early` unpulled; COFF global fixed point pulls
  * liblate.a first, then revisits libearly.a. */
 
 #include <kit/archive.h>
 #include <kit/core.h>
 #include <string.h>
 
 #include "core/core.h"
 #include "core/pool.h"
 #include "lib/kit_unit.h"
 #include "link/link.h"
 #include "link/link_internal.h"
 #include "obj/obj.h"
 
 static KitUnit g_u;
 #define EXPECT(cond, ...) CU_EXPECT(&g_u, cond, __VA_ARGS__)
 
 static Sym intern(Compiler* c, const char* s) {
   return pool_intern_slice(c->global, (Slice){.s = s, .len = (u32)strlen(s)});
 }
 
 static ObjBuilder* make_obj(Compiler* c, Sym def, Sym undef) {
   ObjBuilder* ob = obj_new(c);
   ObjSecId data;
   ObjSymId usym;
   static const u8 byte = 1;
   if (!ob) return NULL;
   if (def != 0) {
     data = obj_section(ob, intern(c, ".data"), SEC_DATA, SF_ALLOC | SF_WRITE,
                        1);
     obj_write(ob, data, &byte, sizeof byte);
     obj_symbol(ob, def, SB_GLOBAL, SK_OBJ, data, 0, sizeof byte);
   }
   if (undef != 0) {
     usym = obj_symbol_ex(ob, undef, SB_GLOBAL, SV_DEFAULT, SK_UNDEF,
                          OBJ_SEC_NONE, 0, 0, 0);
     obj_sym_mark_referenced(ob, usym);
   }
   obj_finalize(ob);
   return ob;
 }
 
 static u8* copy_writer_bytes(KitWriter* w, size_t* len_out) {
   size_t n = 0;
   const u8* src = kit_writer_mem_bytes(w, &n);
   u8* dst = (u8*)g_u.heap.alloc(&g_u.heap, n ? n : 1u, _Alignof(u8));
   if (dst && n) memcpy(dst, src, n);
   if (len_out) *len_out = n;
   return dst;
 }
 
 static u8* emit_member(Compiler* c, Sym def, Sym undef, size_t* len_out) {
   ObjBuilder* ob = make_obj(c, def, undef);
   KitWriter* w = NULL;
   u8* bytes = NULL;
   if (!ob) return NULL;
   if (kit_writer_mem(&g_u.heap, &w) == KIT_OK && w) {
     emit_coff(c, ob, w);
     bytes = copy_writer_bytes(w, len_out);
     kit_writer_close(w);
   }
   obj_free(ob);
   return bytes;
 }
 
 static u8* make_archive_bytes(const char* member_name, const u8* member,
                               size_t member_len, size_t* len_out) {
   KitArInput in;
   KitArWriteOptions opts;
   KitWriter* w = NULL;
   u8* bytes = NULL;
   memset(&in, 0, sizeof in);
   memset(&opts, 0, sizeof opts);
   in.name = kit_slice_cstr(member_name);
   in.bytes.data = member;
   in.bytes.len = member_len;
   if (kit_writer_mem(&g_u.heap, &w) != KIT_OK || !w) return NULL;
   if (kit_ar_write(w, &in, 1, &opts) == KIT_OK)
     bytes = copy_writer_bytes(w, len_out);
   kit_writer_close(w);
   return bytes;
 }
 
 static int input_has_defined(Linker* l, Sym name) {
   u32 i;
   for (i = 0; i < LinkInputs_count(&l->inputs); ++i) {
     LinkInput* in = LinkInputs_at(&l->inputs, i);
     ObjSymIter* it;
     ObjSymEntry e;
     if (!in->obj) continue;
     it = obj_symiter_new(in->obj);
     while (obj_symiter_next(it, &e)) {
       const ObjSym* s = e.sym;
       if (s->name == name && s->kind != SK_UNDEF &&
           (s->bind == SB_GLOBAL || s->bind == SB_WEAK)) {
         obj_symiter_free(it);
         return 1;
       }
     }
     obj_symiter_free(it);
   }
   return 0;
 }
 
 int main(void) {
   KitCompiler* kc = NULL;
   Compiler* c;
   Linker* l = NULL;
   ObjBuilder* seed = NULL;
   Sym early, late;
   u8 *early_member = NULL, *late_member = NULL;
   u8 *early_archive = NULL, *late_archive = NULL;
   size_t early_member_len = 0, late_member_len = 0;
   size_t early_archive_len = 0, late_archive_len = 0;
   int status;
 
   kit_unit_init(&g_u);
   {
     KitTargetSpec t =
         kit_unit_target(KIT_ARCH_X86_64, KIT_OS_WINDOWS, KIT_OBJ_COFF);
     if (kit_unit_compiler_new(&g_u, t, &kc) != KIT_OK || !kc) {
       fprintf(stderr, "compiler_new failed\n");
       return 2;
     }
   }
   c = (Compiler*)kc;
   early = intern(c, "early");
   late = intern(c, "late");
 
   seed = make_obj(c, 0, late);
   early_member = emit_member(c, early, 0, &early_member_len);
   late_member = emit_member(c, late, early, &late_member_len);
   EXPECT(seed != NULL, "seed object allocation failed");
   EXPECT(early_member != NULL && early_member_len > 0,
          "early member emit failed");
   EXPECT(late_member != NULL && late_member_len > 0, "late member emit failed");
 
   if (early_member && late_member) {
     early_archive = make_archive_bytes("early.o", early_member,
                                        early_member_len, &early_archive_len);
     late_archive =
         make_archive_bytes("late.o", late_member, late_member_len,
                            &late_archive_len);
   }
   EXPECT(early_archive != NULL && early_archive_len > 0,
          "early archive build failed");
   EXPECT(late_archive != NULL && late_archive_len > 0,
          "late archive build failed");
 
   l = link_new(c);
   EXPECT(l != NULL, "link_new failed");
   if (l && seed && early_archive && late_archive) {
     link_add_obj(l, seed);
     link_add_archive_bytes(l, "libearly.a", early_archive, early_archive_len,
                            0, 0, 0);
     link_add_archive_bytes(l, "liblate.a", late_archive, late_archive_len, 0,
                            0, 0);
     link_ingest_archives(l);
     EXPECT(input_has_defined(l, late), "late archive member was not pulled");
     EXPECT(input_has_defined(l, early),
            "COFF global archive fixed point did not revisit libearly.a");
   }
 
   if (l) link_free(l);
   if (seed) obj_free(seed);
   if (early_member)
     g_u.heap.free(&g_u.heap, early_member, early_member_len ? early_member_len
                                                            : 1u);
   if (late_member)
     g_u.heap.free(&g_u.heap, late_member, late_member_len ? late_member_len
                                                          : 1u);
   if (early_archive)
     g_u.heap.free(&g_u.heap, early_archive,
                   early_archive_len ? early_archive_len : 1u);
   if (late_archive)
     g_u.heap.free(&g_u.heap, late_archive,
                   late_archive_len ? late_archive_len : 1u);
 
   kit_unit_summary(&g_u, "coff_archive_fixpoint_test");
   status = kit_unit_status(&g_u);
   return status;
 }