Compile a C Function to Wasm and Inspect the Binary

Topic Overview

Compiling C to Wasm

WebAssembly is a portable binary ISA. LLVM's \`clang --target=wasm32\` plus \`wasm-ld\` turns C into a \`.wasm\` module browsers and standalone runtimes can load.

Toolchain Steps

Pipeline:

1. \`clang --target=wasm32 -c add.c -o add.o\`
2. \`wasm-ld add.o -o add.wasm --export=add\`
3. \`wasm2wat add.wasm\` for readable WAT

C symbols are hidden by default. Export with \`attribute((visibility("default")))\` or a linker \`--export\` flag so JavaScript or WASI can call \`add\`.

For example:

\`\`\`c attribute((export_name("add"))) int add(int a, int b) { return a + b; } \`\`\`

compiles to \`i32.add\` on two parameters in the Wasm stack machine.

Binary starts with magic \`\\0asm\` and version bytes, then type, function, export, and code sections.

Design Notes

Inspect both WAT and the raw binary hex for the same module. Seeing `00 61 73 6D` at offset zero confirms you are looking at Wasm, not a mislabeled object file from a wrong target triple.

For This Exercise

This exercise asks you to document the clang/wasm-ld pipeline for a simple \`add\` function. You will show C source, linker commands, and the resulting WAT so you can read what the compiler produced.

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

What clang --target=wasm32 + wasm-ld produce for int add(int a, int b) { return a + b; } is a 41-byte module. Build the back half of that pipeline: an assembler that turns functions written in WebAssembly text instructions into the binary format. The encoder must handle:

• the magic and version;
• the type, function, export and code sections, each prefixed by its id and ULEB128 byte size;
• deduplicated function types;
• grouped local declarations;
• signed LEB128 constants.

Print the result as an annotated hex dump.

Input

;; starts a comment.

cCopy
Loading…

Instructions:

• unreachable 00, nop 01, return 0F, call NAME 10, drop 1A;
• local.get/set/tee 20/21/22 (index);
• i32.const 41 (int32), i64.const 42;
• i32.eqz 45, i32.eq 46, i32.ne 47, i32.lt_s 48, i32.gt_s 4A;
• i32.add 6A, i32.sub 6B, i32.mul 6C, i32.div_s 6D, i32.rem_s 6F;
• i32.and 71, i32.or 72, i32.shl 74;
• i64.add 7C, i64.mul 7E, i32.wrap_i64 A7, i64.extend_i32_s AC.

Every body ends with end (0B). Value types are i32 7F, i64 7E, f32 7D and f64 7C.

Encoding

• Type section (1): the count, then per distinct signature (in order of first use) 60, the param count, the params, the result count and the results. Functions with equal signatures share a type.
• Function section (3): the count, then each function's type index.
• Export section (7), only if something is exported: the count, then per export the name length, the name bytes, 00 (func) and the function index.
• Code section (10): the count, then per body its byte size (ULEB), the local groups (count, then n type per run of equal consecutive types), the instructions and 0B.
• Immediates: local indices and function indices are ULEB128. Constants are signed LEB128.

Output

cCopy
Loading…

• Lines: each line is %04x:, the bytes as %02x, then ; COMMENT.
• One line per item:
  • the magic and the version;
  • each section header (section ID (NAME), N bytes);
  • each vector count (N type(s), N export(s), N bod(y|ies)). The function section's count and type indices share one line, N function(s);
  • each type, each export, and each body header (its size and local groups, as in body 1 (main): 29 bytes, 2 local groups: 2 x i32, 1 x i64);
  • each instruction, indented by two spaces, with call NAME (func I) for calls.
• Errors: all are reported: line errors in input order, then missing end, then unknown calls (in function order), then N error(s), no module written.
  • line N: unknown instruction X
  • line N: bad immediate X for OP (locals must be 0-255, and i32 constants must fit in 32 bits)
  • line N: OP needs one immediate / line N: OP takes no immediate
  • line N: local I out of range in F
  • line N: bad func header word X, line N: at most one result, line N: bad local type X
  • line N: func inside func F, line N: instruction outside a func
  • func F: missing end, func F: call to unknown function X
• An input with no functions prints no functions.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Build each section's contents first, then emit the id and the ULEB128 size, because sizes precede contents.
2. Implement signed LEB128 with an arithmetic shift. Stop once the remaining value is all sign bits and the last byte's bit 6 matches.

Hidden tests cover three functions with a shared type, grouped locals, multi-byte positive and negative constants (624485 and -123456), -64 versus 64, calls, and every kind of error.