kit

link_flags.c (30220B)

---

 #include "link_flags.h"
 
 #include <string.h>
 
 static int lf_tok_eq(const char* tok, size_t n, const char* lit) {
   size_t ln = driver_strlen(lit);
   return n == ln && driver_strneq(tok, lit, ln);
 }
 
 static int lf_tok_prefix(const char* tok, size_t n, const char* lit) {
   size_t ln = driver_strlen(lit);
   return n >= ln && driver_strneq(tok, lit, ln);
 }
 
 static int lf_grow_rpaths(DriverLinkFlags* lf) {
   uint32_t old_cap = lf->cap_rpaths;
   uint32_t new_cap = old_cap ? old_cap * 2u : 8u;
   const char** nr;
   if (new_cap <= old_cap) return 1;
   nr =
       (const char**)driver_alloc_zeroed(lf->env, (size_t)new_cap * sizeof(*nr));
   if (!nr) return 1;
   if (lf->rpaths) {
     driver_memcpy(nr, lf->rpaths, (size_t)lf->nrpaths * sizeof(*lf->rpaths));
     driver_free(lf->env, lf->rpaths, (size_t)old_cap * sizeof(*lf->rpaths));
   }
   lf->rpaths = nr;
   lf->cap_rpaths = new_cap;
   return 0;
 }
 
 static int lf_grow_owned(DriverLinkFlags* lf) {
   uint32_t old_cap = lf->cap_owned_strings;
   uint32_t new_cap = old_cap ? old_cap * 2u : 8u;
   char** ns;
   size_t* nsz;
   if (new_cap <= old_cap) return 1;
   ns = (char**)driver_alloc_zeroed(lf->env, (size_t)new_cap * sizeof(*ns));
   nsz = (size_t*)driver_alloc_zeroed(lf->env, (size_t)new_cap * sizeof(*nsz));
   if (!ns || !nsz) {
     if (ns) driver_free(lf->env, ns, (size_t)new_cap * sizeof(*ns));
     if (nsz) driver_free(lf->env, nsz, (size_t)new_cap * sizeof(*nsz));
     return 1;
   }
   if (lf->owned_strings) {
     driver_memcpy(ns, lf->owned_strings,
                   (size_t)lf->nowned_strings * sizeof(*lf->owned_strings));
     driver_free(lf->env, lf->owned_strings,
                 (size_t)old_cap * sizeof(*lf->owned_strings));
   }
   if (lf->owned_string_sizes) {
     driver_memcpy(nsz, lf->owned_string_sizes,
                   (size_t)lf->nowned_strings * sizeof(*lf->owned_string_sizes));
     driver_free(lf->env, lf->owned_string_sizes,
                 (size_t)old_cap * sizeof(*lf->owned_string_sizes));
   }
   lf->owned_strings = ns;
   lf->owned_string_sizes = nsz;
   lf->cap_owned_strings = new_cap;
   return 0;
 }
 
 static int lf_take_owned(DriverLinkFlags* lf, char* s, size_t n) {
   if (lf->nowned_strings >= lf->cap_owned_strings && lf_grow_owned(lf) != 0)
     return 1;
   lf->owned_strings[lf->nowned_strings] = s;
   lf->owned_string_sizes[lf->nowned_strings] = n;
   lf->nowned_strings++;
   return 0;
 }
 
 static char* lf_dup_owned(DriverLinkFlags* lf, const char* s, size_t n) {
   size_t bytes = n + 1u;
   char* buf;
   if (bytes == 0) return NULL;
   buf = (char*)driver_alloc(lf->env, bytes);
   if (!buf) return NULL;
   driver_memcpy(buf, s, n);
   buf[n] = '\0';
   if (lf_take_owned(lf, buf, bytes) != 0) {
     driver_free(lf->env, buf, bytes);
     return NULL;
   }
   return buf;
 }
 
 static void lf_free_build_id(DriverLinkFlags* lf) {
   if (lf->build_id_bytes) {
     driver_free(lf->env, lf->build_id_bytes, lf->build_id_size);
     lf->build_id_bytes = NULL;
     lf->build_id_len = 0;
     lf->build_id_size = 0;
   }
 }
 
 static int lf_parse_hex_bytes(DriverLinkFlags* lf, const char* s, size_t n,
                               uint8_t** out_bytes, uint32_t* out_len,
                               size_t* out_size) {
   uint8_t* bs;
   size_t i;
   if (n == 0 || (n & 1u) || n / 2u > UINT32_MAX) return 1;
   bs = (uint8_t*)driver_alloc(lf->env, n / 2u);
   if (!bs) return 1;
   for (i = 0; i < n; i += 2u) {
     int hi = driver_hex_nibble(s[i]);
     int lo = driver_hex_nibble(s[i + 1u]);
     if (hi < 0 || lo < 0) {
       driver_free(lf->env, bs, n / 2u);
       return 1;
     }
     bs[i / 2u] = (uint8_t)((hi << 4) | lo);
   }
   *out_bytes = bs;
   *out_len = (uint32_t)(n / 2u);
   *out_size = n / 2u;
   return 0;
 }
 
 static int lf_record_build_id_span(DriverLinkFlags* lf, const char* val,
                                    size_t n) {
   if (n == 4 && driver_strneq(val, "none", 4)) {
     lf_free_build_id(lf);
     lf->build_id_mode = KIT_BUILDID_NONE;
     return 0;
   }
   if (n == 6 && driver_strneq(val, "sha256", 6)) {
     lf_free_build_id(lf);
     lf->build_id_mode = KIT_BUILDID_SHA256;
     return 0;
   }
   if (n == 4 && driver_strneq(val, "uuid", 4)) {
     lf_free_build_id(lf);
     lf->build_id_mode = KIT_BUILDID_UUID;
     return 0;
   }
   if (n >= 2 && driver_strneq(val, "0x", 2)) {
     uint8_t* bytes = NULL;
     uint32_t len = 0;
     size_t size = 0;
     if (lf_parse_hex_bytes(lf, val + 2, n - 2u, &bytes, &len, &size) != 0) {
       driver_errf(lf->tool,
                   "--build-id=0x... requires an even-length hex string");
       return 1;
     }
     lf_free_build_id(lf);
     lf->build_id_bytes = bytes;
     lf->build_id_len = len;
     lf->build_id_size = size;
     lf->build_id_mode = KIT_BUILDID_USER;
     return 0;
   }
   driver_errf(lf->tool, "unknown --build-id value: %.*s", (int)n, val);
   return 1;
 }
 
 static int lf_record_rpath(DriverLinkFlags* lf, const char* s, size_t n) {
   char* buf;
   if (lf->nrpaths >= lf->cap_rpaths && lf_grow_rpaths(lf) != 0) {
     driver_errf(lf->tool, "out of memory");
     return 1;
   }
   buf = lf_dup_owned(lf, s, n);
   if (!buf) {
     driver_errf(lf->tool, "out of memory");
     return 1;
   }
   lf->rpaths[lf->nrpaths++] = buf;
   return 0;
 }
 
 static int lf_record_soname(DriverLinkFlags* lf, const char* s, size_t n) {
   char* buf = lf_dup_owned(lf, s, n);
   if (!buf) {
     driver_errf(lf->tool, "out of memory");
     return 1;
   }
   lf->soname = buf;
   return 0;
 }
 
 static int lf_record_interp(DriverLinkFlags* lf, const char* s, size_t n) {
   char* buf = lf_dup_owned(lf, s, n);
   if (!buf) {
     driver_errf(lf->tool, "out of memory");
     return 1;
   }
   lf->interp_path = buf;
   return 0;
 }
 
 int driver_link_flags_record_entry(DriverLinkFlags* lf, const char* val,
                                    size_t n) {
   char* buf;
   if (!val || n == 0) {
     driver_errf(lf->tool, "--entry requires a non-empty symbol");
     return 1;
   }
   buf = lf_dup_owned(lf, val, n);
   if (!buf) {
     driver_errf(lf->tool, "out of memory");
     return 1;
   }
   lf->entry = buf;
   return 0;
 }
 
 int driver_link_flags_record_script(DriverLinkFlags* lf, const char* val,
                                     size_t n) {
   char* buf;
   if (!val || n == 0) {
     driver_errf(lf->tool, "--script requires a non-empty path");
     return 1;
   }
   buf = lf_dup_owned(lf, val, n);
   if (!buf) {
     driver_errf(lf->tool, "out of memory");
     return 1;
   }
   lf->linker_script = buf;
   return 0;
 }
 
 int driver_link_flags_record_map(DriverLinkFlags* lf, const char* val,
                                  size_t n) {
   char* buf;
   if (!val || n == 0) {
     driver_errf(lf->tool, "--map requires a non-empty path");
     return 1;
   }
   buf = lf_dup_owned(lf, val, n);
   if (!buf) {
     driver_errf(lf->tool, "out of memory");
     return 1;
   }
   lf->map_path = buf;
   return 0;
 }
 
 int driver_link_flags_record_symbols(DriverLinkFlags* lf, const char* val,
                                      size_t n) {
   char* buf;
   if (!val || n == 0) {
     driver_errf(lf->tool, "--symbols requires a non-empty path");
     return 1;
   }
   buf = lf_dup_owned(lf, val, n);
   if (!buf) {
     driver_errf(lf->tool, "out of memory");
     return 1;
   }
   lf->symbols_path = buf;
   return 0;
 }
 
 int driver_link_flags_record_symbols_format(DriverLinkFlags* lf,
                                             const char* val, size_t n) {
   if (n == 2 && driver_strneq(val, "nm", 2)) {
     lf->symbols_format = KIT_LINK_SYMBOLS_NM;
     return 0;
   }
   driver_errf(lf->tool, "unsupported --symbols-format: %.*s", (int)n, val);
   return 1;
 }
 
 int driver_link_flags_record_text_base(DriverLinkFlags* lf, const char* val) {
   uint64_t v;
   if (!val || driver_parse_u64(val, &v) != 0) {
     driver_errf(lf->tool, "-Ttext: invalid address: %s", val ? val : "");
     return 1;
   }
   lf->text_base = v;
   lf->text_base_set = 1;
   return 0;
 }
 
 /* Is this span a numeric (hex/dec) literal, or a symbol name? Used to decide
  * the --defsym RHS form. A literal starts with a digit (0x.. or decimal). */
 static int lf_span_is_number(const char* s, size_t n) {
   if (n == 0) return 0;
   return s[0] >= '0' && s[0] <= '9';
 }
 
 /* Parse a possibly-NUL-unterminated numeric span as u64. */
 static int lf_parse_u64_span(DriverLinkFlags* lf, const char* s, size_t n,
                              uint64_t* out) {
   char* buf = lf_dup_owned(lf, s, n);
   if (!buf) {
     driver_errf(lf->tool, "out of memory");
     return 1;
   }
   return driver_parse_u64(buf, out);
 }
 
 static int lf_grow_defsyms(DriverLinkFlags* lf) {
   uint32_t old_cap = lf->cap_defsyms;
   uint32_t new_cap = old_cap ? old_cap * 2u : 4u;
   KitLinkDefsym* nd;
   if (new_cap <= old_cap) return 1;
   nd = (KitLinkDefsym*)driver_alloc_zeroed(lf->env,
                                            (size_t)new_cap * sizeof(*nd));
   if (!nd) return 1;
   if (lf->defsyms) {
     driver_memcpy(nd, lf->defsyms, (size_t)lf->ndefsyms * sizeof(*lf->defsyms));
     driver_free(lf->env, lf->defsyms, (size_t)old_cap * sizeof(*lf->defsyms));
   }
   lf->defsyms = nd;
   lf->cap_defsyms = new_cap;
   return 0;
 }
 
 static int lf_grow_section_starts(DriverLinkFlags* lf) {
   uint32_t old_cap = lf->cap_section_starts;
   uint32_t new_cap = old_cap ? old_cap * 2u : 4u;
   KitLinkSectionStart* ns;
   if (new_cap <= old_cap) return 1;
   ns = (KitLinkSectionStart*)driver_alloc_zeroed(
       lf->env, (size_t)new_cap * sizeof(*ns));
   if (!ns) return 1;
   if (lf->section_starts) {
     driver_memcpy(ns, lf->section_starts,
                   (size_t)lf->nsection_starts * sizeof(*lf->section_starts));
     driver_free(lf->env, lf->section_starts,
                 (size_t)old_cap * sizeof(*lf->section_starts));
   }
   lf->section_starts = ns;
   lf->cap_section_starts = new_cap;
   return 0;
 }
 
 int driver_link_flags_record_defsym(DriverLinkFlags* lf, const char* val,
                                     size_t n) {
   size_t eq = 0;
   const char* name;
   size_t name_len;
   const char* rhs;
   size_t rhs_len;
   KitLinkDefsym* d;
   char* name_buf;
   while (eq < n && val[eq] != '=') ++eq;
   if (eq == 0 || eq >= n) {
     driver_errf(lf->tool, "--defsym requires NAME=EXPR: %.*s", (int)n, val);
     return 1;
   }
   name = val;
   name_len = eq;
   rhs = val + eq + 1u;
   rhs_len = n - eq - 1u;
   if (rhs_len == 0) {
     driver_errf(lf->tool, "--defsym requires a value: %.*s", (int)n, val);
     return 1;
   }
   if (lf->ndefsyms >= lf->cap_defsyms && lf_grow_defsyms(lf) != 0) {
     driver_errf(lf->tool, "out of memory");
     return 1;
   }
   name_buf = lf_dup_owned(lf, name, name_len);
   if (!name_buf) {
     driver_errf(lf->tool, "out of memory");
     return 1;
   }
   d = &lf->defsyms[lf->ndefsyms];
   memset(d, 0, sizeof(*d));
   d->name = kit_slice_cstr(name_buf);
   if (lf_span_is_number(rhs, rhs_len)) {
     uint64_t v;
     if (lf_parse_u64_span(lf, rhs, rhs_len, &v) != 0) {
       driver_errf(lf->tool, "--defsym: invalid value: %.*s", (int)rhs_len, rhs);
       return 1;
     }
     d->value = v;
   } else {
     char* alias_buf = lf_dup_owned(lf, rhs, rhs_len);
     if (!alias_buf) {
       driver_errf(lf->tool, "out of memory");
       return 1;
     }
     d->alias = kit_slice_cstr(alias_buf);
     d->value = 0;
   }
   lf->ndefsyms++;
   return 0;
 }
 
 int driver_link_flags_record_section_addr(DriverLinkFlags* lf,
                                           const char* secname,
                                           const char* addr) {
   uint64_t v;
   KitLinkSectionStart* ss;
   char* name_buf;
   if (!secname || !*secname || !addr || !*addr) {
     driver_errf(lf->tool, "--section-start requires .NAME=ADDR");
     return 1;
   }
   if (driver_parse_u64(addr, &v) != 0) {
     driver_errf(lf->tool, "--section-start: invalid address: %s", addr);
     return 1;
   }
   if (lf->nsection_starts >= lf->cap_section_starts &&
       lf_grow_section_starts(lf) != 0) {
     driver_errf(lf->tool, "out of memory");
     return 1;
   }
   name_buf = lf_dup_owned(lf, secname, driver_strlen(secname));
   if (!name_buf) {
     driver_errf(lf->tool, "out of memory");
     return 1;
   }
   ss = &lf->section_starts[lf->nsection_starts];
   memset(ss, 0, sizeof(*ss));
   ss->name = kit_slice_cstr(name_buf);
   ss->addr = v;
   lf->nsection_starts++;
   return 0;
 }
 
 int driver_link_flags_record_section_start(DriverLinkFlags* lf, const char* val,
                                            size_t n) {
   /* --section-start=.NAME=ADDR — split on the LAST '='. */
   size_t eq = n;
   size_t i;
   char* name_buf;
   char* addr_buf;
   int rc;
   for (i = 0; i < n; ++i)
     if (val[i] == '=') eq = i;
   if (eq == n || eq == 0) {
     driver_errf(lf->tool, "--section-start requires .NAME=ADDR: %.*s", (int)n,
                 val);
     return 1;
   }
   name_buf = lf_dup_owned(lf, val, eq);
   addr_buf = lf_dup_owned(lf, val + eq + 1u, n - eq - 1u);
   if (!name_buf || !addr_buf) {
     driver_errf(lf->tool, "out of memory");
     return 1;
   }
   rc = driver_link_flags_record_section_addr(lf, name_buf, addr_buf);
   return rc;
 }
 
 int driver_link_flags_record_orphan_handling(DriverLinkFlags* lf,
                                              const char* val, size_t n) {
   if (lf_tok_eq(val, n, "place")) {
     lf->orphan_handling = KIT_LINK_ORPHAN_PLACE;
     return 0;
   }
   if (lf_tok_eq(val, n, "warn")) {
     lf->orphan_handling = KIT_LINK_ORPHAN_WARN;
     return 0;
   }
   if (lf_tok_eq(val, n, "error")) {
     lf->orphan_handling = KIT_LINK_ORPHAN_ERROR;
     return 0;
   }
   if (lf_tok_eq(val, n, "discard")) {
     lf->orphan_handling = KIT_LINK_ORPHAN_DISCARD;
     return 0;
   }
   driver_errf(lf->tool, "unsupported --orphan-handling: %.*s", (int)n, val);
   return 1;
 }
 
 int driver_link_flags_record_cref(DriverLinkFlags* lf, const char* val,
                                   size_t n) {
   char* buf;
   if (!val || n == 0) {
     driver_errf(lf->tool, "--cref requires a non-empty path");
     return 1;
   }
   buf = lf_dup_owned(lf, val, n);
   if (!buf) {
     driver_errf(lf->tool, "out of memory");
     return 1;
   }
   lf->cref_path = buf;
   return 0;
 }
 
 int driver_link_flags_record_z(DriverLinkFlags* lf, const char* val, size_t n) {
   if (lf_tok_eq(val, n, "defs")) {
     lf->allow_undefined = 0;
     return 0;
   }
   if (lf_tok_eq(val, n, "nodefs")) {
     lf->allow_undefined = 1;
     return 0;
   }
   if (lf_tok_eq(val, n, "noexecstack") || lf_tok_eq(val, n, "relro") ||
       lf_tok_eq(val, n, "now") || lf_tok_eq(val, n, "text")) {
     return 0;
   }
   driver_errf(lf->tool, "unsupported -z option: %.*s", (int)n, val);
   return 1;
 }
 
 static int lf_subsystem_eq(const char* val, size_t n, const char* want) {
   size_t i;
   for (i = 0; want[i]; ++i) {
     char a;
     char b;
     if (i >= n) return 0;
     a = val[i];
     b = want[i];
     if (a >= 'a' && a <= 'z') a = (char)(a - 'a' + 'A');
     if (b >= 'a' && b <= 'z') b = (char)(b - 'a' + 'A');
     if (a != b) return 0;
   }
   return i == n || val[i] == ',';
 }
 
 int driver_link_flags_init(DriverLinkFlags* lf, DriverEnv* env,
                            const char* tool, uint32_t initial_cap) {
   uint32_t cap = initial_cap ? initial_cap : 8u;
   memset(lf, 0, sizeof(*lf));
   lf->env = env;
   lf->tool = tool;
   lf->new_dtags = 1;
   lf->cap_rpaths = cap;
   lf->cap_owned_strings = cap;
   lf->rpaths =
       (const char**)driver_alloc_zeroed(env, (size_t)cap * sizeof(*lf->rpaths));
   lf->owned_strings = (char**)driver_alloc_zeroed(
       env, (size_t)cap * sizeof(*lf->owned_strings));
   lf->owned_string_sizes = (size_t*)driver_alloc_zeroed(
       env, (size_t)cap * sizeof(*lf->owned_string_sizes));
   if (!lf->rpaths || !lf->owned_strings || !lf->owned_string_sizes) {
     driver_link_flags_fini(lf);
     return 1;
   }
   return 0;
 }
 
 void driver_link_flags_fini(DriverLinkFlags* lf) {
   uint32_t i;
   if (!lf || !lf->env) return;
   for (i = 0; i < lf->nowned_strings; ++i) {
     if (lf->owned_strings[i])
       driver_free(lf->env, lf->owned_strings[i], lf->owned_string_sizes[i]);
   }
   lf_free_build_id(lf);
   if (lf->rpaths)
     driver_free(lf->env, lf->rpaths,
                 (size_t)lf->cap_rpaths * sizeof(*lf->rpaths));
   if (lf->owned_strings)
     driver_free(lf->env, lf->owned_strings,
                 (size_t)lf->cap_owned_strings * sizeof(*lf->owned_strings));
   if (lf->owned_string_sizes)
     driver_free(
         lf->env, lf->owned_string_sizes,
         (size_t)lf->cap_owned_strings * sizeof(*lf->owned_string_sizes));
   if (lf->defsyms)
     driver_free(lf->env, lf->defsyms,
                 (size_t)lf->cap_defsyms * sizeof(*lf->defsyms));
   if (lf->section_starts)
     driver_free(lf->env, lf->section_starts,
                 (size_t)lf->cap_section_starts * sizeof(*lf->section_starts));
   memset(lf, 0, sizeof(*lf));
 }
 
 int driver_link_flags_record_build_id(DriverLinkFlags* lf, const char* val) {
   return lf_record_build_id_span(lf, val, driver_strlen(val));
 }
 
 int driver_link_flags_record_pe_subsystem(DriverLinkFlags* lf, const char* val,
                                           size_t n) {
   if (lf_subsystem_eq(val, n, "CONSOLE") || lf_subsystem_eq(val, n, "CUI")) {
     lf->pe_subsystem = KIT_PE_SUBSYSTEM_WINDOWS_CUI;
     return 0;
   }
   if (lf_subsystem_eq(val, n, "WINDOWS") || lf_subsystem_eq(val, n, "GUI")) {
     lf->pe_subsystem = KIT_PE_SUBSYSTEM_WINDOWS_GUI;
     return 0;
   }
   driver_errf(lf->tool, "unsupported subsystem: %.*s", (int)n, val);
   return 1;
 }
 
 int driver_link_flags_record_wl(DriverLinkFlags* lf, const char* arg) {
   const char* p = arg;
   int expect_rpath = 0;
   int expect_soname = 0;
   int expect_interp = 0;
   int expect_subsystem = 0;
   int expect_z = 0;
   int expect_map = 0;
   int expect_symbols = 0;
   int expect_ttext = 0;
   int expect_defsym = 0;
   int expect_section_start = 0;
   int expect_cref = 0;
   int expect_orphan = 0;
   int expect_entry = 0;
   int expect_script = 0;
   while (*p) {
     const char* tok = p;
     size_t n = 0;
     while (p[n] && p[n] != ',') ++n;
     p = tok + n + (tok[n] == ',' ? 1u : 0u);
 
     if (expect_rpath || expect_soname || expect_interp || expect_subsystem ||
         expect_z || expect_map || expect_symbols || expect_ttext ||
         expect_defsym || expect_section_start || expect_cref || expect_orphan ||
         expect_entry || expect_script) {
       int rc = 0;
       if (expect_rpath)
         rc = lf_record_rpath(lf, tok, n);
       else if (expect_soname)
         rc = lf_record_soname(lf, tok, n);
       else if (expect_interp)
         rc = lf_record_interp(lf, tok, n);
       else if (expect_subsystem)
         rc = driver_link_flags_record_pe_subsystem(lf, tok, n);
       else if (expect_z)
         rc = driver_link_flags_record_z(lf, tok, n);
       else if (expect_map)
         rc = driver_link_flags_record_map(lf, tok, n);
       else if (expect_symbols)
         rc = driver_link_flags_record_symbols(lf, tok, n);
       else if (expect_defsym)
         rc = driver_link_flags_record_defsym(lf, tok, n);
       else if (expect_section_start)
         rc = driver_link_flags_record_section_start(lf, tok, n);
       else if (expect_cref)
         rc = driver_link_flags_record_cref(lf, tok, n);
       else if (expect_orphan)
         rc = driver_link_flags_record_orphan_handling(lf, tok, n);
       else if (expect_entry)
         rc = driver_link_flags_record_entry(lf, tok, n);
       else if (expect_script)
         rc = driver_link_flags_record_script(lf, tok, n);
       else if (expect_ttext) {
         char* buf = lf_dup_owned(lf, tok, n);
         if (!buf) {
           driver_errf(lf->tool, "out of memory");
           return 1;
         }
         rc = driver_link_flags_record_text_base(lf, buf);
       }
       if (rc != 0) return 1;
       expect_rpath = expect_soname = expect_interp = expect_subsystem =
           expect_z = expect_map = expect_symbols = expect_ttext =
               expect_defsym = expect_section_start = expect_cref =
                   expect_orphan = expect_entry = expect_script = 0;
       continue;
     }
 
     if (lf_tok_eq(tok, n, "-e") || lf_tok_eq(tok, n, "--entry")) {
       expect_entry = 1;
       continue;
     }
     if (lf_tok_prefix(tok, n, "--entry=")) {
       if (driver_link_flags_record_entry(lf, tok + 8, n - 8u) != 0) return 1;
       continue;
     }
     if (n > 2 && tok[0] == '-' && tok[1] == 'e') {
       if (driver_link_flags_record_entry(lf, tok + 2, n - 2u) != 0) return 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "-T") || lf_tok_eq(tok, n, "--script")) {
       expect_script = 1;
       continue;
     }
     if (lf_tok_prefix(tok, n, "--script=")) {
       if (driver_link_flags_record_script(lf, tok + 9, n - 9u) != 0) return 1;
       continue;
     }
     if (n > 2 && tok[0] == '-' && tok[1] == 'T' &&
         !lf_tok_prefix(tok, n, "-Ttext") &&
         !lf_tok_prefix(tok, n, "-Tdata") &&
         !lf_tok_prefix(tok, n, "-Tbss")) {
       if (driver_link_flags_record_script(lf, tok + 2, n - 2u) != 0) return 1;
       continue;
     }
 
     if (lf_tok_prefix(tok, n, "-soname=")) {
       if (lf_record_soname(lf, tok + 8, n - 8u) != 0) return 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "-soname")) {
       expect_soname = 1;
       continue;
     }
     if (lf_tok_prefix(tok, n, "-rpath=")) {
       if (lf_record_rpath(lf, tok + 7, n - 7u) != 0) return 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "-rpath")) {
       expect_rpath = 1;
       continue;
     }
     if (lf_tok_prefix(tok, n, "-dynamic-linker=")) {
       if (lf_record_interp(lf, tok + 16, n - 16u) != 0) return 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "-dynamic-linker")) {
       expect_interp = 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "--enable-new-dtags")) {
       lf->new_dtags = 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "--disable-new-dtags")) {
       lf->new_dtags = 0;
       continue;
     }
     if (lf_tok_eq(tok, n, "--gc-sections")) {
       lf->gc_sections = 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "--no-gc-sections")) {
       lf->gc_sections = 0;
       continue;
     }
     if (lf_tok_eq(tok, n, "-S") || lf_tok_eq(tok, n, "--strip-debug")) {
       lf->strip_debug = 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "--no-undefined")) {
       lf->allow_undefined = 0;
       continue;
     }
     if (lf_tok_eq(tok, n, "--allow-undefined") ||
         lf_tok_eq(tok, n, "--allow-shlib-undefined")) {
       lf->allow_undefined = 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "-z")) {
       expect_z = 1;
       continue;
     }
     if (n > 2 && tok[0] == '-' && tok[1] == 'z') {
       if (driver_link_flags_record_z(lf, tok + 2, n - 2u) != 0) return 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "-Ttext")) {
       expect_ttext = 1;
       continue;
     }
     if (lf_tok_prefix(tok, n, "-Ttext=")) {
       char* buf = lf_dup_owned(lf, tok + 7, n - 7u);
       if (!buf) {
         driver_errf(lf->tool, "out of memory");
         return 1;
       }
       if (driver_link_flags_record_text_base(lf, buf) != 0) return 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "--map") || lf_tok_eq(tok, n, "-Map")) {
       expect_map = 1;
       continue;
     }
     if (lf_tok_prefix(tok, n, "--map=")) {
       if (driver_link_flags_record_map(lf, tok + 6, n - 6u) != 0) return 1;
       continue;
     }
     if (lf_tok_prefix(tok, n, "-Map=")) {
       if (driver_link_flags_record_map(lf, tok + 5, n - 5u) != 0) return 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "--symbols")) {
       expect_symbols = 1;
       continue;
     }
     if (lf_tok_prefix(tok, n, "--symbols=")) {
       if (driver_link_flags_record_symbols(lf, tok + 10, n - 10u) != 0)
         return 1;
       continue;
     }
     if (lf_tok_prefix(tok, n, "--symbols-format=")) {
       if (driver_link_flags_record_symbols_format(lf, tok + 17, n - 17u) != 0)
         return 1;
       continue;
     }
     if (lf_tok_prefix(tok, n, "--build-id=")) {
       if (lf_record_build_id_span(lf, tok + 11, n - 11u) != 0) return 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "--build-id")) {
       lf_free_build_id(lf);
       lf->build_id_mode = KIT_BUILDID_SHA256;
       continue;
     }
     if (lf_tok_prefix(tok, n, "--subsystem=")) {
       if (driver_link_flags_record_pe_subsystem(lf, tok + 12, n - 12u) != 0)
         return 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "--subsystem")) {
       expect_subsystem = 1;
       continue;
     }
     if (lf_tok_prefix(tok, n, "/SUBSYSTEM:")) {
       if (driver_link_flags_record_pe_subsystem(lf, tok + 11, n - 11u) != 0)
         return 1;
       continue;
     }
     /* -Tdata / -Tbss: section base overrides, folded into section_starts. */
     if (lf_tok_eq(tok, n, "-Tdata") || lf_tok_eq(tok, n, "-Tbss")) {
       /* The next comma token is the address. Reuse the section-start consume
        * via a synthesized ".data=ADDR" / ".bss=ADDR" on the following token;
        * simplest is a dedicated tiny state, but section_start expects NAME=ADDR.
        * Stash the chosen section name and read the address as a fresh token. */
       const char* secname = lf_tok_eq(tok, n, "-Tdata") ? ".data" : ".bss";
       const char* atok = p;
       size_t an = 0;
       char* addr_buf;
       if (!*atok) {
         driver_errf(lf->tool, "%.*s requires an address", (int)n, tok);
         return 1;
       }
       while (atok[an] && atok[an] != ',') ++an;
       p = atok + an + (atok[an] == ',' ? 1u : 0u);
       addr_buf = lf_dup_owned(lf, atok, an);
       if (!addr_buf) {
         driver_errf(lf->tool, "out of memory");
         return 1;
       }
       if (driver_link_flags_record_section_addr(lf, secname, addr_buf) != 0)
         return 1;
       continue;
     }
     if (lf_tok_prefix(tok, n, "-Tdata=")) {
       char* addr_buf = lf_dup_owned(lf, tok + 7, n - 7u);
       if (!addr_buf) {
         driver_errf(lf->tool, "out of memory");
         return 1;
       }
       if (driver_link_flags_record_section_addr(lf, ".data", addr_buf) != 0)
         return 1;
       continue;
     }
     if (lf_tok_prefix(tok, n, "-Tbss=")) {
       char* addr_buf = lf_dup_owned(lf, tok + 6, n - 6u);
       if (!addr_buf) {
         driver_errf(lf->tool, "out of memory");
         return 1;
       }
       if (driver_link_flags_record_section_addr(lf, ".bss", addr_buf) != 0)
         return 1;
       continue;
     }
     /* --defsym NAME=EXPR */
     if (lf_tok_prefix(tok, n, "--defsym=")) {
       if (driver_link_flags_record_defsym(lf, tok + 9, n - 9u) != 0) return 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "--defsym")) {
       expect_defsym = 1;
       continue;
     }
     /* --section-start=.NAME=ADDR */
     if (lf_tok_prefix(tok, n, "--section-start=")) {
       if (driver_link_flags_record_section_start(lf, tok + 16, n - 16u) != 0)
         return 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "--section-start")) {
       expect_section_start = 1;
       continue;
     }
     /* --cref [FILE] */
     if (lf_tok_prefix(tok, n, "--cref=")) {
       if (driver_link_flags_record_cref(lf, tok + 7, n - 7u) != 0) return 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "--cref")) {
       expect_cref = 1;
       continue;
     }
     /* --orphan-handling=MODE */
     if (lf_tok_prefix(tok, n, "--orphan-handling=")) {
       if (driver_link_flags_record_orphan_handling(lf, tok + 18, n - 18u) != 0)
         return 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "--orphan-handling")) {
       expect_orphan = 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "--fatal-warnings")) {
       lf->fatal_warnings = 1;
       continue;
     }
     if (lf_tok_eq(tok, n, "--no-fatal-warnings")) {
       lf->fatal_warnings = 0;
       continue;
     }
     if (lf_tok_eq(tok, n, "--print-memory-usage")) {
       lf->print_memory_usage = 1;
       continue;
     }
 
     driver_errf(lf->tool, "unsupported -Wl, token: %.*s", (int)n, tok);
     return 1;
   }
   if (expect_rpath || expect_soname || expect_interp || expect_subsystem ||
       expect_z || expect_map || expect_symbols || expect_ttext ||
       expect_defsym || expect_section_start || expect_cref || expect_orphan ||
       expect_entry || expect_script) {
     driver_errf(lf->tool, "-Wl option requires another comma argument");
     return 1;
   }
   return 0;
 }
 
 int driver_link_flags_fill_options(const DriverLinkFlags* lf,
                                    KitTargetSpec target, int explicit_pie,
                                    int shared, int relocatable,
                                    uint8_t output_kind,
                                    const KitLinkScript* script,
                                    KitLinkSessionOptions* lopts,
                                    KitSlice** rpath_slices_out) {
   KitSlice* rpath_slices = NULL;
   uint32_t i;
   *rpath_slices_out = NULL;
   if (lf->nrpaths) {
     rpath_slices = (KitSlice*)driver_alloc_zeroed(
         lf->env, (size_t)lf->nrpaths * sizeof(*rpath_slices));
     if (!rpath_slices) {
       driver_errf(lf->tool, "out of memory");
       return 1;
     }
     for (i = 0; i < lf->nrpaths; ++i)
       rpath_slices[i] = kit_slice_cstr(lf->rpaths[i]);
   }
   memset(lopts, 0, sizeof(*lopts));
   lopts->output_kind = output_kind;
   lopts->entry = kit_slice_cstr(lf->entry);
   lopts->linker_script = script;
   lopts->build_id_mode = lf->build_id_mode;
   lopts->build_id_bytes = lf->build_id_bytes;
   lopts->build_id_len = lf->build_id_len;
   lopts->gc_sections = lf->gc_sections != 0;
   lopts->strip_debug = lf->strip_debug != 0;
   lopts->text_base_set = lf->text_base_set != 0;
   lopts->text_base = lf->text_base;
   lopts->defsyms = lf->defsyms;
   lopts->ndefsyms = lf->ndefsyms;
   lopts->section_starts = lf->section_starts;
   lopts->nsection_starts = lf->nsection_starts;
   lopts->orphan_handling = lf->orphan_handling;
   lopts->fatal_warnings = lf->fatal_warnings != 0;
   lopts->pie = driver_link_pie(target, explicit_pie, shared, relocatable) != 0;
   lopts->pe_subsystem = lf->pe_subsystem;
   lopts->interp_path = kit_slice_cstr(lf->interp_path);
   lopts->soname = kit_slice_cstr(lf->soname);
   if (lf->new_dtags) {
     lopts->runpaths = rpath_slices;
     lopts->nrunpaths = lf->nrpaths;
   } else {
     lopts->rpaths = rpath_slices;
     lopts->nrpaths = lf->nrpaths;
   }
   lopts->allow_undefined = lf->allow_undefined != 0;
   *rpath_slices_out = rpath_slices;
   return 0;
 }
 
 void driver_link_flags_free_rpath_slices(const DriverLinkFlags* lf,
                                          KitSlice* rpath_slices) {
   if (rpath_slices)
     driver_free(lf->env, rpath_slices,
                 (size_t)lf->nrpaths * sizeof(*rpath_slices));
 }