RicMoo's WASM Utilities

A simple WASM container parser and WASM expression parser.

The allows reading the WASM container and parsing the code within into its opcode and immediates, including byte ranges of each op.

Note

The original purpose of this library was to experiment with various techniques for compressing WASM.

The original idea was to deflate the opcodes and immediates seaparately and recombine them after re-inflating. As such, the API is feared towards extracting the bytes associated with each part of a WASM file and expression.

While this did result in smaller sizes, it only saved about 2-5% so I don't believe it is worth the additional complexity.

That said, someone (like me?) might find this useful.

API

Parse a WASM binary file into its sections.

import { parse } from "@ricmoo/wasm"

parse(wasm)
// {
//    magic,
//    version,
//    sections: [
//        {
//            type: "Code",
//            data: Uint8Array(), 
//            start, length
//        },
//        ...
//    ]
// }

import { parseExpr } from "@ricmoo/wasm"

parseExpr(expr, base = 0)
// [
//   {
//     opcode: 41, mnemonic: "i64.load", start: 100, length: 1,
//     imms: [
//       type: "memarg", value: { memidx: 0, align: 0, offset: 8 },
//       start: 101, length: 2
//     ]
//   },
//   ...
// ]

Example

import { readFileSync } from "node:fs";

import { parse, parseExpr } from "@ricmoo/wasm";


const data = readFileSync("test.wasm");

// Parse the code into its sections
const code = parse(data);

for (const sec of code.sections) {

    // Ignore non-CodeSection
    if (sec.type !== "Code") { continue; }

    // For each code in the CodeSection (e.g. each function)
    for (const { code, offset } of sec.code) {

        // Parse the code expression
        // Providing an offset will make `start` offset from `data`,
        // otherwise the offset is from `code`.
        const ops = parseExpr(code, offset);
        for (const op of ops) {

            // Show the opcode and raw bytes
            console.log(op.mnemonic, data.subarray(op.start, op.start + op.length));

            // For each immediate
            for (const imm of op.imms) {
                // Show the immediate type, value and raw bytes
                console.log("    ", imm.type, imm.value, data.subarray(imm.start, imm.start + imm.length));
            }
        }
    }
}

License

MIT LIcense.