gofront 1.7.0 → 1.8.0

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

@@ -96,6 +96,8 @@ export class ExtendedPackagesEmitter {
 		this.pushInstruction("drop");
 		if (method === "TryLock" || method === "TryRLock") {
 			this.pushInstruction({ op: "i32.const", value: 1 });
+		} else if (method === "RLocker") {
+			this.pushInstruction({ op: "ref.null", type: "any" });
 		}
 	}
 

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

@@ -1,13 +1,54 @@
 // src/backend/wasm/stdlib/simd.js
 // FunctionEmitter mixin: gofront/simd (F32x4 vector math, load/store, composite literals).
 
-const SIMD_BINARY_OPS = {
+// Methods lowered to one instruction over the receiver and its vector arguments.
+const SIMD_LANEWISE_OPS = {
 	Add: "f32x4.add",
 	Sub: "f32x4.sub",
 	Mul: "f32x4.mul",
 	Div: "f32x4.div",
 	Min: "f32x4.min",
 	Max: "f32x4.max",
+	Neg: "f32x4.neg",
+	Abs: "f32x4.abs",
+	Sqrt: "f32x4.sqrt",
+	Floor: "f32x4.floor",
+	Ceil: "f32x4.ceil",
+	Trunc: "f32x4.trunc",
+	RoundToEven: "f32x4.nearest",
+	Equal: "f32x4.eq",
+	NotEqual: "f32x4.ne",
+	Less: "f32x4.lt",
+	LessEqual: "f32x4.le",
+	Greater: "f32x4.gt",
+	GreaterEqual: "f32x4.ge",
+};
+
+const SIMD_MASK_OPS = {
+	And: "v128.and",
+	Or: "v128.or",
+	Xor: "v128.xor",
+	AndNot: "v128.andnot",
+	Not: "v128.not",
+	Any: "v128.any_true",
+	All: "i32x4.all_true",
+};
+
+// Methods with their own emitter: name -> FunctionEmitter method.
+const SIMD_SPECIAL_METHODS = {
+	MulAdd: "_emitSimdMulAdd",
+	Sum: "_emitSimdSum",
+	Swizzle: "_emitSimdSwizzle",
+	Dot3: "_emitSimdDot3",
+	Dot4: "_emitSimdDot4",
+	Lane: "_emitSimdLane",
+	WithLane: "_emitSimdWithLane",
+	Splat: "_emitSimdSplat",
+};
+
+const SIMD_MASK_SPECIAL_METHODS = {
+	Bits: "_emitSimdMaskBits",
+	Lane: "_emitSimdMaskLane",
 };
 
 export class SimdEmitter {
@@ -59,41 +100,162 @@ export class SimdEmitter {
 		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;
+	_isSimdMaskType(goType) {
+		return (
+			goType?.name === "simd.Mask32x4" ||
+			goType?.name === "Mask32x4" ||
+			goType?.simd === "Mask32x4" ||
+			goType?.underlying?.simd === "Mask32x4"
+		);
+	}
+
+	// Lane-wise equality of two vectors on the stack -> i32 (Go array `==`:
+	// NaN != NaN, -0 == +0).
+	_emitSimdEq(goType) {
+		this.pushInstruction(
+			this._isSimdMaskType(goType) ? "i32x4.eq" : "f32x4.eq",
+		);
+		this.pushInstruction("i32x4.all_true");
+	}
+
+	_emitSimdSum(recvExpr) {
+		this.emitExpr(recvExpr, "v128");
+		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 < 4; i++) {
+			this.pushInstruction({ op: "local.get", index: tmp });
+			this.pushInstruction({ op: "f32x4.extract_lane", lane: i });
+			this.pushInstruction("f32.add");
 		}
-		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;
+		this.releaseTemp(tmp, "v128");
+	}
+
+	// Lane i (0-3 from a, 4-7 from b) as the four byte indices of an i8x16.shuffle.
+	_simdShuffleBytes(lanes) {
+		const out = [];
+		for (const lane of lanes) {
+			for (let k = 0; k < 4; k++) out.push(lane * 4 + k);
 		}
-		if (method === "Splat") {
-			this.emitExpr(args[0], "f32");
-			this.pushInstruction("f32x4.splat");
+		return out;
+	}
+
+	_simdLaneConsts(nodes, max) {
+		return nodes.map((n) => {
+			const v = this._constIntValue(n);
+			if (v === null || v < 0 || v > max)
+				throw new Error(`simd: lane index must be a constant in [0, ${max}]`);
+			return v;
+		});
+	}
+
+	_emitSimdSwizzle(recvExpr, args) {
+		const lanes = this._simdLaneConsts(args, 3);
+		const tmp = this.acquireTemp("v128");
+		this.emitExpr(recvExpr, "v128");
+		this.pushInstruction({ op: "local.tee", index: tmp });
+		this.pushInstruction({ op: "local.get", index: tmp });
+		this.pushInstruction({
+			op: "i8x16.shuffle",
+			lanes: this._simdShuffleBytes(lanes),
+		});
+		this.releaseTemp(tmp, "v128");
+	}
+
+	_emitSimdSelect(args) {
+		const maskTmp = this.acquireTemp("v128");
+		this.emitExpr(args[0], "v128");
+		this.pushInstruction({ op: "local.set", index: maskTmp });
+		this.emitExpr(args[1], "v128");
+		this.emitExpr(args[2], "v128");
+		this.pushInstruction({ op: "local.get", index: maskTmp });
+		this.pushInstruction("v128.bitselect");
+		this.releaseTemp(maskTmp, "v128");
+	}
+
+	_emitSimdShuffle(args) {
+		const lanes = this._simdLaneConsts(args.slice(2, 6), 7);
+		this.emitExpr(args[0], "v128");
+		this.emitExpr(args[1], "v128");
+		this.pushInstruction({
+			op: "i8x16.shuffle",
+			lanes: this._simdShuffleBytes(lanes),
+		});
+	}
+
+	_emitSimdOp(op, recvExpr, args) {
+		this.emitExpr(recvExpr, "v128");
+		for (const arg of args) this.emitExpr(arg, "v128");
+		this.pushInstruction(op);
+	}
+
+	_emitSimdMaskBits(recvExpr) {
+		this._emitSimdOp("i32x4.bitmask", recvExpr, []);
+		this.pushInstruction("i64.extend_i32_u");
+	}
+
+	_emitSimdMaskLane(recvExpr, args) {
+		const [lane] = this._simdLaneConsts([args[0]], 3);
+		this.emitExpr(recvExpr, "v128");
+		this.pushInstruction({ op: "i32x4.extract_lane", lane });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction("i32.ne");
+	}
+
+	_emitSimdMulAdd(recvExpr, args) {
+		// Two roundings (mul, then add), not fused.
+		this._emitSimdOp("f32x4.mul", recvExpr, [args[0]]);
+		this.emitExpr(args[1], "v128");
+		this.pushInstruction("f32x4.add");
+	}
+
+	_emitSimdDot3(recvExpr, args) {
+		this._emitSimdDot(recvExpr, args[0], 3);
+	}
+
+	_emitSimdDot4(recvExpr, args) {
+		this._emitSimdDot(recvExpr, args[0], 4);
+	}
+
+	_emitSimdLane(recvExpr, args) {
+		const lane = this._constIntValue(args[0]) ?? 0;
+		this.emitExpr(recvExpr, "v128");
+		this.pushInstruction({ op: "f32x4.extract_lane", lane });
+	}
+
+	_emitSimdWithLane(recvExpr, args) {
+		const lane = this._constIntValue(args[0]) ?? 0;
+		this.emitExpr(recvExpr, "v128");
+		this.emitExpr(args[1], "f32");
+		this.pushInstruction({ op: "f32x4.replace_lane", lane });
+	}
+
+	_emitSimdSplat(_recvExpr, args) {
+		this.emitExpr(args[0], "f32");
+		this.pushInstruction("f32x4.splat");
+	}
+
+	emitSimdMethodCall(method, recvExpr, args, _targetWasmType, isMask = false) {
+		const ops = isMask ? SIMD_MASK_OPS : SIMD_LANEWISE_OPS;
+		const specials = isMask ? SIMD_MASK_SPECIAL_METHODS : SIMD_SPECIAL_METHODS;
+		if (ops[method]) {
+			this._emitSimdOp(ops[method], recvExpr, args);
 			return true;
 		}
-		return false;
+		if (!specials[method]) return false;
+		this[specials[method]](recvExpr, args);
+		return true;
 	}
 
 	emitSimdPackageCall(fn, args, _targetWasmType) {
 		switch (fn) {
+			case "Select":
+				this._emitSimdSelect(args);
+				return true;
+			case "Shuffle":
+				this._emitSimdShuffle(args);
+				return true;
 			case "Splat":
 				this.emitExpr(args[0], "f32");
 				this.pushInstruction("f32x4.splat");
@@ -114,6 +276,15 @@ export class SimdEmitter {
 			case "StoreF32x4":
 				this.emitSimdStore(args[0], args[1], args[2]);
 				return true;
+			case "LoadF32x4Slice":
+				this.emitSimdSliceAccess(args[0], args[1], null);
+				return true;
+			case "StoreF32x4Slice":
+				this.emitSimdSliceAccess(args[0], args[1], args[2]);
+				return true;
+			case "Pad4":
+				this._emitSimdPad4(args[0]);
+				return true;
 			default:
 				return false;
 		}
@@ -190,8 +361,102 @@ export class SimdEmitter {
 		this.pushInstruction({ op: "v128.store", align: 2, offset: 0 });
 	}
 
+	// Pad4(n) = (n + 3) &^ 3; a Go int, so always computed as i64.
+	_emitSimdPad4(nNode) {
+		this.emitExpr(nNode, "i64");
+		this.pushInstruction({ op: "i64.const", value: 3n });
+		this.pushInstruction("i64.add");
+		this.pushInstruction({ op: "i64.const", value: -4n });
+		this.pushInstruction("i64.and");
+	}
+
+	// LoadF32x4Slice (valNode null) and StoreF32x4Slice on a []float32: a
+	// GC array cannot be read as v128, so each lane is moved on its own.
+	emitSimdSliceAccess(sliceNode, indexNode, valNode) {
+		const sliceType = sliceNode._type ?? this._resolveExprGoType(sliceNode);
+		const elemGoType = this._getArrayElemType(sliceType);
+		const arrInfo = this.mod.getArrayType(elemGoType);
+		const sliceInfo = this.mod.getSliceType(elemGoType);
+		const sTI = sliceInfo.typeIndex;
+		const sliceWType = { kind: "ref", nullable: true, typeIndex: sTI };
+		const sliceTmp = this.acquireTemp(sliceWType);
+		const idx64 = this.acquireTemp("i64");
+		const baseTmp = this.acquireTemp("i32");
+		const vecTmp = valNode ? this.acquireTemp("v128") : null;
+		const lenOf = () => {
+			this.pushInstruction({ op: "local.get", index: sliceTmp });
+			this.pushInstruction({ op: "struct.get", typeIndex: sTI, fieldIndex: 2 });
+		};
+
+		this.emitExpr(sliceNode, sliceWType);
+		this.pushInstruction({ op: "local.set", index: sliceTmp });
+		if (this._isI32IndexExpr(indexNode)) {
+			this.emitExpr(indexNode, "i32");
+			this.pushInstruction("i64.extend_i32_s");
+		} else {
+			this.emitExpr(indexNode, "i64");
+		}
+		this.pushInstruction({ op: "local.set", index: idx64 });
+		if (valNode) {
+			this.emitExpr(valNode, "v128");
+			this.pushInstruction({ op: "local.set", index: vecTmp });
+		}
+
+		// Out of range when len < 4 or unsigned(i) > len - 4 (negative i wraps).
+		lenOf();
+		this.pushInstruction({ op: "i32.const", value: 4 });
+		this.pushInstruction("i32.lt_u");
+		this._emitBoundsBranch();
+		this.pushInstruction({ op: "local.get", index: idx64 });
+		lenOf();
+		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: sliceTmp });
+		this.pushInstruction({ op: "struct.get", typeIndex: sTI, fieldIndex: 1 });
+		this.pushInstruction({ op: "local.get", index: idx64 });
+		this.pushInstruction("i32.wrap_i64");
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: baseTmp });
+
+		const elemAt = (lane) => {
+			this.pushInstruction({ op: "local.get", index: sliceTmp });
+			this.pushInstruction({ op: "struct.get", typeIndex: sTI, fieldIndex: 0 });
+			this.pushInstruction({ op: "local.get", index: baseTmp });
+			if (lane) {
+				this.pushInstruction({ op: "i32.const", value: lane });
+				this.pushInstruction("i32.add");
+			}
+		};
+		if (valNode) {
+			for (let lane = 0; lane < 4; lane++) {
+				elemAt(lane);
+				this.pushInstruction({ op: "local.get", index: vecTmp });
+				this.pushInstruction({ op: "f32x4.extract_lane", lane });
+				this.pushInstruction({ op: "array.set", typeIndex: arrInfo.typeIndex });
+			}
+		} else {
+			elemAt(0);
+			this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+			this.pushInstruction("f32x4.splat");
+			for (let lane = 1; lane < 4; lane++) {
+				elemAt(lane);
+				this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+				this.pushInstruction({ op: "f32x4.replace_lane", lane });
+			}
+		}
+		if (vecTmp !== null) this.releaseTemp(vecTmp, "v128");
+		this.releaseTemp(baseTmp, "i32");
+		this.releaseTemp(idx64, "i64");
+		this.releaseTemp(sliceTmp, sliceWType);
+	}
+
 	_constIntValue(node) {
 		if (!node) return null;
+		if (typeof node._constInt === "number") return node._constInt;
 		if (node.kind === "BasicLit" && node.litKind === "INT") {
 			return Number(node.value);
 		}