kit

disasm.c (7264B)

---

 /* Wasm disassembler.
  *
  * Renders the code section of a .wasm module (as exposed by read_wasm) into
  * WAT instruction text. The code section payload is framed — a function count,
  * then per function a body size, a locals declaration, an instruction stream,
  * and a terminating `end` — so unlike the flat ISAs this decoder is stateful:
  * it walks the framing across successive decode calls, emits one ".locals"
  * line per function body (at the offset read_wasm records as that function's
  * symbol value, so objdump labels each body), then decodes the body's
  * instructions one per call. Instruction decoding reuses the shared
  * wasm_decode_one_insn so the opcode mapping has a single source of truth. */
 
 #include "arch/wasm/disasm.h"
 
 #include <stdio.h>
 #include <string.h>
 
 #include "core/heap.h"
 #include "core/strbuf.h"
 #include "wasm/wasm.h"
 #include "wasm/wasm_insn_table.h"
 
 #define WASM_DASM_MNEM_CAP 32u
 #define WASM_DASM_OPS_CAP 192u
 
 typedef struct WasmDisasm {
   ArchDisasm base;
   Compiler* c;
   Heap* heap;
   WasmModule scratch; /* reusable decode buffer for wasm_decode_one_insn */
   int inited;         /* read the function count yet? */
   u32 funcs_left;     /* function bodies not yet started */
   int in_body;        /* currently emitting a body's instructions */
   u32 depth;          /* block/loop/if nesting, for indentation */
   char mnem_buf[WASM_DASM_MNEM_CAP];
   char ops_buf[WASM_DASM_OPS_CAP];
   StrBuf mnem;
   StrBuf ops;
 } WasmDisasm;
 
 /* Bounds-checked uleb over [*p, end); leaves *p past end and returns 0 on
  * overrun (caller treats a 0-length decode as truncated). */
 static u32 dis_uleb(const u8** p, const u8* end) {
   u32 result = 0, shift = 0;
   while (*p < end) {
     u8 b = *(*p)++;
     result |= (u32)(b & 0x7fu) << shift;
     if (!(b & 0x80u)) return result;
     shift += 7u;
     if (shift >= 32u) break;
   }
   return result;
 }
 
 static const char* valtype_name(i64 b) {
   switch ((u8)b) {
     case 0x7f:
       return "i32";
     case 0x7e:
       return "i64";
     case 0x7d:
       return "f32";
     case 0x7c:
       return "f64";
     case 0x70:
       return "funcref";
     case 0x6f:
       return "externref";
     default:
       return "?";
   }
 }
 
 /* Render an instruction's immediate operands into d->ops, dispatched on the
  * shared operand class from WASM_INSN_TABLE rather than re-listing kinds. */
 static void render_operands(WasmDisasm* d, const WasmInsn* in) {
   const WasmInsnInfo* info = wasm_insn_info((WasmInsnKind)in->kind);
   WasmOperandClass oc = info ? (WasmOperandClass)info->operand_class : WASM_OC_NONE;
   switch (oc) {
     case WASM_OC_SLEB:
       strbuf_put_i64(&d->ops, in->imm);
       break;
     case WASM_OC_FP: {
       char buf[40];
       (void)snprintf(buf, sizeof buf, "%g", in->fp);
       strbuf_puts(&d->ops, buf);
       break;
     }
     case WASM_OC_IDX:
     case WASM_OC_TYPED_REF:
       strbuf_put_u64(&d->ops, (u64)in->imm);
       break;
     case WASM_OC_CALL_INDIRECT:
       strbuf_put_u64(&d->ops, (u64)in->imm);
       strbuf_puts(&d->ops, " ");
       strbuf_put_u64(&d->ops, (u64)in->aux_idx);
       break;
     case WASM_OC_BR_TABLE: {
       u32 i;
       for (i = 0; i < in->ntargets; ++i) {
         if (i) strbuf_putc(&d->ops, ' ');
         strbuf_put_u64(&d->ops, (u64)in->targets[i]);
       }
       break;
     }
     case WASM_OC_REF_NULL:
       strbuf_puts(&d->ops, valtype_name(in->imm));
       break;
     case WASM_OC_MEMARG: {
       int wrote = 0;
       if (in->offset64) {
         strbuf_puts(&d->ops, "offset=");
         strbuf_put_u64(&d->ops, in->offset64);
         wrote = 1;
       }
       if (in->align) {
         if (wrote) strbuf_putc(&d->ops, ' ');
         strbuf_puts(&d->ops, "align=");
         strbuf_put_u64(&d->ops, (u64)(1u << in->align));
       }
       break;
     }
     default:
       break;
   }
 }
 
 /* Indentation prefix: two spaces per nesting level, baked into the mnemonic so
  * objdump's column layout reads as nested WAT. */
 static void put_indent(WasmDisasm* d, u32 depth) {
   u32 i;
   for (i = 0; i < depth; ++i) strbuf_puts(&d->mnem, "  ");
 }
 
 static u32 wasm_decode(ArchDisasm* base, const u8* bytes, size_t len, u64 vaddr,
                        KitInsn* out) {
   WasmDisasm* d = (WasmDisasm*)base;
   const u8* p = bytes;
   const u8* end = bytes + len;
 
   strbuf_reset(&d->mnem);
   strbuf_reset(&d->ops);
   out->annotation = SLICE_LIT("");
 
   if (len == 0) return 0;
 
   if (!d->inited) {
     d->inited = 1;
     d->funcs_left = dis_uleb(&p, end);
     d->in_body = 0;
   }
 
   if (!d->in_body) {
     /* Start of a function body: consume the body size LEB and the locals
      * vector, emitting one ".locals" line whose address is the locals-vector
      * start (matching read_wasm's function symbol value). */
     size_t header;
     u64 body_vaddr;
     u32 ngroups, g;
     if (d->funcs_left == 0) return 0;
     (void)dis_uleb(&p, end); /* body size; body end tracked via depth */
     header = (size_t)(p - bytes);
     body_vaddr = vaddr + header;
     ngroups = dis_uleb(&p, end);
     strbuf_puts(&d->mnem, ".locals");
     for (g = 0; g < ngroups && p < end; ++g) {
       u32 n = dis_uleb(&p, end);
       u8 vt = (p < end) ? *p++ : 0;
       u32 k;
       for (k = 0; k < n; ++k) {
         strbuf_putc(&d->ops, ' ');
         strbuf_puts(&d->ops, valtype_name(vt));
       }
     }
     d->in_body = 1;
     d->depth = 0;
     d->funcs_left--;
     out->vaddr = body_vaddr;
     out->bytes = bytes + header;
     out->nbytes = (u32)((size_t)(p - bytes) - header);
     out->mnemonic = strbuf_slice(&d->mnem);
     out->operands = strbuf_slice(&d->ops);
     return (u32)(p - bytes);
   }
 
   /* Inside a body: decode one instruction. */
   {
     WasmInsn insn;
     size_t n = wasm_decode_one_insn(d->c, &d->scratch, bytes, len, 0, &insn);
     WasmInsnKind k;
     if (n == 0) return 0;
     k = (WasmInsnKind)insn.kind;
     /* Dedent for the closing/middle keywords before printing them. */
     if (k == WASM_INSN_ELSE && d->depth) {
       put_indent(d, d->depth - 1u);
     } else if (k == WASM_INSN_END && d->depth) {
       put_indent(d, d->depth - 1u);
     } else {
       put_indent(d, d->depth);
     }
     strbuf_puts(&d->mnem, wasm_insn_mnemonic(k));
     render_operands(d, &insn);
 
     if (k == WASM_INSN_BLOCK || k == WASM_INSN_LOOP || k == WASM_INSN_IF) {
       d->depth++;
     } else if (k == WASM_INSN_END) {
       if (d->depth == 0)
         d->in_body = 0; /* body-terminating end */
       else
         d->depth--;
     }
 
     out->vaddr = vaddr;
     out->bytes = bytes;
     out->nbytes = (u32)n;
     out->mnemonic = strbuf_slice(&d->mnem);
     out->operands = strbuf_slice(&d->ops);
     return (u32)n;
   }
 }
 
 static void wasm_disasm_destroy(ArchDisasm* base) {
   WasmDisasm* d = (WasmDisasm*)base;
   Heap* h = d->heap;
   wasm_module_free(&d->scratch);
   h->free(h, d, sizeof *d);
 }
 
 ArchDisasm* wasm_disasm_new(Compiler* c) {
   Heap* h = (Heap*)c->ctx->heap;
   WasmDisasm* d = (WasmDisasm*)h->alloc(h, sizeof *d, _Alignof(WasmDisasm));
   if (!d) return NULL;
   memset(d, 0, sizeof *d);
   d->c = c;
   d->heap = h;
   d->base.decode = wasm_decode;
   d->base.destroy = wasm_disasm_destroy;
   wasm_module_init(&d->scratch, h);
   strbuf_init(&d->mnem, d->mnem_buf, sizeof d->mnem_buf);
   strbuf_init(&d->ops, d->ops_buf, sizeof d->ops_buf);
   return &d->base;
 }