kit

kit
git clone https://git.ryansepassi.com/git/kit.git
Log | Files | Refs | README

symbol.c (3988B)

      1 #include "cg/internal.h"
      2 
      3 SymBind api_map_bind(KitSymBind b) {
      4   switch (b) {
      5     case KIT_SB_LOCAL:
      6       return SB_LOCAL;
      7     case KIT_SB_GLOBAL:
      8       return SB_GLOBAL;
      9     case KIT_SB_WEAK:
     10       return SB_WEAK;
     11   }
     12   return SB_LOCAL;
     13 }
     14 
     15 SymVis api_map_vis(KitCgVisibility v) {
     16   switch (v) {
     17     case KIT_CG_VIS_DEFAULT:
     18       return SV_DEFAULT;
     19     case KIT_CG_VIS_HIDDEN:
     20       return SV_HIDDEN;
     21     case KIT_CG_VIS_PROTECTED:
     22       return SV_PROTECTED;
     23   }
     24   return SV_DEFAULT;
     25 }
     26 
     27 SymKind api_decl_sym_kind(KitCgDecl decl) {
     28   if (decl.kind == KIT_CG_DECL_FUNC) {
     29     if (decl.as.func.flags & KIT_CG_FUNC_IFUNC) return SK_IFUNC;
     30     return SK_FUNC;
     31   }
     32   if (decl.as.object.flags & KIT_CG_OBJ_TLS) return SK_TLS;
     33   return SK_OBJ;
     34 }
     35 
     36 Sym api_cg_symbol_section_name(KitCg* g, Slice base, KitSym linkage_name) {
     37   Compiler* c;
     38   Heap* h;
     39   Slice name;
     40   size_t len;
     41   char* buf;
     42   Sym out;
     43   if (!g || !base.len || !linkage_name) return 0;
     44   c = g->c;
     45   name = pool_slice(c->global, (Sym)linkage_name);
     46   if (!name.len) return 0;
     47   if (base.len > SIZE_MAX - 2u || name.len > SIZE_MAX - base.len - 2u) {
     48     compiler_panic(c, api_no_loc(), "KitCg: section name too long");
     49     return 0;
     50   }
     51   len = base.len + 1u + name.len;
     52   h = c->ctx->heap;
     53   buf = (char*)h->alloc(h, len + 1u, 1);
     54   if (!buf) {
     55     compiler_panic(c, api_no_loc(), "KitCg: oom building section name");
     56     return 0;
     57   }
     58   memcpy(buf, base.s, base.len);
     59   buf[base.len] = '.';
     60   memcpy(buf + base.len + 1u, name.s, name.len);
     61   buf[len] = '\0';
     62   out = pool_intern_slice(c->global, (Slice){.s = buf, .len = len});
     63   h->free(h, buf, len + 1u);
     64   return out;
     65 }
     66 
     67 void api_remember_sym(KitCg* g, ObjSymId sym, KitCgTypeId ty, KitCgDecl decl) {
     68   Heap* h;
     69   KitCgTypeId* nts;
     70   KitCgDecl* nas;
     71   u32 cap;
     72   if (!g || sym == OBJ_SYM_NONE) return;
     73   if (sym < g->sym_cap) {
     74     g->sym_types[sym] = ty;
     75     g->sym_attrs[sym] = decl;
     76     return;
     77   }
     78   h = g->c->ctx->heap;
     79   cap = g->sym_cap ? g->sym_cap : 16u;
     80   while (cap <= sym) cap *= 2u;
     81   nts = (KitCgTypeId*)h->alloc(h, sizeof(*nts) * cap, _Alignof(KitCgTypeId));
     82   nas = (KitCgDecl*)h->alloc(h, sizeof(*nas) * cap, _Alignof(KitCgDecl));
     83   if (!nts || !nas) {
     84     if (nts) h->free(h, nts, sizeof(*nts) * cap);
     85     if (nas) h->free(h, nas, sizeof(*nas) * cap);
     86     return;
     87   }
     88   memset(nts, 0, sizeof(*nts) * cap);
     89   memset(nas, 0, sizeof(*nas) * cap);
     90   if (g->sym_types) {
     91     memcpy(nts, g->sym_types, sizeof(*nts) * g->sym_cap);
     92     h->free(h, g->sym_types, sizeof(*g->sym_types) * g->sym_cap);
     93   }
     94   if (g->sym_attrs) {
     95     memcpy(nas, g->sym_attrs, sizeof(*nas) * g->sym_cap);
     96     h->free(h, g->sym_attrs, sizeof(*g->sym_attrs) * g->sym_cap);
     97   }
     98   g->sym_types = nts;
     99   g->sym_attrs = nas;
    100   g->sym_cap = cap;
    101   g->sym_types[sym] = ty;
    102   g->sym_attrs[sym] = decl;
    103 }
    104 
    105 KitCgTypeId api_sym_type(KitCg* g, KitCgSym sym) {
    106   if (!g || sym == KIT_CG_SYM_NONE || sym >= g->sym_cap) {
    107     return KIT_CG_TYPE_NONE;
    108   }
    109   return g->sym_types[sym];
    110 }
    111 
    112 KitCgDecl api_sym_attrs(KitCg* g, KitCgSym sym) {
    113   KitCgDecl decl;
    114   memset(&decl, 0, sizeof(decl));
    115   decl.kind = KIT_CG_DECL_OBJECT;
    116   decl.sym.bind = KIT_SB_GLOBAL;
    117   decl.sym.visibility = KIT_CG_VIS_DEFAULT;
    118   if (!g || sym == KIT_CG_SYM_NONE || sym >= g->sym_cap) return decl;
    119   return g->sym_attrs[sym];
    120 }
    121 
    122 int api_sym_is_tls(KitCg* g, KitCgSym sym) {
    123   KitCgDecl decl = api_sym_attrs(g, sym);
    124   return decl.kind == KIT_CG_DECL_OBJECT &&
    125          (decl.as.object.flags & KIT_CG_OBJ_TLS);
    126 }
    127 
    128 RelocKind api_data_reloc_kind(int pcrel, uint32_t width) {
    129   if (pcrel) {
    130     if (width == 4) return R_PC32;
    131     if (width == 8) return R_PC64;
    132   } else {
    133     if (width == 4) return R_ABS32;
    134     if (width == 8) return R_ABS64;
    135   }
    136   return R_NONE;
    137 }
    138 
    139 /* ============================================================
    140  * Public API: KitCg lifecycle
    141  * ============================================================ */
    142 
    143 SrcLoc api_no_loc(void) {
    144   SrcLoc loc;
    145   loc.file_id = 0;
    146   loc.line = 0;
    147   loc.col = 0;
    148   return loc;
    149 }