Merge pull request #11280 from Luukdegram/wasm-errors

stage2: wasm - `@errorName` and more
2022-03-23 20:18:50 -04:00
parent a36f4ee290 5cb16dfa59
commit e02ec8f7f5
15 changed files with 263 additions and 76 deletions
--- a/src/arch/wasm/CodeGen.zig
+++ b/src/arch/wasm/CodeGen.zig
@@ -1329,6 +1329,7 @@ fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
        .fptrunc => self.airFptrunc(inst),
        .fpext => self.airFpext(inst),
        .float_to_int => self.airFloatToInt(inst),
+        .int_to_float => self.airIntToFloat(inst),
        .get_union_tag => self.airGetUnionTag(inst),

        // TODO
@@ -1382,6 +1383,8 @@ fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
        .slice_elem_val => self.airSliceElemVal(inst),
        .slice_elem_ptr => self.airSliceElemPtr(inst),
        .slice_ptr => self.airSlicePtr(inst),
+        .ptr_slice_len_ptr => self.airPtrSliceFieldPtr(inst, self.ptrSize()),
+        .ptr_slice_ptr_ptr => self.airPtrSliceFieldPtr(inst, 0),
        .store => self.airStore(inst),

        .set_union_tag => self.airSetUnionTag(inst),
@@ -1398,11 +1401,14 @@ fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
        .unreach => self.airUnreachable(inst),

        .wrap_optional => self.airWrapOptional(inst),
-        .unwrap_errunion_payload => self.airUnwrapErrUnionPayload(inst),
-        .unwrap_errunion_err => self.airUnwrapErrUnionError(inst),
+        .unwrap_errunion_payload => self.airUnwrapErrUnionPayload(inst, false),
+        .unwrap_errunion_payload_ptr => self.airUnwrapErrUnionPayload(inst, true),
+        .unwrap_errunion_err => self.airUnwrapErrUnionError(inst, false),
+        .unwrap_errunion_err_ptr => self.airUnwrapErrUnionError(inst, true),
        .wrap_errunion_payload => self.airWrapErrUnionPayload(inst),
        .wrap_errunion_err => self.airWrapErrUnionErr(inst),
        .errunion_payload_ptr_set => self.airErrUnionPayloadPtrSet(inst),
+        .error_name => self.airErrorName(inst),

        .wasm_memory_size => self.airWasmMemorySize(inst),
        .wasm_memory_grow => self.airWasmMemoryGrow(inst),
@@ -1428,8 +1434,6 @@ fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
        .bit_reverse,
        .is_err_ptr,
        .is_non_err_ptr,
-        .unwrap_errunion_payload_ptr,
-        .unwrap_errunion_err_ptr,

        .sqrt,
        .sin,
@@ -1445,9 +1449,6 @@ fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
        .round,
        .trunc_float,

-        .ptr_slice_len_ptr,
-        .ptr_slice_ptr_ptr,
-        .int_to_float,
        .cmpxchg_weak,
        .cmpxchg_strong,
        .fence,
@@ -1458,7 +1459,6 @@ fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
        .atomic_store_seq_cst,
        .atomic_rmw,
        .tag_name,
-        .error_name,
        .mul_add,

        // For these 4, probably best to wait until https://github.com/ziglang/zig/issues/10248
@@ -1886,6 +1886,23 @@ fn lowerParentPtr(self: *Self, ptr_val: Value, ptr_child_ty: Type) InnerError!WV
                .offset = @intCast(u32, offset),
            } };
        },
+        .opt_payload_ptr => {
+            const payload_ptr = ptr_val.castTag(.opt_payload_ptr).?.data;
+            const parent_ptr = try self.lowerParentPtr(payload_ptr.container_ptr, payload_ptr.container_ty);
+            var buf: Type.Payload.ElemType = undefined;
+            const payload_ty = payload_ptr.container_ty.optionalChild(&buf);
+            if (!payload_ty.hasRuntimeBitsIgnoreComptime() or payload_ty.isPtrLikeOptional()) {
+                return parent_ptr;
+            }
+
+            const abi_size = payload_ptr.container_ty.abiSize(self.target);
+            const offset = abi_size - payload_ty.abiSize(self.target);
+
+            return WValue{ .memory_offset = .{
+                .pointer = parent_ptr.memory,
+                .offset = @intCast(u32, offset),
+            } };
+        },
        else => |tag| return self.fail("TODO: Implement lowerParentPtr for tag: {}", .{tag}),
    }
 }
@@ -1948,7 +1965,7 @@ fn lowerConstant(self: *Self, val: Value, ty: Type) InnerError!WValue {
            else => unreachable,
        },
        .Pointer => switch (val.tag()) {
-            .field_ptr, .elem_ptr => {
+            .field_ptr, .elem_ptr, .opt_payload_ptr => {
                return self.lowerParentPtr(val, ty.childType());
            },
            .int_u64, .one => return WValue{ .imm32 = @intCast(u32, val.toUnsignedInt(target)) },
@@ -2452,7 +2469,11 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
                        if (case_value.integer == value) break :blk @intCast(u32, idx);
                    }
                }
-                break :blk if (has_else_body) case_i else unreachable;
+                // error sets are almost always sparse so we use the default case
+                // for errors that are not present in any branch. This is fine as this default
+                // case will never be hit for those cases but we do save runtime cost and size
+                // by using a jump table for this instead of if-else chains.
+                break :blk if (has_else_body or target_ty.zigTypeTag() == .ErrorSet) case_i else unreachable;
            };
            self.mir_extra.appendAssumeCapacity(idx);
        } else if (has_else_body) {
@@ -2539,30 +2560,32 @@ fn airIsErr(self: *Self, inst: Air.Inst.Index, opcode: wasm.Opcode) InnerError!W
    return is_err_tmp;
 }

-fn airUnwrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
+fn airUnwrapErrUnionPayload(self: *Self, inst: Air.Inst.Index, op_is_ptr: bool) InnerError!WValue {
    if (self.liveness.isUnused(inst)) return WValue{ .none = {} };
    const ty_op = self.air.instructions.items(.data)[inst].ty_op;
    const operand = try self.resolveInst(ty_op.operand);
-    const err_ty = self.air.typeOf(ty_op.operand);
+    const op_ty = self.air.typeOf(ty_op.operand);
+    const err_ty = if (op_is_ptr) op_ty.childType() else op_ty;
    const payload_ty = err_ty.errorUnionPayload();
    if (!payload_ty.hasRuntimeBits()) return WValue{ .none = {} };
    const err_align = err_ty.abiAlignment(self.target);
    const set_size = err_ty.errorUnionSet().abiSize(self.target);
    const offset = mem.alignForwardGeneric(u64, set_size, err_align);
-    if (isByRef(payload_ty, self.target)) {
+    if (op_is_ptr or isByRef(payload_ty, self.target)) {
        return self.buildPointerOffset(operand, offset, .new);
    }
    return self.load(operand, payload_ty, @intCast(u32, offset));
 }

-fn airUnwrapErrUnionError(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
+fn airUnwrapErrUnionError(self: *Self, inst: Air.Inst.Index, op_is_ptr: bool) InnerError!WValue {
    if (self.liveness.isUnused(inst)) return WValue{ .none = {} };

    const ty_op = self.air.instructions.items(.data)[inst].ty_op;
    const operand = try self.resolveInst(ty_op.operand);
-    const err_ty = self.air.typeOf(ty_op.operand);
+    const op_ty = self.air.typeOf(ty_op.operand);
+    const err_ty = if (op_is_ptr) op_ty.childType() else op_ty;
    const payload_ty = err_ty.errorUnionPayload();
-    if (!payload_ty.hasRuntimeBits()) {
+    if (op_is_ptr or !payload_ty.hasRuntimeBits()) {
        return operand;
    }

@@ -3210,6 +3233,28 @@ fn airFloatToInt(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
    return result;
 }

+fn airIntToFloat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
+    if (self.liveness.isUnused(inst)) return WValue{ .none = {} };
+
+    const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+    const operand = try self.resolveInst(ty_op.operand);
+    const dest_ty = self.air.typeOfIndex(inst);
+    const op_ty = self.air.typeOf(ty_op.operand);
+
+    try self.emitWValue(operand);
+    const op = buildOpcode(.{
+        .op = .convert,
+        .valtype1 = typeToValtype(dest_ty, self.target),
+        .valtype2 = typeToValtype(op_ty, self.target),
+        .signedness = if (op_ty.isSignedInt()) .signed else .unsigned,
+    });
+    try self.addTag(Mir.Inst.Tag.fromOpcode(op));
+
+    const result = try self.allocLocal(dest_ty);
+    try self.addLabel(.local_set, result.local);
+    return result;
+}
+
 fn airSplat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
    if (self.liveness.isUnused(inst)) return WValue{ .none = {} };

@@ -3618,3 +3663,54 @@ fn airPopcount(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
    try self.addLabel(.local_set, result.local);
    return result;
 }
+
+fn airErrorName(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
+    if (self.liveness.isUnused(inst)) return WValue{ .none = {} };
+
+    const un_op = self.air.instructions.items(.data)[inst].un_op;
+    const operand = try self.resolveInst(un_op);
+
+    // First retrieve the symbol index to the error name table
+    // that will be used to emit a relocation for the pointer
+    // to the error name table.
+    //
+    // Each entry to this table is a slice (ptr+len).
+    // The operand in this instruction represents the index within this table.
+    // This means to get the final name, we emit the base pointer and then perform
+    // pointer arithmetic to find the pointer to this slice and return that.
+    //
+    // As the names are global and the slice elements are constant, we do not have
+    // to make a copy of the ptr+value but can point towards them directly.
+    const error_table_symbol = try self.bin_file.getErrorTableSymbol();
+    const name_ty = Type.initTag(.const_slice_u8_sentinel_0);
+    const abi_size = name_ty.abiSize(self.target);
+
+    const error_name_value: WValue = .{ .memory = error_table_symbol }; // emitting this will create a relocation
+    try self.emitWValue(error_name_value);
+    try self.emitWValue(operand);
+    switch (self.arch()) {
+        .wasm32 => {
+            try self.addImm32(@bitCast(i32, @intCast(u32, abi_size)));
+            try self.addTag(.i32_mul);
+            try self.addTag(.i32_add);
+        },
+        .wasm64 => {
+            try self.addImm64(abi_size);
+            try self.addTag(.i64_mul);
+            try self.addTag(.i64_add);
+        },
+        else => unreachable,
+    }
+
+    const result_ptr = try self.allocLocal(Type.usize);
+    try self.addLabel(.local_set, result_ptr.local);
+    return result_ptr;
+}
+
+fn airPtrSliceFieldPtr(self: *Self, inst: Air.Inst.Index, offset: u32) InnerError!WValue {
+    if (self.liveness.isUnused(inst)) return WValue{ .none = {} };
+
+    const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+    const slice_ptr = try self.resolveInst(ty_op.operand);
+    return self.buildPointerOffset(slice_ptr, offset, .new);
+}
--- a/src/arch/wasm/Emit.zig
+++ b/src/arch/wasm/Emit.zig
@@ -203,6 +203,14 @@ pub fn emitMir(emit: *Emit) InnerError!void {
            .i64_trunc_f32_u => try emit.emitTag(tag),
            .i64_trunc_f64_s => try emit.emitTag(tag),
            .i64_trunc_f64_u => try emit.emitTag(tag),
+            .f32_convert_i32_s => try emit.emitTag(tag),
+            .f32_convert_i32_u => try emit.emitTag(tag),
+            .f32_convert_i64_s => try emit.emitTag(tag),
+            .f32_convert_i64_u => try emit.emitTag(tag),
+            .f64_convert_i32_s => try emit.emitTag(tag),
+            .f64_convert_i32_u => try emit.emitTag(tag),
+            .f64_convert_i64_s => try emit.emitTag(tag),
+            .f64_convert_i64_u => try emit.emitTag(tag),
            .i32_rem_s => try emit.emitTag(tag),
            .i32_rem_u => try emit.emitTag(tag),
            .i64_rem_s => try emit.emitTag(tag),
--- a/src/arch/wasm/Mir.zig
+++ b/src/arch/wasm/Mir.zig
@@ -451,8 +451,24 @@ pub const Inst = struct {
        /// Uses `tag`
        i64_trunc_f64_u = 0xB1,
        /// Uses `tag`
+        f32_convert_i32_s = 0xB2,
+        /// Uses `tag`
+        f32_convert_i32_u = 0xB3,
+        /// Uses `tag`
+        f32_convert_i64_s = 0xB4,
+        /// Uses `tag`
+        f32_convert_i64_u = 0xB5,
+        /// Uses `tag`
        f32_demote_f64 = 0xB6,
        /// Uses `tag`
+        f64_convert_i32_s = 0xB7,
+        /// Uses `tag`
+        f64_convert_i32_u = 0xB8,
+        /// Uses `tag`
+        f64_convert_i64_s = 0xB9,
+        /// Uses `tag`
+        f64_convert_i64_u = 0xBA,
+        /// Uses `tag`
        f64_promote_f32 = 0xBB,
        /// Uses `tag`
        i32_reinterpret_f32 = 0xBC,
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -123,6 +123,13 @@ symbol_atom: std.AutoHashMapUnmanaged(SymbolLoc, *Atom) = .{},
 /// Note: The value represents the offset into the string table, rather than the actual string.
 export_names: std.AutoHashMapUnmanaged(SymbolLoc, u32) = .{},

+/// Represents the symbol index of the error name table
+/// When this is `null`, no code references an error using runtime `@errorName`.
+/// During initializion, a symbol with corresponding atom will be created that is
+/// used to perform relocations to the pointer of this table.
+/// The actual table is populated during `flush`.
+error_table_symbol: ?u32 = null,
+
 pub const Segment = struct {
    alignment: u32,
    size: u32,
@@ -1322,6 +1329,123 @@ pub fn getMatchingSegment(self: *Wasm, object_index: u16, relocatable_index: u32
    }
 }

+/// Returns the symbol index of the error name table.
+///
+/// When the symbol does not yet exist, it will create a new one instead.
+pub fn getErrorTableSymbol(self: *Wasm) !u32 {
+    if (self.error_table_symbol) |symbol| {
+        return symbol;
+    }
+
+    // no error was referenced yet, so create a new symbol and atom for it
+    // and then return said symbol's index. The final table will be populated
+    // during `flush` when we know all possible error names.
+
+    // As sym_index '0' is reserved, we use it for our stack pointer symbol
+    const symbol_index = self.symbols_free_list.popOrNull() orelse blk: {
+        const index = @intCast(u32, self.symbols.items.len);
+        _ = try self.symbols.addOne(self.base.allocator);
+        break :blk index;
+    };
+
+    const sym_name = try self.string_table.put(self.base.allocator, "__zig_err_name_table");
+    const symbol = &self.symbols.items[symbol_index];
+    symbol.* = .{
+        .name = sym_name,
+        .tag = .data,
+        .flags = 0,
+        .index = 0,
+    };
+    symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
+
+    const slice_ty = Type.initTag(.const_slice_u8_sentinel_0);
+
+    const atom = try self.base.allocator.create(Atom);
+    atom.* = Atom.empty;
+    atom.sym_index = symbol_index;
+    atom.alignment = slice_ty.abiAlignment(self.base.options.target);
+    try self.managed_atoms.append(self.base.allocator, atom);
+    const loc = atom.symbolLoc();
+    try self.resolved_symbols.put(self.base.allocator, loc, {});
+    try self.symbol_atom.put(self.base.allocator, loc, atom);
+
+    log.debug("Error name table was created with symbol index: ({d})", .{symbol_index});
+    self.error_table_symbol = symbol_index;
+    return symbol_index;
+}
+
+/// Populates the error name table, when `error_table_symbol` is not null.
+///
+/// This creates a table that consists of pointers and length to each error name.
+/// The table is what is being pointed to within the runtime bodies that are generated.
+fn populateErrorNameTable(self: *Wasm) !void {
+    const symbol_index = self.error_table_symbol orelse return;
+    const atom: *Atom = self.symbol_atom.get(.{ .file = null, .index = symbol_index }).?;
+    // Rather than creating a symbol for each individual error name,
+    // we create a symbol for the entire region of error names. We then calculate
+    // the pointers into the list using addends which are appended to the relocation.
+    const names_atom = try self.base.allocator.create(Atom);
+    names_atom.* = Atom.empty;
+    try self.managed_atoms.append(self.base.allocator, names_atom);
+    const names_symbol_index = self.symbols_free_list.popOrNull() orelse blk: {
+        const index = @intCast(u32, self.symbols.items.len);
+        _ = try self.symbols.addOne(self.base.allocator);
+        break :blk index;
+    };
+    names_atom.sym_index = names_symbol_index;
+    names_atom.alignment = 1;
+    const sym_name = try self.string_table.put(self.base.allocator, "__zig_err_names");
+    const names_symbol = &self.symbols.items[names_symbol_index];
+    names_symbol.* = .{
+        .name = sym_name,
+        .tag = .data,
+        .flags = 0,
+        .index = 0,
+    };
+    names_symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
+
+    log.debug("Populating error names", .{});
+
+    // Addend for each relocation to the table
+    var addend: u32 = 0;
+    const module = self.base.options.module.?;
+    for (module.error_name_list.items) |error_name| {
+        const len = @intCast(u32, error_name.len + 1); // names are 0-termianted
+
+        const slice_ty = Type.initTag(.const_slice_u8_sentinel_0);
+        const offset = @intCast(u32, atom.code.items.len);
+        // first we create the data for the slice of the name
+        try atom.code.appendNTimes(self.base.allocator, 0, 4); // ptr to name, will be relocated
+        try atom.code.writer(self.base.allocator).writeIntLittle(u32, len - 1);
+        // create relocation to the error name
+        try atom.relocs.append(self.base.allocator, .{
+            .index = names_symbol_index,
+            .relocation_type = .R_WASM_MEMORY_ADDR_I32,
+            .offset = offset,
+            .addend = addend,
+        });
+        atom.size += @intCast(u32, slice_ty.abiSize(self.base.options.target));
+        addend += len;
+
+        // as we updated the error name table, we now store the actual name within the names atom
+        try names_atom.code.ensureUnusedCapacity(self.base.allocator, len);
+        names_atom.code.appendSliceAssumeCapacity(error_name);
+        names_atom.code.appendAssumeCapacity(0);
+
+        log.debug("Populated error name: '{s}'", .{error_name});
+    }
+    names_atom.size = addend;
+
+    const name_loc = names_atom.symbolLoc();
+    try self.resolved_symbols.put(self.base.allocator, name_loc, {});
+    try self.symbol_atom.put(self.base.allocator, name_loc, names_atom);
+
+    // link the atoms with the rest of the binary so they can be allocated
+    // and relocations will be performed.
+    try self.parseAtom(atom, .data);
+    try self.parseAtom(names_atom, .data);
+}
+
 fn resetState(self: *Wasm) void {
    for (self.segment_info.items) |*segment_info| {
        self.base.allocator.free(segment_info.name);
@@ -1373,6 +1497,9 @@ pub fn flushModule(self: *Wasm, comp: *Compilation) !void {
        }
    }

+    // ensure the error names table is populated when an error name is referenced
+    try self.populateErrorNameTable();
+
    // The amount of sections that will be written
    var section_count: u32 = 0;
    // Index of the code section. Used to tell relocation table where the section lives.
--- a/test/behavior/bugs/11159.zig
+++ b/test/behavior/bugs/11159.zig
@@ -10,7 +10,6 @@ test {
 test {
    if (builtin.zig_backend == .stage1) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO

    const S = struct {
        comptime x: i32 = 0,
--- a/test/behavior/bugs/5398.zig
+++ b/test/behavior/bugs/5398.zig
@@ -19,7 +19,6 @@ pub const Renderable = struct {
 var renderable: Renderable = undefined;

 test "assignment of field with padding" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
--- a/test/behavior/bugs/6456.zig
+++ b/test/behavior/bugs/6456.zig
@@ -12,7 +12,6 @@ const text =

 test "issue 6456" {
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -96,7 +96,6 @@ test "comptime_int @intToFloat" {
 }

 test "@intToFloat" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@@ -545,7 +544,6 @@ test "cast *[1][*]const u8 to [*]const ?[*]const u8" {
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO

    const window_name = [1][*]const u8{"window name"};
    const x: [*]const ?[*]const u8 = &window_name;
@@ -607,7 +605,6 @@ test "@floatCast cast down" {
 }

 test "peer type resolution: unreachable, error set, unreachable" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@@ -818,7 +815,6 @@ test "peer resolution of string literals" {
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO

    const S = struct {
        const E = enum { a, b, c, d };
@@ -910,7 +906,6 @@ test "peer cast [:x]T to [*:x]T" {
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO

    const S = struct {
        fn doTheTest() !void {
@@ -930,7 +925,6 @@ test "peer cast [:x]T to [*:x]T" {

 test "peer type resolution implicit cast to return type" {
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

    const S = struct {
@@ -951,7 +945,6 @@ test "peer type resolution implicit cast to return type" {

 test "peer type resolution implicit cast to variable type" {
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO

@@ -991,7 +984,6 @@ test "cast between C pointer with different but compatible types" {
 }

 test "peer type resolve string lit with sentinel-terminated mutable slice" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
@@ -1011,7 +1003,6 @@ test "peer type resolve array pointers, one of them const" {
 }

 test "peer type resolve array pointer and unknown pointer" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO

    const const_array: [4]u8 = undefined;
@@ -1084,7 +1075,6 @@ test "compile time int to ptr of function" {
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO

    try foobar(FUNCTION_CONSTANT);
 }
--- a/test/behavior/error.zig
+++ b/test/behavior/error.zig
@@ -178,8 +178,6 @@ fn testErrorUnionType() !void {
 }

 test "error set type" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
-
    try testErrorSetType();
    comptime try testErrorSetType();
 }
@@ -221,7 +219,6 @@ fn testExplicitErrorSetCast(set1: Set1) !void {
 }

 test "comptime test error for empty error set" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@@ -338,7 +335,6 @@ fn intLiteral(str: []const u8) !?i64 {
 }

 test "nested error union function call in optional unwrap" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@@ -386,7 +382,6 @@ test "nested error union function call in optional unwrap" {
 }

 test "return function call to error set from error union function" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@@ -418,7 +413,6 @@ test "optional error set is the same size as error set" {
 }

 test "nested catch" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@@ -451,7 +445,6 @@ test "function pointer with return type that is error union with payload which i
    }

    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@@ -477,7 +470,6 @@ test "function pointer with return type that is error union with payload which i
 }

 test "return result loc as peer result loc in inferred error set function" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@@ -509,7 +501,6 @@ test "return result loc as peer result loc in inferred error set function" {
 }

 test "error payload type is correctly resolved" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@@ -540,7 +531,6 @@ test "error union comptime caching" {

 test "@errorName" {
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
@@ -555,7 +545,6 @@ fn gimmeItBroke() anyerror {

 test "@errorName sentinel length matches slice length" {
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
--- a/test/behavior/optional.zig
+++ b/test/behavior/optional.zig
@@ -65,7 +65,6 @@ test "optional with void type" {
 }

 test "address of unwrap optional" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
--- a/test/behavior/pointers.zig
+++ b/test/behavior/pointers.zig
@@ -166,7 +166,6 @@ test "implicit casting between C pointer and optional non-C pointer" {
 }

 test "implicit cast error unions with non-optional to optional pointer" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@@ -282,7 +281,6 @@ test "null terminated pointer" {
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO

    const S = struct {
        fn doTheTest() !void {
@@ -301,7 +299,6 @@ test "allow any sentinel" {
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO

    const S = struct {
        fn doTheTest() !void {
@@ -318,7 +315,6 @@ test "pointer sentinel with enums" {
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO

    const S = struct {
        const Number = enum {
@@ -340,7 +336,6 @@ test "pointer sentinel with optional element" {
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO

    const S = struct {
        fn doTheTest() !void {
@@ -424,7 +419,6 @@ test "@ptrToInt on null optional at comptime" {
 }

 test "indexing array with sentinel returns correct type" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -282,7 +282,6 @@ const Val = struct {

 test "struct point to self" {
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

@@ -300,7 +299,6 @@ test "struct point to self" {

 test "void struct fields" {
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@@ -321,7 +319,6 @@ const VoidStructFieldsFoo = struct {

 test "return empty struct from fn" {
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO

    _ = testReturnEmptyStructFromFn();
@@ -333,7 +330,6 @@ fn testReturnEmptyStructFromFn() EmptyStruct2 {

 test "pass slice of empty struct to fn" {
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO

    try expect(testPassSliceOfEmptyStructToFn(&[_]EmptyStruct2{EmptyStruct2{}}) == 1);
@@ -344,7 +340,6 @@ fn testPassSliceOfEmptyStructToFn(slice: []const EmptyStruct2) usize {

 test "self-referencing struct via array member" {
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@@ -358,7 +353,6 @@ test "self-referencing struct via array member" {
 }

 test "empty struct method call" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO

    const es = EmptyStruct{};
@@ -373,7 +367,6 @@ const EmptyStruct = struct {

 test "align 1 field before self referential align 8 field as slice return type" {
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO

    const result = alloc(Expr);
@@ -633,7 +626,6 @@ fn getC(data: *const BitField1) u2 {

 test "default struct initialization fields" {
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO

    const S = struct {
@@ -775,7 +767,6 @@ test "packed struct with u0 field access" {
 }

 test "access to global struct fields" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
@@ -903,7 +894,6 @@ test "packed struct field passed to generic function" {

 test "anonymous struct literal syntax" {
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO

    const S = struct {
@@ -992,7 +982,6 @@ test "comptime struct field" {
 }

 test "tuple element initialized with fn call" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@@ -1030,7 +1019,6 @@ test "struct with union field" {
 }

 test "type coercion of anon struct literal to struct" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@@ -1069,7 +1057,6 @@ test "type coercion of anon struct literal to struct" {
 }

 test "type coercion of pointer to anon struct literal to pointer to struct" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@@ -1181,7 +1168,6 @@ test "for loop over pointers to struct, getting field from struct pointer" {
 test "anon init through error unions and optionals" {
    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@@ -1210,7 +1196,6 @@ test "anon init through error unions and optionals" {
 test "anon init through optional" {
    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@@ -1232,7 +1217,6 @@ test "anon init through optional" {
 test "anon init through error union" {
    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@@ -1254,7 +1238,6 @@ test "anon init through error union" {
 test "typed init through error unions and optionals" {
    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
--- a/test/behavior/switch.zig
+++ b/test/behavior/switch.zig
@@ -434,7 +434,6 @@ test "else prong of switch on error set excludes other cases" {
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO

    const S = struct {
        fn doTheTest() !void {
@@ -581,7 +580,6 @@ test "switch prongs with cases with identical payload types" {
 }

 test "switch on pointer type" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@@ -630,7 +628,6 @@ test "switch on error set with single else" {
 }

 test "switch capture copies its payload" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
--- a/test/behavior/type.zig
+++ b/test/behavior/type.zig
@@ -353,7 +353,6 @@ test "Type.Struct" {
 }

 test "Type.Enum" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@@ -465,7 +464,6 @@ test "Type.Union" {
 }

 test "Type.Union from Type.Enum" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@@ -496,7 +494,6 @@ test "Type.Union from Type.Enum" {
 }

 test "Type.Union from regular enum" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
--- a/test/behavior/typename.zig
+++ b/test/behavior/typename.zig
@@ -18,7 +18,6 @@ test "anon fn param" {
        return error.SkipZigTest;
    }

-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@@ -51,7 +50,6 @@ test "anon field init" {
        return error.SkipZigTest;
    }

-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@@ -78,7 +76,6 @@ test "anon field init" {
 }

 test "basic" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@@ -95,7 +92,6 @@ test "top level decl" {
        return error.SkipZigTest;
    }

-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@@ -147,7 +143,6 @@ test "fn body decl" {
        return error.SkipZigTest;
    }

-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@@ -182,7 +177,6 @@ const B = struct {
 };

 test "fn param" {
-    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO