kit

tbd_read.c (6230B)

---

 /* Apple `.tbd` (text-based stub) reader.
  *
  * `.tbd` files describe a dylib's ABI surface in a YAML-shaped TAPI
  * format — Apple ships them in the macOS SDK as a substitute for the
  * actual .dylib bytes.  kit's linker treats them as a peer of
  * read_macho_dso: extract install-name + the exported symbol set, and
  * surface that as an ObjBuilder full of defined OBJ_SEC_NONE entries.
  *
  * The TAPI grammar is intricate (per-target `exports:` blocks, weak
  * symbols, Obj-C metadata, re-exports, ...).  Rather than re-implement
  * a YAML parser, this reader takes the conservative approach: it
  * extracts the FIRST document's `install-name:` (the umbrella the
  * consumer records in LC_LOAD_DYLIB) and then **scans the entire file
  * for symbol-looking tokens** — sequences starting with `_` followed by
  * identifier chars.  The result is the union of every C, Obj-C class,
  * weak, and re-exported symbol declared anywhere in the file.
  *
  * Why the union is safe:
  *   - kit's linker only consults the DSO's exported set to satisfy
  *     undefs.  Including a symbol the consumer never references is
  *     harmless — the symbol simply never appears in our output's
  *     LC_LOAD_DYLIB chain.
  *   - dyld at runtime walks libSystem's full re-export graph to bind
  *     each name; our static-link decision (which dylib provides it)
  *     reduces to "the umbrella" anyway.  We only need to convince the
  *     static linker that the name is bindable, then write
  *     LC_LOAD_DYLIB against the umbrella's install-name.
  *
  * The scanner skips the top-of-file `install-name:` line so its path
  * (`/usr/lib/libSystem.B.dylib`) doesn't end up as a fake symbol — but
  * since paths don't start with `_`, that wasn't actually a risk.
  *
  * Identifier alphabet: A-Z, a-z, 0-9, `_`, `$`, `.`.  This matches
  * Apple's C / Obj-C symbol mangling (e.g. `'_OBJC_CLASS_$_NSString'`,
  * `'_pause$NOCANCEL'`).  Tokens may be surrounded by single or double
  * quotes — the scanner doesn't see those, since they aren't in the
  * identifier alphabet, so a token like `'_pause$NOCANCEL'` matches as
  * just `_pause$NOCANCEL`. */
 
 #include <string.h>
 
 #include "core/heap.h"
 #include "core/pool.h"
 #include "core/slice.h"
 #include "obj/obj.h"
 
 static int is_id_start(u8 c) { return c == '_'; }
 static int is_id_cont(u8 c) {
   return (c == '_') || (c == '$') || (c == '.') || (c >= 'A' && c <= 'Z') ||
          (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9');
 }
 
 /* Extract the install-name from the first document.  We look for a
  * line beginning with "install-name:" and take the value up to EOL,
  * then strip whitespace and surrounding quotes.  Returns 0 if absent. */
 static Sym extract_install_name(Compiler* c, const u8* data, size_t len) {
   static const char KEY[] = "install-name:";
   size_t klen = sizeof(KEY) - 1u;
   for (size_t i = 0; i + klen <= len; ++i) {
     /* Match at start of line (i==0 or preceded by '\n'). */
     if (i > 0 && data[i - 1] != '\n') continue;
     if (memcmp(data + i, KEY, klen) != 0) continue;
     /* Skip past the colon and surrounding whitespace. */
     size_t j = i + klen;
     while (j < len && (data[j] == ' ' || data[j] == '\t')) ++j;
     /* Take to EOL. */
     size_t start = j;
     while (j < len && data[j] != '\n' && data[j] != '\r') ++j;
     size_t end = j;
     /* Strip trailing whitespace. */
     while (end > start && (data[end - 1] == ' ' || data[end - 1] == '\t' ||
                            data[end - 1] == '\r'))
       --end;
     /* Strip surrounding single or double quotes. */
     if (end > start + 1u && (data[start] == '\'' || data[start] == '"') &&
         data[end - 1] == data[start]) {
       ++start;
       --end;
     }
     if (end > start)
       return pool_intern_slice(
           c->global,
           (Slice){.s = (const char*)(data + start), .len = (u32)(end - start)});
     return 0;
   }
   return 0;
 }
 
 ObjBuilder* read_tbd(Compiler* c, const char* name, const u8* data, size_t len,
                      Sym* install_name_out) {
   (void)name;
   if (install_name_out) *install_name_out = 0;
   if (!data || !len) compiler_panic(c, SRCLOC_NONE, "read_tbd: empty input");
 
   /* Validate magic: a tbd starts with `--- !tapi-tbd` (or any `---`). */
   if (len < 4 || data[0] != '-' || data[1] != '-' || data[2] != '-')
     compiler_panic(c, SRCLOC_NONE, "read_tbd: not a tbd file (missing '---')");
 
   /* Reject obviously-wrong target arches up front so we don't stream a
    * bunch of irrelevant symbols in. */
   switch (c->target.arch) {
     case KIT_ARCH_ARM_64:
     case KIT_ARCH_X86_64:
       break;
     default:
       compiler_panic(c, SRCLOC_NONE,
                      "read_tbd: unsupported target arch %u for tbd lookup",
                      (u32)c->target.arch);
   }
 
   ObjBuilder* ob = obj_new(c);
   if (!ob) compiler_panic(c, SRCLOC_NONE, "read_tbd: obj_new failed");
 
   if (install_name_out) *install_name_out = extract_install_name(c, data, len);
 
   /* Token scanner: walk the file, emit every `_id` token as a defined
    * external ObjSymbol.  Tracking already-seen names via a tiny linear
    * dedup list would be linear-quadratic on a multi-MB tbd; instead we
    * rely on the pool's intern de-dup downstream — duplicate ObjSymbol
    * names are tolerated by the linker's hash, with the second insert
    * resolving to the existing entry on collision. */
   size_t i = 0;
   while (i < len) {
     /* Skip non-token bytes. */
     while (i < len && !is_id_start(data[i])) ++i;
     if (i >= len) break;
     size_t start = i;
     while (i < len && is_id_cont(data[i])) ++i;
     size_t tlen = i - start;
     if (tlen == 0) continue;
     /* Filter out the obvious YAML-key-like collisions: tokens that are
      * field names ("_macos" doesn't occur, but be defensive).  All
      * Apple symbols start with `_` followed by another id char, so we
      * keep tokens of length >= 2.  Single `_` is the throwaway-name
      * convention and never an exported symbol. */
     if (tlen < 2u) continue;
     Sym sn = pool_intern_slice(
         c->global, (Slice){.s = (const char*)(data + start), .len = (u32)tlen});
     obj_symbol_ex(ob, sn, SB_GLOBAL, SV_DEFAULT, SK_NOTYPE, OBJ_SEC_NONE, 0, 0,
                   0);
   }
 
   obj_finalize(ob);
   return ob;
 }