Parse a Wasm Binary Module: Sections, Types, Function Bodies

Topic Overview

Wasm Binary Modules

A \`.wasm\` file is a sequence of sections, each with an ID, size, and payload. Parsers walk them in order to build types, functions, memories, and code bodies.

Section Layout

Standard sections include:

• Type: function signatures (\`i32 i32 -> i32\`)
• Import / Export: host bindings
• Function: type indices per function
• Memory / Table / Global
• Code: function bodies with locals and bytecode

LEB128 encodes variable-length integers compactly. Function bodies prefix local decls then expr bytecode terminated by \`end\`.

For example, a module exporting \`add\` might have type section entry \`(func (param i32 i32) (result i32))\`, export name \`add\`, and a two-instruction body: \`local.get 0; local.get 1; i32.add\`.

Magic: \`00 61 73 6D\` (\`\\0asm\`), version \`01 00 00 00\`.

Design Notes

LEB128 decode errors cascade: one wrong length corrupts every following section offset. Parse section sizes strictly and bounds-check before advancing the cursor.

For This Exercise

This exercise asks you to parse Wasm section headers and dump structure. You will read magic, version, and section IDs from bytes the way wasm-tools and browsers do at load time.

You will use the same mental model here when reading production interpreter source later in the track. Sketch one concrete input on paper, predict the outcome, then confirm with code. That discipline catches logic errors early and makes debugging far faster when you extend the implementation in follow-on tasks.

Your Task

Parse a WebAssembly binary module and print what it contains: every section with its offset and size, the types, imports, function-to-type mapping, memories and exports, and a disassembly of each function body. Every integer in the format is LEB128, so decoding must be bounds-checked and length-checked everywhere.

Input

Hex bytes separated by whitespace. A token starting with # comments out the rest of its line. The token next separates modules, whose outputs are separated by ---.

Format

• Header: 00 61 73 6d, then the version as a u32 little-endian, which must be 1.
• Sections: id:u8 size:uleb, then size bytes. Non-custom sections must appear in increasing id order. Ids above 11 are unknown.
• Contents:
  • 0 custom: a name, then opaque bytes.
  • 1 type: a vector of 60 params results, with value types i32 7F, i64 7E, f32 7D, f64 7C.
  • 2 import: a vector of module:name field:name kind. Kind 0 is a func (a type index). Kind 2 is a memory (limits: flag 0 = min, flag 1 = min max). Imported functions take the first function indices.
  • 3 function: a vector of type indices for the module's own functions.
  • 5 memory: a vector of limits.
  • 7 export: a vector of name kind:u8 index (kinds func/table/memory/global).
  • 10 code: a vector of bodies, each size:uleb, then local groups (count type), then instructions up to 0B.
  • Other known sections are skipped.
• Names and vectors: names are uleb length + bytes, and vectors are uleb count + items.

Instructions

The opcodes from the assembler task:

• Control: unreachable nop return call drop.
• Locals: local.get/set/tee.
• Constants: i32.const (signed LEB, 32-bit) and i64.const (64-bit).
• i32 comparisons: eqz eq ne lt_s gt_s.
• i32 arithmetic: add sub mul div_s rem_s and or shl.
• i64: i64.add i64.mul i32.wrap_i64 i64.extend_i32_s.

Output

cCopy
Loading…

• Memory lines: memory 0: min 2 pages (64 KiB each), or memory 0: min 1, max 4 pages (64 KiB each).
• Function names: a function is named by its first func export, an import by module.field, and anything else is unnamed. An unnamed body prints func N: …. A call prints call I <NAME>, where NAME is func I for unnamed functions.
• Unknown opcode: OFFS: unknown opcode 0xXX, skipping the rest of the body. A body whose bytes run out without end prints missing end.

Errors

These stop the module with error: …:

• bad magic (expected 00 61 73 6d), unsupported version N
• truncated at 0xN (reads are also limited to the current section and body)
• LEB128 too long at 0xN
• unknown section id N at 0xN, section NAME out of order at 0xN
• section NAME declared N bytes but used M
• type index N out of range
• code count N does not match function count M
• bad value type 0xNN at 0xN, expected 0x60 at 0xN, unsupported import kind N
• body N ends at 0xN, expected 0xN
• function section without code section, empty input

A bad hex token prints bad byte: X for that module.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Decode ULEB128 in at most 5 bytes for u32 values, and reject longer encodings.
2. While parsing a section, clamp the readable length to the section end. A section cannot read into its neighbour.

Hidden tests cover imports that shift function indices, a memory section, a custom section, an unknown opcode, and each structural error: version, order, LEB length, size mismatch, count mismatch, truncation and a bad type index.