gofront 1.6.1 → 1.7.0

package/src/backend/js/stdlib/simd.js

@@ -0,0 +1,24 @@
+// src/backend/js/stdlib/simd.js
+// CodeGen for the `gofront/simd` package in JS packages.
+
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
+export const simdMethods = {
+	_genSimd(fn, a) {
+		this.useHelper("simd");
+		const args = a();
+		switch (fn) {
+			case "Splat":
+				return `__simd_splat(${args[0]})`;
+			case "NewF32x4":
+				return `__simd_f32x4(${args[0]}, ${args[1]}, ${args[2]}, ${args[3]})`;
+			case "LoadF32x4":
+				return `__simd_load(${args[0]}, ${args[1]})`;
+			case "StoreF32x4":
+				return `__simd_store(${args[0]}, ${args[1]}, ${args[2]})`;
+			default:
+				return undefined;
+		}
+	},
+};

package/src/backend/wasm/boundary.js

@@ -147,6 +147,11 @@ function classifyType(goType, mod) {
 			return classifyFunc(t, mod);
 		case "interface":
 			return classifyInterface(t, mod);
+		case "simd":
+			return {
+				k: "unsupported",
+				what: "simd.F32x4 cannot cross the JS↔WASM boundary in 1.7.0 (use shared.Float32 instead)",
+			};
 		default:
 			return {
 				k: "unsupported",
@@ -211,6 +216,16 @@ function classifyBasic(n) {
 }
 
 function classifyNamed(t, mod) {
+	if (
+		t.name === "simd.F32x4" ||
+		t.name === "F32x4" ||
+		t.underlying?.kind === "simd"
+	) {
+		return {
+			k: "unsupported",
+			what: "simd.F32x4 cannot cross the JS↔WASM boundary in 1.7.0 (use shared.Float32 instead)",
+		};
+	}
 	if (t.name === "error") return { k: "error", wType: "anyref" };
 	if (t.name === "time.Duration")
 		return { k: "i64", unsigned: false, wType: "i64" };
@@ -506,6 +521,9 @@ function literalConst(spec, i) {
 }
 
 function unsupportedMsg(where, what) {
+	if (typeof what === "string" && what.includes("boundary")) {
+		return `${where}: ${what}`;
+	}
 	return `${where}: ${what} is not yet supported across the wasm boundary (planned)`;
 }
 

package/src/backend/wasm/emit-builtins.js

@@ -930,6 +930,9 @@ export class BuiltinsEmitter {
 			case "base64":
 				this.emitBase64Call(func.field, call, targetWasmType);
 				return true;
+			case "simd":
+				this.emitSimdPackageCall(func.field, args, targetWasmType);
+				return true;
 			default:
 				return false;
 		}
@@ -946,6 +949,20 @@ export class BuiltinsEmitter {
 			return true;
 		}
 		const recvTypeName = this._getReceiverTypeName(recvType, func.expr);
+		if (
+			recvTypeName === "simd.F32x4" ||
+			recvTypeName === "gofront/simd.F32x4" ||
+			recvType?.kind === "simd" ||
+			recvType?.underlying?.kind === "simd" ||
+			recvType?.name === "simd.F32x4"
+		) {
+			return this.emitSimdMethodCall(
+				func.field,
+				func.expr,
+				args,
+				targetWasmType,
+			);
+		}
 		if (
 			this._emitStdlibReceiverMethod(
 				recvTypeName,

package/src/backend/wasm/emit-exprs.js

@@ -275,6 +275,17 @@ export class ExprsEmitter {
 
 	emitCompositeLit(lit) {
 		const litType = lit._type ?? lit.typeExpr?._type ?? lit.typeExpr;
+		if (
+			litType?.kind === "simd" ||
+			litType?.name === "simd.F32x4" ||
+			litType?.underlying?.kind === "simd" ||
+			(lit.typeExpr?.kind === "SelectorExpr" &&
+				lit.typeExpr.field === "F32x4" &&
+				lit.typeExpr.expr?.name === "simd")
+		) {
+			this.emitSimdCompositeLit(lit);
+			return;
+		}
 		if (isMapType(litType, this.mod.checker)) {
 			const { keyType, valType } = getMapKeyValTypes(litType, this.mod.checker);
 			const mapInfo = this.mod.getMapType(keyType, valType);

package/src/backend/wasm/emit.js

@@ -14,6 +14,7 @@ import {
 	ExtendedPackagesEmitter,
 	IoEmitter,
 	PurePackagesEmitter,
+	SimdEmitter,
 	StdlibCoreEmitter,
 	TimeEmitter,
 } from "./stdlib/index.js";
@@ -958,6 +959,11 @@ export class FunctionEmitter {
 		if (recvType) {
 			let t = recvType;
 			while (t.kind === "pointer") t = t.base;
+			if (t.kind === "SelectorExpr") {
+				const pkg = t.expr?.name;
+				if (pkg) return `${pkg}.${t.field}`;
+			}
+			if (t.kind === "simd") return "simd.F32x4";
 			if (t.name) return t.name;
 			if (t.kind === "named") return t.name;
 			if (t.kind === "TypeName" || t.kind === "Ident") return t.name;
@@ -1106,6 +1112,8 @@ export class FunctionEmitter {
 			this.pushInstruction({ op: "f32.const", value: 0.0 });
 		} else if (wType === "f64") {
 			this.pushInstruction({ op: "f64.const", value: 0.0 });
+		} else if (wType === "v128") {
+			this.pushInstruction({ op: "v128.const", bytes: new Array(16).fill(0) });
 		} else if (
 			typeof wType === "object" &&
 			wType !== null &&
@@ -1402,3 +1410,4 @@ copyMethods(FunctionEmitter, IoEmitter);
 copyMethods(FunctionEmitter, TimeEmitter);
 copyMethods(FunctionEmitter, ExtendedPackagesEmitter);
 copyMethods(FunctionEmitter, SharedEmitter);
+copyMethods(FunctionEmitter, SimdEmitter);

package/src/backend/wasm/encode.js

@@ -393,6 +393,49 @@ const GC_OPCODES = {
 	"extern.convert_any": 0x1b,
 };
 
+// 0xFD prefixed SIMD instructions (Wasm SIMD / v128)
+const SIMD_OPCODES = {
+	"v128.load": 0,
+	"v128.store": 11,
+	"v128.const": 12,
+	"i8x16.shuffle": 13,
+	"i8x16.swizzle": 14,
+	"i8x16.splat": 15,
+	"i16x8.splat": 16,
+	"i32x4.splat": 17,
+	"i64x2.splat": 18,
+	"f32x4.splat": 19,
+	"f64x2.splat": 20,
+	"i8x16.extract_lane_s": 21,
+	"i8x16.extract_lane_u": 22,
+	"i8x16.replace_lane": 23,
+	"i16x8.extract_lane_s": 24,
+	"i16x8.extract_lane_u": 25,
+	"i16x8.replace_lane": 26,
+	"i32x4.extract_lane": 27,
+	"i32x4.replace_lane": 28,
+	"i64x2.extract_lane": 29,
+	"i64x2.replace_lane": 30,
+	"f32x4.extract_lane": 31,
+	"f32x4.replace_lane": 32,
+	"v128.not": 77,
+	"v128.and": 78,
+	"v128.andnot": 79,
+	"v128.or": 80,
+	"v128.xor": 81,
+	"f32x4.abs": 224,
+	"f32x4.neg": 225,
+	"f32x4.sqrt": 227,
+	"f32x4.add": 228,
+	"f32x4.sub": 229,
+	"f32x4.mul": 230,
+	"f32x4.div": 231,
+	"f32x4.min": 232,
+	"f32x4.max": 233,
+	"f32x4.pmin": 234,
+	"f32x4.pmax": 235,
+};
+
 // Natural alignment (log2) per load/store opcode; memarg = align, offset.
 const MEM_ALIGN = {
 	"i32.load": 2,
@@ -433,6 +476,48 @@ function encodeInstruction(inst) {
 		return [0xfc, ...encodeU32LEB(SAT_TRUNC_OPCODES[op])];
 	}
 
+	// 2. Check SIMD opcodes (0xFD prefix)
+	if (SIMD_OPCODES[op] !== undefined) {
+		const subOp = SIMD_OPCODES[op];
+		const bytes = [0xfd, ...encodeU32LEB(subOp)];
+		if (op === "v128.load" || op === "v128.store") {
+			bytes.push(...encodeU32LEB(inst.align ?? 2));
+			bytes.push(...encodeU32LEB(inst.offset ?? 0));
+			return bytes;
+		}
+		if (op === "v128.const") {
+			const prefixLen = bytes.length;
+			if (inst.bytes) {
+				for (let i = 0; i < 16; i++) {
+					bytes.push(inst.bytes[i] ?? 0);
+				}
+			} else if (inst.values) {
+				const vals = inst.values.slice(0, 4);
+				for (const val of vals) {
+					bytes.push(...encodeF32(val));
+				}
+				while (bytes.length < prefixLen + 16) {
+					bytes.push(0);
+				}
+			} else {
+				for (let i = 0; i < 16; i++) bytes.push(0);
+			}
+			return bytes;
+		}
+		if (op === "i8x16.shuffle") {
+			const lanes = inst.lanes ?? inst.indices ?? [];
+			for (let i = 0; i < 16; i++) {
+				bytes.push(lanes[i] ?? 0);
+			}
+			return bytes;
+		}
+		if (op.includes("extract_lane") || op.includes("replace_lane")) {
+			bytes.push((inst.lane ?? inst.index ?? 0) & 0xff);
+			return bytes;
+		}
+		return bytes;
+	}
+
 	// 2. Check WasmGC opcodes (0xFB prefix)
 	if (GC_OPCODES[op] !== undefined) {
 		const subOp = GC_OPCODES[op];

package/src/backend/wasm/optimize.js

@@ -24,8 +24,8 @@ import { join } from "node:path";
 import { GOFRONT_SECTION_BYTES, isGoFrontWasm } from "./encode.js";
 
 // Binaryen feature bitmask: GC (1024) | ReferenceTypes (256) | BulkMemory (16) | Multivalue (512) |
-// ExceptionHandling (64) | MutableGlobals (2) | NontrappingFPToInt (4) | TailCall (128) = 2006
-export const DEFAULT_WASM_FEATURES = 2006;
+// ExceptionHandling (64) | MutableGlobals (2) | NontrappingFPToInt (4) | TailCall (128) | SIMD (8) = 2014
+export const DEFAULT_WASM_FEATURES = 2014;
 
 let _nativeWasmOptAvailable = null;
 let _npmWasmOptPath = null;
@@ -98,6 +98,7 @@ function runWasmOpt(
 			"--enable-mutable-globals",
 			"--enable-nontrapping-float-to-int",
 			"--enable-tail-call",
+			"--enable-simd",
 		];
 		if (options.gufa !== false) {
 			args.push("--gufa");
@@ -141,6 +142,7 @@ function runWasmOpt(
 					"--enable-mutable-globals",
 					"--enable-nontrapping-float-to-int",
 					"--enable-tail-call",
+					"--enable-simd",
 					output,
 					"-S",
 					"-o",

package/src/backend/wasm/stdlib/index.js

@@ -13,6 +13,7 @@ import { BINARY_MATH_IMPORTS, StdlibCoreEmitter } from "./core.js";
 import { IoEmitter } from "./io.js";
 import { ExtendedPackagesEmitter } from "./packages.js";
 import { PurePackagesEmitter } from "./pure.js";
+import { SimdEmitter } from "./simd.js";
 import { TimeEmitter } from "./time.js";
 
 // Aliases for backwards compatibility
@@ -24,6 +25,7 @@ export {
 	IoEmitter as Phase7Emitter,
 	PurePackagesEmitter,
 	PurePackagesEmitter as Phase6Emitter,
+	SimdEmitter,
 	StdlibCoreEmitter,
 	StdlibCoreEmitter as StdlibEmitter,
 	TimeEmitter,
@@ -37,4 +39,5 @@ export const stdlibEmitters = [
 	IoEmitter,
 	TimeEmitter,
 	ExtendedPackagesEmitter,
+	SimdEmitter,
 ];

package/src/backend/wasm/stdlib/simd.js

@@ -0,0 +1,234 @@
+// src/backend/wasm/stdlib/simd.js
+// FunctionEmitter mixin: gofront/simd (F32x4 vector math, load/store, composite literals).
+
+const SIMD_BINARY_OPS = {
+	Add: "f32x4.add",
+	Sub: "f32x4.sub",
+	Mul: "f32x4.mul",
+	Div: "f32x4.div",
+	Min: "f32x4.min",
+	Max: "f32x4.max",
+};
+
+export class SimdEmitter {
+	emitSimdCompositeLit(lit) {
+		const elems = lit.elems ?? [];
+		if (elems.length === 0) {
+			this.pushInstruction({ op: "v128.const", bytes: new Array(16).fill(0) });
+			return;
+		}
+
+		const constVals = elems.map((e) => this._getConstFloatValue(e));
+		const allConst = constVals.every((v) => v !== null);
+
+		if (allConst) {
+			const vals = [0, 0, 0, 0];
+			for (let i = 0; i < Math.min(elems.length, 4); i++) {
+				vals[i] = constVals[i];
+			}
+			this.pushInstruction({ op: "v128.const", values: vals });
+			return;
+		}
+
+		// Runtime elements: splat lane 0, replace lanes 1, 2, 3
+		this.emitExpr(elems[0], "f32");
+		this.pushInstruction("f32x4.splat");
+		for (let i = 1; i < 4; i++) {
+			if (elems[i]) {
+				this.emitExpr(elems[i], "f32");
+			} else {
+				this.pushInstruction({ op: "f32.const", value: 0.0 });
+			}
+			this.pushInstruction({ op: "f32x4.replace_lane", lane: i });
+		}
+	}
+
+	_emitSimdDot(recvExpr, otherExpr, count) {
+		this.emitExpr(recvExpr, "v128");
+		this.emitExpr(otherExpr, "v128");
+		this.pushInstruction("f32x4.mul");
+		const tmp = this.acquireTemp("v128");
+		this.pushInstruction({ op: "local.set", index: tmp });
+		this.pushInstruction({ op: "local.get", index: tmp });
+		this.pushInstruction({ op: "f32x4.extract_lane", lane: 0 });
+		for (let i = 1; i < count; i++) {
+			this.pushInstruction({ op: "local.get", index: tmp });
+			this.pushInstruction({ op: "f32x4.extract_lane", lane: i });
+			this.pushInstruction("f32.add");
+		}
+		this.releaseTemp(tmp, "v128");
+	}
+
+	emitSimdMethodCall(method, recvExpr, args, _targetWasmType) {
+		const op = SIMD_BINARY_OPS[method];
+		if (op) {
+			this.emitExpr(recvExpr, "v128");
+			this.emitExpr(args[0], "v128");
+			this.pushInstruction(op);
+			return true;
+		}
+		if (method === "Dot3" || method === "Dot4") {
+			this._emitSimdDot(recvExpr, args[0], method === "Dot3" ? 3 : 4);
+			return true;
+		}
+		if (method === "Lane") {
+			const laneIdx = this._constIntValue(args[0]) ?? 0;
+			this.emitExpr(recvExpr, "v128");
+			this.pushInstruction({ op: "f32x4.extract_lane", lane: laneIdx });
+			return true;
+		}
+		if (method === "WithLane") {
+			const laneIdx = this._constIntValue(args[0]) ?? 0;
+			this.emitExpr(recvExpr, "v128");
+			this.emitExpr(args[1], "f32");
+			this.pushInstruction({ op: "f32x4.replace_lane", lane: laneIdx });
+			return true;
+		}
+		if (method === "Splat") {
+			this.emitExpr(args[0], "f32");
+			this.pushInstruction("f32x4.splat");
+			return true;
+		}
+		return false;
+	}
+
+	emitSimdPackageCall(fn, args, _targetWasmType) {
+		switch (fn) {
+			case "Splat":
+				this.emitExpr(args[0], "f32");
+				this.pushInstruction("f32x4.splat");
+				return true;
+			case "NewF32x4":
+				this.emitExpr(args[0], "f32");
+				this.pushInstruction("f32x4.splat");
+				this.emitExpr(args[1], "f32");
+				this.pushInstruction({ op: "f32x4.replace_lane", lane: 1 });
+				this.emitExpr(args[2], "f32");
+				this.pushInstruction({ op: "f32x4.replace_lane", lane: 2 });
+				this.emitExpr(args[3], "f32");
+				this.pushInstruction({ op: "f32x4.replace_lane", lane: 3 });
+				return true;
+			case "LoadF32x4":
+				this.emitSimdLoad(args[0], args[1]);
+				return true;
+			case "StoreF32x4":
+				this.emitSimdStore(args[0], args[1], args[2]);
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	_emitSharedFloat32Address(bufNode, indexNode) {
+		const { wType, typeIndex } = this.mod.getSharedType();
+		const bufTmp = this.acquireTemp(wType);
+		const iTmp = this.acquireTemp("i32");
+
+		this.emitExpr(bufNode, wType);
+		this.pushInstruction({ op: "local.set", index: bufTmp });
+
+		// Bounds check 1: if unsigned(len) < 4 branch to OOB
+		this.pushInstruction({ op: "local.get", index: bufTmp });
+		this.pushInstruction({ op: "struct.get", typeIndex, fieldIndex: 1 });
+		this.pushInstruction({ op: "i32.const", value: 4 });
+		this.pushInstruction("i32.lt_u");
+		this._emitBoundsBranch();
+
+		if (this._isI32IndexExpr(indexNode)) {
+			this.emitExpr(indexNode, "i32");
+			this.pushInstruction({ op: "local.set", index: iTmp });
+
+			// Bounds check: if unsigned(i) > len - 4 branch to OOB
+			this.pushInstruction({ op: "local.get", index: iTmp });
+			this.pushInstruction({ op: "local.get", index: bufTmp });
+			this.pushInstruction({ op: "struct.get", typeIndex, fieldIndex: 1 });
+			this.pushInstruction({ op: "i32.const", value: 4 });
+			this.pushInstruction("i32.sub");
+			this.pushInstruction("i32.gt_u");
+			this._emitBoundsBranch();
+		} else {
+			const idx64 = this.acquireTemp("i64");
+			this.emitExpr(indexNode, "i64");
+			this.pushInstruction({ op: "local.set", index: idx64 });
+
+			// Bounds check in 64-bit: if unsigned(idx64) > unsigned(len - 4) branch to OOB
+			this.pushInstruction({ op: "local.get", index: idx64 });
+			this.pushInstruction({ op: "local.get", index: bufTmp });
+			this.pushInstruction({ op: "struct.get", typeIndex, fieldIndex: 1 });
+			this.pushInstruction({ op: "i32.const", value: 4 });
+			this.pushInstruction("i32.sub");
+			this.pushInstruction("i64.extend_i32_u");
+			this.pushInstruction("i64.gt_u");
+			this._emitBoundsBranch();
+
+			this.pushInstruction({ op: "local.get", index: idx64 });
+			this.pushInstruction("i32.wrap_i64");
+			this.pushInstruction({ op: "local.set", index: iTmp });
+			this.releaseTemp(idx64, "i64");
+		}
+
+		// Address: buf.base + (i << 2)
+		this.pushInstruction({ op: "local.get", index: bufTmp });
+		this.pushInstruction({ op: "struct.get", typeIndex, fieldIndex: 0 });
+		this.pushInstruction({ op: "local.get", index: iTmp });
+		this.pushInstruction({ op: "i32.const", value: 2 });
+		this.pushInstruction("i32.shl");
+		this.pushInstruction("i32.add");
+
+		this.releaseTemp(bufTmp, wType);
+		this.releaseTemp(iTmp, "i32");
+	}
+
+	emitSimdLoad(bufNode, indexNode) {
+		this._emitSharedFloat32Address(bufNode, indexNode);
+		this.pushInstruction({ op: "v128.load", align: 2, offset: 0 });
+	}
+
+	emitSimdStore(bufNode, indexNode, valNode) {
+		this._emitSharedFloat32Address(bufNode, indexNode);
+		this.emitExpr(valNode, "v128");
+		this.pushInstruction({ op: "v128.store", align: 2, offset: 0 });
+	}
+
+	_constIntValue(node) {
+		if (!node) return null;
+		if (node.kind === "BasicLit" && node.litKind === "INT") {
+			return Number(node.value);
+		}
+		if (node.kind === "Ident") {
+			const c = this.mod?.resolveConst?.(node.name);
+			if (c && c.kind === "BasicLit") {
+				return Number(c.value);
+			}
+		}
+		if (node.kind === "ParenExpr") {
+			return this._constIntValue(node.expr);
+		}
+		if (node.kind === "UnaryExpr" && node.op === "+") {
+			return this._constIntValue(node.operand);
+		}
+		return null;
+	}
+
+	_getConstFloatValue(e) {
+		if (!e) return null;
+		if (
+			e.kind === "BasicLit" &&
+			(e.litKind === "FLOAT" || e.litKind === "INT")
+		) {
+			return Number(e.value);
+		}
+		if (e.kind === "UnaryExpr" && (e.op === "-" || e.op === "+")) {
+			const v = this._getConstFloatValue(e.operand);
+			return v !== null ? (e.op === "-" ? -v : v) : null;
+		}
+		if (e.kind === "Ident") {
+			const c = this.mod?.resolveConst?.(e.name);
+			if (c) return this._getConstFloatValue(c);
+		}
+		if (e.kind === "ParenExpr") {
+			return this._getConstFloatValue(e.expr);
+		}
+		return null;
+	}
+}

package/src/backend/wasm/types.js

@@ -27,6 +27,7 @@ export function toWasmType(goType, checker = null, mod = null) {
 			goType === "i64" ||
 			goType === "f32" ||
 			goType === "f64" ||
+			goType === "v128" ||
 			goType === "anyref" ||
 			goType === "externref" ||
 			goType === "funcref"
@@ -39,6 +40,16 @@ export function toWasmType(goType, checker = null, mod = null) {
 	}
 	if (isTestingT(goType)) return "externref";
 
+	if (
+		goType.kind === "simd" ||
+		(goType.kind === "named" &&
+			(goType.name === "simd.F32x4" ||
+				goType.name === "F32x4" ||
+				goType.underlying?.kind === "simd"))
+	) {
+		return "v128";
+	}
+
 	// Pointer AST nodes
 	if (goType.kind === "PointerType") {
 		return toWasmType({ kind: "pointer", base: goType.base }, checker, mod);
@@ -68,6 +79,9 @@ export function toWasmType(goType, checker = null, mod = null) {
 
 	// TypeName AST node
 	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		if (goType.name === "simd.F32x4" || goType.name === "F32x4") {
+			return "v128";
+		}
 		if (mod?.getStructType(goType.name)) {
 			return {
 				kind: "ref",
@@ -84,6 +98,13 @@ export function toWasmType(goType, checker = null, mod = null) {
 
 	// Unwrap named types
 	if (goType.kind === "named") {
+		if (
+			goType.name === "simd.F32x4" ||
+			goType.name === "F32x4" ||
+			goType.underlying?.kind === "simd"
+		) {
+			return "v128";
+		}
 		if (mod?.getStructType(goType.name)) {
 			return {
 				kind: "ref",

package/src/backend/wasm/wat.js

@@ -98,6 +98,43 @@ function formatInstruction(inst) {
 		case "i32.store8":
 		case "i32.store16":
 			return inst.offset ? `${op} offset=${inst.offset}` : op;
+		case "v128.load":
+		case "v128.store": {
+			const parts = [op];
+			if (inst.offset) parts.push(`offset=${inst.offset}`);
+			if (inst.align !== undefined) parts.push(`align=${1 << inst.align}`);
+			return parts.join(" ");
+		}
+		case "v128.const": {
+			if (inst.values && inst.values.length === 4) {
+				return `${op} f32x4 ${inst.values.join(" ")}`;
+			}
+			if (inst.bytes) {
+				const b = new Uint8Array(16);
+				b.set(inst.bytes.slice(0, 16));
+				const dv = new DataView(b.buffer);
+				return `${op} i32x4 ${dv.getInt32(0, true)} ${dv.getInt32(4, true)} ${dv.getInt32(8, true)} ${dv.getInt32(12, true)}`;
+			}
+			return `${op} i32x4 0 0 0 0`;
+		}
+		case "i8x16.shuffle": {
+			const lanes = (inst.lanes ?? inst.indices ?? []).slice(0, 16);
+			while (lanes.length < 16) lanes.push(0);
+			return `${op} ${lanes.join(" ")}`;
+		}
+		case "i8x16.extract_lane_s":
+		case "i8x16.extract_lane_u":
+		case "i8x16.replace_lane":
+		case "i16x8.extract_lane_s":
+		case "i16x8.extract_lane_u":
+		case "i16x8.replace_lane":
+		case "i32x4.extract_lane":
+		case "i32x4.replace_lane":
+		case "i64x2.extract_lane":
+		case "i64x2.replace_lane":
+		case "f32x4.extract_lane":
+		case "f32x4.replace_lane":
+			return `${op} ${inst.lane ?? inst.index ?? 0}`;
 		case "i32.const":
 		case "i64.const":
 			return `${op} ${inst.value ?? 0}`;