kit

strip.c (20180B)

---

 #include <kit/archive.h>
 #include <kit/core.h>
 #include <kit/object.h>
 #include <stdint.h>
 #include <string.h>
 
 #include "driver.h"
 #include "inputs.h"
 
 /* `kit strip` — drop debug sections and / or unwanted symbols from a
  * relocatable object or static archive, then write the result back. Scope
  * for the first cut matches the CTOOLCHAIN.md plan: relocatable .o and
  * .a inputs only — linked ELF (ET_EXEC / ET_DYN) is rejected.
  *
  * Operations (the last one wins; default is --strip-all):
  *   --strip-debug        drop sections whose kind is KIT_SEC_DEBUG
  *   --strip-unneeded     drop debug + symbols not referenced by any reloc
  *   --strip-all          drop debug + every non-essential symbol (default)
  *
  * Filters applied on top of the operation:
  *   --keep-symbol=NAME, -K NAME    keep NAME even if the operation would drop
  * it
  *   --strip-symbol=NAME, -N NAME   always drop NAME
  *
  * I/O:
  *   -o PATH              write output to PATH (else rewrite the input in place)
  */
 
 #define STRIP_TOOL "strip"
 
 void driver_help_strip(void) {
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "kit strip — drop debug sections and/or symbols\n"
           "\n"
           "USAGE\n"
           "  kit strip [OPTIONS] FILE\n"
           "\n"
           "OPERATIONS (last one wins; default is --strip-all)\n"
           "  --strip-debug         remove debug-info sections\n"
           "  --strip-unneeded      remove debug + symbols not needed by "
           "relocs\n"
           "  --strip-all           remove debug + all non-essential symbols\n"
           "\n"
           "SYMBOL FILTERS (may repeat)\n"
           "  --keep-symbol=NAME, -K NAME   keep NAME even when the operation\n"
           "                                would otherwise drop it\n"
           "  --strip-symbol=NAME, -N NAME  always drop NAME\n"
           "\n"
           "OUTPUT\n"
           "  -o PATH               write to PATH (default: rewrite FILE in "
           "place)\n"
           "\n"
           "INPUTS\n"
           "  FILE may be a relocatable .o or a static .a archive. Linked\n"
           "  executables / shared libraries are not supported yet.\n"
           "\n"
           "EXIT CODES\n"
           "  0   success           1   I/O or strip error           2   bad "
           "usage\n")));
 }
 
 typedef enum StripOp {
   STRIP_OP_DEBUG,
   STRIP_OP_UNNEEDED,
   STRIP_OP_ALL,
 } StripOp;
 
 typedef struct StripOpts {
   StripOp op;
   const char** keep;
   uint32_t nkeep;
   uint32_t cap_keep;
   const char** strip;
   uint32_t nstrip;
   uint32_t cap_strip;
   const char* output;
   const char* input;
 } StripOpts;
 
 static int name_in_list(KitSlice name, const char* const* list, uint32_t n) {
   uint32_t i;
   if (!name.len) return 0;
   for (i = 0; i < n; ++i) {
     if (list[i] && kit_slice_eq_cstr(name, list[i])) return 1;
   }
   return 0;
 }
 
 static int push_name(DriverEnv* env, const char*** arr, uint32_t* n,
                      uint32_t* cap, const char* name) {
   if (*n >= *cap) {
     uint32_t newcap = *cap ? *cap * 2u : 8u;
     const char** nb =
         (const char**)driver_alloc_zeroed(env, (size_t)newcap * sizeof(*nb));
     if (!nb) {
       driver_errf(STRIP_TOOL, "out of memory");
       return -1;
     }
     if (*arr) {
       memcpy(nb, *arr, (size_t)(*n) * sizeof(*nb));
       driver_free(env, (void*)*arr, (size_t)(*cap) * sizeof(*nb));
     }
     *arr = nb;
     *cap = newcap;
   }
   (*arr)[(*n)++] = name;
   return 0;
 }
 
 static int parse_name_arg(int* i, int argc, char** argv, const char* flag,
                           const char* short_flag, const char** out) {
   const char* a = argv[*i];
   size_t flen = kit_slice_cstr(flag).len;
   /* --flag=NAME ; prefix match */
   if (driver_strneq(a, flag, flen) && a[flen] == '=') {
     *out = a + flen + 1;
     return 1;
   }
   /* --flag NAME (no '='): treat as "next argv" form, used when --flag is
    * passed without value. Not standard; skip. */
   if (driver_streq(a, flag)) {
     if (*i + 1 >= argc) return -1;
     *out = argv[++(*i)];
     return 1;
   }
   /* -K NAME / -N NAME */
   if (short_flag && driver_streq(a, short_flag)) {
     if (*i + 1 >= argc) return -1;
     *out = argv[++(*i)];
     return 1;
   }
   return 0;
 }
 
 /* Collect the set of KitObjSymbol ids targeted by any reloc whose
  * containing section will survive emit — relocs inside the
  * about-to-be-removed KIT_SEC_DEBUG sections don't count. Otherwise a
  * symbol that's referenced only from DWARF (e.g. main's debug_info entry)
  * keeps every function symbol alive even though the on-disk relocs
  * holding it won't make it to the output. */
 static int collect_needed_syms(DriverEnv* env, KitObjFile* of,
                                KitObjSymbol** needed_out, uint32_t* n_out,
                                uint32_t* cap_out) {
   KitObjRelocIter* rit = NULL;
   KitObjSymbol* arr = NULL;
   uint32_t n = 0, cap = 0;
 
   if (kit_obj_reliter_new(of, &rit) != KIT_OK) {
     driver_errf(STRIP_TOOL, "out of memory");
     return 1;
   }
   for (;;) {
     KitObjReloc r;
     KitIterResult ir = kit_obj_reliter_next(rit, &r);
     uint32_t k;
     int seen = 0;
     if (ir != KIT_ITER_ITEM) break;
     if (r.sym == KIT_OBJ_SYMBOL_NONE) continue;
     /* Skip relocs hosted in a debug section — that section is being
      * dropped, so its relocs don't actually "need" their targets. */
     if (r.section != KIT_SECTION_NONE) {
       KitObjSecInfo hi;
       if (kit_obj_section(of, r.section, &hi) == KIT_OK &&
           hi.kind == KIT_SEC_DEBUG) {
         continue;
       }
     }
     for (k = 0; k < n; ++k) {
       if (arr[k] == r.sym) {
         seen = 1;
         break;
       }
     }
     if (seen) continue;
     if (n >= cap) {
       uint32_t newcap = cap ? cap * 2u : 32u;
       KitObjSymbol* nb =
           (KitObjSymbol*)driver_alloc_zeroed(env, (size_t)newcap * sizeof(*nb));
       if (!nb) {
         kit_obj_reliter_free(rit);
         if (arr) driver_free(env, arr, (size_t)cap * sizeof(*arr));
         driver_errf(STRIP_TOOL, "out of memory");
         return 1;
       }
       if (arr) {
         memcpy(nb, arr, (size_t)n * sizeof(*arr));
         driver_free(env, arr, (size_t)cap * sizeof(*arr));
       }
       arr = nb;
       cap = newcap;
     }
     arr[n++] = r.sym;
   }
   kit_obj_reliter_free(rit);
   *needed_out = arr;
   *n_out = n;
   *cap_out = cap;
   return 0;
 }
 
 static int id_in_set(KitObjSymbol id, const KitObjSymbol* arr, uint32_t n) {
   uint32_t i;
   for (i = 0; i < n; ++i) {
     if (arr[i] == id) return 1;
   }
   return 0;
 }
 
 /* The core strip pass: drop debug sections, then walk symbols and apply
  * keep/strip lists and the operation policy. Mutations are issued
  * against the builder; emit-time sweep cleans up cascades (orphan
  * relocs against removed sections, dropped group memberships, etc.). */
 static int strip_one_builder(DriverEnv* env, KitObjFile* of, KitObjBuilder* b,
                              const StripOpts* opts) {
   uint32_t i, nsec;
   int filter_syms = (opts->op == STRIP_OP_UNNEEDED || opts->op == STRIP_OP_ALL);
   KitObjSymbol* needed = NULL;
   uint32_t nneeded = 0, cap_needed = 0;
   KitObjSymIter* sit = NULL;
   int rc = 1;
 
   /* Step 1: drop debug sections (every supported op does this). */
   nsec = kit_obj_nsections(of);
   for (i = 0; i < nsec; ++i) {
     KitObjSecInfo si;
     if (kit_obj_section(of, i, &si) != KIT_OK) continue;
     if (si.kind == KIT_SEC_DEBUG) {
       kit_obj_builder_remove_section(b, i);
     }
   }
 
   /* Step 2: compute the needed-sym set. */
   if (filter_syms) {
     if (collect_needed_syms(env, of, &needed, &nneeded, &cap_needed) != 0) {
       return 1;
     }
   }
 
   /* Step 3: walk symbols and apply filters. */
   if (kit_obj_symiter_new(of, &sit) != KIT_OK) {
     driver_errf(STRIP_TOOL, "out of memory");
     goto done;
   }
   for (;;) {
     KitObjSymInfo si;
     KitIterResult ir = kit_obj_symiter_next(sit, &si);
     int drop = 0;
     if (ir != KIT_ITER_ITEM) break;
     /* --strip-symbol wins over --keep-symbol if both list the same name. */
     if (opts->nstrip && name_in_list(si.name, opts->strip, opts->nstrip)) {
       drop = 1;
     } else if (opts->nkeep && name_in_list(si.name, opts->keep, opts->nkeep)) {
       drop = 0;
     } else if (filter_syms) {
       /* Keep undefined externals so the .o stays linkable; keep symbols
        * targeted by a surviving reloc; drop everything else. Note that
        * section symbols defined in removed debug sections are already
        * tombstoned by the emit-time sweep cascade — no explicit handling
        * needed here. */
       if (si.kind == KIT_SK_UNDEF) {
         drop = 0;
       } else if (id_in_set(si.id, needed, nneeded)) {
         drop = 0;
       } else {
         drop = 1;
       }
     }
     if (drop) {
       kit_obj_builder_remove_symbol(b, si.id);
     }
   }
   kit_obj_symiter_free(sit);
   rc = 0;
 
 done:
   if (needed) driver_free(env, needed, (size_t)cap_needed * sizeof(*needed));
   return rc;
 }
 
 static int strip_object_bytes(DriverEnv* env, const KitContext* ctx,
                               const KitSlice* input, const StripOpts* opts,
                               uint8_t** out_data, size_t* out_size) {
   KitObjFile* of = NULL;
   KitObjBuilder* b;
   KitWriter* w = NULL;
   size_t n = 0;
   const uint8_t* data;
   uint8_t* copy;
   int rc = 1;
 
   *out_data = NULL;
   *out_size = 0;
 
   if (kit_obj_open(ctx, KIT_SLICE_NULL, input, &of) != KIT_OK) {
     driver_errf(STRIP_TOOL, "not a recognized object");
     return 1;
   }
   b = kit_obj_file_builder(of);
   if (!b) {
     driver_errf(STRIP_TOOL, "no builder for object");
     kit_obj_free(of);
     return 1;
   }
 
   if (strip_one_builder(env, of, b, opts) != 0) {
     kit_obj_free(of);
     return 1;
   }
 
   if (kit_writer_mem(env->heap, &w) != KIT_OK || !w) {
     driver_errf(STRIP_TOOL, "out of memory");
     kit_obj_free(of);
     return 1;
   }
   if (kit_obj_builder_emit(b, w) != KIT_OK) {
     driver_errf(STRIP_TOOL, "emit failed");
     kit_writer_close(w);
     kit_obj_free(of);
     return 1;
   }
   data = kit_writer_mem_bytes(w, &n);
   copy = (uint8_t*)driver_alloc(env, n ? n : 1u);
   if (!copy) {
     driver_errf(STRIP_TOOL, "out of memory");
     kit_writer_close(w);
     kit_obj_free(of);
     return 1;
   }
   if (n) memcpy(copy, data, n);
   kit_writer_close(w);
   kit_obj_free(of);
 
   *out_data = copy;
   *out_size = n;
   rc = 0;
   return rc;
 }
 
 static uint64_t strip_epoch_from_env(void) {
   const char* s = driver_getenv("SOURCE_DATE_EPOCH");
   uint64_t v = 0;
   if (!s || !*s) return 0;
   for (; *s; ++s) {
     if (*s < '0' || *s > '9') return 0;
     v = v * 10 + (uint64_t)(*s - '0');
   }
   return v;
 }
 
 /* Strip every object member of an archive, write a fresh archive with
  * a refreshed System-V symbol index. Non-object members pass through
  * unchanged. */
 static int strip_archive(DriverEnv* env, const KitContext* ctx,
                          const KitSlice* input, const StripOpts* opts,
                          const char* output_path) {
   KitArIter* it = NULL;
   KitArMember m;
   KitArInput* members = NULL;
   uint8_t** owned_data = NULL;
   size_t* owned_size = NULL;
   char* name_storage = NULL;
   size_t name_bytes_total = 0;
   uint32_t nmembers = 0, k;
   KitArMemberSymbols* msyms = NULL;
   void** sym_allocs = NULL;
   size_t* sym_alloc_szs = NULL;
   KitWriter* out = NULL;
   KitArWriteOptions opts_ar = {0};
   int rc = 1;
 
   /* Pass 1: count members + total name bytes. */
   if (kit_ar_iter_new(ctx, input, &it) != KIT_OK) {
     driver_errf(STRIP_TOOL, "not an archive");
     return 1;
   }
   for (;;) {
     KitIterResult r = kit_ar_iter_next(it, &m);
     if (r != KIT_ITER_ITEM) break;
     nmembers++;
     name_bytes_total += m.name.len + 1;
   }
   kit_ar_iter_free(it);
   it = NULL;
 
   if (nmembers) {
     members = (KitArInput*)driver_alloc_zeroed(
         env, (size_t)nmembers * sizeof(*members));
     owned_data = (uint8_t**)driver_alloc_zeroed(
         env, (size_t)nmembers * sizeof(*owned_data));
     owned_size = (size_t*)driver_alloc_zeroed(
         env, (size_t)nmembers * sizeof(*owned_size));
     if (!members || !owned_data || !owned_size) {
       driver_errf(STRIP_TOOL, "out of memory");
       goto done;
     }
   }
   if (name_bytes_total) {
     name_storage = (char*)driver_alloc_zeroed(env, name_bytes_total);
     if (!name_storage) {
       driver_errf(STRIP_TOOL, "out of memory");
       goto done;
     }
   }
 
   /* Pass 2: walk members; strip object members, pass others through. */
   if (kit_ar_iter_new(ctx, input, &it) != KIT_OK) {
     driver_errf(STRIP_TOOL, "iter re-open failed");
     goto done;
   }
   {
     size_t cursor = 0;
     k = 0;
     while (k < nmembers) {
       KitIterResult r = kit_ar_iter_next(it, &m);
       size_t j;
       char* dst;
       KitBinFmt fmt;
       KitSlice mbytes;
       if (r != KIT_ITER_ITEM) break;
       dst = name_storage + cursor;
       for (j = 0; j < m.name.len; ++j) *dst++ = m.name.s[j];
       *dst++ = '\0';
       members[k].name.s = name_storage + cursor;
       members[k].name.len = m.name.len;
       cursor = (size_t)(dst - name_storage);
 
       mbytes.data = m.data;
       mbytes.len = m.size;
       fmt = kit_detect_fmt(m.data, m.size);
       if (fmt == KIT_BIN_ELF || fmt == KIT_BIN_COFF || fmt == KIT_BIN_MACHO ||
           fmt == KIT_BIN_WASM) {
         uint8_t* sd = NULL;
         size_t ss = 0;
         if (strip_object_bytes(env, ctx, &mbytes, opts, &sd, &ss) != 0) {
           kit_ar_iter_free(it);
           it = NULL;
           goto done;
         }
         owned_data[k] = sd;
         owned_size[k] = ss;
         members[k].bytes.data = sd;
         members[k].bytes.len = ss;
       } else {
         members[k].bytes.data = m.data;
         members[k].bytes.len = m.size;
       }
       k++;
     }
   }
   kit_ar_iter_free(it);
   it = NULL;
 
   /* Pass 3: rebuild the System-V symbol index from the new bytes. */
   if (nmembers) {
     msyms = (KitArMemberSymbols*)driver_alloc_zeroed(
         env, (size_t)nmembers * sizeof(*msyms));
     sym_allocs = (void**)driver_alloc_zeroed(
         env, (size_t)nmembers * sizeof(*sym_allocs));
     sym_alloc_szs = (size_t*)driver_alloc_zeroed(
         env, (size_t)nmembers * sizeof(*sym_alloc_szs));
     if (!msyms || !sym_allocs || !sym_alloc_szs) {
       driver_errf(STRIP_TOOL, "out of memory");
       goto done;
     }
     for (k = 0; k < nmembers; ++k) {
       void* blob = NULL;
       size_t blob_size = 0;
       const KitSlice* names = NULL;
       uint32_t count = 0;
       if (driver_collect_obj_global_syms(env, ctx, STRIP_TOOL,
                                          &members[k].bytes, &blob, &blob_size,
                                          &names, &count) != 0) {
         goto done;
       }
       sym_allocs[k] = blob;
       sym_alloc_szs[k] = blob_size;
       msyms[k].names = names;
       msyms[k].count = count;
     }
   }
 
   if (ctx->file_io->open_writer(ctx->file_io->user, output_path, &out) !=
       KIT_OK) {
     driver_errf(STRIP_TOOL, "failed to open: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(output_path)));
     goto done;
   }
   opts_ar.epoch = strip_epoch_from_env();
   opts_ar.long_names = 1;
   opts_ar.symbol_index = 1;
   opts_ar.member_symbols = msyms;
   rc = kit_ar_write(out, members, nmembers, &opts_ar) == KIT_OK ? 0 : 1;
   if (rc == 0 && kit_writer_status(out) != KIT_OK) rc = 1;
 
 done:
   if (out) kit_writer_close(out);
   if (it) kit_ar_iter_free(it);
   if (sym_allocs) {
     for (k = 0; k < nmembers; ++k) {
       if (sym_allocs[k])
         driver_collect_obj_global_syms_free(env, sym_allocs[k],
                                             sym_alloc_szs[k]);
     }
     driver_free(env, sym_allocs, (size_t)nmembers * sizeof(*sym_allocs));
   }
   if (sym_alloc_szs)
     driver_free(env, sym_alloc_szs, (size_t)nmembers * sizeof(*sym_alloc_szs));
   if (msyms) driver_free(env, msyms, (size_t)nmembers * sizeof(*msyms));
   if (owned_data) {
     for (k = 0; k < nmembers; ++k) {
       if (owned_data[k]) driver_free(env, owned_data[k], owned_size[k]);
     }
     driver_free(env, owned_data, (size_t)nmembers * sizeof(*owned_data));
   }
   if (owned_size)
     driver_free(env, owned_size, (size_t)nmembers * sizeof(*owned_size));
   if (members) driver_free(env, members, (size_t)nmembers * sizeof(*members));
   if (name_storage) driver_free(env, name_storage, name_bytes_total);
   return rc;
 }
 
 int driver_strip(int argc, char** argv) {
   DriverEnv env;
   KitContext ctx;
   StripOpts opts;
   KitFileData input_fd = {0};
   KitSlice input;
   KitWriter* w = NULL;
   uint8_t* out_data = NULL;
   size_t out_size = 0;
   int have_input = 0;
   int rc = 1;
   int i;
 
   if (argc < 2 || driver_argv_wants_help(argc, argv, 1)) {
     driver_help_strip();
     return 0;
   }
 
   memset(&opts, 0, sizeof opts);
   opts.op = STRIP_OP_ALL;
   driver_env_init(&env);
   ctx = driver_env_to_context(&env);
 
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
     const char* val = NULL;
     int matched;
     if (driver_streq(a, "--strip-debug")) {
       opts.op = STRIP_OP_DEBUG;
       continue;
     }
     if (driver_streq(a, "--strip-unneeded")) {
       opts.op = STRIP_OP_UNNEEDED;
       continue;
     }
     if (driver_streq(a, "--strip-all") || driver_streq(a, "-s")) {
       opts.op = STRIP_OP_ALL;
       continue;
     }
     if (driver_streq(a, "-o")) {
       if (i + 1 >= argc) {
         driver_errf(STRIP_TOOL, "-o requires a path");
         rc = 2;
         goto done;
       }
       opts.output = argv[++i];
       continue;
     }
     matched = parse_name_arg(&i, argc, argv, "--keep-symbol", "-K", &val);
     if (matched < 0) {
       driver_errf(STRIP_TOOL, "%.*s requires a symbol name",
                   KIT_SLICE_ARG(kit_slice_cstr(a)));
       rc = 2;
       goto done;
     }
     if (matched) {
       if (push_name(&env, &opts.keep, &opts.nkeep, &opts.cap_keep, val) != 0) {
         rc = 1;
         goto done;
       }
       continue;
     }
     matched = parse_name_arg(&i, argc, argv, "--strip-symbol", "-N", &val);
     if (matched < 0) {
       driver_errf(STRIP_TOOL, "%.*s requires a symbol name",
                   KIT_SLICE_ARG(kit_slice_cstr(a)));
       rc = 2;
       goto done;
     }
     if (matched) {
       if (push_name(&env, &opts.strip, &opts.nstrip, &opts.cap_strip, val) !=
           0) {
         rc = 1;
         goto done;
       }
       continue;
     }
     if (a[0] == '-' && a[1] != '\0') {
       driver_errf(STRIP_TOOL, "unknown option: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(a)));
       rc = 2;
       goto done;
     }
     if (opts.input) {
       driver_errf(STRIP_TOOL, "only one input file is supported");
       rc = 2;
       goto done;
     }
     opts.input = a;
   }
 
   if (!opts.input) {
     driver_errf(STRIP_TOOL, "missing input file");
     rc = 2;
     goto done;
   }
 
   if (ctx.file_io->read_all(ctx.file_io->user, opts.input, &input_fd) !=
       KIT_OK) {
     driver_errf(STRIP_TOOL, "failed to read: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(opts.input)));
     goto done;
   }
   have_input = 1;
   input.data = input_fd.data;
   input.len = input_fd.size;
 
   {
     KitBinFmt fmt = kit_detect_fmt(input.data, input.len);
     const char* out_path = opts.output ? opts.output : opts.input;
     if (fmt == KIT_BIN_AR) {
       rc = strip_archive(&env, &ctx, &input, &opts, out_path);
       goto done;
     }
     if (strip_object_bytes(&env, &ctx, &input, &opts, &out_data, &out_size) !=
         0) {
       goto done;
     }
     if (ctx.file_io->open_writer(ctx.file_io->user, out_path, &w) != KIT_OK) {
       driver_errf(STRIP_TOOL, "failed to open: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(out_path)));
       goto done;
     }
     kit_writer_write(w, out_data, out_size);
     if (kit_writer_status(w) != KIT_OK) {
       driver_errf(STRIP_TOOL, "write failed: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(out_path)));
       goto done;
     }
     rc = 0;
   }
 
 done:
   if (w) kit_writer_close(w);
   if (out_data) driver_free(&env, out_data, out_size);
   if (have_input) ctx.file_io->release(ctx.file_io->user, &input_fd);
   if (opts.keep)
     driver_free(&env, (void*)opts.keep,
                 (size_t)opts.cap_keep * sizeof(*opts.keep));
   if (opts.strip)
     driver_free(&env, (void*)opts.strip,
                 (size_t)opts.cap_strip * sizeof(*opts.strip));
   driver_env_fini(&env);
   return rc;
 }