kit

decl.c (6135B)

---

 /* DeclTable — C declaration semantics above the public CG API.
  *
  * Maps DeclId → Decl record. Allocates a KitCgSym for any non-typedef,
  * non-auto/register decl with linkage.
  *
  * Identifier *lookup* is not handled here — that lives on the parser's
  * scope stack so block scopes and shadowing fall out naturally. DeclTable
  * is just the C-language layer above CG: storage class, linkage,
  * static-locals, tentative defs, and global initializers.
  *
  * v1 surface is intentionally minimal: just enough for the spine corpus
  * (functions; ints; static locals) plus the hooks DESIGN.md §5.3.1
  * commits to. Tentative-definition coalescing, COMDAT, and aliases are
  * stubs at the API edge; their full semantics arrive with the multi-TU
  * corpus. */
 
 #include "decl/decl.h"
 
 #include <string.h>
 
 struct DeclTable {
   Compiler* c;
   Pool* pool;
   KitCg* cg;
   Decl* slots; /* index 0 reserved as DECL_NONE */
   u32 nslots;
   u32 cap;
 };
 
 #define DECL_INITIAL_CAP 16u
 
 static void decls_grow(DeclTable* t, u32 want) {
   Heap* h = kit_compiler_context(t->c)->heap;
   u32 cap = t->cap;
   Decl* nb;
   if (cap >= want) return;
   while (cap < want) cap = cap ? cap * 2u : DECL_INITIAL_CAP;
   nb = (Decl*)h->alloc(h, sizeof(Decl) * cap, _Alignof(Decl));
   if (t->slots) {
     memcpy(nb, t->slots, sizeof(Decl) * t->nslots);
     h->free(h, t->slots, sizeof(Decl) * t->cap);
   }
   t->slots = nb;
   t->cap = cap;
 }
 
 DeclTable* decl_new(Compiler* c, Pool* pool, KitCg* cg) {
   Heap* h = kit_compiler_context(c)->heap;
   DeclTable* t =
       (DeclTable*)h->alloc(h, sizeof(DeclTable), _Alignof(DeclTable));
   memset(t, 0, sizeof *t);
   t->c = c;
   t->pool = pool;
   t->cg = cg;
   decls_grow(t, 1);
   memset(&t->slots[0], 0, sizeof(Decl));
   t->nslots = 1;
   return t;
 }
 
 void decl_free(DeclTable* t) {
   Heap* h;
   if (!t) return;
   h = kit_compiler_context(t->c)->heap;
   if (t->slots) h->free(h, t->slots, sizeof(Decl) * t->cap);
   h->free(h, t, sizeof(*t));
 }
 
 static KitCgSymbolAttrs decl_sym_attrs(const Decl* d) {
   KitCgSymbolAttrs a;
   memset(&a, 0, sizeof a);
   a.bind = (d->linkage == DL_EXTERNAL) ? KIT_SB_GLOBAL : KIT_SB_LOCAL;
   if (d->flags & DF_WEAK) a.bind = KIT_SB_WEAK;
   a.visibility = (KitCgVisibility)d->visibility;
   if (d->flags & DF_USED) a.flags |= KIT_CG_SYM_USED;
   return a;
 }
 
 static KitCgInlinePolicy decl_inline_policy(const Decl* d) {
   if (d->flags & DF_NOINLINE) return KIT_CG_INLINE_NEVER;
   if (d->flags & DF_ALWAYS_INLINE) return KIT_CG_INLINE_ALWAYS;
   if (d->flags & DF_INLINE) return KIT_CG_INLINE_HINT;
   return KIT_CG_INLINE_DEFAULT;
 }
 
 /* Build the public CG declaration for an already-validated Decl and emit it.
  * Returns the resulting KitCgSym. Emission is idempotent for a name that
  * already has a symbol: kit_cg_decl reuses the existing symbol and only
  * refreshes attributes (e.g. promoting a strong global to weak). */
 static ObjSymId decl_emit_cg_sym(DeclTable* t, const Decl* slot) {
   KitCgDecl decl;
   memset(&decl, 0, sizeof decl);
   decl.kind = (slot->type && slot->type->kind == TY_FUNC) ? KIT_CG_DECL_FUNC
                                                           : KIT_CG_DECL_OBJECT;
   decl.display_name = slot->name;
   /* An asm label (`extern T f(...) __asm__("name")`) is the verbatim linker
    * symbol name: it bypasses C name mangling, including the Mach-O leading
    * underscore. The Darwin system headers spell the underscore themselves
    * (e.g. realpath's `__asm("_realpath$DARWIN_EXTSN")`), so routing the label
    * back through kit_cg_c_linkage_name would double it. Only mangle the plain
    * source name. */
   decl.linkage_name =
       slot->asm_name ? slot->asm_name : kit_cg_c_linkage_name(t->c, slot->name);
   decl.type = type_cg_id_in_pool(t->c, t->pool, slot->type);
   decl.sym = decl_sym_attrs(slot);
   if (decl.kind == KIT_CG_DECL_FUNC) {
     if (slot->flags & DF_NORETURN) decl.as.func.flags |= KIT_CG_FUNC_NORETURN;
     decl.as.func.inline_policy = decl_inline_policy(slot);
     decl.as.func.section = slot->section_id;
     decl.as.func.debug_type =
         type_cg_debug_in_pool(t->cg, t->c, t->pool, slot->type);
     decl.as.func.wasm_import_module = slot->wasm_import_module;
     decl.as.func.wasm_import_name = slot->wasm_import_name;
   } else {
     if (slot->flags & DF_THREAD) decl.as.object.flags |= KIT_CG_OBJ_TLS;
     decl.as.object.section = slot->section_id;
     decl.as.object.align = slot->align;
     decl.as.object.debug_type =
         type_cg_debug_in_pool(t->cg, t->c, t->pool, slot->type);
   }
   return kit_cg_decl(t->cg, decl);
 }
 
 DeclId decl_declare(DeclTable* t, const Decl* in) {
   DeclId id;
   Decl* slot;
   decls_grow(t, t->nslots + 1);
   id = (DeclId)t->nslots++;
   slot = &t->slots[id];
   *slot = *in;
   slot->id = id;
   if (slot->obj_sym == OBJ_SYM_NONE && slot->name &&
       slot->storage != DS_TYPEDEF && slot->storage != DS_AUTO &&
       slot->storage != DS_REGISTER) {
     if (slot->flags & DF_WEAK) {
       if (slot->linkage != DL_EXTERNAL)
         compiler_panic(t->c, slot->loc,
                        "weak attribute requires external linkage");
     }
     slot->obj_sym = decl_emit_cg_sym(t, slot);
   }
   return id;
 }
 
 void decl_apply_redecl_flags(DeclTable* t, DeclId id, u32 new_flags) {
   Decl* slot;
   if (id == DECL_NONE || id >= t->nslots) return;
   slot = &t->slots[id];
   /* C lets the `weak` attribute appear on any declaration; if a later
    * redeclaration or the definition introduces it, the already-emitted symbol
    * must become weak too. Other redeclaration-merge flags don't affect the
    * emitted symbol, so weak is all we re-apply here. */
   if (!(new_flags & DF_WEAK) || (slot->flags & DF_WEAK)) return;
   if (slot->linkage != DL_EXTERNAL)
     compiler_panic(t->c, slot->loc, "weak attribute requires external linkage");
   slot->flags |= DF_WEAK;
   if (slot->obj_sym != OBJ_SYM_NONE) decl_emit_cg_sym(t, slot);
 }
 
 const Decl* decl_get(const DeclTable* t, DeclId id) {
   if (!t || id == DECL_NONE || id >= t->nslots) return NULL;
   return &t->slots[id];
 }
 
 ObjSymId decl_obj_sym(const DeclTable* t, DeclId id) {
   const Decl* d = decl_get(t, id);
   return d ? d->obj_sym : OBJ_SYM_NONE;
 }