kit

obj_secnames.c (16721B)

---

 /* Format-aware canonical section names.
  *
  * The kit-internal section model (obj/obj.h) is format-neutral: every
  * Section carries a single Sym name plus a SecKind tag.  Most sections
  * keep ELF-style dot-prefixed names ("`.text`", "`.data`", …) end-to-end
  * because the per-format writer translates them as it emits headers.
  *
  * A handful of *synthetic* sections — built by the linker rather than
  * the front end — diverge in name across formats.  Their names need to
  * be picked at synthesis time, before any writer sees them, because the
  * linker uses the name to drive layout, symbol-boundary emission, and
  * the writer's output-section bucketing.  This TU centralizes that
  * choice so callers don't sprinkle target-format switches through
  * link_layout.c / link_dyn.c.
  *
  * Phase 1: ELF returns the historical name; Mach-O
  * panics with a "TODO" until the macho writer lands in Phase 2/3.  COFF
  * panics in the same way and is filled in later. */
 
 #include <kit/cg.h>
 #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"
 
 /* The C-symbol prefix for the active object format, never NULL: a format
  * row with a NULL c_label_prefix (or no format match) is treated as "". */
 const char* obj_format_c_label_prefix(const Compiler* c) {
   const ObjFormatImpl* fmt = c ? obj_format_lookup(c->target.obj) : NULL;
   const char* p = fmt ? fmt->c_label_prefix : NULL;
   return p ? p : "";
 }
 
 int obj_macho_debug_sectname(const char* name, size_t len, char out[17]) {
   /* Only ".debug_*" sections translate here; ".eh_frame" lives in __TEXT
    * and is handled by the writer's generic SecKind path and the reader's
    * own candidate list, not this helper. */
   static const char kPrefix[] = ".debug_";
   const size_t plen = sizeof(kPrefix) - 1; /* 7 */
   size_t i;
   if (!name || len < plen || memcmp(name, kPrefix, plen) != 0) return 0;
   /* out = "__" + name-without-dot, capped at Mach-O's 16-byte sectname.
    * The cap yields Apple's spelling for the one overlong DWARF5 name
    * (".debug_str_offsets" -> "__debug_str_offs"). */
   out[0] = '_';
   out[1] = '_';
   for (i = 0; i + 1 < len && i < 14u; ++i) out[2 + i] = name[1 + i];
   out[2 + i] = '\0';
   return 1;
 }
 
 const char* obj_macho_canon_secname(SecKind kind) {
   /* Mirrors the SecKind cases of name_to_seg_sect (src/obj/macho/emit.c):
    * keep the two in lockstep so a section's text spelling and its binary
    * header land in the same Mach-O (segment,section). */
   switch (kind) {
     case SEC_TEXT:
       return "__TEXT,__text";
     case SEC_RODATA:
       return "__TEXT,__const";
     case SEC_DATA:
       return "__DATA,__data";
     case SEC_BSS:
       return "__DATA,__bss";
     default: /* SEC_OTHER / SEC_DEBUG: spelled from the section's own name. */
       return NULL;
   }
 }
 
 /* Inverse of obj_macho_canon_secname: classify a Mach-O native
  * "segname,sectname" spelling into a SecKind.  Mirrors the per-segment
  * rules of the Mach-O reader (sec_kind_from_seg_sect in macho/read.c)
  * for the canonical names, but is name-only (no S_TYPE flags) so a
  * format-neutral caller can classify without the raw section header. */
 int obj_macho_seckind_for_secname(const char* name, size_t len, SecKind* kind) {
   const char* comma;
   size_t seg_len, sect_off, sect_len;
   if (!name || len == 0) return 0;
   comma = (const char*)memchr(name, ',', len);
   if (!comma) return 0;
   seg_len = (size_t)(comma - name);
   sect_off = seg_len + 1u;
   sect_len = len - sect_off;
   {
     const char* seg = name;
     const char* sect = name + sect_off;
     SecKind k;
     if (seg_len == 7 && memcmp(seg, "__DWARF", 7) == 0) {
       k = SEC_DEBUG;
     } else if (seg_len == 6 && memcmp(seg, "__TEXT", 6) == 0) {
       k = (sect_len == 6 && memcmp(sect, "__text", 6) == 0) ? SEC_TEXT
                                                             : SEC_RODATA;
     } else if (seg_len == 6 && memcmp(seg, "__DATA", 6) == 0) {
       k = (sect_len == 5 && memcmp(sect, "__bss", 5) == 0) ? SEC_BSS : SEC_DATA;
     } else {
       return 0;
     }
     if (kind) *kind = k;
     return 1;
   }
 }
 
 /* Translate a kit-internal (ELF-spelled) section name to its Mach-O
  * native "segname,sectname" spelling.  Generalizes
  * obj_macho_debug_sectname: the ".debug_*" DWARF case routes to
  * "__DWARF,__debug_*" (truncated to Mach-O's 16-byte sectname), and
  * ".eh_frame" routes to "__TEXT,__eh_frame".  Returns 0 for any other
  * name (caller falls back to its own spelling). */
 int obj_macho_native_secname(const char* name, size_t len, char out[40]) {
   char ds[17];
   if (!name || len == 0) return 0;
   if (obj_macho_debug_sectname(name, len, ds)) {
     /* "__DWARF," + ds (already "__debug_*", <=16 chars). */
     size_t dl = slice_from_cstr(ds).len;
     memcpy(out, "__DWARF,", 8);
     memcpy(out + 8, ds, dl);
     out[8 + dl] = '\0';
     return 1;
   }
   if (len == 9 && memcmp(name, ".eh_frame", 9) == 0) {
     memcpy(out, "__TEXT,__eh_frame", 17);
     out[17] = '\0';
     return 1;
   }
   return 0;
 }
 
 static Sym secname_panic_unimpl(Compiler* c, const char* which) {
   SrcLoc l = {0, 0, 0};
   compiler_panic(c, l,
                  "obj section name '%.*s' for target obj=%u not yet "
                  "implemented",
                  SLICE_ARG(slice_from_cstr(which)), (unsigned)c->target.obj);
   return 0;
 }
 
 Sym obj_secname_init_array(Compiler* c) {
   switch (c->target.obj) {
     case KIT_OBJ_ELF:
       return pool_intern_slice(c->global, SLICE_LIT(".init_array"));
     case KIT_OBJ_MACHO:
       return pool_intern_slice(c->global, SLICE_LIT("__DATA,__mod_init_func"));
     case KIT_OBJ_COFF:
       /* CRT runtime scans `.CRT$X[A-Z]` for ctor/dtor tables; XCU is
        * the user-constructor bucket.  See doc/OBJ.md. */
       return pool_intern_slice(c->global, SLICE_LIT(".CRT$XCU"));
     default:
       return secname_panic_unimpl(c, ".init_array");
   }
 }
 
 Sym obj_secname_fini_array(Compiler* c) {
   switch (c->target.obj) {
     case KIT_OBJ_ELF:
       return pool_intern_slice(c->global, SLICE_LIT(".fini_array"));
     case KIT_OBJ_MACHO:
       return pool_intern_slice(c->global, SLICE_LIT("__DATA,__mod_term_func"));
     case KIT_OBJ_COFF:
       /* `.CRT$XPA`/`XPZ` are markers; XPU is the user-destructor
        * bucket.  See doc/OBJ.md. */
       return pool_intern_slice(c->global, SLICE_LIT(".CRT$XPU"));
     default:
       return secname_panic_unimpl(c, ".fini_array");
   }
 }
 
 Sym obj_secname_preinit_array(Compiler* c) {
   switch (c->target.obj) {
     case KIT_OBJ_ELF:
       return pool_intern_slice(c->global, SLICE_LIT(".preinit_array"));
     case KIT_OBJ_MACHO:
       /* Mach-O has no direct `.preinit_array` analogue — dyld runs
        * S_MOD_INIT_FUNC_POINTERS only.  Phase 3 of the linker will
        * route preinit ctors through __mod_init_func; until then any
        * caller hitting this on a MACHO target is doing something the
        * platform can't represent. */
       return secname_panic_unimpl(c, ".preinit_array");
     case KIT_OBJ_COFF:
       /* CRT's own setup runs in `.CRT$XI*`; user pre-init lives at
        * XIA just after the CRT.  See doc/OBJ.md. */
       return pool_intern_slice(c->global, SLICE_LIT(".CRT$XIA"));
     default:
       return secname_panic_unimpl(c, ".preinit_array");
   }
 }
 
 Sym obj_secname_tdata(Compiler* c) {
   switch (c->target.obj) {
     case KIT_OBJ_ELF:
       return pool_intern_slice(c->global, SLICE_LIT(".tdata"));
     case KIT_OBJ_MACHO:
       return pool_intern_slice(c->global, SLICE_LIT("__DATA,__thread_data"));
     case KIT_OBJ_COFF:
       /* MSVC `.tls$` convention; linker concatenates `.tls$*` sorted
        * by suffix.  See doc/OBJ.md. */
       return pool_intern_slice(c->global, SLICE_LIT(".tls$"));
     case KIT_OBJ_WASM:
       /* Wasm has no thread-local storage model: a module instance owns a
        * single linear memory, so a thread-local is just an ordinary
        * data object. Keep the `.tdata` name (laid out like `.data`) and
        * lower tls_addr_of to a plain symbol address. */
       return pool_intern_slice(c->global, SLICE_LIT(".tdata"));
     default:
       return secname_panic_unimpl(c, ".tdata");
   }
 }
 
 Sym obj_secname_tbss(Compiler* c) {
   switch (c->target.obj) {
     case KIT_OBJ_ELF:
       return pool_intern_slice(c->global, SLICE_LIT(".tbss"));
     case KIT_OBJ_MACHO:
       return pool_intern_slice(c->global, SLICE_LIT("__DATA,__thread_bss"));
     case KIT_OBJ_COFF:
       /* sorted-alphabetically-last so it falls at the tail of the TLS
        * image's zero-fill region.  See doc/OBJ.md. */
       return pool_intern_slice(c->global, SLICE_LIT(".tls$ZZZ"));
     case KIT_OBJ_WASM:
       /* See obj_secname_tdata: wasm thread-locals are ordinary
        * (zero-filled) data. */
       return pool_intern_slice(c->global, SLICE_LIT(".tbss"));
     default:
       return secname_panic_unimpl(c, ".tbss");
   }
 }
 
 int obj_format_extern_via_got(const Compiler* c) {
   /* Mach-O always binds extern data through __got / non-lazy pointers
    * — direct ADRP+ADD to an imported symbol isn't representable in
    * ld64's reloc set.
    *
    * ELF static link: extern data is resolved at link time, so direct
    * page-relative addressing works (linker patches the ADRP+ADD).
    *
    * ELF -fPIC / -fPIE: extern data may resolve to a symbol defined
    * in a DSO at runtime; the codegen must route through the GOT so
    * the loader can patch a single slot rather than touching .text. */
   /* Mach-O always binds extern data through its own static GOT / non-lazy
    * pointers — same property the builds_own_static_got field records. */
   if (obj_format_builds_own_static_got(c)) return 1;
   if (c->target.obj == KIT_OBJ_ELF &&
       (c->target.pic == KIT_PIC_PIC || c->target.pic == KIT_PIC_PIE))
     return 1;
   return 0;
 }
 
 int obj_symbol_extern_via_got(const Compiler* c, ObjBuilder* obj,
                               ObjSymId sym) {
   const ObjSym* s;
   if (!obj_format_extern_via_got(c)) return 0;
   s = obj_symbol_get(obj, sym);
   return s && s->section_id == OBJ_SEC_NONE;
 }
 
 int obj_format_split_sections_as_atoms(const Compiler* c) {
   const ObjFormatImpl* fmt;
   if (!c) return 0;
   fmt = obj_format_lookup(c->target.obj);
   return fmt && fmt->split_sections_as_atoms;
 }
 
 /* C-symbol mangling for the active object format.  Mach-O prepends a
  * single `_` to every C source-level symbol on disk (matching Apple cc
  * and decl.c): "main" → `_main`, "_start" → `__start`,
  * "__init_array_start" → `___init_array_start`.  ELF / COFF / Wasm
  * intern verbatim.  The temp buffer for the Mach-O case comes from
  * `c->ctx->heap`, the same allocator the existing call sites
  * (boundary_name, kit_jit_lookup, link_intern_c_name) already use. */
 Sym obj_format_c_mangle(Compiler* c, const char* name) {
   size_t n, plen;
   const char* prefix;
   Heap* h;
   char* buf;
   Sym s;
   SrcLoc loc = {0, 0, 0};
   if (!c || !name) return 0;
   prefix = obj_format_c_label_prefix(c);
   plen = slice_from_cstr(prefix).len;
   if (plen == 0) return pool_intern_slice(c->global, slice_from_cstr(name));
   n = slice_from_cstr(name).len;
   h = (Heap*)c->ctx->heap;
   buf = (char*)h->alloc(h, n + plen + 1u, 1);
   if (!buf)
     compiler_panic(c, loc, "obj_format_c_mangle: oom prefixing '%.*s'",
                    SLICE_ARG(slice_from_cstr(name)));
   memcpy(buf, prefix, plen);
   memcpy(buf + plen, name, n);
   buf[n + plen] = 0;
   s = pool_intern_slice(c->global, (Slice){.s = buf, .len = (u32)(n + plen)});
   h->free(h, buf, n + plen + 1u);
   return s;
 }
 
 /* Inverse of obj_format_c_mangle for diagnostic display.  Strips the
  * format's leading C-mangle byte from `*name` (advancing the pointer
  * and decrementing `*len`) so panic text shows the source-level name
  * regardless of target format.  No-op for formats with no prefix. */
 void obj_format_demangle_c(const Compiler* c, const char** name, size_t* len) {
   const char* prefix;
   size_t plen;
   if (!c || !name || !len || !*name) return;
   prefix = obj_format_c_label_prefix(c);
   plen = slice_from_cstr(prefix).len;
   if (plen == 0 || *len < plen) return;
   if (memcmp(*name, prefix, plen) != 0) return;
   *name += plen;
   *len -= plen;
 }
 
 /* Default entry symbol name baked into a freshly created Linker for
  * this object format.  Mach-O uses `_main` because LC_MAIN names main
  * directly (dyld owns C runtime startup); ELF / COFF / Wasm use the
  * historical `_start` produced by crt1.o.  Returned as a NUL-terminated
  * literal; caller interns. */
 const char* obj_format_default_entry_name(const Compiler* c) {
   /* Mach-O: `_main` (LC_MAIN names main; dyld owns startup).
    * COFF: `mainCRTStartup` (PE/Windows CRT entry sets up argc/argv and
    *   calls main; resolved against the user CRT archive, mingw's
    *   libmingwex.a — see doc/OBJ.md).
    * ELF / Wasm: the historical `_start` produced by crt1.o.
    * All driven by the per-format default_entry_name field; a row with a
    * NULL field (or no format match) falls back to "_start". */
   const ObjFormatImpl* fmt = c ? obj_format_lookup(c->target.obj) : NULL;
   const char* e = fmt ? fmt->default_entry_name : NULL;
   return e ? e : "_start";
 }
 
 int obj_format_carries_file_only_debug(const Compiler* c) {
   const ObjFormatImpl* fmt = c ? obj_format_lookup(c->target.obj) : NULL;
   return fmt && fmt->carries_file_only_debug;
 }
 
 int obj_format_builds_own_static_got(const Compiler* c) {
   const ObjFormatImpl* fmt = c ? obj_format_lookup(c->target.obj) : NULL;
   return fmt && fmt->builds_own_static_got;
 }
 
 int obj_format_weak_undef_pulls_archive_member(const Compiler* c) {
   const ObjFormatImpl* fmt = c ? obj_format_lookup(c->target.obj) : NULL;
   return fmt && fmt->weak_undef_pulls_archive_member;
 }
 
 int obj_format_weak_extern_underscore_alias(const Compiler* c) {
   const ObjFormatImpl* fmt = c ? obj_format_lookup(c->target.obj) : NULL;
   return fmt && fmt->weak_extern_underscore_alias;
 }
 
 int obj_format_supports_symbol_feature(const Compiler* c, int symfeat) {
   /* The only format-divergent feature axis today is TLS access: only ELF and
    * Mach-O can represent the ELF/Mach-O TLS-access features the CG layer mints.
    * COFF (Windows TEB model) and Wasm cannot. Every other (non-TLS) feature is
    * representable by every format. The per-format answer lives on the vtable.
    */
   switch (symfeat) {
     case KIT_CG_SYMFEAT_TLS_LOCAL_EXEC:
     case KIT_CG_SYMFEAT_TLS_INITIAL_EXEC:
     case KIT_CG_SYMFEAT_TLS_LOCAL_DYNAMIC:
     case KIT_CG_SYMFEAT_TLS_GENERAL_DYNAMIC: {
       const ObjFormatImpl* fmt = c ? obj_format_lookup(c->target.obj) : NULL;
       return fmt && fmt->tls_symbol_features;
     }
     default:
       return 1;
   }
 }
 
 int obj_format_static_ifunc_via_rela_iplt(const Compiler* c) {
   /* The single home for the (os == FREEBSD && obj == ELF) knowledge:
    * FreeBSD's crt walks [__rela_iplt_start, __rela_iplt_end) of
    * R_*_IRELATIVE relocs before main, so kit emits that table instead of
    * the ctor-based __kit_ifunc_init path on FreeBSD/ELF. */
   return c && c->target.os == KIT_OS_FREEBSD && c->target.obj == KIT_OBJ_ELF;
 }
 
 u32 obj_format_static_ifunc_irelative_type(const Compiler* c) {
   /* The R_*_IRELATIVE resolver wire type for the __rela_iplt table the
    * predicate above selects. Resolves through the *target* format rather
    * than a literal KIT_OBJ_ELF so the generic iplt pass names no format
    * constant; non-ELF formats have no elf_arch and yield 0. */
   const ObjFormatImpl* fmt;
   const ObjElfArchOps* ao;
   if (!c) return 0u;
   fmt = obj_format_lookup(c->target.obj);
   ao = (fmt && fmt->elf_arch) ? fmt->elf_arch(c->target.arch) : NULL;
   return ao ? ao->r_irelative : 0u;
 }
 
 u32 obj_format_elf_tls_tp_bias(const Compiler* c) {
   const ObjFormatImpl* fmt;
   const ObjElfArchOps* arch;
   if (!c || c->target.obj != KIT_OBJ_ELF) return 0u;
   fmt = obj_format_lookup(KIT_OBJ_ELF);
   arch = (fmt && fmt->elf_arch) ? fmt->elf_arch(c->target.arch) : NULL;
   return arch ? arch->tls_tp_bias : 0u;
 }
 
 int obj_format_boundary_sym_kind(const Compiler* c, KitSlice name,
                                  int* symkind) {
   /* PE/COFF owns two synthetic absolute globals the linker emits:
    * `__ImageBase` (image base for ASLR-relative math) and `_tls_used`
    * (the IMAGE_TLS_DIRECTORY anchor).  Both are SK_ABS.  Other formats
    * own no boundary symbols here. */
   if (!c || c->target.obj != KIT_OBJ_COFF) return 0;
   if (slice_eq_cstr(name, "__ImageBase") || slice_eq_cstr(name, "_tls_used")) {
     if (symkind) *symkind = SK_ABS;
     return 1;
   }
   return 0;
 }
 
 void obj_format_synth_inputs(const Compiler* c, Linker* l) {
   const ObjFormatImpl* fmt = c ? obj_format_lookup(c->target.obj) : NULL;
   if (fmt && fmt->synth_inputs) fmt->synth_inputs(l);
 }