authorgravatar for luuk@degram.devLuuk de Gram <luuk@degram.dev> 2023-06-01 19:42:04+02:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2023-06-01 19:42:04+02:00
log3faf376b081caa47a98a172fe7c7f63f82b150e4
tree26924f0e7aa1720da8e21b9e784b7725246ab712
parent6c2f3745564aefa669b336e249888bb7390b3a3f
parent1042deb86fd57278f3a16fd064b370bf72f28160
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #15919 from Luukdegram/wasm-behavior-tests

21 files changed, 197 insertions(+), 82 deletions(-)

src/arch/wasm/CodeGen.zig+193-36
......@@ -1014,6 +1014,17 @@ fn typeToValtype(ty: Type, target: std.Target) wasm.Valtype {
10141014 .direct => wasm.Valtype.v128,
10151015 .unrolled => wasm.Valtype.i32,
10161016 },
1017 .Union => switch (ty.containerLayout()) {
1018 .Packed => {
1019 var int_ty_payload: Type.Payload.Bits = .{
1020 .base = .{ .tag = .int_unsigned },
1021 .data = @intCast(u16, ty.bitSize(target)),
1022 };
1023 const int_ty = Type.initPayload(&int_ty_payload.base);
1024 return typeToValtype(int_ty, target);
1025 },
1026 else => wasm.Valtype.i32,
1027 },
10171028 else => wasm.Valtype.i32, // all represented as reference/immediate
10181029 };
10191030}
......@@ -1715,8 +1726,15 @@ fn isByRef(ty: Type, target: std.Target) bool {
17151726
17161727 .Array,
17171728 .Frame,
1718 .Union,
17191729 => return ty.hasRuntimeBitsIgnoreComptime(),
1730 .Union => {
1731 if (ty.castTag(.@"union")) |union_ty| {
1732 if (union_ty.data.layout == .Packed) {
1733 return ty.abiSize(target) > 8;
1734 }
1735 }
1736 return ty.hasRuntimeBitsIgnoreComptime();
1737 },
17201738 .Struct => {
17211739 if (ty.castTag(.@"struct")) |struct_ty| {
17221740 const struct_obj = struct_ty.data;
......@@ -2311,6 +2329,7 @@ fn airStore(func: *CodeGen, inst: Air.Inst.Index, safety: bool) InnerError!void
23112329
23122330fn store(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerError!void {
23132331 assert(!(lhs != .stack and rhs == .stack));
2332 const abi_size = ty.abiSize(func.target);
23142333 switch (ty.zigTypeTag()) {
23152334 .ErrorUnion => {
23162335 const pl_ty = ty.errorUnionPayload();
......@@ -2318,7 +2337,7 @@ fn store(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerE
23182337 return func.store(lhs, rhs, Type.anyerror, 0);
23192338 }
23202339
2321 const len = @intCast(u32, ty.abiSize(func.target));
2340 const len = @intCast(u32, abi_size);
23222341 return func.memcpy(lhs, rhs, .{ .imm32 = len });
23232342 },
23242343 .Optional => {
......@@ -2334,16 +2353,16 @@ fn store(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerE
23342353 return func.store(lhs, rhs, Type.anyerror, 0);
23352354 }
23362355
2337 const len = @intCast(u32, ty.abiSize(func.target));
2356 const len = @intCast(u32, abi_size);
23382357 return func.memcpy(lhs, rhs, .{ .imm32 = len });
23392358 },
23402359 .Struct, .Array, .Union => if (isByRef(ty, func.target)) {
2341 const len = @intCast(u32, ty.abiSize(func.target));
2360 const len = @intCast(u32, abi_size);
23422361 return func.memcpy(lhs, rhs, .{ .imm32 = len });
23432362 },
23442363 .Vector => switch (determineSimdStoreStrategy(ty, func.target)) {
23452364 .unrolled => {
2346 const len = @intCast(u32, ty.abiSize(func.target));
2365 const len = @intCast(u32, abi_size);
23472366 return func.memcpy(lhs, rhs, .{ .imm32 = len });
23482367 },
23492368 .direct => {
......@@ -2375,7 +2394,7 @@ fn store(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerE
23752394 return;
23762395 }
23772396 },
2378 .Int => if (ty.intInfo(func.target).bits > 64) {
2397 .Int, .Float => if (abi_size > 8 and abi_size <= 16) {
23792398 try func.emitWValue(lhs);
23802399 const lsb = try func.load(rhs, Type.u64, 0);
23812400 try func.store(.{ .stack = {} }, lsb, Type.u64, 0 + lhs.offset());
......@@ -2384,8 +2403,15 @@ fn store(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerE
23842403 const msb = try func.load(rhs, Type.u64, 8);
23852404 try func.store(.{ .stack = {} }, msb, Type.u64, 8 + lhs.offset());
23862405 return;
2406 } else if (abi_size > 16) {
2407 try func.memcpy(lhs, rhs, .{ .imm32 = @intCast(u32, ty.abiSize(func.target)) });
2408 },
2409 else => if (abi_size > 8) {
2410 return func.fail("TODO: `store` for type `{}` with abisize `{d}`", .{
2411 ty.fmt(func.bin_file.base.options.module.?),
2412 abi_size,
2413 });
23872414 },
2388 else => {},
23892415 }
23902416 try func.emitWValue(lhs);
23912417 // In this case we're actually interested in storing the stack position
......@@ -2393,11 +2419,9 @@ fn store(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerE
23932419 try func.lowerToStack(rhs);
23942420
23952421 const valtype = typeToValtype(ty, func.target);
2396 const abi_size = @intCast(u8, ty.abiSize(func.target));
2397
23982422 const opcode = buildOpcode(.{
23992423 .valtype1 = valtype,
2400 .width = abi_size * 8,
2424 .width = @intCast(u8, abi_size * 8),
24012425 .op = .store,
24022426 });
24032427
......@@ -3131,6 +3155,14 @@ fn lowerConstant(func: *CodeGen, arg_val: Value, ty: Type) InnerError!WValue {
31313155 val.writeToMemory(ty, func.bin_file.base.options.module.?, &buf) catch unreachable;
31323156 return func.storeSimdImmd(buf);
31333157 },
3158 .Union => {
3159 // in this case we have a packed union which will not be passed by reference.
3160 const union_ty = ty.cast(Type.Payload.Union).?.data;
3161 const union_obj = val.castTag(.@"union").?.data;
3162 const field_index = ty.unionTagFieldIndex(union_obj.tag, func.bin_file.base.options.module.?).?;
3163 const field_ty = union_ty.fields.values()[field_index].ty;
3164 return func.lowerConstant(union_obj.val, field_ty);
3165 },
31343166 else => |zig_type| return func.fail("Wasm TODO: LowerConstant for zigTypeTag {}", .{zig_type}),
31353167 }
31363168}
......@@ -3146,7 +3178,7 @@ fn storeSimdImmd(func: *CodeGen, value: [16]u8) !WValue {
31463178fn emitUndefined(func: *CodeGen, ty: Type) InnerError!WValue {
31473179 switch (ty.zigTypeTag()) {
31483180 .Bool, .ErrorSet => return WValue{ .imm32 = 0xaaaaaaaa },
3149 .Int => switch (ty.intInfo(func.target).bits) {
3181 .Int, .Enum => switch (ty.intInfo(func.target).bits) {
31503182 0...32 => return WValue{ .imm32 = 0xaaaaaaaa },
31513183 33...64 => return WValue{ .imm64 = 0xaaaaaaaaaaaaaaaa },
31523184 else => unreachable,
......@@ -3617,7 +3649,6 @@ fn airStructFieldVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
36173649 .Packed => switch (struct_ty.zigTypeTag()) {
36183650 .Struct => result: {
36193651 const struct_obj = struct_ty.castTag(.@"struct").?.data;
3620 assert(struct_obj.layout == .Packed);
36213652 const offset = struct_obj.packedFieldBitOffset(func.target, field_index);
36223653 const backing_ty = struct_obj.backing_int_ty;
36233654 const wasm_bits = toWasmBits(backing_ty.intInfo(func.target).bits) orelse {
......@@ -3661,7 +3692,44 @@ fn airStructFieldVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
36613692 const truncated = try func.trunc(shifted_value, field_ty, backing_ty);
36623693 break :result try truncated.toLocal(func, field_ty);
36633694 },
3664 .Union => return func.fail("TODO: airStructFieldVal for packed unions", .{}),
3695 .Union => result: {
3696 if (isByRef(struct_ty, func.target)) {
3697 if (!isByRef(field_ty, func.target)) {
3698 const val = try func.load(operand, field_ty, 0);
3699 break :result try val.toLocal(func, field_ty);
3700 } else {
3701 const new_stack_val = try func.allocStack(field_ty);
3702 try func.store(new_stack_val, operand, field_ty, 0);
3703 break :result new_stack_val;
3704 }
3705 }
3706
3707 var payload: Type.Payload.Bits = .{
3708 .base = .{ .tag = .int_unsigned },
3709 .data = @intCast(u16, struct_ty.bitSize(func.target)),
3710 };
3711 const union_int_type = Type.initPayload(&payload.base);
3712 if (field_ty.zigTypeTag() == .Float) {
3713 var int_payload: Type.Payload.Bits = .{
3714 .base = .{ .tag = .int_unsigned },
3715 .data = @intCast(u16, field_ty.bitSize(func.target)),
3716 };
3717 const int_type = Type.initPayload(&int_payload.base);
3718 const truncated = try func.trunc(operand, int_type, union_int_type);
3719 const bitcasted = try func.bitcast(field_ty, int_type, truncated);
3720 break :result try bitcasted.toLocal(func, field_ty);
3721 } else if (field_ty.isPtrAtRuntime()) {
3722 var int_payload: Type.Payload.Bits = .{
3723 .base = .{ .tag = .int_unsigned },
3724 .data = @intCast(u16, field_ty.bitSize(func.target)),
3725 };
3726 const int_type = Type.initPayload(&int_payload.base);
3727 const truncated = try func.trunc(operand, int_type, union_int_type);
3728 break :result try truncated.toLocal(func, field_ty);
3729 }
3730 const truncated = try func.trunc(operand, field_ty, union_int_type);
3731 break :result try truncated.toLocal(func, field_ty);
3732 },
36653733 else => unreachable,
36663734 },
36673735 else => result: {
......@@ -3907,7 +3975,12 @@ fn airUnwrapErrUnionPayload(func: *CodeGen, inst: Air.Inst.Index, op_is_ptr: boo
39073975 const payload_ty = err_ty.errorUnionPayload();
39083976
39093977 const result = result: {
3910 if (!payload_ty.hasRuntimeBitsIgnoreComptime()) break :result WValue{ .none = {} };
3978 if (!payload_ty.hasRuntimeBitsIgnoreComptime()) {
3979 if (op_is_ptr) {
3980 break :result func.reuseOperand(ty_op.operand, operand);
3981 }
3982 break :result WValue{ .none = {} };
3983 }
39113984
39123985 const pl_offset = @intCast(u32, errUnionPayloadOffset(payload_ty, func.target));
39133986 if (op_is_ptr or isByRef(payload_ty, func.target)) {
......@@ -4397,7 +4470,7 @@ fn airPtrElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
43974470 try func.addTag(.i32_add);
43984471
43994472 const elem_result = val: {
4400 var result = try func.allocLocal(elem_ty);
4473 var result = try func.allocLocal(Type.usize);
44014474 try func.addLabel(.local_set, result.local.value);
44024475 if (isByRef(elem_ty, func.target)) {
44034476 break :val result;
......@@ -4864,6 +4937,9 @@ fn airAggregateInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
48644937 const result = try func.allocStack(result_ty);
48654938 const elem_ty = result_ty.childType();
48664939 const elem_size = @intCast(u32, elem_ty.abiSize(func.target));
4940 const sentinel = if (result_ty.sentinel()) |sent| blk: {
4941 break :blk try func.lowerConstant(sent, elem_ty);
4942 } else null;
48674943
48684944 // When the element type is by reference, we must copy the entire
48694945 // value. It is therefore safer to move the offset pointer and store
......@@ -4876,10 +4952,13 @@ fn airAggregateInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
48764952 const elem_val = try func.resolveInst(elem);
48774953 try func.store(offset, elem_val, elem_ty, 0);
48784954
4879 if (elem_index < elements.len - 1) {
4955 if (elem_index < elements.len - 1 and sentinel == null) {
48804956 _ = try func.buildPointerOffset(offset, elem_size, .modify);
48814957 }
48824958 }
4959 if (sentinel) |sent| {
4960 try func.store(offset, sent, elem_ty, 0);
4961 }
48834962 } else {
48844963 var offset: u32 = 0;
48854964 for (elements) |elem| {
......@@ -4887,6 +4966,9 @@ fn airAggregateInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
48874966 try func.store(result, elem_val, elem_ty, offset);
48884967 offset += elem_size;
48894968 }
4969 if (sentinel) |sent| {
4970 try func.store(result, sent, elem_ty, offset);
4971 }
48904972 }
48914973 break :result_value result;
48924974 },
......@@ -4982,31 +5064,85 @@ fn airUnionInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
49825064 const result = result: {
49835065 const union_ty = func.air.typeOfIndex(inst);
49845066 const layout = union_ty.unionGetLayout(func.target);
5067 const union_obj = union_ty.cast(Type.Payload.Union).?.data;
5068 const field = union_obj.fields.values()[extra.field_index];
5069 const field_name = union_obj.fields.keys()[extra.field_index];
5070
5071 const tag_int = blk: {
5072 const tag_ty = union_ty.unionTagTypeHypothetical();
5073 const enum_field_index = tag_ty.enumFieldIndex(field_name).?;
5074 var tag_val_payload: Value.Payload.U32 = .{
5075 .base = .{ .tag = .enum_field_index },
5076 .data = @intCast(u32, enum_field_index),
5077 };
5078 const tag_val = Value.initPayload(&tag_val_payload.base);
5079 break :blk try func.lowerConstant(tag_val, tag_ty);
5080 };
49855081 if (layout.payload_size == 0) {
49865082 if (layout.tag_size == 0) {
49875083 break :result WValue{ .none = {} };
49885084 }
49895085 assert(!isByRef(union_ty, func.target));
4990 break :result WValue{ .imm32 = extra.field_index };
5086 break :result tag_int;
49915087 }
4992 assert(isByRef(union_ty, func.target));
49935088
4994 const result_ptr = try func.allocStack(union_ty);
4995 const payload = try func.resolveInst(extra.init);
4996 const union_obj = union_ty.cast(Type.Payload.Union).?.data;
4997 assert(union_obj.haveFieldTypes());
4998 const field = union_obj.fields.values()[extra.field_index];
5089 if (isByRef(union_ty, func.target)) {
5090 const result_ptr = try func.allocStack(union_ty);
5091 const payload = try func.resolveInst(extra.init);
5092 if (layout.tag_align >= layout.payload_align) {
5093 if (isByRef(field.ty, func.target)) {
5094 const payload_ptr = try func.buildPointerOffset(result_ptr, layout.tag_size, .new);
5095 try func.store(payload_ptr, payload, field.ty, 0);
5096 } else {
5097 try func.store(result_ptr, payload, field.ty, @intCast(u32, layout.tag_size));
5098 }
49995099
5000 if (layout.tag_align >= layout.payload_align) {
5001 const payload_ptr = try func.buildPointerOffset(result_ptr, layout.tag_size, .new);
5002 try func.store(payload_ptr, payload, field.ty, 0);
5100 if (layout.tag_size > 0) {
5101 try func.store(result_ptr, tag_int, union_obj.tag_ty, 0);
5102 }
5103 } else {
5104 try func.store(result_ptr, payload, field.ty, 0);
5105 if (layout.tag_size > 0) {
5106 try func.store(
5107 result_ptr,
5108 tag_int,
5109 union_obj.tag_ty,
5110 @intCast(u32, layout.payload_size),
5111 );
5112 }
5113 }
5114 break :result result_ptr;
50035115 } else {
5004 try func.store(result_ptr, payload, field.ty, 0);
5116 const operand = try func.resolveInst(extra.init);
5117 var payload: Type.Payload.Bits = .{
5118 .base = .{ .tag = .int_unsigned },
5119 .data = @intCast(u16, union_ty.bitSize(func.target)),
5120 };
5121 const union_int_type = Type.initPayload(&payload.base);
5122 if (field.ty.zigTypeTag() == .Float) {
5123 var int_payload: Type.Payload.Bits = .{
5124 .base = .{ .tag = .int_unsigned },
5125 .data = @intCast(u16, field.ty.bitSize(func.target)),
5126 };
5127 const int_type = Type.initPayload(&int_payload.base);
5128 const bitcasted = try func.bitcast(field.ty, int_type, operand);
5129 const casted = try func.trunc(bitcasted, int_type, union_int_type);
5130 break :result try casted.toLocal(func, field.ty);
5131 } else if (field.ty.isPtrAtRuntime()) {
5132 var int_payload: Type.Payload.Bits = .{
5133 .base = .{ .tag = .int_unsigned },
5134 .data = @intCast(u16, field.ty.bitSize(func.target)),
5135 };
5136 const int_type = Type.initPayload(&int_payload.base);
5137 const casted = try func.intcast(operand, int_type, union_int_type);
5138 break :result try casted.toLocal(func, field.ty);
5139 }
5140 const casted = try func.intcast(operand, field.ty, union_int_type);
5141 break :result try casted.toLocal(func, field.ty);
50055142 }
5006 break :result result_ptr;
50075143 };
50085144
5009 func.finishAir(inst, result, &.{extra.init});
5145 return func.finishAir(inst, result, &.{extra.init});
50105146}
50115147
50125148fn airPrefetch(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
......@@ -5073,8 +5209,8 @@ fn cmpOptionals(func: *CodeGen, lhs: WValue, rhs: WValue, operand_ty: Type, op:
50735209fn cmpBigInt(func: *CodeGen, lhs: WValue, rhs: WValue, operand_ty: Type, op: std.math.CompareOperator) InnerError!WValue {
50745210 assert(operand_ty.abiSize(func.target) >= 16);
50755211 assert(!(lhs != .stack and rhs == .stack));
5076 if (operand_ty.intInfo(func.target).bits > 128) {
5077 return func.fail("TODO: Support cmpBigInt for integer bitsize: '{d}'", .{operand_ty.intInfo(func.target).bits});
5212 if (operand_ty.bitSize(func.target) > 128) {
5213 return func.fail("TODO: Support cmpBigInt for integer bitsize: '{d}'", .{operand_ty.bitSize(func.target)});
50785214 }
50795215
50805216 var lhs_high_bit = try (try func.load(lhs, Type.u64, 0)).toLocal(func, Type.u64);
......@@ -5295,11 +5431,23 @@ fn airMemcpy(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
52955431 const bin_op = func.air.instructions.items(.data)[inst].bin_op;
52965432 const dst = try func.resolveInst(bin_op.lhs);
52975433 const dst_ty = func.air.typeOf(bin_op.lhs);
5434 const ptr_elem_ty = dst_ty.childType();
52985435 const src = try func.resolveInst(bin_op.rhs);
52995436 const src_ty = func.air.typeOf(bin_op.rhs);
53005437 const len = switch (dst_ty.ptrSize()) {
5301 .Slice => try func.sliceLen(dst),
5302 .One => @as(WValue, .{ .imm32 = @intCast(u32, dst_ty.childType().arrayLen()) }),
5438 .Slice => blk: {
5439 const slice_len = try func.sliceLen(dst);
5440 if (ptr_elem_ty.abiSize(func.target) != 1) {
5441 try func.emitWValue(slice_len);
5442 try func.emitWValue(.{ .imm32 = @intCast(u32, ptr_elem_ty.abiSize(func.target)) });
5443 try func.addTag(.i32_mul);
5444 try func.addLabel(.local_set, slice_len.local.value);
5445 }
5446 break :blk slice_len;
5447 },
5448 .One => @as(WValue, .{
5449 .imm32 = @intCast(u32, ptr_elem_ty.arrayLen() * ptr_elem_ty.childType().abiSize(func.target)),
5450 }),
53035451 .C, .Many => unreachable,
53045452 };
53055453 const dst_ptr = try func.sliceOrArrayPtr(dst, dst_ty);
......@@ -5559,6 +5707,7 @@ fn airShlWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
55595707 const lhs = try func.resolveInst(extra.lhs);
55605708 const rhs = try func.resolveInst(extra.rhs);
55615709 const lhs_ty = func.air.typeOf(extra.lhs);
5710 const rhs_ty = func.air.typeOf(extra.rhs);
55625711
55635712 if (lhs_ty.zigTypeTag() == .Vector) {
55645713 return func.fail("TODO: Implement overflow arithmetic for vectors", .{});
......@@ -5570,7 +5719,15 @@ fn airShlWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
55705719 return func.fail("TODO: Implement shl_with_overflow for integer bitsize: {d}", .{int_info.bits});
55715720 };
55725721
5573 var shl = try (try func.binOp(lhs, rhs, lhs_ty, .shl)).toLocal(func, lhs_ty);
5722 // Ensure rhs is coerced to lhs as they must have the same WebAssembly types
5723 // before we can perform any binary operation.
5724 const rhs_wasm_bits = toWasmBits(rhs_ty.intInfo(func.target).bits).?;
5725 const rhs_final = if (wasm_bits != rhs_wasm_bits) blk: {
5726 const rhs_casted = try func.intcast(rhs, rhs_ty, lhs_ty);
5727 break :blk try rhs_casted.toLocal(func, lhs_ty);
5728 } else rhs;
5729
5730 var shl = try (try func.binOp(lhs, rhs_final, lhs_ty, .shl)).toLocal(func, lhs_ty);
55745731 defer shl.free(func);
55755732 var result = if (wasm_bits != int_info.bits) blk: {
55765733 break :blk try (try func.wrapOperand(shl, lhs_ty)).toLocal(func, lhs_ty);
......@@ -5581,11 +5738,11 @@ fn airShlWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
55815738 // emit lhs to stack to we can keep 'wrapped' on the stack also
55825739 try func.emitWValue(lhs);
55835740 const abs = try func.signAbsValue(shl, lhs_ty);
5584 const wrapped = try func.wrapBinOp(abs, rhs, lhs_ty, .shr);
5741 const wrapped = try func.wrapBinOp(abs, rhs_final, lhs_ty, .shr);
55855742 break :blk try func.cmp(.{ .stack = {} }, wrapped, lhs_ty, .neq);
55865743 } else blk: {
55875744 try func.emitWValue(lhs);
5588 const shr = try func.binOp(result, rhs, lhs_ty, .shr);
5745 const shr = try func.binOp(result, rhs_final, lhs_ty, .shr);
55895746 break :blk try func.cmp(.{ .stack = {} }, shr, lhs_ty, .neq);
55905747 };
55915748 var overflow_local = try overflow_bit.toLocal(func, Type.initTag(.u1));
src/codegen.zig+4
......@@ -611,6 +611,10 @@ pub fn generateSymbol(
611611 }
612612 }
613613
614 if (layout.padding > 0) {
615 try code.writer().writeByteNTimes(0, layout.padding);
616 }
617
614618 return Result.ok;
615619 },
616620 .Optional => {
test/behavior/align.zig-1
......@@ -16,7 +16,6 @@ test "global variable alignment" {
1616}
1717
1818test "slicing array of length 1 can not assume runtime index is always zero" {
19 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2019 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2120 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2221 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
test/behavior/atomics.zig-1
......@@ -383,7 +383,6 @@ fn testAtomicRmwInt128(comptime signedness: std.builtin.Signedness) !void {
383383}
384384
385385test "atomics with different types" {
386 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
387386 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
388387 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
389388 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
test/behavior/basic.zig-3
......@@ -413,7 +413,6 @@ test "array 2D const double ptr with offset" {
413413 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
414414 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
415415 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
416 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
417416 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
418417
419418 const rect_2d_vertexes = [_][2]f32{
......@@ -427,7 +426,6 @@ test "array 3D const double ptr with offset" {
427426 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
428427 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
429428 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
430 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
431429 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
432430
433431 const rect_3d_vertexes = [_][2][2]f32{
......@@ -1052,7 +1050,6 @@ test "inline call of function with a switch inside the return statement" {
10521050}
10531051
10541052test "namespace lookup ignores decl causing the lookup" {
1055 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
10561053 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10571054 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10581055 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
test/behavior/bugs/12142.zig-1
......@@ -19,7 +19,6 @@ fn letter(e: Letter) u8 {
1919}
2020
2121test {
22 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2322 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
2423 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2524 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
test/behavior/bugs/13113.zig-1
......@@ -7,7 +7,6 @@ const Foo = extern struct {
77};
88
99test {
10 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1110 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1211 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1312 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
test/behavior/bugs/13128.zig-1
......@@ -14,7 +14,6 @@ fn foo(val: U) !void {
1414test "runtime union init, most-aligned field != largest" {
1515 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1616 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
17 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1817 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1918 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2019
test/behavior/bugs/13664.zig-1
......@@ -13,7 +13,6 @@ fn value() i64 {
1313 return 1341;
1414}
1515test {
16 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1716 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1817 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1918 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
test/behavior/bugs/1381.zig-1
......@@ -15,7 +15,6 @@ test "union that needs padding bytes inside an array" {
1515 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1616 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1717 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
18 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
1918 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2019 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2120
test/behavior/cast_int.zig-1
......@@ -4,7 +4,6 @@ const expect = std.testing.expect;
44const maxInt = std.math.maxInt;
55
66test "@intCast i32 to u7" {
7 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
87 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
98 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
109 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/empty_union.zig-5
......@@ -3,15 +3,12 @@ const std = @import("std");
33const expect = std.testing.expect;
44
55test "switch on empty enum" {
6 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
7
86 const E = enum {};
97 var e: E = undefined;
108 switch (e) {}
119}
1210
1311test "switch on empty enum with a specified tag type" {
14 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1512 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1613
1714 const E = enum(u8) {};
......@@ -21,7 +18,6 @@ test "switch on empty enum with a specified tag type" {
2118
2219test "switch on empty auto numbered tagged union" {
2320 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
24 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2521 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2622
2723 const U = union(enum(u8)) {};
......@@ -31,7 +27,6 @@ test "switch on empty auto numbered tagged union" {
3127
3228test "switch on empty tagged union" {
3329 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
34 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
3530
3631 const E = enum {};
3732 const U = union(E) {};
test/behavior/enum.zig-2
......@@ -1079,7 +1079,6 @@ const bit_field_1 = BitFieldOfEnums{
10791079};
10801080
10811081test "bit field access with enum fields" {
1082 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
10831082 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
10841083 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10851084 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1120,7 +1119,6 @@ test "enum literal in array literal" {
11201119}
11211120
11221121test "tag name functions are unique" {
1123 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
11241122 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
11251123 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11261124 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/error.zig-5
......@@ -720,7 +720,6 @@ test "ret_ptr doesn't cause own inferred error set to be resolved" {
720720}
721721
722722test "simple else prong allowed even when all errors handled" {
723 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
724723 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
725724 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
726725
......@@ -749,7 +748,6 @@ test "simple else prong allowed even when all errors handled" {
749748test "pointer to error union payload" {
750749 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
751750 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
752 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
753751 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
754752 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
755753
......@@ -783,7 +781,6 @@ const NoReturn = struct {
783781test "error union of noreturn used with if" {
784782 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
785783 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
786 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
787784 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
788785 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
789786
......@@ -798,7 +795,6 @@ test "error union of noreturn used with if" {
798795test "error union of noreturn used with try" {
799796 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
800797 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
801 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
802798 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
803799 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
804800
......@@ -810,7 +806,6 @@ test "error union of noreturn used with try" {
810806test "error union of noreturn used with catch" {
811807 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
812808 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
813 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
814809 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
815810 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
816811
test/behavior/eval.zig-5
......@@ -470,7 +470,6 @@ test "binary math operator in partially inlined function" {
470470}
471471
472472test "comptime shl" {
473 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
474473 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
475474 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
476475 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -501,7 +500,6 @@ test "comptime bitwise operators" {
501500
502501test "comptime shlWithOverflow" {
503502 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
504 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
505503 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
506504
507505 const ct_shifted = @shlWithOverflow(~@as(u64, 0), 16)[0];
......@@ -812,7 +810,6 @@ test "array concatenation peer resolves element types - pointer" {
812810}
813811
814812test "array concatenation sets the sentinel - value" {
815 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
816813 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
817814 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
818815 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -850,7 +847,6 @@ test "array concatenation sets the sentinel - pointer" {
850847}
851848
852849test "array multiplication sets the sentinel - value" {
853 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
854850 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
855851 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
856852 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1550,7 +1546,6 @@ test "x or true is comptime-known true" {
15501546test "non-optional and optional array elements concatenated" {
15511547 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
15521548 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1553 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
15541549 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
15551550 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
15561551
test/behavior/optional.zig-1
......@@ -365,7 +365,6 @@ test "optional pointer to zero bit optional payload" {
365365test "optional pointer to zero bit error union payload" {
366366 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
367367 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
368 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
369368 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
370369 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
371370
test/behavior/ptrcast.zig-2
......@@ -129,7 +129,6 @@ fn testReinterpretOverAlignedExternStructAsExternStruct() !void {
129129test "lower reinterpreted comptime field ptr (with under-aligned fields)" {
130130 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
131131 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
132 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
133132 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
134133 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
135134
......@@ -153,7 +152,6 @@ test "lower reinterpreted comptime field ptr (with under-aligned fields)" {
153152test "lower reinterpreted comptime field ptr" {
154153 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
155154 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
156 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
157155 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
158156 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
159157
test/behavior/return_address.zig-1
......@@ -6,7 +6,6 @@ fn retAddr() usize {
66}
77
88test "return address" {
9 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
109 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1110 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1211 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/type.zig-2
......@@ -258,7 +258,6 @@ test "Type.ErrorSet" {
258258}
259259
260260test "Type.Struct" {
261 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
262261 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
263262 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
264263 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -488,7 +487,6 @@ test "Type.Union from regular enum" {
488487}
489488
490489test "Type.Fn" {
491 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
492490 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
493491 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
494492
test/behavior/union.zig-11
......@@ -452,7 +452,6 @@ var glbl: Foo1 = undefined;
452452test "global union with single field is correctly initialized" {
453453 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
454454 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
455 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
456455 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
457456 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
458457
......@@ -500,7 +499,6 @@ test "update the tag value for zero-sized unions" {
500499test "union initializer generates padding only if needed" {
501500 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
502501 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
503 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
504502 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
505503 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
506504
......@@ -788,7 +786,6 @@ fn Setter(comptime attr: Attribute) type {
788786test "return union init with void payload" {
789787 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
790788 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
791 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
792789 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
793790 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
794791
......@@ -814,7 +811,6 @@ test "return union init with void payload" {
814811test "@unionInit stored to a const" {
815812 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
816813 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
817 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
818814 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
819815 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
820816
......@@ -985,7 +981,6 @@ test "function call result coerces from tagged union to the tag" {
985981test "cast from anonymous struct to union" {
986982 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
987983 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
988 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
989984 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
990985 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
991986
......@@ -1018,7 +1013,6 @@ test "cast from anonymous struct to union" {
10181013test "cast from pointer to anonymous struct to pointer to union" {
10191014 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10201015 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1021 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
10221016 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10231017 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10241018
......@@ -1108,7 +1102,6 @@ test "containers with single-field enums" {
11081102test "@unionInit on union with tag but no fields" {
11091103 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11101104 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1111 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
11121105 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11131106 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11141107
......@@ -1382,7 +1375,6 @@ test "union and enum field order doesn't match" {
13821375test "@unionInit uses tag value instead of field index" {
13831376 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
13841377 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1385 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
13861378 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13871379 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
13881380
......@@ -1440,7 +1432,6 @@ test "union field ptr - zero sized field" {
14401432test "packed union in packed struct" {
14411433 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
14421434 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1443 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
14441435 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
14451436 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14461437
......@@ -1528,7 +1519,6 @@ test "union reassignment can use previous value" {
15281519test "packed union with zero-bit field" {
15291520 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
15301521 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1531 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
15321522 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
15331523 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
15341524
......@@ -1549,7 +1539,6 @@ test "packed union with zero-bit field" {
15491539test "reinterpreting enum value inside packed union" {
15501540 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
15511541 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1552 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
15531542 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
15541543
15551544 const U = packed union {
test/behavior/union_with_members.zig-1
......@@ -17,7 +17,6 @@ const ET = union(enum) {
1717};
1818
1919test "enum with members" {
20 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2120 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2221 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2322 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO