kit

link.c (18037B)

---

 /* Public link API entries.
  *
  * Thin orchestrators over the Linker primitives in link.c / link_resolve.c /
  * link_layout.c / link_jit.c. Each entry:
  *   - allocates a Linker against the caller's Compiler,
  *   - feeds in the KitLinkInputs,
  *   - configures lane-specific flags (pie, shared, jit),
  *   - calls link_resolve,
  *   - dispatches to the emit (writer) or JIT-map (kit_jit_from_image) tail.
  *
  * The driver's job ends at populating KitLinkInputs; everything below this
  * line is libkit-internal. */
 
 #include "link/link.h"
 
 #include <kit/core.h>
 #include <kit/jit.h>
 #include <kit/link.h>
 #include <setjmp.h>
 #include <string.h>
 
 #include "cg/internal.h"
 #include "cg/ir_recorder.h"
 #include "core/core.h"
 #include "link/link_internal.h"
 
 KitJit* kit_jit_from_image(LinkImage*);
 
 static KitStatus link_session_guard(KitLinkSession* s,
                                     void (*fn)(KitLinkSession*, void*),
                                     void* arg) {
   PanicFrame panic;
   if (!s || !s->c || !s->linker || !fn) return KIT_INVALID;
   compiler_panic_push(s->c, &panic);
   if (setjmp(panic.env)) {
     compiler_run_cleanups(s->c);
     s->linker = NULL;
     s->image = NULL;
     compiler_panic_pop(s->c, &panic);
     return KIT_ERR;
   }
   fn(s, arg);
   compiler_panic_pop(s->c, &panic);
   return KIT_OK;
 }
 
 static KitStatus link_session_remember_publish_obj(KitLinkSession* s,
                                                    KitObjBuilder* ob) {
   Heap* h;
   KitObjBuilder** nb;
   u32 new_cap;
   if (!s || !ob) return KIT_INVALID;
   if (s->npublish_objs < s->publish_objs_cap) {
     s->publish_objs[s->npublish_objs++] = ob;
     return KIT_OK;
   }
   h = s->c->ctx->heap;
   new_cap = s->publish_objs_cap ? s->publish_objs_cap * 2u : 8u;
   nb = (KitObjBuilder**)h->realloc(
       h, s->publish_objs, sizeof(*s->publish_objs) * s->publish_objs_cap,
       sizeof(*s->publish_objs) * new_cap, _Alignof(KitObjBuilder*));
   if (!nb) return KIT_NOMEM;
   s->publish_objs = nb;
   s->publish_objs_cap = new_cap;
   s->publish_objs[s->npublish_objs++] = ob;
   return KIT_OK;
 }
 
 KitStatus kit_link_session_new(KitCompiler* c,
                                const KitLinkSessionOptions* opts,
                                KitLinkSession** out) {
   Heap* h;
   KitLinkSession* s;
   Linker* l;
   if (!out) return KIT_INVALID;
   *out = NULL;
   if (!c || !opts) return KIT_INVALID;
   h = c->ctx->heap;
   l = link_new(c);
   if (!l) return KIT_NOMEM;
   s = (KitLinkSession*)h->alloc(h, sizeof(*s), _Alignof(KitLinkSession));
   if (!s) {
     link_free(l);
     return KIT_NOMEM;
   }
   memset(s, 0, sizeof(*s));
   s->c = (Compiler*)c;
   s->linker = l;
   s->opts = *opts;
   if (opts->output_kind > KIT_LINK_OUTPUT_JIT) {
     h->free(h, s, sizeof(*s));
     link_free(l);
     return KIT_INVALID;
   }
   if (opts->pe_subsystem != KIT_PE_SUBSYSTEM_DEFAULT &&
       opts->pe_subsystem != KIT_PE_SUBSYSTEM_WINDOWS_GUI &&
       opts->pe_subsystem != KIT_PE_SUBSYSTEM_WINDOWS_CUI) {
     h->free(h, s, sizeof(*s));
     link_free(l);
     return KIT_INVALID;
   }
   link_set_pe_subsystem(l, opts->pe_subsystem);
 
   switch ((KitLinkOutputKind)opts->output_kind) {
     case KIT_LINK_OUTPUT_EXE:
       link_set_emit_static_exe(l, 1);
       link_set_gc_sections(l, opts->gc_sections);
       link_set_strip_debug(l, opts->strip_debug);
       link_set_pie(l, opts->pie);
       link_set_interp_path(l, opts->interp_path);
       break;
     case KIT_LINK_OUTPUT_SHARED:
       link_set_gc_sections(l, opts->gc_sections);
       link_set_strip_debug(l, opts->strip_debug);
       link_set_pie(l, 1);
       (void)opts->soname;
       (void)opts->rpaths;
       (void)opts->nrpaths;
       (void)opts->runpaths;
       (void)opts->nrunpaths;
       (void)opts->exports;
       (void)opts->nexports;
       (void)opts->allow_undefined;
       break;
     case KIT_LINK_OUTPUT_RELOCATABLE:
       break;
     case KIT_LINK_OUTPUT_JIT:
       if (!opts->jit_host) {
         h->free(h, s, sizeof(*s));
         link_free(l);
         return KIT_INVALID;
       }
       link_set_jit_host(l, opts->jit_host);
       link_set_jit_mode(l, 1);
       link_set_gc_sections(l, opts->gc_sections);
       if (!opts->entry.s || opts->entry.len == 0) link_clear_entry(l);
       if (opts->extern_resolver) {
         link_set_extern_resolver(l, opts->extern_resolver,
                                  opts->extern_resolver_user);
       }
       break;
   }
   if (opts->linker_script) link_set_script(l, opts->linker_script);
   if (opts->text_base_set) link_set_text_base(l, opts->text_base);
   if (opts->entry.s && opts->entry.len) {
     link_set_entry(l, opts->entry);
   } else if (opts->pe_subsystem == KIT_PE_SUBSYSTEM_WINDOWS_GUI &&
              !(opts->linker_script && opts->linker_script->entry.s &&
                opts->linker_script->entry.len)) {
     link_set_entry(l, KIT_SLICE_LIT("WinMainCRTStartup"));
   }
   (void)opts->build_id_mode;
   (void)opts->build_id_bytes;
   (void)opts->build_id_len;
   *out = s;
   return KIT_OK;
 }
 
 typedef struct LinkAddObjArg {
   KitObjBuilder* ob;
 } LinkAddObjArg;
 
 static void link_session_add_obj_inner(KitLinkSession* s, void* arg) {
   LinkAddObjArg* a = (LinkAddObjArg*)arg;
   link_add_obj(s->linker, (ObjBuilder*)a->ob);
 }
 
 KitStatus kit_link_session_add_obj(KitLinkSession* s, KitObjBuilder* ob) {
   LinkAddObjArg arg;
   KitStatus st;
   if (!s || !ob || s->resolved) return KIT_INVALID;
   arg.ob = ob;
   st = link_session_guard(s, link_session_add_obj_inner, &arg);
   if (st != KIT_OK) return st;
   return link_session_remember_publish_obj(s, ob);
 }
 
 typedef struct LinkAddBytesArg {
   KitSlice name;
   const KitSlice* bytes;
   const KitLinkArchiveInput* archive;
 } LinkAddBytesArg;
 
 static void link_session_add_obj_bytes_inner(KitLinkSession* s, void* arg) {
   LinkAddBytesArg* a = (LinkAddBytesArg*)arg;
   link_add_obj_bytes(s->linker, a->name.s, a->bytes->data, a->bytes->len);
 }
 
 KitStatus kit_link_session_add_obj_bytes(KitLinkSession* s, KitSlice name,
                                          const KitSlice* bytes) {
   LinkAddBytesArg arg;
   if (!s || !bytes || s->resolved) return KIT_INVALID;
   arg.name = name;
   arg.bytes = bytes;
   arg.archive = NULL;
   s->non_obj_inputs++;
   return link_session_guard(s, link_session_add_obj_bytes_inner, &arg);
 }
 
 static void link_session_add_archive_bytes_inner(KitLinkSession* s, void* arg) {
   const KitLinkArchiveInput* a = ((LinkAddBytesArg*)arg)->archive;
   link_add_archive_bytes(s->linker, a->name.s, a->bytes.data, a->bytes.len,
                          a->whole_archive, a->link_mode, a->group_id);
 }
 
 KitStatus kit_link_session_add_archive_bytes(
     KitLinkSession* s, const KitLinkArchiveInput* archive) {
   LinkAddBytesArg arg;
   if (!s || !archive || s->resolved) return KIT_INVALID;
   arg.bytes = NULL;
   arg.archive = archive;
   s->non_obj_inputs++;
   return link_session_guard(s, link_session_add_archive_bytes_inner, &arg);
 }
 
 static void link_session_add_dso_bytes_inner(KitLinkSession* s, void* arg) {
   LinkAddBytesArg* a = (LinkAddBytesArg*)arg;
   link_add_dso_bytes(s->linker, a->name.s, a->bytes->data, a->bytes->len);
 }
 
 KitStatus kit_link_session_add_dso_bytes(KitLinkSession* s, KitSlice name,
                                          const KitSlice* bytes) {
   LinkAddBytesArg arg;
   if (!s || !bytes || s->resolved) return KIT_INVALID;
   arg.name = name;
   arg.bytes = bytes;
   arg.archive = NULL;
   s->non_obj_inputs++;
   return link_session_guard(s, link_session_add_dso_bytes_inner, &arg);
 }
 
 typedef struct LinkLtoPreserveArg {
   KitObjBuilder* lto_obj;
   KitCg* lto_cg;
   KitLinkLtoPreservedCallback cb;
   void* user;
 } LinkLtoPreserveArg;
 
 typedef struct LinkLtoRefMark {
   ObjSymId sym;
   u8 referenced;
   u8 pad[3];
 } LinkLtoRefMark;
 
 typedef struct LinkLtoRefMarks {
   Compiler* c;
   ObjBuilder* ob;
   LinkLtoRefMark* marks;
   u32 nmarks;
   u32 cap;
 } LinkLtoRefMarks;
 
 static int link_lto_sym_is_logical_undef(const ObjSym* s) {
   return s && s->section_id == OBJ_SEC_NONE && s->kind != SK_ABS &&
          s->kind != SK_COMMON;
 }
 
 static int link_lto_sym_is_preservable_def(const ObjSym* s) {
   return s && !s->removed && s->name != 0 && s->bind != SB_LOCAL &&
          link_sym_is_def(s);
 }
 
 static void link_lto_preserve_name(LinkLtoPreserveArg* a, Sym name) {
   ObjSymIter* it;
   ObjSymEntry e;
   if (!a || !name) return;
   it = obj_symiter_new((ObjBuilder*)a->lto_obj);
   while (it && obj_symiter_next(it, &e)) {
     const ObjSym* s = e.sym;
     if (!s || s->name != name) continue;
     if (link_lto_sym_is_preservable_def(s)) a->cb(a->user, (KitCgSym)e.id);
   }
   if (it) obj_symiter_free(it);
 }
 
 static int link_lto_sym_in_preserved_section(ObjBuilder* ob, ObjSymId sym,
                                              const ObjSym* s) {
   const Section* sec;
   const ObjAtom* atom;
   ObjAtomId aid;
   if (!ob || !s) return 0;
   if (s->section_id == OBJ_SEC_NONE) return 0;
   sec = obj_section_get(ob, s->section_id);
   if (sec && ((sec->flags & SF_RETAIN) || sec->sem == SSEM_INIT_ARRAY ||
               sec->sem == SSEM_FINI_ARRAY || sec->sem == SSEM_PREINIT_ARRAY))
     return 1;
   aid = obj_atom_find_symbol(ob, sym);
   atom = obj_atom_get(ob, aid);
   return atom && (atom->flags & OBJ_ATOM_RETAIN);
 }
 
 static void link_lto_refmarks_add(LinkLtoRefMarks* marks, ObjSymId sym,
                                   const ObjSym* s) {
   Heap* h;
   LinkLtoRefMark* nm;
   u32 ncap;
   if (!marks || sym == OBJ_SYM_NONE || !s) return;
   for (u32 i = 0; i < marks->nmarks; ++i)
     if (marks->marks[i].sym == sym) return;
   if (marks->nmarks == marks->cap) {
     h = marks->c->ctx->heap;
     ncap = marks->cap ? marks->cap * 2u : 32u;
     nm = (LinkLtoRefMark*)h->realloc(h, marks->marks,
                                      sizeof(*marks->marks) * marks->cap,
                                      sizeof(*marks->marks) * ncap,
                                      _Alignof(LinkLtoRefMark));
     if (!nm)
       compiler_panic(marks->c, SRCLOC_NONE,
                      "link: oom on LTO semantic-ref marks");
     marks->marks = nm;
     marks->cap = ncap;
   }
   marks->marks[marks->nmarks].sym = sym;
   marks->marks[marks->nmarks].referenced = s->referenced ? 1u : 0u;
   marks->nmarks++;
 }
 
 static void link_lto_mark_refset(ObjBuilder* ob, const ObjSymSet* refs,
                                  LinkLtoRefMarks* marks) {
   if (!ob || !refs || !refs->cap) return;
   for (u32 i = 0; i < refs->cap; ++i) {
     ObjSymId sym = refs->slots[i].k;
     const ObjSym* s;
     if (sym == OBJ_SYM_NONE) continue;
     s = obj_symbol_get(ob, sym);
     if (link_lto_sym_is_logical_undef(s)) {
       link_lto_refmarks_add(marks, sym, s);
       obj_sym_mark_referenced(ob, sym);
     }
   }
 }
 
 static int link_lto_module_has_asm(const CgIrModule* module) {
   if (!module) return 0;
   if (module->nfile_scope_asms) return 1;
   for (u32 i = 0; i < module->nfuncs; ++i) {
     const CgIrFunc* f = module->funcs[i];
     if (!f || f->removed) continue;
     for (u32 k = 0; k < f->ninsts; ++k)
       if (f->insts[k].op == CG_IR_ASM_BLOCK) return 1;
   }
   return 0;
 }
 
 static void link_lto_mark_semantic_refs(LinkLtoPreserveArg* a,
                                         LinkLtoRefMarks* marks) {
   ObjBuilder* ob = (ObjBuilder*)a->lto_obj;
   const CgIrModule* module;
   if (!a->lto_cg || !a->lto_cg->target) return;
   module = cg_ir_recorder_module(a->lto_cg->target);
   if (!module) return;
   for (u32 i = 0; i < module->nfuncs; ++i) {
     const CgIrFunc* f = module->funcs[i];
     if (!f || f->removed) continue;
     link_lto_mark_refset(ob, &f->call_refs, marks);
     link_lto_mark_refset(ob, &f->global_refs, marks);
   }
 }
 
 static void link_lto_refmarks_restore(LinkLtoRefMarks* marks) {
   if (!marks || !marks->ob) return;
   for (u32 i = 0; i < marks->nmarks; ++i) {
     obj_sym_set_referenced(marks->ob, marks->marks[i].sym,
                            marks->marks[i].referenced);
   }
 }
 
 static void link_lto_refmarks_fini(LinkLtoRefMarks* marks) {
   Heap* h;
   if (!marks || !marks->marks) return;
   h = marks->c->ctx->heap;
   h->free(h, marks->marks, sizeof(*marks->marks) * marks->cap);
   memset(marks, 0, sizeof(*marks));
 }
 
 static void link_lto_preserve_intrinsic_roots(KitLinkSession* s,
                                               LinkLtoPreserveArg* a) {
   ObjBuilder* ob = (ObjBuilder*)a->lto_obj;
   const CgIrModule* module = NULL;
   int preserve_all_nonlocal = 0;
   ObjSymIter* it;
   ObjSymEntry e;
 
   if (a->lto_cg && a->lto_cg->target)
     module = cg_ir_recorder_module(a->lto_cg->target);
 
   preserve_all_nonlocal = s->opts.output_kind != KIT_LINK_OUTPUT_EXE ||
                           link_lto_module_has_asm(module);
   if (s->opts.output_kind == KIT_LINK_OUTPUT_SHARED) preserve_all_nonlocal = 1;
 
   it = obj_symiter_new(ob);
   while (it && obj_symiter_next(it, &e)) {
     const ObjSym* os = e.sym;
     if (!link_lto_sym_is_preservable_def(os)) continue;
     if (preserve_all_nonlocal || os->bind == SB_WEAK || os->kind == SK_IFUNC ||
         (os->flags & KIT_CG_SYM_USED) ||
         link_lto_sym_in_preserved_section(ob, e.id, os)) {
       a->cb(a->user, (KitCgSym)e.id);
     }
   }
   if (it) obj_symiter_free(it);
 
   if (s->linker->entry_name) link_lto_preserve_name(a, s->linker->entry_name);
   for (u32 i = 0; i < s->opts.nexports; ++i) {
     const KitSlice* ex = &s->opts.exports[i];
     if (ex->s && ex->len)
       link_lto_preserve_name(
           a,
           pool_intern_slice(s->c->global, (Slice){.s = ex->s, .len = ex->len}));
   }
 }
 
 static void link_lto_preserve_opaque_undef_refs(KitLinkSession* s,
                                                 LinkLtoPreserveArg* a) {
   u32 ninputs = LinkInputs_count(&s->linker->inputs);
   for (u32 ii = 0; ii < ninputs; ++ii) {
     LinkInput* in = LinkInputs_at(&s->linker->inputs, ii);
     ObjSymIter* it;
     ObjSymEntry e;
     if (!in || !in->obj || in->obj == (ObjBuilder*)a->lto_obj) continue;
     it = obj_symiter_new(in->obj);
     while (it && obj_symiter_next(it, &e)) {
       const ObjSym* os = e.sym;
       if (!os || os->name == 0 || os->bind == SB_LOCAL) continue;
       if (link_sym_is_spurious_undef(os)) continue;
       if (!link_lto_sym_is_logical_undef(os)) continue;
       link_lto_preserve_name(a, os->name);
     }
     if (it) obj_symiter_free(it);
   }
 }
 
 static void link_session_visit_lto_preserved_inner(KitLinkSession* s,
                                                    void* arg) {
   LinkLtoPreserveArg* a = (LinkLtoPreserveArg*)arg;
   LinkLtoRefMarks marks;
   memset(&marks, 0, sizeof marks);
   marks.c = s->c;
   marks.ob = (ObjBuilder*)a->lto_obj;
   if (s->opts.output_kind != KIT_LINK_OUTPUT_RELOCATABLE) {
     /* Archive selection needs pre-finish semantic refs, but those refs may
      * disappear after LTO internalization/DCE. Borrow ObjSym::referenced only
      * for archive ingestion, then restore it before CG finish. */
     link_lto_mark_semantic_refs(a, &marks);
     link_ingest_archives(s->linker);
     link_lto_refmarks_restore(&marks);
     link_lto_refmarks_fini(&marks);
   }
   link_lto_preserve_intrinsic_roots(s, a);
   link_lto_preserve_opaque_undef_refs(s, a);
 }
 
 KitStatus kit_link_session_visit_lto_preserved(KitLinkSession* s,
                                                KitObjBuilder* lto_obj,
                                                KitCg* lto_cg,
                                                KitLinkLtoPreservedCallback cb,
                                                void* user) {
   LinkLtoPreserveArg arg;
   if (!s || !lto_obj || !lto_cg || !cb || s->resolved) return KIT_INVALID;
   memset(&arg, 0, sizeof arg);
   arg.lto_obj = lto_obj;
   arg.lto_cg = lto_cg;
   arg.cb = cb;
   arg.user = user;
   return link_session_guard(s, link_session_visit_lto_preserved_inner, &arg);
 }
 
 static void link_session_resolve_inner(KitLinkSession* s, void* arg) {
   (void)arg;
   if ((KitLinkOutputKind)s->opts.output_kind == KIT_LINK_OUTPUT_RELOCATABLE) {
     s->resolved = 1;
     return;
   }
   s->image = link_resolve(s->linker);
   s->resolved = 1;
 }
 
 KitStatus kit_link_session_resolve(KitLinkSession* s) {
   if (!s || s->resolved) return KIT_INVALID;
   return link_session_guard(s, link_session_resolve_inner, NULL);
 }
 
 typedef struct LinkEmitArg {
   KitWriter* out;
 } LinkEmitArg;
 
 static void link_session_emit_inner(KitLinkSession* s, void* arg) {
   KitWriter* out = ((LinkEmitArg*)arg)->out;
   if ((KitLinkOutputKind)s->opts.output_kind == KIT_LINK_OUTPUT_RELOCATABLE) {
     link_emit_relocatable_writer(s->linker, out);
   } else {
     link_emit_image_writer(s->image, out);
   }
 }
 
 KitStatus kit_link_session_emit(KitLinkSession* s, KitWriter* out) {
   LinkEmitArg arg;
   KitStatus st;
   if (!s || !out) return KIT_INVALID;
   if (!s->resolved) {
     st = kit_link_session_resolve(s);
     if (st != KIT_OK) return st;
   }
   if ((KitLinkOutputKind)s->opts.output_kind == KIT_LINK_OUTPUT_JIT)
     return KIT_INVALID;
   arg.out = out;
   return link_session_guard(s, link_session_emit_inner, &arg);
 }
 
 typedef struct LinkJitArg {
   KitJit* jit;
 } LinkJitArg;
 
 static void link_session_jit_inner(KitLinkSession* s, void* arg) {
   LinkJitArg* a = (LinkJitArg*)arg;
   a->jit = kit_jit_from_image(s->image);
   if (a->jit) {
     s->image = NULL;
     s->linker_transferred = 1;
     s->linker = NULL;
   }
 }
 
 KitStatus kit_link_session_jit(KitLinkSession* s, KitJit** out_jit) {
   LinkJitArg arg;
   KitStatus st;
   if (!out_jit) return KIT_INVALID;
   *out_jit = NULL;
   if (!s || (KitLinkOutputKind)s->opts.output_kind != KIT_LINK_OUTPUT_JIT)
     return KIT_INVALID;
   if (!s->resolved) {
     st = kit_link_session_resolve(s);
     if (st != KIT_OK) return st;
   }
   arg.jit = NULL;
   st = link_session_guard(s, link_session_jit_inner, &arg);
   if (st != KIT_OK) return st;
   if (!arg.jit) return KIT_ERR;
   *out_jit = arg.jit;
   return KIT_OK;
 }
 
 void kit_link_session_free(KitLinkSession* s) {
   Heap* h;
   if (!s) return;
   h = s->c->ctx->heap;
   if (s->image) link_image_free(s->image);
   if (s->linker) link_free(s->linker);
   if (s->publish_objs) {
     h->free(h, s->publish_objs, sizeof(*s->publish_objs) * s->publish_objs_cap);
   }
   h->free(h, s, sizeof(*s));
 }