kit

core.c (6886B)

---

 /* Compiler lifecycle, panic, and cleanup-stack machinery. */
 
 #include "core/core.h"
 
 #include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "abi/abi.h"
 #include "api/lang_registry.h"
 #include "core/arena.h"
 #include "core/diag.h"
 #include "core/heap.h"
 #include "core/pool.h"
 
 #if defined(__GNUC__) || defined(__clang__) || defined(__kit__)
 __attribute__((weak))
 #endif
 void kit_debug_printf(const char* fmt, ...) {
   (void)fmt;
 }
 
 #if defined(__GNUC__) || defined(__clang__) || defined(__kit__)
 __attribute__((weak))
 #endif
 const char* kit_debug_getenv(const char* name) {
   (void)name;
   return NULL;
 }
 
 /* Weak fallbacks for the tracing seam (kit/trace.h). libkit holds no trace
  * state, so the library-side gate is always closed and the sink is a no-op;
  * hosted binaries (driver/env) override both with the KIT_TRACE-driven
  * implementation. */
 #if defined(__GNUC__) || defined(__clang__) || defined(__kit__)
 __attribute__((weak))
 #endif
 int kit_trace_enabled(const char* module, int level) {
   (void)module;
   (void)level;
   return 0;
 }
 
 #if defined(__GNUC__) || defined(__clang__) || defined(__kit__)
 __attribute__((weak))
 #endif
 void kit_trace_emit(const char* module, int level, const char* file, int line,
                     const char* fmt, ...) {
   (void)module;
   (void)level;
   (void)file;
   (void)line;
   (void)fmt;
 }
 
 /* Weak fallback for the <assert.h> failure hook (rt/include/assert.h). kit's
  * own code uses compiler_panic, not C assert(), but vendored code compiled into
  * libkit (the lz4 codecs) references __kit_assert_fail in non-NDEBUG builds.
  * A hidden weak trap lets every libkit.a consumer -- the kit binary, the
  * test harnesses that link the archive directly, a standalone embedder --
  * resolve it without pulling in the runtime. Hidden (the -fvisibility=hidden
  * default, NOT visibility-default) keeps it off libkit's public export
  * surface that scripts/lib_reloc_defined_prefixes.py guards. The freestanding
  * runtime ships its own weak __kit_assert_fail (rt/lib/assert) for programs
  * that link it. The contract is _Noreturn, so trap rather than return. */
 #if defined(__GNUC__) || defined(__clang__) || defined(__kit__)
 __attribute__((weak))
 #endif
 _Noreturn void __kit_assert_fail(const char* expr, const char* file, int line,
                                  const char* func) {
   (void)expr;
   (void)file;
   (void)line;
   (void)func;
   __builtin_trap();
   for (;;) {
   }
 }
 
 SourceManager* source_new(Compiler*);
 void source_free(SourceManager*);
 
 struct CompilerCleanup {
   void (*fn)(void*);
   void* arg;
   CompilerCleanup* prev;
 };
 
 KitStatus compiler_init(Compiler* c, const KitTarget* target,
                         const KitContext* ctx) {
   Heap* h = ctx->heap;
   KitStatus st;
 
   if (!c || !target || !ctx || !h) return KIT_INVALID;
   memset(c, 0, sizeof(*c));
   c->ctx = ctx;
   c->target_ref = target;
   c->target = target->spec;
 
   c->global = (Pool*)h->alloc(h, sizeof(Pool), _Alignof(Pool));
   if (!c->global) goto nomem;
   pool_init(c->global, h);
 
   c->tu = (Arena*)h->alloc(h, sizeof(Arena), _Alignof(Arena));
   if (!c->tu) goto nomem;
   arena_init(c->tu, h, 0);
 
   c->scratch = (Arena*)h->alloc(h, sizeof(Arena), _Alignof(Arena));
   if (!c->scratch) goto nomem;
   arena_init(c->scratch, h, 0);
 
   c->sources = source_new(c);
   if (!c->sources) goto nomem;
 
   c->abi = abi_new(c);
   if (!c->abi) goto nomem;
 
   c->cleanup = NULL;
 
   st = lang_registry_init(c);
   if (st != KIT_OK) goto err_status;
   return KIT_OK;
 
 nomem:
   compiler_fini(c);
   return KIT_NOMEM;
 
 err_status:
   compiler_fini(c);
   return st;
 }
 
 void compiler_fini(Compiler* c) {
   Heap* h = c->ctx->heap;
 
   compiler_run_cleanups(c);
 
   if (c->cg_api_free) {
     c->cg_api_free(c);
     c->cg_api_free = NULL;
   }
   if (c->frontends) {
     h->free(h, c->frontends, c->frontends_cap * sizeof(*c->frontends));
     c->frontends = NULL;
     c->nfrontends = 0;
     c->frontends_cap = 0;
   }
 
   if (c->abi) {
     abi_free(c->abi);
     c->abi = NULL;
   }
   if (c->sources) source_free(c->sources);
   if (c->scratch) {
     arena_fini(c->scratch);
     h->free(h, c->scratch, sizeof(Arena));
   }
   if (c->tu) {
     arena_fini(c->tu);
     h->free(h, c->tu, sizeof(Arena));
   }
   if (c->global) {
     pool_fini(c->global);
     h->free(h, c->global, sizeof(Pool));
   }
   c->global = NULL;
   c->tu = c->scratch = NULL;
   c->sources = NULL;
 }
 
 CompilerCleanup* compiler_defer(Compiler* c, void (*fn)(void*), void* arg) {
   CompilerCleanup* node;
   node = (CompilerCleanup*)arena_alloc(c->scratch, sizeof(*node),
                                        _Alignof(CompilerCleanup));
   if (!node) return NULL;
   node->fn = fn;
   node->arg = arg;
   node->prev = c->cleanup;
   c->cleanup = node;
   return node;
 }
 
 void compiler_undefer(Compiler* c, CompilerCleanup* node) {
   CompilerCleanup** link = &c->cleanup;
   while (*link) {
     if (*link == node) {
       *link = node->prev;
       return;
     }
     link = &(*link)->prev;
   }
 }
 
 void compiler_run_cleanups(Compiler* c) {
   while (c->cleanup) {
     CompilerCleanup* node = c->cleanup;
     c->cleanup = node->prev;
     node->fn(node->arg);
   }
 }
 
 void compiler_panic_push(Compiler* c, PanicFrame* frame) {
   frame->prev = c->panic_frame;
   c->panic_frame = frame;
 }
 
 void compiler_panic_pop(Compiler* c, PanicFrame* frame) {
   PanicFrame** link;
   if (!c || !frame) return;
   if (c->panic_frame == frame) {
     c->panic_frame = frame->prev;
     frame->prev = NULL;
     return;
   }
   link = &c->panic_frame;
   while (*link) {
     if (*link == frame) {
       *link = frame->prev;
       frame->prev = NULL;
       return;
     }
     link = &(*link)->prev;
   }
 }
 
 void compiler_panic(Compiler* c, SrcLoc loc, const char* fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
   compiler_panicv(c, loc, fmt, ap);
   va_end(ap);
 }
 
 void compiler_panicv(Compiler* c, SrcLoc loc, const char* fmt, va_list ap) {
   /* Route through diag_emitv so the FATAL bumps the sink's error counter
    * before we longjmp away (diag_emitv tolerates a NULL emit slot). */
   if (c->ctx && c->ctx->diag) {
     diag_emitv(c->ctx->diag, DIAG_FATAL, loc, fmt, ap);
   }
   if (c->panic_frame) longjmp(c->panic_frame->env, 1);
   /* No active panic handler. Every compile/codegen entry point pushes a panic
    * frame (compiler_panic_push + setjmp) before reaching code that can panic, so
    * reaching here is an internal-consistency failure, not a recoverable error.
    * The legacy bare `c->panic` jmp_buf is never armed by anyone, so longjmp'ing
    * it would jump into garbage — a wild SEGV that hides the real fault. Trap
    * deterministically instead; the FATAL diagnostic above has already been
    * emitted, so the failing location is reported before we abort. (libkit is
    * freestanding — __builtin_trap is the same unrecoverable primitive
    * __kit_assert_fail uses; there is no exit() to call here.) */
   __builtin_trap();
 }