kit

read.c (6789B)

---

 /* read_wasm: parse a .wasm binary into a format-neutral ObjBuilder.
  *
  * A wasm module is a container, much like ELF: the type/import/function/
  * table/memory/global/export/elem/data and custom sections are object-format
  * metadata, and the code section holds the function bodies. We expose each
  * wasm section as an ObjBuilder section carrying its original payload bytes
  * (so objdump -h/-s show the real container), mark the code section SF_EXEC
  * (so objdump -d disassembles it via the wasm ArchDisasm), and add one
  * function symbol per defined function so -t lists them and -d labels each
  * body. Container metadata beyond raw bytes is decoded only to recover
  * function names; see read_wasm's contract in obj/wasm/wasm.h. */
 
 #include <stdio.h>
 #include <string.h>
 
 #include "core/heap.h"
 #include "core/pool.h"
 #include "core/slice.h"
 #include "obj/format.h"
 #include "obj/obj.h"
 #include "obj/wasm/wasm.h"
 #include "wasm/wasm.h"
 
 /* Minimal bounds-checked cursor over the raw module bytes. */
 typedef struct WasmCur {
   Compiler* c;
   const u8* data;
   size_t len;
   size_t pos;
 } WasmCur;
 
 static u8 cur_u8(WasmCur* w) {
   if (w->pos >= w->len)
     compiler_panic(w->c, SRCLOC_NONE, "read_wasm: unexpected end of file");
   return w->data[w->pos++];
 }
 
 static u32 cur_uleb(WasmCur* w) {
   u32 result = 0, shift = 0, nbytes = 0;
   for (;;) {
     u8 b = cur_u8(w);
     if (nbytes++ >= 5u || (shift == 28u && (b & 0xf0u)))
       compiler_panic(w->c, SRCLOC_NONE, "read_wasm: invalid uleb128");
     result |= (u32)(b & 0x7fu) << shift;
     if (!(b & 0x80u)) return result;
     shift += 7u;
   }
 }
 
 /* Canonical section name for the standard section ids (WebAssembly spec). */
 static const char* wasm_section_name(u8 id) {
   switch (id) {
     case 1:
       return "type";
     case 2:
       return "import";
     case 3:
       return "function";
     case 4:
       return "table";
     case 5:
       return "memory";
     case 6:
       return "global";
     case 7:
       return "export";
     case 8:
       return "start";
     case 9:
       return "elem";
     case 10:
       return "code";
     case 11:
       return "data";
     case 12:
       return "datacount";
     default:
       return "section";
   }
 }
 
 static Sym intern_cstr(Compiler* c, const char* s) {
   return pool_intern_slice(c->global, (Slice){.s = s, .len = (u32)strlen(s)});
 }
 
 /* Best name for the j-th defined function: explicit (name section), else the
  * export name, else a synthesized func[index] placeholder. */
 static Sym func_symbol_name(Compiler* c, const WasmFunc* f, u32 func_index) {
   char buf[32];
   if (f && f->name && f->name[0]) return intern_cstr(c, f->name);
   if (f && f->export_name && f->export_name[0])
     return intern_cstr(c, f->export_name);
   (void)snprintf(buf, sizeof buf, "func[%u]", func_index);
   return intern_cstr(c, buf);
 }
 
 /* Add one function symbol per defined function, with value = byte offset of the
  * body's size-prefixed content (locals vector start) within the code-section
  * payload. `payload` points at the code section content (the function-count
  * LEB); `size` is its length. */
 static void add_code_symbols(Compiler* c, ObjBuilder* ob, ObjSecId code_sec,
                              const WasmModule* mod, const u8* payload,
                              size_t size) {
   WasmCur w = {c, payload, size, 0};
   u32 count = cur_uleb(&w);
   u32 fi = 0; /* index into mod->funcs (wasm function index space) */
   u32 k;
   for (k = 0; k < count; ++k) {
     u32 body_size = cur_uleb(&w);
     u64 body_off = (u64)w.pos; /* offset of locals vector within payload */
     const WasmFunc* f = NULL;
     Sym nm;
     SymBind bind;
     /* Skip imported functions: only defined funcs have code bodies. */
     while (fi < mod->nfuncs && mod->funcs[fi].is_import) fi++;
     if (fi < mod->nfuncs) f = &mod->funcs[fi];
     nm = func_symbol_name(c, f, fi);
     bind = (f && f->export_name && f->export_name[0]) ? SB_GLOBAL : SB_LOCAL;
     {
       ObjSymId sid = obj_symbol_ex(ob, nm, bind, SV_DEFAULT, SK_FUNC, code_sec,
                                    body_off, body_size, 0);
       obj_sym_mark_referenced(ob, sid);
     }
     fi++;
     /* Advance past the body to the next size LEB. */
     if (body_size > w.len || w.pos > w.len - body_size)
       compiler_panic(c, SRCLOC_NONE, "read_wasm: code body out of bounds");
     w.pos += body_size;
   }
 }
 
 ObjBuilder* read_wasm(Compiler* c, const char* name, const u8* data,
                       size_t len) {
   KitSlice input;
   WasmModule mod;
   ObjBuilder* ob;
   WasmCur w;
   (void)name;
 
   input.data = data;
   input.len = len;
   if (!wasm_is_binary(&input))
     compiler_panic(c, SRCLOC_NONE, "read_wasm: not a wasm binary");
 
   ob = obj_new(c);
   if (!ob) compiler_panic(c, SRCLOC_NONE, "read_wasm: obj_new failed");
 
   /* Decode the module model so we can recover function names. Names are
    * interned into c->global before the module is freed, so the module's own
    * storage need not outlive this function. */
   wasm_module_init(&mod, c->ctx->heap);
   wasm_decode_binary(c, &input, &mod);
 
   /* Walk the raw section framing and mirror each section into the builder with
    * its original payload bytes. */
   w.c = c;
   w.data = data;
   w.len = len;
   w.pos = 8; /* past magic + version */
   while (w.pos < w.len) {
     u8 id = cur_u8(&w);
     u32 size = cur_uleb(&w);
     size_t payload = w.pos;
     size_t payload_end;
     Sym sname;
     SecKind kind;
     SecSem sem;
     u16 flags;
     ObjSecId sid;
     if (size > w.len || w.pos > w.len - size)
       compiler_panic(c, SRCLOC_NONE, "read_wasm: section out of bounds");
     payload_end = payload + size;
 
     if (id == 0) {
       /* Custom section: name it after its embedded name field. */
       u32 nlen = cur_uleb(&w);
       const char* nm = (const char*)(w.data + w.pos);
       if (nlen > w.len || w.pos > w.len - nlen)
         compiler_panic(c, SRCLOC_NONE, "read_wasm: custom name out of bounds");
       sname = pool_intern_slice(c->global, (Slice){.s = nm, .len = nlen});
       kind = SEC_OTHER;
       sem = SSEM_WASM_CUSTOM;
       flags = 0;
     } else {
       sname = intern_cstr(c, wasm_section_name(id));
       sem = SSEM_PROGBITS;
       if (id == 10) {
         kind = SEC_TEXT;
         flags = (u16)(SF_EXEC | SF_ALLOC);
       } else if (id == 11) {
         kind = SEC_DATA;
         flags = SF_ALLOC;
       } else {
         kind = SEC_OTHER;
         flags = 0;
       }
     }
 
     sid = obj_section_ex(ob, sname, kind, sem, flags, 1, 0, OBJ_SEC_NONE, 0);
     if (sid == OBJ_SEC_NONE)
       compiler_panic(c, SRCLOC_NONE, "read_wasm: obj_section_ex failed");
     if (size) obj_write(ob, sid, data + payload, size);
 
     if (id == 10) add_code_symbols(c, ob, sid, &mod, data + payload, size);
 
     w.pos = payload_end;
   }
 
   wasm_module_free(&mod);
   return ob;
 }