kit

obj_tls.c (8699B)

---

 /* Format-aware thread-local storage emission.
  *
  * `_Thread_local` storage has the same source-level shape across object
  * formats (a global with a per-thread instance), but the on-disk
  * representation diverges sharply:
  *
  *   ELF   : one symbol in `.tdata` / `.tbss`; access via direct
  *           TP-relative offset (TLSLE relocs).
  *   Mach-O: storage and access are split.  The bytes live under a
  *           private `<name>$tlv$init` symbol in `__DATA,__thread_data`
  *           / `__DATA,__thread_bss`.  The user-visible symbol points
  *           at a 24-byte *descriptor* in `__DATA,__thread_vars`:
  *             +0  : ptr to `_tlv_bootstrap` (BIND; dyld rewrites to a
  *                   per-descriptor thunk after allocating a pthread key)
  *             +8  : pthread key (0 on disk; filled by dyld)
  *             +16 : ptr to the data symbol (REBASE; link_macho rewrites
  *                   the literal to (target_vaddr - tls_image_vaddr))
  *           Access from compiled code is an indirect call through the
  *           descriptor's slot[0]; the TLVP_LOAD_PAGE21/PAGEOFF12 reloc
  *           pair targets the descriptor symbol, not the data.
  *
  * Centralizing the split here keeps the frontend (parse_init.c) and the
  * codegen (per-arch ops.c) format-agnostic — they pass the canonical
  * SK_TLS symbol plus byte buffer to `obj_define_tls`, and consult
  * `obj_format_tls_via_descriptor` when choosing an access sequence.
  *
  * The `_tlv_bootstrap` undef extern is cached on ObjBuilder so multiple
  * TLV vars in one TU share one entry; the linker dedupes across TUs by
  * name. */
 
 #include <string.h>
 
 #include "core/core.h"
 #include "core/heap.h"
 #include "core/pool.h"
 #include "core/slice.h"
 #include "obj/format.h"
 #include "obj/obj.h"
 
 /* ObjBuilder is opaque outside obj.c; obj_tls.c reaches the bootstrap
  * cache via these accessors defined in obj.c.  Declared here to avoid
  * exposing the field in obj.h's public ObjBuilder layout. */
 ObjSymId obj_tlv_bootstrap_get(const ObjBuilder*);
 void obj_tlv_bootstrap_set(ObjBuilder*, ObjSymId);
 
 /* TLS-access model for the active (format, OS): COFF -> Windows TEB,
  * Mach-O -> per-variable descriptor + thunk, everything else -> ELF
  * Local-Exec / Initial-Exec.  The single source of truth for the
  * TLS-access decision. */
 ObjTlsModel obj_format_tls_model(const Compiler* c) {
   if (!c) return OBJ_TLS_ELF_LE;
   if (c->target.obj == KIT_OBJ_COFF) return OBJ_TLS_WINDOWS_TEB;
   if (c->target.obj == KIT_OBJ_MACHO) return OBJ_TLS_MACHO_DESCRIPTOR;
   return OBJ_TLS_ELF_LE;
 }
 
 /* Thin wrapper kept for existing callers (per-arch ops.c, NativeDirect,
  * internal define_tls dispatch); later waves migrate them to
  * obj_format_tls_model directly. */
 int obj_format_tls_via_descriptor(const Compiler* c) {
   return obj_format_tls_model(c) == OBJ_TLS_MACHO_DESCRIPTOR;
 }
 
 /* In-process JIT: 1 when a reference to symbol `name` is dropped because the
  * access idiom that materializes it is relaxed to in-image addressing. The
  * COFF Windows TEB model loads a per-module `_tls_index`; the JIT rewrites that
  * load away, so its relocs must not be applied. None elsewhere. Sits beside
  * obj_format_tls_model as the TLS-mechanism authority, so src/link stays free
  * of the format-specific pseudo-symbol name. */
 int obj_format_jit_drops_symbol_ref(const Compiler* c, Sym name) {
   Slice nm;
   if (!c || name == 0) return 0;
   if (obj_format_tls_model(c) != OBJ_TLS_WINDOWS_TEB) return 0;
   nm = pool_slice(c->global, name);
   return nm.len == 10u && memcmp(nm.s, "_tls_index", 10u) == 0;
 }
 
 static void define_tls_elf(ObjBuilder* ob, Compiler* c, ObjSymId sym,
                            const u8* data, u32 size, int has_nonzero_init,
                            u32 align, const ObjTlsReloc* relocs, u32 nrelocs) {
   u32 a = align ? align : 1u;
   if (!data || !has_nonzero_init) {
     Sym sname = obj_secname_tbss(c);
     ObjSecId sec =
         obj_section_ex(ob, sname, SEC_BSS, SSEM_NOBITS,
                        SF_ALLOC | SF_WRITE | SF_TLS, a, 0, OBJ_SEC_NONE, 0);
     u32 base = obj_align_to(ob, sec, a);
     obj_reserve_bss(ob, sec, base + size, a);
     obj_symbol_define(ob, sym, sec, base, size);
     return;
   }
   Sym sname = obj_secname_tdata(c);
   ObjSecId sec =
       obj_section(ob, sname, SEC_DATA, SF_ALLOC | SF_WRITE | SF_TLS, a);
   u32 base = obj_align_to(ob, sec, a);
   {
     u8* dst = obj_reserve(ob, sec, size);
     if (dst) memcpy(dst, data, size);
   }
   obj_symbol_define(ob, sym, sec, base, size);
   for (u32 i = 0; i < nrelocs; ++i) {
     obj_reloc(ob, sec, base + relocs[i].offset, relocs[i].kind,
               relocs[i].target, relocs[i].addend);
   }
 }
 
 static ObjSymId tlv_bootstrap(ObjBuilder* ob, Compiler* c) {
   ObjSymId s = obj_tlv_bootstrap_get(ob);
   if (s != OBJ_SYM_NONE) return s;
   /* On-disk name carries the Mach-O leading underscore: source-level
    * `_tlv_bootstrap` becomes `__tlv_bootstrap`. */
   Sym name = pool_intern_slice(c->global, SLICE_LIT("__tlv_bootstrap"));
   s = obj_symbol(ob, name, SB_GLOBAL, SK_UNDEF, OBJ_SEC_NONE, 0, 0);
   obj_tlv_bootstrap_set(ob, s);
   return s;
 }
 
 static ObjSymId mint_init_sym(ObjBuilder* ob, Compiler* c, Sym desc_name) {
   Slice nm_s = pool_slice(c->global, desc_name);
   const char* nm = nm_s.s;
   size_t nlen = nm_s.len;
   static const char suffix[] = "$tlv$init";
   size_t slen = sizeof(suffix) - 1u;
   Heap* h = (Heap*)c->ctx->heap;
   char* buf = (char*)h->alloc(h, nlen + slen + 1u, 1);
   if (!buf)
     compiler_panic(c, (SrcLoc){0, 0, 0},
                    "obj_define_tls: oom interning init name");
   if (nlen) memcpy(buf, nm, nlen);
   memcpy(buf + nlen, suffix, slen);
   buf[nlen + slen] = 0;
   Sym n = pool_intern_slice(c->global,
                             (Slice){.s = buf, .len = (u32)(nlen + slen)});
   h->free(h, buf, nlen + slen + 1u);
   return obj_symbol(ob, n, SB_LOCAL, SK_TLS, OBJ_SEC_NONE, 0, 0);
 }
 
 static void define_tls_macho(ObjBuilder* ob, Compiler* c, ObjSymId sym,
                              const u8* data, u32 size, int has_nonzero_init,
                              u32 align, const ObjTlsReloc* relocs,
                              u32 nrelocs) {
   const ObjSym* desc_os = obj_symbol_get(ob, sym);
   if (!desc_os)
     compiler_panic(c, (SrcLoc){0, 0, 0},
                    "obj_define_tls: descriptor sym not found");
   ObjSymId data_sym = mint_init_sym(ob, c, desc_os->name);
 
   /* Storage section: __thread_data (initialized) or __thread_bss (BSS).
    * Same SF_TLS flag as ELF — macho_emit's section_flags_for maps SF_TLS
    * + sectname to the right S_THREAD_LOCAL_* type. */
   u32 a = align ? align : 1u;
   if (!data || !has_nonzero_init) {
     Sym sname = obj_secname_tbss(c);
     ObjSecId sec =
         obj_section_ex(ob, sname, SEC_BSS, SSEM_NOBITS,
                        SF_ALLOC | SF_WRITE | SF_TLS, a, 0, OBJ_SEC_NONE, 0);
     u32 base = obj_align_to(ob, sec, a);
     obj_reserve_bss(ob, sec, base + size, a);
     obj_symbol_define(ob, data_sym, sec, base, size);
   } else {
     Sym sname = obj_secname_tdata(c);
     ObjSecId sec =
         obj_section(ob, sname, SEC_DATA, SF_ALLOC | SF_WRITE | SF_TLS, a);
     u32 base = obj_align_to(ob, sec, a);
     {
       u8* dst = obj_reserve(ob, sec, size);
       if (dst) memcpy(dst, data, size);
     }
     obj_symbol_define(ob, data_sym, sec, base, size);
     for (u32 i = 0; i < nrelocs; ++i) {
       obj_reloc(ob, sec, base + relocs[i].offset, relocs[i].kind,
                 relocs[i].target, relocs[i].addend);
     }
   }
 
   /* Descriptor in __DATA,__thread_vars: 24 bytes aligned 8.
    * The user-visible `sym` lives here; the TLVP relocs in code target
    * this symbol so the linker can route them through __thread_ptrs. */
   Sym vars_name =
       pool_intern_slice(c->global, SLICE_LIT("__DATA,__thread_vars"));
   ObjSecId vars_sec =
       obj_section(ob, vars_name, SEC_DATA, SF_ALLOC | SF_WRITE | SF_TLS, 8u);
   u32 desc_base = obj_align_to(ob, vars_sec, 8u);
   {
     u8* dst = obj_reserve(ob, vars_sec, 24u);
     if (dst) memset(dst, 0, 24u);
   }
   obj_symbol_define(ob, sym, vars_sec, desc_base, 24u);
   obj_reloc(ob, vars_sec, desc_base + 0u, R_ABS64, tlv_bootstrap(ob, c), 0);
   obj_reloc(ob, vars_sec, desc_base + 16u, R_ABS64, data_sym, 0);
 }
 
 void obj_define_tls(Compiler* c, ObjBuilder* ob, ObjSymId sym, const u8* data,
                     u32 size, int has_nonzero_init, u32 align,
                     const ObjTlsReloc* relocs, u32 nrelocs) {
   if (obj_format_tls_via_descriptor(c)) {
     define_tls_macho(ob, c, sym, data, size, has_nonzero_init, align, relocs,
                      nrelocs);
     return;
   }
   define_tls_elf(ob, c, sym, data, size, has_nonzero_init, align, relocs,
                  nrelocs);
 }