kit

interp_program.c (5981B)

---

 /* InterpProgram lifecycle, capture (called from the optimizer), symbol/name
  * lookup, and the pluggable memory/symbol resolution used by the engine. */
 
 #include <string.h>
 
 #include "core/arena.h"
 #include "core/core.h"
 #include "core/slice.h"
 #include "interp/interp.h"
 
 static void* ip_alloc(InterpProgram* p, size_t n, size_t align) {
   Heap* h = p->c->ctx->heap;
   void* q = h->alloc(h, n, align);
   if (!q) compiler_panic(p->c, (SrcLoc){0, 0, 0}, "interp: out of memory");
   memset(q, 0, n);
   return q;
 }
 
 static void ip_free(InterpProgram* p, void* q, size_t n) {
   Heap* h = p->c->ctx->heap;
   if (q) h->free(h, q, n);
 }
 
 KitInterpProgram* kit_interp_program_new(KitCompiler* cc) {
   Compiler* c = (Compiler*)cc;
   Heap* h;
   InterpProgram* p;
   if (!c) return NULL;
   h = c->ctx->heap;
   p = (InterpProgram*)h->alloc(h, sizeof(*p), _Alignof(InterpProgram));
   if (!p) return NULL;
   memset(p, 0, sizeof(*p));
   p->c = c;
   return (KitInterpProgram*)p;
 }
 
 void kit_interp_program_free(KitInterpProgram* pp) {
   InterpProgram* p = (InterpProgram*)pp;
   Heap* h;
   if (!p) return;
   h = p->c->ctx->heap;
   if (p->funcs) ip_free(p, p->funcs, sizeof(p->funcs[0]) * p->funcs_cap);
   /* InterpFunc bodies live on c->tu (compiler-lifetime arena); only the
    * function-pointer table and the program struct are heap-owned. */
   h->free(h, p, sizeof(*p));
 }
 
 void kit_interp_program_attach(KitInterpProgram* pp, KitCompiler* cc) {
   Compiler* c = (Compiler*)cc;
   if (!c) return;
   c->interp_sink = pp; /* may be NULL to detach */
 }
 
 void kit_interp_program_set_host(KitInterpProgram* pp,
                                  const KitInterpHost* host) {
   InterpProgram* p = (InterpProgram*)pp;
   if (!p) return;
   if (host) {
     p->host = *host;
     p->have_host = 1;
   } else {
     p->have_host = 0;
   }
 }
 
 static void ip_register(InterpProgram* p, InterpFunc* fn) {
   if (p->nfuncs == p->funcs_cap) {
     u32 ncap = p->funcs_cap ? p->funcs_cap * 2u : 16u;
     InterpFunc** nf = ip_alloc(p, sizeof(nf[0]) * ncap, _Alignof(InterpFunc*));
     if (p->nfuncs) memcpy(nf, p->funcs, sizeof(nf[0]) * p->nfuncs);
     if (p->funcs) ip_free(p, p->funcs, sizeof(p->funcs[0]) * p->funcs_cap);
     p->funcs = nf;
     p->funcs_cap = ncap;
   }
   p->funcs[p->nfuncs++] = fn;
 }
 
 void interp_capture_func(void* program, Func* f, ObjSymId sym, const char* name,
                          u32 name_len, const ObjBuilder* obj) {
   InterpProgram* p = (InterpProgram*)program;
   Slice nm;
   InterpFunc* fn;
   if (!p || !f) return;
   nm.s = name;
   nm.len = name_len;
   fn = interp_lower(p, f, sym, nm, obj);
   if (fn) ip_register(p, fn);
 }
 
 InterpFunc* interp_func_for_sym(InterpProgram* p, ObjSymId sym) {
   u32 i;
   if (!p || sym == OBJ_SYM_NONE) return NULL;
   for (i = 0; i < p->nfuncs; ++i)
     if (p->funcs[i]->sym == sym) return p->funcs[i];
   return NULL;
 }
 
 InterpFunc* interp_func_for_addr(InterpProgram* p, void* addr) {
   u32 i;
   if (!p || !addr) return NULL;
   for (i = 0; i < p->nfuncs; ++i) {
     InterpFunc* fn = p->funcs[i];
     if (!fn->ok || !fn->name.s) continue;
     if (interp_resolve_sym(p, fn->name) == addr) return fn;
   }
   return NULL;
 }
 
 void* interp_global_base(InterpFunc* fn, ObjSymId sym) {
   u32 i;
   if (!fn) return NULL;
   for (i = 0; i < fn->nglobals; ++i) {
     InterpGlobal* g = &fn->globals[i];
     if (g->sym != sym) continue;
     if (!g->resolved) {
       g->cached = interp_resolve_sym(fn->prog, g->name);
       g->resolved = 1;
     }
     return g->cached;
   }
   return NULL;
 }
 
 void* interp_tls_addr(InterpFunc* fn, ObjSymId sym, i64 addend) {
   InterpProgram* p = fn ? fn->prog : NULL;
   u32 i;
   if (!p) return NULL;
   if (p->have_host && p->host.resolve_tls) {
     /* Resolve by symbol name (the host maps a thread-local name + addend to the
      * running thread's storage, unwrapping a TLV descriptor where needed). */
     for (i = 0; i < fn->nglobals; ++i)
       if (fn->globals[i].sym == sym)
         return p->host.resolve_tls(p->host.ctx, fn->globals[i].name, addend);
     return NULL;
   }
   /* No TLS resolver bound: treat as a plain global (correct only where the
    * symbol already denotes the variable's storage). */
   {
     void* base = interp_global_base(fn, sym);
     return base ? (u8*)base + (u64)addend : NULL;
   }
 }
 
 /* Match a stored (possibly target-mangled) symbol name against an unmangled
  * query, tolerating a single leading-underscore prefix (Mach-O / COFF C
  * mangling). ELF stores the bare name, so the exact branch handles it. */
 static int name_matches(Slice stored, KitSlice q) {
   if (!stored.s) return 0;
   if (stored.len == q.len && memcmp(stored.s, q.s, q.len) == 0) return 1;
   if (stored.len == q.len + 1u && stored.s[0] == '_' &&
       memcmp(stored.s + 1, q.s, q.len) == 0)
     return 1;
   return 0;
 }
 
 KitInterpFunc* kit_interp_lookup(KitInterpProgram* pp, KitSlice name) {
   InterpProgram* p = (InterpProgram*)pp;
   u32 i;
   if (!p || !name.s) return NULL;
   /* Newest-first: the emu re-lifts a block (same guest_pc-derived name) after
    * self-modifying code bumps the addr-space generation and flushes the code
    * cache. Capture is append-only, so the LAST same-named InterpFunc is the
    * freshest re-translation — returning it keeps INTERP in step with the fresh
    * code the JIT runs via its per-block object lookup. For the host-identity
    * --no-jit path each name is captured exactly once, so last == first. */
   for (i = p->nfuncs; i-- > 0;)
     if (name_matches(p->funcs[i]->name, name))
       return (KitInterpFunc*)p->funcs[i];
   return NULL;
 }
 
 u8* interp_translate(InterpProgram* p, u64 addr, u64 n, int perms) {
   if (p && p->have_host && p->host.translate)
     return p->host.translate(p->host.ctx, addr, n, perms);
   /* Host-identity: abstract addresses are real host pointers. */
   return (u8*)(uintptr_t)addr;
 }
 
 void* interp_resolve_sym(InterpProgram* p, Slice name) {
   if (p && p->have_host && p->host.resolve_sym)
     return p->host.resolve_sym(p->host.ctx, name);
   return NULL;
 }