Commit 22945fbbdc1ec89def58f39ddc8c35502b6e05dd | zig

src/Air/Legalize.zig+9-4

 @@ -1503,7 +1503,7 @@ fn scalarizeBitcastBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index) Error!?
             l,
             .store,
             index_ptr,
-            .fromValue(try pt.intValue(.usize, operand_ty.arrayLen(zcu))),
+            .fromValue(try pt.intValue(.usize, operand_ty.arrayLen(zcu) - 1)),
         );
         _ = uint_block.addBinOp(l, .store, result_ptr, .fromValue(try pt.intValue(uint_ty, 0)));
 @@ -1811,6 +1811,7 @@ fn scalarizeReduceBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index, optimize
         .Or, .Xor, .Add => switch (scalar_ty.zigTypeTag(zcu)) {
             .int => try pt.intValue(scalar_ty, 0),
             .float => try pt.floatValue(scalar_ty, 0.0),
+            .bool => .false,
             else => unreachable,
         },
         // identity for multiplication is 1
 @@ -1820,9 +1821,13 @@ fn scalarizeReduceBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index, optimize
             else => unreachable,
         },
         // identity for AND is all 1 bits
-        .And => switch (scalar_ty.intInfo(zcu).signedness) {
+        .And => switch (scalar_ty.zigTypeTag(zcu)) {
-            .unsigned => try scalar_ty.maxIntScalar(pt, scalar_ty),
+            .int => switch (scalar_ty.intInfo(zcu).signedness) {
-            .signed => try pt.intValue(scalar_ty, -1),
+                .unsigned => try scalar_ty.maxIntScalar(pt, scalar_ty),
+                .signed => try pt.intValue(scalar_ty, -1),
+            },
+            .bool => .true,
+            else => unreachable,
         },
         // identity for @min is maximum value
         .Min => switch (scalar_ty.zigTypeTag(zcu)) {

src/Type.zig+2-2

src/codegen.zig+5-1

 @@ -484,7 +484,11 @@ pub fn generateSymbol(
             },
             .vector_type => |vector_type| {
                 const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow;
-                if (vector_type.child == .bool_type) {
+                const vector_bool_bitpacked = switch (zcu.comp.getZigBackend()) {
+                    .stage2_wasm => false,
+                    else => true,
+                };
+                if (vector_type.child == .bool_type and vector_bool_bitpacked) {
                     const bytes = try w.writableSlice(abi_size);
                     @memset(bytes, 0xaa);
                     var index: usize = 0;

src/codegen/wasm/CodeGen.zig+369-262

...	@@ -43,6 +43,83 @@ pub fn legalizeFeatures(_: const std.Target) const Air.Legalize.Features {	...	@@ -43,6 +43,83 @@ pub fn legalizeFeatures(_: const std.Target) const Air.Legalize.Features {
43	.expand_packed_store,	43	.expand_packed_store,
44	.expand_packed_struct_field_val,	44	.expand_packed_struct_field_val,
45	.expand_packed_aggregate_init,	45	.expand_packed_aggregate_init,
		46
		47	.scalarize_add,
		48	.scalarize_add_optimized,
		49	.scalarize_add_wrap,
		50	.scalarize_add_sat,
		51	.scalarize_sub,
		52	.scalarize_sub_optimized,
		53	.scalarize_sub_wrap,
		54	.scalarize_sub_sat,
		55	.scalarize_mul,
		56	.scalarize_mul_optimized,
		57	.scalarize_mul_wrap,
		58	.scalarize_mul_sat,
		59	.scalarize_div_float,
		60	.scalarize_div_float_optimized,
		61	.scalarize_div_trunc,
		62	.scalarize_div_trunc_optimized,
		63	.scalarize_div_floor,
		64	.scalarize_div_floor_optimized,
		65	.scalarize_div_exact,
		66	.scalarize_div_exact_optimized,
		67	.scalarize_rem,
		68	.scalarize_rem_optimized,
		69	.scalarize_mod,
		70	.scalarize_mod_optimized,
		71	.scalarize_max,
		72	.scalarize_min,
		73	.scalarize_add_with_overflow,
		74	.scalarize_sub_with_overflow,
		75	.scalarize_mul_with_overflow,
		76	.scalarize_shl_with_overflow,
		77	.scalarize_bit_and,
		78	.scalarize_bit_or,
		79	.scalarize_shr,
		80	.scalarize_shr_exact,
		81	.scalarize_shl,
		82	.scalarize_shl_exact,
		83	.scalarize_shl_sat,
		84	.scalarize_xor,
		85	.scalarize_not,
		86	.scalarize_bitcast,
		87	.scalarize_clz,
		88	.scalarize_ctz,
		89	.scalarize_popcount,
		90	.scalarize_byte_swap,
		91	.scalarize_bit_reverse,
		92	.scalarize_sqrt,
		93	.scalarize_sin,
		94	.scalarize_cos,
		95	.scalarize_tan,
		96	.scalarize_exp,
		97	.scalarize_exp2,
		98	.scalarize_log,
		99	.scalarize_log2,
		100	.scalarize_log10,
		101	.scalarize_abs,
		102	.scalarize_floor,
		103	.scalarize_ceil,
		104	.scalarize_round,
		105	.scalarize_trunc_float,
		106	.scalarize_neg,
		107	.scalarize_neg_optimized,
		108	.scalarize_cmp_vector,
		109	.scalarize_cmp_vector_optimized,
		110	.scalarize_fptrunc,
		111	.scalarize_fpext,
		112	.scalarize_intcast,
		113	.scalarize_trunc,
		114	.scalarize_int_from_float,
		115	.scalarize_int_from_float_optimized,
		116	.scalarize_float_from_int,
		117	.scalarize_reduce,
		118	.scalarize_reduce_optimized,
		119	.scalarize_shuffle_one,
		120	.scalarize_shuffle_two,
		121	.scalarize_select,
		122	.scalarize_mul_add,
46	});	123	});
47	}	124	}
48		125
...	@@ -217,8 +294,7 @@ const WValue = union(enum) {	...	@@ -217,8 +294,7 @@ const WValue = union(enum) {
217	try gen.addLocal(.local_set, new_local.local.value);	294	try gen.addLocal(.local_set, new_local.local.value);
218	return new_local;	295	return new_local;
219	},	296	},
220	.local, .stack_offset => return value,	297	else => return value,
221	else => unreachable,
222	}	298	}
223	}	299	}
224		300
...	@@ -765,7 +841,8 @@ fn generateInner(cg: *CodeGen, any_returns: bool) InnerError!Mir {	...	@@ -765,7 +841,8 @@ fn generateInner(cg: *CodeGen, any_returns: bool) InnerError!Mir {
765	// In case we have a return value, but the last instruction is a noreturn (such as a while loop)	841	// In case we have a return value, but the last instruction is a noreturn (such as a while loop)
766	// we emit an unreachable instruction to tell the stack validator that part will never be reached.	842	// we emit an unreachable instruction to tell the stack validator that part will never be reached.
767	if (any_returns and cg.air.instructions.len > 0) {	843	if (any_returns and cg.air.instructions.len > 0) {
768	const inst: Air.Inst.Index = @enumFromInt(cg.air.instructions.len - 1);	844	const main_body = cg.air.getMainBody();
		845	const inst: Air.Inst.Index = main_body[main_body.len - 1];
769	const last_inst_ty = cg.typeOfIndex(inst);	846	const last_inst_ty = cg.typeOfIndex(inst);
770	if (!last_inst_ty.hasRuntimeBits(zcu)) {	847	if (!last_inst_ty.hasRuntimeBits(zcu)) {
771	try cg.addTag(.@"unreachable");	848	try cg.addTag(.@"unreachable");
...	@@ -1032,10 +1109,6 @@ fn allocStackPtr(cg: *CodeGen, inst: Air.Inst.Index) !WValue {	...	@@ -1032,10 +1109,6 @@ fn allocStackPtr(cg: *CodeGen, inst: Air.Inst.Index) !WValue {
1032	try cg.initializeStack();	1109	try cg.initializeStack();
1033	}	1110	}
1034		1111
1035	if (!pointee_ty.hasRuntimeBits(zcu)) {
1036	return cg.allocStack(Type.usize); // create a value containing just the stack pointer.
1037	}
1038
1039	const abi_alignment = ptr_ty.ptrAlignment(zcu);	1112	const abi_alignment = ptr_ty.ptrAlignment(zcu);
1040	const abi_size = std.math.cast(u32, pointee_ty.abiSize(zcu)) orelse {	1113	const abi_size = std.math.cast(u32, pointee_ty.abiSize(zcu)) orelse {
1041	return cg.fail("Type {f} with ABI size of {d} exceeds stack frame size", .{	1114	return cg.fail("Type {f} with ABI size of {d} exceeds stack frame size", .{
...	@@ -1050,157 +1123,67 @@ fn allocStackPtr(cg: *CodeGen, inst: Air.Inst.Index) !WValue {	...	@@ -1050,157 +1123,67 @@ fn allocStackPtr(cg: *CodeGen, inst: Air.Inst.Index) !WValue {
1050	return .{ .stack_offset = .{ .value = offset, .references = 1 } };	1123	return .{ .stack_offset = .{ .value = offset, .references = 1 } };
1051	}	1124	}
1052		1125
1053	/// Performs a copy of bytes for a given type. Copying all bytes	1126	fn emitMemoryCopy(cg: *CodeGen, dst: WValue, src: WValue, len: WValue) !void {
1054	/// from rhs to lhs.
1055	fn memcpy(cg: *CodeGen, dst: WValue, src: WValue, len: WValue) !void {
1056	const len_known_neq_0 = switch (len) {	1127	const len_known_neq_0 = switch (len) {
1057	.imm32 => \|val\| if (val != 0) true else return,	1128	.imm32 => \|val\| if (val != 0) true else return,
1058	.imm64 => \|val\| if (val != 0) true else return,	1129	.imm64 => \|val\| if (val != 0) true else return,
1059	else => false,	1130	else => false,
1060	};	1131	};
1061	// When bulk_memory is enabled, we lower it to wasm's memcpy instruction.	1132	const len0_ok = cg.target.cpu.has(.wasm, .nontrapping_bulk_memory_len0);
1062	// If not, we lower it ourselves manually	1133	const emit_check = !(len0_ok or len_known_neq_0);
1063	if (cg.target.cpu.has(.wasm, .bulk_memory)) {
1064	const len0_ok = cg.target.cpu.has(.wasm, .nontrapping_bulk_memory_len0);
1065	const emit_check = !(len0_ok or len_known_neq_0);
1066		1134
1067	if (emit_check) {	1135	if (emit_check) {
1068	try cg.startBlock(.block, .empty);	1136	try cg.startBlock(.block, .empty);
1069
1070	// Even if `len` is zero, the spec requires an implementation to trap if `src + len` or
1071	// `dst + len` are out of memory bounds. This can easily happen in Zig in a case such
1072	// as:
1073	//
1074	// const dst: [*]u8 = undefined;
1075	// const src: [*]u8 = undefined;
1076	// var len: usize = runtime_zero();
1077	// @memcpy(dst[0..len], src[0..len]);
1078	//
1079	// So explicitly avoid using `memory.copy` in the `len == 0` case. Lovely design.
1080	try cg.emitWValue(len);
1081	try cg.addTag(.i32_eqz);
1082	try cg.addLabel(.br_if, 0);
1083	}
1084		1137
1085	try cg.lowerToStack(dst);	1138	// Even if `len` is zero, the spec requires an implementation to trap if `src + len` or
1086	try cg.lowerToStack(src);	1139	// `dst + len` are out of memory bounds. This can easily happen in Zig in a case such
		1140	// as:
		1141	//
		1142	// const dst: [*]u8 = undefined;
		1143	// const src: [*]u8 = undefined;
		1144	// var len: usize = runtime_zero();
		1145	// @memcpy(dst[0..len], src[0..len]);
		1146	//
		1147	// So explicitly avoid using `memory.copy` in the `len == 0` case. Lovely design.
1087	try cg.emitWValue(len);	1148	try cg.emitWValue(len);
1088	try cg.addExtended(.memory_copy);	1149	try cg.addTag(.i32_eqz);
1089		1150	try cg.addLabel(.br_if, 0);
1090	if (emit_check) {
1091	try cg.endBlock();
1092	}
1093
1094	return;
1095	}	1151	}
1096		1152
1097	// when the length is comptime-known, rather than a runtime value, we can optimize the generated code by having	1153	try cg.lowerToStack(dst);
1098	// the loop during codegen, rather than inserting a runtime loop into the binary.	1154	try cg.lowerToStack(src);
1099	switch (len) {	1155	try cg.emitWValue(len);
1100	.imm32, .imm64 => blk: {	1156	try cg.addExtended(.memory_copy);
1101	const length = switch (len) {
1102	.imm32 => \|val\| val,
1103	.imm64 => \|val\| val,
1104	else => unreachable,
1105	};
1106	// if the size (length) is more than 32 bytes, we use a runtime loop instead to prevent
1107	// binary size bloat.
1108	if (length > 32) break :blk;
1109	var offset: u32 = 0;
1110	const lhs_base = dst.offset();
1111	const rhs_base = src.offset();
1112	while (offset < length) : (offset += 1) {
1113	// get dst's address to store the result
1114	try cg.emitWValue(dst);
1115	// load byte from src's address
1116	try cg.emitWValue(src);
1117	switch (cg.ptr_size) {
1118	.wasm32 => {
1119	try cg.addMemArg(.i32_load8_u, .{ .offset = rhs_base + offset, .alignment = 1 });
1120	try cg.addMemArg(.i32_store8, .{ .offset = lhs_base + offset, .alignment = 1 });
1121	},
1122	.wasm64 => {
1123	try cg.addMemArg(.i64_load8_u, .{ .offset = rhs_base + offset, .alignment = 1 });
1124	try cg.addMemArg(.i64_store8, .{ .offset = lhs_base + offset, .alignment = 1 });
1125	},
1126	}
1127	}
1128	return;
1129	},
1130	else => {},
1131	}
1132		1157
1133	// allocate a local for the offset, and set it to 0.	1158	if (emit_check) {
1134	// This to ensure that inside loops we correctly re-set the counter.	1159	try cg.endBlock();
1135	var offset = try cg.allocLocal(Type.usize); // local for counter
1136	defer offset.free(cg);
1137	switch (cg.ptr_size) {
1138	.wasm32 => try cg.addImm32(0),
1139	.wasm64 => try cg.addImm64(0),
1140	}	1160	}
1141	try cg.addLocal(.local_set, offset.local.value);	1161	}
1142
1143	// outer block to jump to when loop is done
1144	try cg.startBlock(.block, .empty);
1145	try cg.startBlock(.loop, .empty);
1146		1162
1147	// loop condition (offset == length -> break)	1163	fn memcpy(cg: *CodeGen, dst: WValue, src: WValue, len: WValue) !void {
1148	{	1164	if (cg.target.cpu.has(.wasm, .bulk_memory)) {
1149	try cg.emitWValue(offset);	1165	try cg.emitMemoryCopy(dst, src, len);
1150	try cg.emitWValue(len);	1166	return;
1151	switch (cg.ptr_size) {
1152	.wasm32 => try cg.addTag(.i32_eq),
1153	.wasm64 => try cg.addTag(.i64_eq),
1154	}
1155	try cg.addLabel(.br_if, 1); // jump out of loop into outer block (finished)
1156	}	1167	}
1157		1168
1158	// get dst ptr	1169	try cg.lowerToStack(dst);
1159	{	1170	try cg.lowerToStack(src);
1160	try cg.emitWValue(dst);	1171	try cg.emitWValue(len);
1161	try cg.emitWValue(offset);	1172	try cg.addCallIntrinsic(.memcpy);
1162	switch (cg.ptr_size) {	1173	try cg.addTag(.drop);
1163	.wasm32 => try cg.addTag(.i32_add),	1174	}
1164	.wasm64 => try cg.addTag(.i64_add),
1165	}
1166	}
1167		1175
1168	// get src value and also store in dst	1176	fn memmove(cg: *CodeGen, dst: WValue, src: WValue, len: WValue) !void {
1169	{	1177	if (cg.target.cpu.has(.wasm, .bulk_memory)) {
1170	try cg.emitWValue(src);	1178	try cg.emitMemoryCopy(dst, src, len);
1171	try cg.emitWValue(offset);	1179	return;
1172	switch (cg.ptr_size) {
1173	.wasm32 => {
1174	try cg.addTag(.i32_add);
1175	try cg.addMemArg(.i32_load8_u, .{ .offset = src.offset(), .alignment = 1 });
1176	try cg.addMemArg(.i32_store8, .{ .offset = dst.offset(), .alignment = 1 });
1177	},
1178	.wasm64 => {
1179	try cg.addTag(.i64_add);
1180	try cg.addMemArg(.i64_load8_u, .{ .offset = src.offset(), .alignment = 1 });
1181	try cg.addMemArg(.i64_store8, .{ .offset = dst.offset(), .alignment = 1 });
1182	},
1183	}
1184	}	1180	}
1185		1181
1186	// increment loop counter	1182	try cg.lowerToStack(dst);
1187	{	1183	try cg.lowerToStack(src);
1188	try cg.emitWValue(offset);	1184	try cg.emitWValue(len);
1189	switch (cg.ptr_size) {	1185	try cg.addCallIntrinsic(.memmove);
1190	.wasm32 => {	1186	try cg.addTag(.drop);
1191	try cg.addImm32(1);
1192	try cg.addTag(.i32_add);
1193	},
1194	.wasm64 => {
1195	try cg.addImm64(1);
1196	try cg.addTag(.i64_add);
1197	},
1198	}
1199	try cg.addLocal(.local_set, offset.local.value);
1200	try cg.addLabel(.br, 0); // jump to start of loop
1201	}
1202	try cg.endBlock(); // close off loop block
1203	try cg.endBlock(); // close off outer block
1204	}	1187	}
1205		1188
1206	fn ptrSize(cg: *const CodeGen) u16 {	1189	fn ptrSize(cg: *const CodeGen) u16 {
...	@@ -1310,14 +1293,34 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -1310,14 +1293,34 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
1310	const zcu = cg.pt.zcu;	1293	const zcu = cg.pt.zcu;
1311	const air_tags = cg.air.instructions.items(.tag);	1294	const air_tags = cg.air.instructions.items(.tag);
1312	return switch (air_tags[@intFromEnum(inst)]) {	1295	return switch (air_tags[@intFromEnum(inst)]) {
1313	// No "scalarize" legalizations are enabled, so these instructions never appear.
1314	.legalize_vec_elem_val => unreachable,
1315	.legalize_vec_store_elem => unreachable,
1316	// No soft float legalizations are enabled.	1296	// No soft float legalizations are enabled.
1317	.legalize_compiler_rt_call => unreachable,	1297	.legalize_compiler_rt_call => unreachable,
1318		1298
1319	.inferred_alloc, .inferred_alloc_comptime => unreachable,	1299	.inferred_alloc, .inferred_alloc_comptime => unreachable,
1320		1300
		1301	.legalize_vec_elem_val => cg.airArrayElemVal(inst),
		1302	.legalize_vec_store_elem => {
		1303	const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
		1304	const bin_op = cg.air.extraData(Air.Bin, pl_op.payload).data;
		1305	const vec_ptr = try cg.resolveInst(pl_op.operand);
		1306	const elem_idx = try cg.resolveInst(bin_op.lhs);
		1307	const elem_val = try cg.resolveInst(bin_op.rhs);
		1308
		1309	const elem_ty = cg.typeOf(bin_op.rhs);
		1310	const elem_size = elem_ty.abiSize(zcu);
		1311
		1312	try cg.lowerToStack(vec_ptr);
		1313	try cg.emitWValue(elem_idx);
		1314	try cg.addImm32(@intCast(elem_size));
		1315	try cg.addTag(.i32_mul);
		1316	try cg.addTag(.i32_add);
		1317	const ptr = try WValue.toLocal(.stack, cg, Type.usize);
		1318
		1319	try cg.store(ptr, elem_val, elem_ty, 0);
		1320
		1321	return cg.finishAir(inst, .none, &.{ pl_op.operand, bin_op.lhs, bin_op.rhs });
		1322	},
		1323
1321	.add,	1324	.add,
1322	.sub,	1325	.sub,
1323	.mul,	1326	.mul,
...	@@ -1818,7 +1821,8 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -1818,7 +1821,8 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
1818	.wasm_memory_size => cg.airWasmMemorySize(inst),	1821	.wasm_memory_size => cg.airWasmMemorySize(inst),
1819	.wasm_memory_grow => cg.airWasmMemoryGrow(inst),	1822	.wasm_memory_grow => cg.airWasmMemoryGrow(inst),
1820		1823
1821	.memcpy, .memmove => cg.airMemcpy(inst),	1824	.memcpy => cg.airMemcpy(inst),
		1825	.memmove => cg.airMemmove(inst),
1822		1826
1823	.ret_addr => cg.airRetAddr(inst),	1827	.ret_addr => cg.airRetAddr(inst),
1824	.tag_name => cg.airTagName(inst),	1828	.tag_name => cg.airTagName(inst),
...	@@ -2105,7 +2109,7 @@ fn airStore(cg: *CodeGen, inst: Air.Inst.Index, safety: bool) InnerError!void {	...	@@ -2105,7 +2109,7 @@ fn airStore(cg: *CodeGen, inst: Air.Inst.Index, safety: bool) InnerError!void {
2105	return cg.finishAir(inst, .none, &.{ bin_op.lhs, bin_op.rhs });	2109	return cg.finishAir(inst, .none, &.{ bin_op.lhs, bin_op.rhs });
2106	}	2110	}
2107		2111
2108	assert(ptr_info.packed_offset.host_size == 0); // legalize .expand_packed_store	2112	assert(!(ptr_info.packed_offset.host_size > 0 and ptr_info.flags.vector_index == .none)); // legalize .expand_packed_store
2109		2113
2110	try cg.store(lhs, rhs, ty, 0);	2114	try cg.store(lhs, rhs, ty, 0);
2111		2115
...	@@ -2180,35 +2184,22 @@ fn airLoad(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -2180,35 +2184,22 @@ fn airLoad(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
2180		2184
2181	if (!ty.hasRuntimeBits(zcu)) return cg.finishAir(inst, .none, &.{ty_op.operand});	2185	if (!ty.hasRuntimeBits(zcu)) return cg.finishAir(inst, .none, &.{ty_op.operand});
2182		2186
2183	assert(ptr_info.packed_offset.host_size == 0); // legalize .expand_packed_load	2187	assert(!(ptr_info.packed_offset.host_size > 0 and ptr_info.flags.vector_index == .none)); // legalize .expand_packed_load
2184
2185	const result = result: {
2186	if (isByRef(ty, zcu, cg.target)) {
2187	const new_local = try cg.allocStack(ty);
2188	try cg.store(new_local, operand, ty, 0);
2189	break :result new_local;
2190	}
2191		2188
2192	const loaded = try cg.load(operand, ty, 0);	2189	const result = try cg.load(operand, ty, 0);
2193	const ty_size = ty.abiSize(zcu);
2194	if (ty.isAbiInt(zcu) and ty_size * 8 > ty.bitSize(zcu)) {
2195	const int_info = ty.intInfo(zcu);
2196	const loaded_int_ty: IntType = .{
2197	.is_signed = int_info.signedness == .signed,
2198	.bits = @intCast(ty_size * 8),
2199	};
2200	break :result try cg.intTrunc(.fromType(cg, ty), loaded_int_ty, loaded);
2201	} else {
2202	break :result loaded;
2203	}
2204	};
2205	return cg.finishAir(inst, result, &.{ty_op.operand});	2190	return cg.finishAir(inst, result, &.{ty_op.operand});
2206	}	2191	}
2207		2192
2208	/// Loads an operand from the linear memory section.	2193	/// Loads an operand from the linear memory section.
2209	/// NOTE: Leaves the value on the stack.	2194	/// NOTE: Leaves the value on the stack, if isByRef == false.
2210	fn load(cg: *CodeGen, operand: WValue, ty: Type, offset: u32) InnerError!WValue {	2195	fn load(cg: *CodeGen, operand: WValue, ty: Type, offset: u32) InnerError!WValue {
2211	const zcu = cg.pt.zcu;	2196	const zcu = cg.pt.zcu;
		2197	if (isByRef(ty, zcu, cg.target)) {
		2198	const val = try cg.allocStack(ty);
		2199	try cg.store(val, try operand.toLocal(cg, .usize), ty, 0);
		2200	return val;
		2201	}
		2202
2212	// load local's value from memory by its stack position	2203	// load local's value from memory by its stack position
2213	try cg.emitWValue(operand);	2204	try cg.emitWValue(operand);
2214		2205
...	@@ -2254,6 +2245,14 @@ fn load(cg: *CodeGen, operand: WValue, ty: Type, offset: u32) InnerError!WValue	...	@@ -2254,6 +2245,14 @@ fn load(cg: *CodeGen, operand: WValue, ty: Type, offset: u32) InnerError!WValue
2254	},	2245	},
2255	);	2246	);
2256		2247
		2248	if (ty.isAbiInt(zcu)) {
		2249	const int_info: IntType = .fromType(cg, ty);
		2250	switch (int_info.bits) {
		2251	8, 16, 32, 64 => {},
		2252	else => _ = try cg.intWrap(int_info, .stack),
		2253	}
		2254	}
		2255
2257	return .stack;	2256	return .stack;
2258	}	2257	}
2259		2258
...	@@ -2321,7 +2320,7 @@ const IntType = struct {	...	@@ -2321,7 +2320,7 @@ const IntType = struct {
2321	.hasRuntimeBits(zcu)) .{ .is_signed = false, .bits = zcu.errorSetBits() } else unreachable,	2320	.hasRuntimeBits(zcu)) .{ .is_signed = false, .bits = zcu.errorSetBits() } else unreachable,
2322	.simple_type => \|simple_type\| return switch (simple_type) {	2321	.simple_type => \|simple_type\| return switch (simple_type) {
2323	.bool => .{ .is_signed = false, .bits = 1 },	2322	.bool => .{ .is_signed = false, .bits = 1 },
2324	.anyerror => .{ .is_signed = false, .bits = zcu.errorSetBits() },	2323	.anyerror, .adhoc_inferred_error_set => .{ .is_signed = false, .bits = zcu.errorSetBits() },
2325	.isize => .{ .is_signed = true, .bits = cg.target.ptrBitWidth() },	2324	.isize => .{ .is_signed = true, .bits = cg.target.ptrBitWidth() },
2326	.usize => .{ .is_signed = false, .bits = cg.target.ptrBitWidth() },	2325	.usize => .{ .is_signed = false, .bits = cg.target.ptrBitWidth() },
2327	.c_char => .{ .is_signed = cg.target.cCharSignedness() == .signed, .bits = cg.target.cTypeBitSize(.char) },	2326	.c_char => .{ .is_signed = cg.target.cCharSignedness() == .signed, .bits = cg.target.cTypeBitSize(.char) },
...	@@ -2334,7 +2333,7 @@ const IntType = struct {	...	@@ -2334,7 +2333,7 @@ const IntType = struct {
2334	.c_longlong => .{ .is_signed = true, .bits = cg.target.cTypeBitSize(.longlong) },	2333	.c_longlong => .{ .is_signed = true, .bits = cg.target.cTypeBitSize(.longlong) },
2335	.c_ulonglong => .{ .is_signed = false, .bits = cg.target.cTypeBitSize(.longlong) },	2334	.c_ulonglong => .{ .is_signed = false, .bits = cg.target.cTypeBitSize(.longlong) },
2336	.f16, .f32, .f64, .f80, .f128, .c_longdouble => unreachable,	2335	.f16, .f32, .f64, .f80, .f128, .c_longdouble => unreachable,
2337	.anyopaque, .void, .type, .comptime_int, .comptime_float, .noreturn, .null, .undefined, .enum_literal, .adhoc_inferred_error_set, .generic_poison => unreachable,	2336	.anyopaque, .void, .type, .comptime_int, .comptime_float, .noreturn, .null, .undefined, .enum_literal, .generic_poison => unreachable,
2338	},	2337	},
2339	.struct_type => {	2338	.struct_type => {
2340	const loaded_struct = ip.loadStructType(ty_index);	2339	const loaded_struct = ip.loadStructType(ty_index);
...	@@ -3069,7 +3068,13 @@ fn intClz(cg: *CodeGen, ty: IntType, operand: WValue) InnerError!WValue {	...	@@ -3069,7 +3068,13 @@ fn intClz(cg: *CodeGen, ty: IntType, operand: WValue) InnerError!WValue {
3069	var msb = try (try cg.load(operand, Type.u64, 8)).toLocal(cg, Type.u64);	3068	var msb = try (try cg.load(operand, Type.u64, 8)).toLocal(cg, Type.u64);
3070	defer msb.free(cg);	3069	defer msb.free(cg);
3071		3070
3072	try cg.emitWValue(msb);	3071	if (ty.is_signed and ty.bits < 128) {
		3072	const mask: u64 = ~@as(u64, 0) >> @intCast(128 - ty.bits);
		3073	_ = try cg.intAnd(.u64, msb, .{ .imm64 = mask });
		3074	} else {
		3075	try cg.emitWValue(msb);
		3076	}
		3077
3073	try cg.addTag(.i64_clz);	3078	try cg.addTag(.i64_clz);
3074	_ = try cg.load(operand, Type.u64, 0);	3079	_ = try cg.load(operand, Type.u64, 0);
3075	try cg.addTag(.i64_clz);	3080	try cg.addTag(.i64_clz);
...	@@ -3078,6 +3083,12 @@ fn intClz(cg: *CodeGen, ty: IntType, operand: WValue) InnerError!WValue {	...	@@ -3078,6 +3083,12 @@ fn intClz(cg: *CodeGen, ty: IntType, operand: WValue) InnerError!WValue {
3078	_ = try cg.intCmp(.u64, .neq, msb, .{ .imm64 = 0 });	3083	_ = try cg.intCmp(.u64, .neq, msb, .{ .imm64 = 0 });
3079	try cg.addTag(.select);	3084	try cg.addTag(.select);
3080	try cg.addTag(.i32_wrap_i64);	3085	try cg.addTag(.i32_wrap_i64);
		3086
		3087	if (ty.bits < 128) {
		3088	try cg.addImm32(128 - ty.bits);
		3089	try cg.addTag(.i32_sub);
		3090	}
		3091
3081	return .stack;	3092	return .stack;
3082	},	3093	},
3083	else => {	3094	else => {
...	@@ -4622,11 +4633,18 @@ fn floatFromInt(cg: *CodeGen, dest_ty: FloatType, src_ty: IntType, operand: WVal	...	@@ -4622,11 +4633,18 @@ fn floatFromInt(cg: *CodeGen, dest_ty: FloatType, src_ty: IntType, operand: WVal
4622	fn lowerPtr(cg: *CodeGen, ptr_val: InternPool.Index, prev_offset: u64) InnerError!WValue {	4633	fn lowerPtr(cg: *CodeGen, ptr_val: InternPool.Index, prev_offset: u64) InnerError!WValue {
4623	const pt = cg.pt;	4634	const pt = cg.pt;
4624	const zcu = pt.zcu;	4635	const zcu = pt.zcu;
		4636	const ip = &zcu.intern_pool;
4625	const ptr = zcu.intern_pool.indexToKey(ptr_val).ptr;	4637	const ptr = zcu.intern_pool.indexToKey(ptr_val).ptr;
4626	const offset: u64 = prev_offset + ptr.byte_offset;	4638	const offset: u64 = prev_offset + ptr.byte_offset;
4627	return switch (ptr.base_addr) {	4639	return switch (ptr.base_addr) {
4628	.nav => \|nav\| return .{ .nav_ref = .{ .nav_index = nav, .offset = @intCast(offset) } },	4640	.nav => \|nav\| return if (Type.fromInterned(ip.getNav(nav).resolved.?.type).isRuntimeFnOrHasRuntimeBits(zcu))
4629	.uav => \|uav\| return .{ .uav_ref = .{ .ip_index = uav.val, .offset = @intCast(offset), .orig_ptr_ty = uav.orig_ty } },	4641	.{ .nav_ref = .{ .nav_index = nav, .offset = @intCast(offset) } }
		4642	else
		4643	.{ .imm32 = @intCast(zcu.navAlignment(nav).forward(@as(u32, 0xaaaaaaaa))) },
		4644	.uav => \|uav\| return if (Type.fromInterned(ip.typeOf(uav.val)).isRuntimeFnOrHasRuntimeBits(zcu))
		4645	.{ .uav_ref = .{ .ip_index = uav.val, .offset = @intCast(offset), .orig_ptr_ty = uav.orig_ty } }
		4646	else
		4647	.{ .imm32 = @intCast(Type.fromInterned(uav.orig_ty).ptrAlignment(zcu).forward(@as(u32, 0xaaaaaaaa))) },
4630	.int => return cg.lowerConstant(try pt.intValue(.usize, offset)),	4648	.int => return cg.lowerConstant(try pt.intValue(.usize, offset)),
4631	.eu_payload => \|eu_ptr\| try cg.lowerPtr(	4649	.eu_payload => \|eu_ptr\| try cg.lowerPtr(
4632	eu_ptr,	4650	eu_ptr,
...	@@ -4960,9 +4978,9 @@ fn airCmp(cg: *CodeGen, inst: Air.Inst.Index, op: std.math.CompareOperator) Inne	...	@@ -4960,9 +4978,9 @@ fn airCmp(cg: *CodeGen, inst: Air.Inst.Index, op: std.math.CompareOperator) Inne
4960	try cg.addImm32(if (op == .eq) 0 else 1);	4978	try cg.addImm32(if (op == .eq) 0 else 1);
4961	try cg.addLocal(.local_set, result.local.value);	4979	try cg.addLocal(.local_set, result.local.value);
4962		4980
4963	_ = try cg.isNull(lhs, operand_ty, .i32_eq);	4981	_ = try cg.isNull(lhs, operand_ty, .i32_eq, .value);
4964	try cg.addLocal(.local_tee, lhs_null.local.value);	4982	try cg.addLocal(.local_tee, lhs_null.local.value);
4965	_ = try cg.isNull(rhs, operand_ty, .i32_eq);	4983	_ = try cg.isNull(rhs, operand_ty, .i32_eq, .value);
4966	try cg.addTag(.i32_ne);	4984	try cg.addTag(.i32_ne);
4967	try cg.addLabel(.br_if, 0);	4985	try cg.addLabel(.br_if, 0);
4968		4986
...	@@ -5234,26 +5252,56 @@ fn airBitcast(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -5234,26 +5252,56 @@ fn airBitcast(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
5234	fn bitcast(cg: *CodeGen, dest_ty: Type, src_ty: Type, operand: WValue) InnerError!?WValue {	5252	fn bitcast(cg: *CodeGen, dest_ty: Type, src_ty: Type, operand: WValue) InnerError!?WValue {
5235	const zcu = cg.pt.zcu;	5253	const zcu = cg.pt.zcu;
5236	const bit_size = src_ty.bitSize(zcu);	5254	const bit_size = src_ty.bitSize(zcu);
5237	const needs_wrapping = (src_ty.isSignedInt(zcu) != dest_ty.isSignedInt(zcu)) and	5255	const dest_signed = if (dest_ty.isAbiInt(zcu)) IntType.fromType(cg, dest_ty).is_signed else false;
		5256	const src_signed = if (src_ty.isAbiInt(zcu)) IntType.fromType(cg, src_ty).is_signed else false;
		5257	const needs_wrapping = (src_signed != dest_signed) and
5238	bit_size != 32 and bit_size != 64 and bit_size != 128;	5258	bit_size != 32 and bit_size != 64 and bit_size != 128;
5239		5259
5240	if (src_ty.isAnyFloat() or dest_ty.isAnyFloat()) {	5260	if (src_ty.isAnyFloat()) {
5241	if (dest_ty.ip_index == .f16_type or src_ty.ip_index == .f16_type) return null;	5261	const float_ty: FloatType = .fromType(cg, src_ty);
5242	if (dest_ty.bitSize(zcu) > 64) return null;	5262	switch (float_ty) {
5243	assert((dest_ty.isInt(zcu) and src_ty.isAnyFloat()) or (dest_ty.isAnyFloat() and src_ty.isInt(zcu)));	5263	.f16, .f80, .f128 => {
5244		5264	if (dest_signed) {
5245	const dest_valtype = typeToValtype(dest_ty, zcu, cg.target);	5265	const int_ty: IntType = .fromType(cg, dest_ty);
5246	const opcode: Mir.Inst.Tag = switch (dest_valtype) {	5266	return try cg.intWrap(int_ty, operand);
5247	.i32 => .i32_reinterpret_f32,	5267	} else {
5248	.i64 => .i64_reinterpret_f64,	5268	return null;
5249	.f32 => .f32_reinterpret_i32,	5269	}
5250	.f64 => .f64_reinterpret_i64,	5270	},
5251	else => unreachable,	5271	.f32 => {
5252	};	5272	try cg.emitWValue(operand);
		5273	try cg.addTag(.i32_reinterpret_f32);
		5274	return .stack;
		5275	},
		5276	.f64 => {
		5277	try cg.emitWValue(operand);
		5278	try cg.addTag(.i64_reinterpret_f64);
		5279	return .stack;
		5280	},
		5281	}
		5282	}
5253		5283
5254	try cg.emitWValue(operand);	5284	if (dest_ty.isAnyFloat()) {
5255	try cg.addTag(opcode);	5285	const float_ty: FloatType = .fromType(cg, dest_ty);
5256	return .stack;	5286	switch (float_ty) {
		5287	.f16, .f80, .f128 => {
		5288	if (src_signed) {
		5289	return try cg.intWrap(.{ .bits = @intCast(bit_size), .is_signed = false }, operand);
		5290	} else {
		5291	return null;
		5292	}
		5293	},
		5294	.f32 => {
		5295	try cg.emitWValue(operand);
		5296	try cg.addTag(.f32_reinterpret_i32);
		5297	return .stack;
		5298	},
		5299	.f64 => {
		5300	try cg.emitWValue(operand);
		5301	try cg.addTag(.f64_reinterpret_i64);
		5302	return .stack;
		5303	},
		5304	}
5257	}	5305	}
5258		5306
5259	if (isByRef(src_ty, zcu, cg.target) and !isByRef(dest_ty, zcu, cg.target)) {	5307	if (isByRef(src_ty, zcu, cg.target) and !isByRef(dest_ty, zcu, cg.target)) {
...	@@ -5751,23 +5799,27 @@ fn airWrapErrUnionErr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -5751,23 +5799,27 @@ fn airWrapErrUnionErr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
5751	return cg.finishAir(inst, result, &.{ty_op.operand});	5799	return cg.finishAir(inst, result, &.{ty_op.operand});
5752	}	5800	}
5753		5801
5754	fn airIsNull(cg: *CodeGen, inst: Air.Inst.Index, opcode: std.wasm.Opcode, op_kind: enum { value, ptr }) InnerError!void {	5802	const OpKind = enum { value, ptr };
5755	const zcu = cg.pt.zcu;	5803
		5804	fn airIsNull(cg: *CodeGen, inst: Air.Inst.Index, opcode: std.wasm.Opcode, op_kind: OpKind) InnerError!void {
5756	const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	5805	const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
5757	const operand = try cg.resolveInst(un_op);	5806	const operand = try cg.resolveInst(un_op);
5758		5807
5759	const op_ty = cg.typeOf(un_op);	5808	const op_ty = cg.typeOf(un_op);
5760	const optional_ty = if (op_kind == .ptr) op_ty.childType(zcu) else op_ty;	5809	const result = try cg.isNull(operand, op_ty, opcode, op_kind);
5761	const result = try cg.isNull(operand, optional_ty, opcode);
5762	return cg.finishAir(inst, result, &.{un_op});	5810	return cg.finishAir(inst, result, &.{un_op});
5763	}	5811	}
5764		5812
5765	/// For a given type and operand, checks if it's considered `null`.	5813	/// For a given type and operand, checks if it's considered `null`.
5766	/// NOTE: Leaves the result on the stack	5814	/// NOTE: Leaves the result on the stack
5767	fn isNull(cg: *CodeGen, operand: WValue, optional_ty: Type, opcode: std.wasm.Opcode) InnerError!WValue {	5815	fn isNull(cg: *CodeGen, operand: WValue, op_ty: Type, opcode: std.wasm.Opcode, op_kind: OpKind) InnerError!WValue {
5768	const pt = cg.pt;	5816	const pt = cg.pt;
5769	const zcu = pt.zcu;	5817	const zcu = pt.zcu;
5770	try cg.emitWValue(operand);	5818	try cg.emitWValue(operand);
		5819	const optional_ty = switch (op_kind) {
		5820	.value => op_ty,
		5821	.ptr => op_ty.childType(zcu),
		5822	};
5771	const payload_ty = optional_ty.optionalChild(zcu);	5823	const payload_ty = optional_ty.optionalChild(zcu);
5772	if (!optional_ty.optionalReprIsPayload(zcu)) {	5824	if (!optional_ty.optionalReprIsPayload(zcu)) {
5773	// When payload is zero-bits, we can treat operand as a value, rather than	5825	// When payload is zero-bits, we can treat operand as a value, rather than
...	@@ -5783,6 +5835,13 @@ fn isNull(cg: *CodeGen, operand: WValue, optional_ty: Type, opcode: std.wasm.Opc	...	@@ -5783,6 +5835,13 @@ fn isNull(cg: *CodeGen, operand: WValue, optional_ty: Type, opcode: std.wasm.Opc
5783	.wasm32 => try cg.addMemArg(.i32_load, .{ .offset = operand.offset(), .alignment = 4 }),	5835	.wasm32 => try cg.addMemArg(.i32_load, .{ .offset = operand.offset(), .alignment = 4 }),
5784	.wasm64 => try cg.addMemArg(.i64_load, .{ .offset = operand.offset(), .alignment = 8 }),	5836	.wasm64 => try cg.addMemArg(.i64_load, .{ .offset = operand.offset(), .alignment = 8 }),
5785	}	5837	}
		5838	} else {
		5839	if (op_kind == .ptr) {
		5840	try cg.addMemArg(.i32_load, .{
		5841	.offset = operand.offset(),
		5842	.alignment = 4,
		5843	});
		5844	}
5786	}	5845	}
5787		5846
5788	// Compare the null value with '0'	5847	// Compare the null value with '0'
...	@@ -5934,10 +5993,7 @@ fn airSliceElemVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -5934,10 +5993,7 @@ fn airSliceElemVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
5934	try cg.addTag(.i32_mul);	5993	try cg.addTag(.i32_mul);
5935	try cg.addTag(.i32_add);	5994	try cg.addTag(.i32_add);
5936		5995
5937	const elem_result = if (isByRef(elem_ty, zcu, cg.target))	5996	const elem_result = try cg.load(.stack, elem_ty, 0);
5938	.stack
5939	else
5940	try cg.load(.stack, elem_ty, 0);
5941		5997
5942	return cg.finishAir(inst, elem_result, &.{ bin_op.lhs, bin_op.rhs });	5998	return cg.finishAir(inst, elem_result, &.{ bin_op.lhs, bin_op.rhs });
5943	}	5999	}
...	@@ -5991,10 +6047,7 @@ fn airArrayToSlice(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -5991,10 +6047,7 @@ fn airArrayToSlice(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
5991	// create a slice on the stack	6047	// create a slice on the stack
5992	const slice_local = try cg.allocStack(slice_ty);	6048	const slice_local = try cg.allocStack(slice_ty);
5993		6049
5994	// store the array ptr in the slice	6050	try cg.store(slice_local, operand, Type.usize, 0);
5995	if (array_ty.hasRuntimeBits(zcu)) {
5996	try cg.store(slice_local, operand, Type.usize, 0);
5997	}
5998		6051
5999	// store the length of the array in the slice	6052	// store the length of the array in the slice
6000	const array_len: u32 = @intCast(array_ty.arrayLen(zcu));	6053	const array_len: u32 = @intCast(array_ty.arrayLen(zcu));
...	@@ -6026,10 +6079,7 @@ fn airPtrElemVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -6026,10 +6079,7 @@ fn airPtrElemVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
6026	try cg.addTag(.i32_mul);	6079	try cg.addTag(.i32_mul);
6027	try cg.addTag(.i32_add);	6080	try cg.addTag(.i32_add);
6028		6081
6029	const elem_result = if (isByRef(elem_ty, zcu, cg.target))	6082	const elem_result = try cg.load(.stack, elem_ty, 0);
6030	.stack
6031	else
6032	try cg.load(.stack, elem_ty, 0);
6033		6083
6034	return cg.finishAir(inst, elem_result, &.{ bin_op.lhs, bin_op.rhs });	6084	return cg.finishAir(inst, elem_result, &.{ bin_op.lhs, bin_op.rhs });
6035	}	6085	}
...	@@ -6349,12 +6399,8 @@ fn airSplat(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -6349,12 +6399,8 @@ fn airSplat(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
6349	else => unreachable,	6399	else => unreachable,
6350	}	6400	}
6351	}	6401	}
6352	const elem_size = elem_ty.bitSize(zcu);
6353	const vector_len = @as(usize, @intCast(ty.vectorLen(zcu)));
6354	if ((!std.math.isPowerOfTwo(elem_size) or elem_size % 8 != 0) and vector_len > 1) {
6355	return cg.fail("TODO: WebAssembly `@splat` for arbitrary element bitsize {d}", .{elem_size});
6356	}
6357		6402
		6403	const vector_len = @as(usize, @intCast(ty.vectorLen(zcu)));
6358	const result = try cg.allocStack(ty);	6404	const result = try cg.allocStack(ty);
6359	const elem_byte_size = @as(u32, @intCast(elem_ty.abiSize(zcu)));	6405	const elem_byte_size = @as(u32, @intCast(elem_ty.abiSize(zcu)));
6360	var index: usize = 0;	6406	var index: usize = 0;
...	@@ -6494,7 +6540,7 @@ fn airAggregateInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -6494,7 +6540,7 @@ fn airAggregateInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
6494		6540
6495	const result: WValue = result_value: {	6541	const result: WValue = result_value: {
6496	switch (result_ty.zigTypeTag(zcu)) {	6542	switch (result_ty.zigTypeTag(zcu)) {
6497	.array => {	6543	.array, .vector => {
6498	const result = try cg.allocStack(result_ty);	6544	const result = try cg.allocStack(result_ty);
6499	const elem_ty = result_ty.childType(zcu);	6545	const elem_ty = result_ty.childType(zcu);
6500	const elem_size = @as(u32, @intCast(elem_ty.abiSize(zcu)));	6546	const elem_size = @as(u32, @intCast(elem_ty.abiSize(zcu)));
...	@@ -6554,7 +6600,6 @@ fn airAggregateInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -6554,7 +6600,6 @@ fn airAggregateInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
6554	break :result_value result;	6600	break :result_value result;
6555	},	6601	},
6556	},	6602	},
6557	.vector => return cg.fail("TODO: Wasm backend: implement airAggregateInit for vectors", .{}),
6558	else => unreachable,	6603	else => unreachable,
6559	}	6604	}
6560	};	6605	};
...	@@ -6792,6 +6837,37 @@ fn airMemcpy(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -6792,6 +6837,37 @@ fn airMemcpy(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
6792	return cg.finishAir(inst, .none, &.{ bin_op.lhs, bin_op.rhs });	6837	return cg.finishAir(inst, .none, &.{ bin_op.lhs, bin_op.rhs });
6793	}	6838	}
6794		6839
		6840	fn airMemmove(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
		6841	const zcu = cg.pt.zcu;
		6842	const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
		6843	const dst = try cg.resolveInst(bin_op.lhs);
		6844	const dst_ty = cg.typeOf(bin_op.lhs);
		6845	const ptr_elem_ty = dst_ty.childType(zcu);
		6846	const src = try cg.resolveInst(bin_op.rhs);
		6847	const src_ty = cg.typeOf(bin_op.rhs);
		6848	const len = switch (dst_ty.ptrSize(zcu)) {
		6849	.slice => blk: {
		6850	const slice_len = try cg.sliceLen(dst);
		6851	if (ptr_elem_ty.abiSize(zcu) != 1) {
		6852	try cg.emitWValue(slice_len);
		6853	try cg.emitWValue(.{ .imm32 = @as(u32, @intCast(ptr_elem_ty.abiSize(zcu))) });
		6854	try cg.addTag(.i32_mul);
		6855	try cg.addLocal(.local_set, slice_len.local.value);
		6856	}
		6857	break :blk slice_len;
		6858	},
		6859	.one => @as(WValue, .{
		6860	.imm32 = @as(u32, @intCast(ptr_elem_ty.arrayLen(zcu) * ptr_elem_ty.childType(zcu).abiSize(zcu))),
		6861	}),
		6862	.c, .many => unreachable,
		6863	};
		6864	const dst_ptr = try cg.sliceOrArrayPtr(dst, dst_ty);
		6865	const src_ptr = try cg.sliceOrArrayPtr(src, src_ty);
		6866	try cg.memmove(dst_ptr, src_ptr, len);
		6867
		6868	return cg.finishAir(inst, .none, &.{ bin_op.lhs, bin_op.rhs });
		6869	}
		6870
6795	fn airRetAddr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	6871	fn airRetAddr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
6796	// TODO: Implement this properly once stack serialization is solved	6872	// TODO: Implement this properly once stack serialization is solved
6797	return cg.finishAir(inst, switch (cg.ptr_size) {	6873	return cg.finishAir(inst, switch (cg.ptr_size) {
...	@@ -6992,7 +7068,7 @@ fn airTagName(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -6992,7 +7068,7 @@ fn airTagName(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
6992		7068
6993	const result_ptr = try cg.allocStack(cg.typeOfIndex(inst));	7069	const result_ptr = try cg.allocStack(cg.typeOfIndex(inst));
6994	try cg.lowerToStack(result_ptr);	7070	try cg.lowerToStack(result_ptr);
6995	try cg.emitWValue(operand);	7071	try cg.lowerToStack(operand);
6996	try cg.addInst(.{ .tag = .call_tag_name, .data = .{ .ip_index = enum_ty.toIntern() } });	7072	try cg.addInst(.{ .tag = .call_tag_name, .data = .{ .ip_index = enum_ty.toIntern() } });
6997		7073
6998	return cg.finishAir(inst, result_ptr, &.{un_op});	7074	return cg.finishAir(inst, result_ptr, &.{un_op});
...	@@ -7195,9 +7271,8 @@ fn airAtomicRmw(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -7195,9 +7271,8 @@ fn airAtomicRmw(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
7195	const ty = cg.typeOfIndex(inst);	7271	const ty = cg.typeOfIndex(inst);
7196	const op: std.builtin.AtomicRmwOp = extra.op();	7272	const op: std.builtin.AtomicRmwOp = extra.op();
7197		7273
7198	const int_ty: IntType = .fromType(cg, ty);
7199
7200	if (cg.useAtomicFeature()) {	7274	if (cg.useAtomicFeature()) {
		7275	const int_ty: IntType = .fromType(cg, ty);
7201	switch (op) {	7276	switch (op) {
7202	.Max,	7277	.Max,
7203	.Min,	7278	.Min,
...	@@ -7312,35 +7387,65 @@ fn airAtomicRmw(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -7312,35 +7387,65 @@ fn airAtomicRmw(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
7312	},	7387	},
7313	.Add,	7388	.Add,
7314	.Sub,	7389	.Sub,
		7390	=> {
		7391	if (ty.isAnyFloat()) {
		7392	const float_ty: FloatType = .fromType(cg, ty);
		7393	try cg.emitWValue(ptr);
		7394	_ = switch (op) {
		7395	.Add => try cg.floatAdd(float_ty, result, operand),
		7396	.Sub => try cg.floatSub(float_ty, result, operand),
		7397	else => unreachable,
		7398	};
		7399	try cg.store(.stack, .stack, ty, ptr.offset());
		7400	} else {
		7401	const int_ty: IntType = .fromType(cg, ty);
		7402	try cg.emitWValue(ptr);
		7403	_ = switch (op) {
		7404	.Add => try cg.intAdd(int_ty, result, operand),
		7405	.Sub => try cg.intSub(int_ty, result, operand),
		7406	else => unreachable,
		7407	};
		7408	_ = try cg.intWrap(int_ty, .stack);
		7409	try cg.store(.stack, .stack, ty, ptr.offset());
		7410	}
		7411	},
7315	.And,	7412	.And,
7316	.Or,	7413	.Or,
7317	.Xor,	7414	.Xor,
7318	=> {	7415	=> {
		7416	const int_ty: IntType = .fromType(cg, ty);
7319	try cg.emitWValue(ptr);	7417	try cg.emitWValue(ptr);
7320	_ = switch (op) {	7418	_ = switch (op) {
7321	.Add => try cg.intAdd(int_ty, result, operand),
7322	.Sub => try cg.intSub(int_ty, result, operand),
7323	.And => try cg.intAnd(int_ty, result, operand),	7419	.And => try cg.intAnd(int_ty, result, operand),
7324	.Or => try cg.intOr(int_ty, result, operand),	7420	.Or => try cg.intOr(int_ty, result, operand),
7325	.Xor => try cg.intXor(int_ty, result, operand),	7421	.Xor => try cg.intXor(int_ty, result, operand),
7326	else => unreachable,	7422	else => unreachable,
7327	};	7423	};
7328	if (ty.isInt(zcu) and (op == .Add or op == .Sub)) {
7329	_ = try cg.intWrap(int_ty, .stack);
7330	}
7331	try cg.store(.stack, .stack, ty, ptr.offset());	7424	try cg.store(.stack, .stack, ty, ptr.offset());
7332	},	7425	},
7333	.Max,	7426	.Max,
7334	.Min,	7427	.Min,
7335	=> {	7428	=> {
7336	try cg.emitWValue(ptr);	7429	if (ty.isAnyFloat()) {
7337	try cg.emitWValue(result);	7430	const float_ty: FloatType = .fromType(cg, ty);
7338	try cg.emitWValue(operand);	7431	try cg.emitWValue(ptr);
7339	_ = try cg.intCmp(int_ty, if (op == .Max) .gt else .lt, result, operand);	7432	try cg.emitWValue(result);
7340	try cg.addTag(.select);	7433	try cg.emitWValue(operand);
7341	try cg.store(.stack, .stack, ty, ptr.offset());	7434	_ = try cg.floatCmp(float_ty, if (op == .Max) .gt else .lt, result, operand);
		7435	try cg.addTag(.select);
		7436	try cg.store(.stack, .stack, ty, ptr.offset());
		7437	} else {
		7438	const int_ty: IntType = .fromType(cg, ty);
		7439	try cg.emitWValue(ptr);
		7440	try cg.emitWValue(result);
		7441	try cg.emitWValue(operand);
		7442	_ = try cg.intCmp(int_ty, if (op == .Max) .gt else .lt, result, operand);
		7443	try cg.addTag(.select);
		7444	try cg.store(.stack, .stack, ty, ptr.offset());
		7445	}
7342	},	7446	},
7343	.Nand => {	7447	.Nand => {
		7448	const int_ty: IntType = .fromType(cg, ty);
7344	try cg.emitWValue(ptr);	7449	try cg.emitWValue(ptr);
7345	const and_res = try cg.intAnd(int_ty, result, operand);	7450	const and_res = try cg.intAnd(int_ty, result, operand);
7346	if (int_ty.bits <= 32) {	7451	if (int_ty.bits <= 32) {
...	@@ -7423,49 +7528,51 @@ fn airAsm(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -7423,49 +7528,51 @@ fn airAsm(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
7423	else	7528	else
7424	.none;	7529	.none;
7425		7530
7426	var local_map: assembly.LocalMap = .empty;	7531	if (unwrapped_asm.source.len != 0) {
7427	defer local_map.deinit(cg.gpa);	7532	var local_map: assembly.LocalMap = .empty;
		7533	defer local_map.deinit(cg.gpa);
7428		7534
7429	{	7535	{
7430	var it = unwrapped_asm.iterateOutputs();	7536	var it = unwrapped_asm.iterateOutputs();
7431	if (it.next()) \|output\| {	7537	if (it.next()) \|output\| {
7432	const constraint = output.constraint;	7538	const constraint = output.constraint;
7433	assert(output.operand == .none);	7539	assert(output.operand == .none);
7434	const name = output.name;	7540	const name = output.name;
7435
7436	if (!mem.eql(u8, constraint, "=r")) {
7437	return cg.fail("Self-hosted wasm backend requires output constraint to be equal \"=r\"", .{});
7438	}
7439		7541
7440	const gop = try local_map.getOrPutValue(cg.gpa, name, result.local.value);	7542	if (!mem.eql(u8, constraint, "=r")) {
7441	assert(!gop.found_existing); // first value	7543	return cg.fail("Self-hosted wasm backend requires output constraint to be equal \"=r\"", .{});
		7544	}
7442		7545
7443	assert(it.next() == null);	7546	const gop = try local_map.getOrPutValue(cg.gpa, name, result.local.value);
7444	}	7547	assert(!gop.found_existing); // first value
7445	}
7446		7548
7447	{	7549	assert(it.next() == null);
7448	var it = unwrapped_asm.iterateInputs();
7449	while (it.next()) \|input\| {
7450	const constraint = input.constraint;
7451	const operand = try cg.resolveInst(input.operand);
7452	const name = input.name;
7453
7454	if (!mem.eql(u8, constraint, "r")) {
7455	return cg.fail("Self-hosted wasm backend requires input constraint to be equal \"r\"", .{});
7456	}	7550	}
		7551	}
7457		7552
7458	try cg.lowerToStack(operand);	7553	{
7459	const op_local = try WValue.toLocal(.stack, cg, cg.typeOf(input.operand));	7554	var it = unwrapped_asm.iterateInputs();
		7555	while (it.next()) \|input\| {
		7556	const constraint = input.constraint;
		7557	const operand = try cg.resolveInst(input.operand);
		7558	const name = input.name;
		7559
		7560	if (!mem.eql(u8, constraint, "r")) {
		7561	return cg.fail("Self-hosted wasm backend requires input constraint to be equal \"r\"", .{});
		7562	}
		7563
		7564	try cg.lowerToStack(operand);
		7565	const op_local = try WValue.toLocal(.stack, cg, cg.typeOf(input.operand));
7460		7566
7461	const gop = try local_map.getOrPutValue(cg.gpa, name, op_local.local.value);	7567	const gop = try local_map.getOrPutValue(cg.gpa, name, op_local.local.value);
7462	if (gop.found_existing) {	7568	if (gop.found_existing) {
7463	return cg.fail("Duplicate asm variable name \"{s}\"", .{name});	7569	return cg.fail("Duplicate asm variable name \"{s}\"", .{name});
		7570	}
7464	}	7571	}
7465	}	7572	}
7466	}
7467		7573
7468	try assembly.assemble(cg, unwrapped_asm.source, &local_map);	7574	try assembly.assemble(cg, unwrapped_asm.source, &local_map);
		7575	}
7469		7576
7470	var bt = cg.liveness.iterateBigTomb(inst);	7577	var bt = cg.liveness.iterateBigTomb(inst);
7471	for (outputs) \|output\| if (output != .none) cg.feed(&bt, output);	7578	for (outputs) \|output\| if (output != .none) cg.feed(&bt, output);

src/codegen/wasm/Mir.zig+3

 @@ -1028,6 +1028,9 @@ pub const Intrinsic = enum(u32) {
     tanf,
     tanq,
     truncq,
+    memcpy,
+    memmove,
+    memset,
     __addo_limb64,
     __subo_limb64,
     __cmp_limb64,

src/link/Wasm/Flush.zig+54-34

...	@@ -1865,7 +1865,6 @@ fn emitTagNameFunction(	...	@@ -1865,7 +1865,6 @@ fn emitTagNameFunction(
1865	) !void {	1865	) !void {
1866	const comp = wasm.base.comp;	1866	const comp = wasm.base.comp;
1867	const gpa = comp.gpa;	1867	const gpa = comp.gpa;
1868	const diags = &comp.link_diags;
1869	const zcu = comp.zcu.?;	1868	const zcu = comp.zcu.?;
1870	const ip = &zcu.intern_pool;	1869	const ip = &zcu.intern_pool;
1871	const enum_type = ip.loadEnumType(enum_type_ip);	1870	const enum_type = ip.loadEnumType(enum_type_ip);
...	@@ -1909,11 +1908,7 @@ fn emitTagNameFunction(	...	@@ -1909,11 +1908,7 @@ fn emitTagNameFunction(
1909	}	1908	}
1910		1909
1911	const int_info = Zcu.Type.intInfo(.fromInterned(enum_type.int_tag_type), zcu);	1910	const int_info = Zcu.Type.intInfo(.fromInterned(enum_type.int_tag_type), zcu);
1912	const outer_block_type: std.wasm.BlockType = switch (int_info.bits) {	1911	const is_big_int = int_info.bits > 64;
1913	0...32 => .i32,
1914	33...64 => .i64,
1915	else => return diags.fail("wasm linker does not yet implement @tagName for sparse enums with more than 64 bit integer tag types", .{}),
1916	};
1917		1912
1918	try code.ensureUnusedCapacity(	1913	try code.ensureUnusedCapacity(
1919	gpa,	1914	gpa,
...	@@ -1930,41 +1925,66 @@ fn emitTagNameFunction(	...	@@ -1930,41 +1925,66 @@ fn emitTagNameFunction(
1930		1925
1931	// Outer block that computes table offset.	1926	// Outer block that computes table offset.
1932	code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.block));	1927	code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.block));
1933	code.appendAssumeCapacity(@intFromEnum(outer_block_type));	1928	code.appendAssumeCapacity(@intFromEnum(std.wasm.BlockType.i32));
1934		1929
1935	for (tag_values, 0..) \|tag_value, tag_index\| {	1930	for (tag_values, 0..) \|tag_value, tag_index\| {
1936	// block for this if case	1931	// block for this if case
1937	code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.block));	1932	code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.block));
1938	code.appendAssumeCapacity(@intFromEnum(std.wasm.BlockType.empty));	1933	code.appendAssumeCapacity(@intFromEnum(std.wasm.BlockType.empty));
1939		1934
1940	// Tag value whose name should be returned.
1941	code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.local_get));
1942	appendReservedUleb32(code, 1);
1943
1944	const val: Zcu.Value = .fromInterned(tag_value);	1935	const val: Zcu.Value = .fromInterned(tag_value);
1945	switch (outer_block_type) {	1936	if (is_big_int) {
1946	.i32 => {	1937	var val_space: Zcu.Value.BigIntSpace = undefined;
1947	const x: u32 = switch (int_info.signedness) {	1938	const val_bigint = val.toBigInt(&val_space, zcu);
1948	.signed => @bitCast(@as(i32, @intCast(val.toSignedInt(zcu)))),	1939	const num_limbs = (int_info.bits + 63) / 64;
1949	.unsigned => @intCast(val.toUnsignedInt(zcu)),	1940
1950	};	1941	const limbs = try gpa.alloc(u64, num_limbs);
1951	appendReservedI32Const(code, x);	1942	defer gpa.free(limbs);
1952	code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i32_ne));	1943	val_bigint.writeTwosComplement(@ptrCast(limbs), .little);
1953	},	1944
1954	.i64 => {	1945	try code.ensureUnusedCapacity(gpa, 35 * num_limbs);
1955	const x: u64 = switch (int_info.signedness) {	1946
1956	.signed => @bitCast(val.toSignedInt(zcu)),	1947	for (0..num_limbs) \|limb_index\| {
1957	.unsigned => val.toUnsignedInt(zcu),	1948	code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.local_get));
1958	};	1949	appendReservedUleb32(code, 1);
1959	appendReservedI64Const(code, x);	1950
		1951	code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i64_load));
		1952	appendReservedUleb32(code, @ctz(@as(u32, 8)));
		1953	appendReservedUleb32(code, @intCast(limb_index * 8));
		1954
		1955	appendReservedI64Const(code, limbs[limb_index]);
1960	code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i64_ne));	1956	code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i64_ne));
1961	},
1962	else => unreachable,
1963	}
1964		1957
1965	// if they're not equal, break out of current branch	1958	code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.br_if));
1966	code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.br_if));	1959	appendReservedUleb32(code, 0);
1967	appendReservedUleb32(code, 0);	1960	}
		1961	} else {
		1962	code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.local_get));
		1963	appendReservedUleb32(code, 1);
		1964
		1965	switch (int_info.bits) {
		1966	0...32 => {
		1967	const x: u32 = switch (int_info.signedness) {
		1968	.signed => @bitCast(@as(i32, @intCast(val.toSignedInt(zcu)))),
		1969	.unsigned => @intCast(val.toUnsignedInt(zcu)),
		1970	};
		1971	appendReservedI32Const(code, x);
		1972	code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i32_ne));
		1973	},
		1974	33...64 => {
		1975	const x: u64 = switch (int_info.signedness) {
		1976	.signed => @bitCast(val.toSignedInt(zcu)),
		1977	.unsigned => val.toUnsignedInt(zcu),
		1978	};
		1979	appendReservedI64Const(code, x);
		1980	code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i64_ne));
		1981	},
		1982	else => unreachable,
		1983	}
		1984
		1985	code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.br_if));
		1986	appendReservedUleb32(code, 0);
		1987	}
1968		1988
1969	// Put the table offset of the result on the stack.	1989	// Put the table offset of the result on the stack.
1970	appendReservedI32Const(code, @intCast(tag_index * slice_abi_size));	1990	appendReservedI32Const(code, @intCast(tag_index * slice_abi_size));
...	@@ -1995,7 +2015,7 @@ fn appendReservedI32Const(bytes: *ArrayList(u8), val: u32) void {	...	@@ -1995,7 +2015,7 @@ fn appendReservedI32Const(bytes: *ArrayList(u8), val: u32) void {
1995	bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i32_const));	2015	bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i32_const));
1996	var w: std.Io.Writer = .fromArrayList(bytes);	2016	var w: std.Io.Writer = .fromArrayList(bytes);
1997	defer bytes.* = w.toArrayList();	2017	defer bytes.* = w.toArrayList();
1998	return w.writeSleb128(val) catch \|err\| switch (err) {	2018	return w.writeSleb128(@as(i32, @bitCast(val))) catch \|err\| switch (err) {
1999	error.WriteFailed => unreachable,	2019	error.WriteFailed => unreachable,
2000	};	2020	};
2001	}	2021	}
...	@@ -2005,7 +2025,7 @@ fn appendReservedI64Const(bytes: *ArrayList(u8), val: u64) void {	...	@@ -2005,7 +2025,7 @@ fn appendReservedI64Const(bytes: *ArrayList(u8), val: u64) void {
2005	bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i64_const));	2025	bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i64_const));
2006	var w: std.Io.Writer = .fromArrayList(bytes);	2026	var w: std.Io.Writer = .fromArrayList(bytes);
2007	defer bytes.* = w.toArrayList();	2027	defer bytes.* = w.toArrayList();
2008	return w.writeSleb128(val) catch \|err\| switch (err) {	2028	return w.writeSleb128(@as(i64, @bitCast(val))) catch \|err\| switch (err) {
2009	error.WriteFailed => unreachable,	2029	error.WriteFailed => unreachable,
2010	};	2030	};
2011	}	2031	}

test/behavior/abs.zig+2-5

test/behavior/align.zig-1

...	@@ -527,7 +527,6 @@ test "alignment of zero-bit types is respected" {	...	@@ -527,7 +527,6 @@ test "alignment of zero-bit types is respected" {
527	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;	527	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
528	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;	528	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
529	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	529	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
530	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
531	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO	530	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
532		531
533	const S = struct { arr: [0]usize = .{} };	532	const S = struct { arr: [0]usize = .{} };

test/behavior/atomics.zig-1

...	@@ -189,7 +189,6 @@ test "atomicrmw with floats" {	...	@@ -189,7 +189,6 @@ test "atomicrmw with floats" {
189	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	189	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
190	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	190	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
191	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO	191	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
192	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
193		192
194	try testAtomicRmwFloat();	193	try testAtomicRmwFloat();
195	try comptime testAtomicRmwFloat();	194	try comptime testAtomicRmwFloat();

test/behavior/basic.zig-1

...	@@ -1147,7 +1147,6 @@ test "arrays and vectors with big integers" {	...	@@ -1147,7 +1147,6 @@ test "arrays and vectors with big integers" {
1147	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1147	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1148	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	1148	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
1149	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	1149	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1150	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
1151	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	1150	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1152	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1151	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1153	if (builtin.zig_backend == .stage2_llvm and (builtin.abi == .gnuabin32 or builtin.abi == .muslabin32)) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/23805	1152	if (builtin.zig_backend == .stage2_llvm and (builtin.abi == .gnuabin32 or builtin.abi == .muslabin32)) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/23805

test/behavior/bitcast.zig-2

test/behavior/bitreverse.zig-5

test/behavior/byteswap.zig-5

test/behavior/cast.zig-15

test/behavior/enum.zig+98-1

...	@@ -1057,7 +1057,6 @@ test "tag name with signed enum values" {	...	@@ -1057,7 +1057,6 @@ test "tag name with signed enum values" {
1057	test "tag name with large enum values" {	1057	test "tag name with large enum values" {
1058	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1058	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1059	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;	1059	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
1060	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
1061		1060
1062	const Kdf = enum(u128) {	1061	const Kdf = enum(u128) {
1063	aes_kdf = 0xea4f8ac1080d74bf60448a629af3d9c9,	1062	aes_kdf = 0xea4f8ac1080d74bf60448a629af3d9c9,
...	@@ -1074,6 +1073,104 @@ test "tag name with large enum values" {	...	@@ -1074,6 +1073,104 @@ test "tag name with large enum values" {
1074	try expect(mem.eql(u8, @tagName(kdf), "argon2id"));	1073	try expect(mem.eql(u8, @tagName(kdf), "argon2id"));
1075	}	1074	}
1076		1075
		1076	test "@tagName with exotic integer enum types" {
		1077	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
		1078	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
		1079
		1080	const S = struct {
		1081	fn testEnumSigned(comptime T: type) !void {
		1082	{
		1083	const E1 = enum(T) {
		1084	a = -125,
		1085	b = 125,
		1086	c = std.math.minInt(T),
		1087	d = std.math.maxInt(T),
		1088	};
		1089
		1090	var e: E1 = .a;
		1091	try expect(mem.eql(u8, @tagName(e), "a"));
		1092	e = .b;
		1093	try expect(mem.eql(u8, @tagName(e), "b"));
		1094	e = .c;
		1095	try expect(mem.eql(u8, @tagName(e), "c"));
		1096	e = .d;
		1097	try expect(mem.eql(u8, @tagName(e), "d"));
		1098	}
		1099	{
		1100	const E2 = enum(T) {
		1101	a = -125,
		1102	b = 125,
		1103	c = std.math.minInt(T),
		1104	d = std.math.maxInt(T),
		1105	_,
		1106	};
		1107
		1108	var e: E2 = .a;
		1109	try expect(mem.eql(u8, @tagName(e), "a"));
		1110	e = .b;
		1111	try expect(mem.eql(u8, @tagName(e), "b"));
		1112	e = .c;
		1113	try expect(mem.eql(u8, @tagName(e), "c"));
		1114	e = .d;
		1115	try expect(mem.eql(u8, @tagName(e), "d"));
		1116	}
		1117	}
		1118
		1119	fn testEnumUnsigned(comptime T: type) !void {
		1120	{
		1121	const E1 = enum(T) {
		1122	a = std.math.maxInt(T) - 125,
		1123	b = 125,
		1124	c = std.math.minInt(T),
		1125	d = std.math.maxInt(T),
		1126	};
		1127
		1128	var e: E1 = .a;
		1129	try expect(mem.eql(u8, @tagName(e), "a"));
		1130	e = .b;
		1131	try expect(mem.eql(u8, @tagName(e), "b"));
		1132	e = .c;
		1133	try expect(mem.eql(u8, @tagName(e), "c"));
		1134	e = .d;
		1135	try expect(mem.eql(u8, @tagName(e), "d"));
		1136	}
		1137	{
		1138	const E2 = enum(T) {
		1139	a = std.math.maxInt(T) - 125,
		1140	b = 125,
		1141	c = std.math.minInt(T),
		1142	d = std.math.maxInt(T),
		1143	_,
		1144	};
		1145
		1146	var e: E2 = .a;
		1147	try expect(mem.eql(u8, @tagName(e), "a"));
		1148	e = .b;
		1149	try expect(mem.eql(u8, @tagName(e), "b"));
		1150	e = .c;
		1151	try expect(mem.eql(u8, @tagName(e), "c"));
		1152	e = .d;
		1153	try expect(mem.eql(u8, @tagName(e), "d"));
		1154	}
		1155	}
		1156
		1157	fn doTheTest() !void {
		1158	try testEnumSigned(i33);
		1159	try testEnumSigned(i95);
		1160	try testEnumSigned(i127);
		1161	try testEnumSigned(i257);
		1162
		1163	try testEnumUnsigned(u33);
		1164	try testEnumUnsigned(u95);
		1165	try testEnumUnsigned(u127);
		1166	try testEnumUnsigned(u257);
		1167	}
		1168	};
		1169
		1170	try S.doTheTest();
		1171	try comptime S.doTheTest();
		1172	}
		1173
1077	test "@tagName in callconv(.c) function" {	1174	test "@tagName in callconv(.c) function" {
1078	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1175	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1079	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	1176	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;

test/behavior/floatop.zig-22

test/behavior/lower_strlit_to_vector.zig-1

...	@@ -4,7 +4,6 @@ const builtin = @import("builtin");	...	@@ -4,7 +4,6 @@ const builtin = @import("builtin");
4	test "strlit to vector" {	4	test "strlit to vector" {
5	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	5	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
6	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	6	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
8	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	7	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
9		8
10	const strlit = "0123456789abcdef0123456789ABCDEF";	9	const strlit = "0123456789abcdef0123456789ABCDEF";

test/behavior/math.zig-12

test/behavior/maximum_minimum.zig-7

test/behavior/memmove.zig-4

test/behavior/memset.zig-2

...	@@ -80,7 +80,6 @@ test "memset with 1-byte struct element" {	...	@@ -80,7 +80,6 @@ test "memset with 1-byte struct element" {
80	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	80	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
81	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	81	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
82	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	82	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
83	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
84		83
85	const S = struct { x: bool };	84	const S = struct { x: bool };
86	var buf: [5]S = undefined;	85	var buf: [5]S = undefined;
...	@@ -93,7 +92,6 @@ test "memset with 1-byte array element" {	...	@@ -93,7 +92,6 @@ test "memset with 1-byte array element" {
93	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	92	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
94	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	93	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
95	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	94	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
96	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
97		95
98	const A = [1]bool;	96	const A = [1]bool;
99	var buf: [5]A = undefined;	97	var buf: [5]A = undefined;

test/behavior/muladd.zig-5

test/behavior/popcount.zig-1

...	@@ -77,7 +77,6 @@ fn testPopCountIntegers() !void {	...	@@ -77,7 +77,6 @@ fn testPopCountIntegers() !void {
77		77
78	test "@popCount vectors" {	78	test "@popCount vectors" {
79	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	79	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
80	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
81	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	80	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
82	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	81	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
83	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	82	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;

test/behavior/ptrcast.zig-2

...	@@ -515,7 +515,6 @@ test "@ptrCast single-item pointer to slice with length 1" {	...	@@ -515,7 +515,6 @@ test "@ptrCast single-item pointer to slice with length 1" {
515	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	515	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
516	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	516	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
517	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	517	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
518	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
519		518
520	const S = struct {	519	const S = struct {
521	fn doTheTest(comptime T: type, ptr: *const T) !void {	520	fn doTheTest(comptime T: type, ptr: *const T) !void {
...	@@ -536,7 +535,6 @@ test "@ptrCast single-item pointer to slice of bytes" {	...	@@ -536,7 +535,6 @@ test "@ptrCast single-item pointer to slice of bytes" {
536	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	535	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
537	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	536	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
538	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	537	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
539	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
540		538
541	const S = struct {	539	const S = struct {
542	fn doTheTest(comptime T: type, ptr: *const T) !void {	540	fn doTheTest(comptime T: type, ptr: *const T) !void {

test/behavior/select.zig-3

test/behavior/shuffle.zig-3

test/behavior/truncate.zig-1

...	@@ -112,7 +112,6 @@ test "@truncate > 128 bits" {	...	@@ -112,7 +112,6 @@ test "@truncate > 128 bits" {
112		112
113	test "truncate on vectors" {	113	test "truncate on vectors" {
114	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	114	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
115	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
116	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	115	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
117	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	116	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
118	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	117	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;

test/behavior/union.zig-1

...	@@ -2184,7 +2184,6 @@ test "matching captures causes union equivalence" {	...	@@ -2184,7 +2184,6 @@ test "matching captures causes union equivalence" {
2184	test "signed enum tag with negative value" {	2184	test "signed enum tag with negative value" {
2185	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2185	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2186	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	2186	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2187	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
2188	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2187	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2189		2188
2190	const Enum = enum(i8) {	2189	const Enum = enum(i8) {

test/behavior/vector.zig+4-49

test/tests.zig+1-1

...	@@ -1473,7 +1473,7 @@ const module_test_targets = blk: {	...	@@ -1473,7 +1473,7 @@ const module_test_targets = blk: {
1473	.os_tag = .wasi,	1473	.os_tag = .wasi,
1474	.abi = .none,	1474	.abi = .none,
1475	},	1475	},
1476	.skip_modules = &.{ "compiler-rt", "std" },	1476	.skip_modules = &.{"compiler-rt"},
1477	.use_llvm = false,	1477	.use_llvm = false,
1478	.use_lld = false,	1478	.use_lld = false,
1479	},	1479	},

author	Pavel Verigo <paul.verigo@gmail.com> 2026-04-20 20:49:35+02:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-04-22 00:19:46+02:00
log	22945fbbdc1ec89def58f39ddc8c35502b6e05dd
tree	2d30a01ac77771db9f74f3927fa86969f6fa94a9
parent	36faf76fe1eeb3aafcc4de94fc83fd8ca3b18b25

...	@@ -935,7 +935,7 @@ pub fn abiAlignment(ty: Type, zcu: *const Zcu) Alignment {	...	@@ -935,7 +935,7 @@ pub fn abiAlignment(ty: Type, zcu: *const Zcu) Alignment {
935	const bytes = ((elem_bits * vector_type.len) + 7) / 8;	935	const bytes = ((elem_bits * vector_type.len) + 7) / 8;
936	return .fromByteUnits(std.math.ceilPowerOfTwoAssert(u32, bytes));	936	return .fromByteUnits(std.math.ceilPowerOfTwoAssert(u32, bytes));
937	},	937	},
938	.stage2_c => return Type.fromInterned(vector_type.child).abiAlignment(zcu),	938	.stage2_c, .stage2_wasm => return Type.fromInterned(vector_type.child).abiAlignment(zcu),
939	.stage2_x86_64 => {	939	.stage2_x86_64 => {
940	if (vector_type.child == .bool_type) {	940	if (vector_type.child == .bool_type) {
941	if (vector_type.len > 256 and target.cpu.has(.x86, .avx512f)) return .@"64";	941	if (vector_type.len > 256 and target.cpu.has(.x86, .avx512f)) return .@"64";
...	@@ -1084,7 +1084,7 @@ pub fn abiSize(ty: Type, zcu: *const Zcu) u64 {	...	@@ -1084,7 +1084,7 @@ pub fn abiSize(ty: Type, zcu: *const Zcu) u64 {
1084	const elem_ty: Type = .fromInterned(vec.child);	1084	const elem_ty: Type = .fromInterned(vec.child);
1085	const bytes = switch (zcu.comp.getZigBackend()) {	1085	const bytes = switch (zcu.comp.getZigBackend()) {
1086	else => std.math.divCeil(u64, vec.len * elem_ty.bitSize(zcu), 8) catch unreachable,	1086	else => std.math.divCeil(u64, vec.len * elem_ty.bitSize(zcu), 8) catch unreachable,
1087	.stage2_c => vec.len * elem_ty.abiSize(zcu),	1087	.stage2_c, .stage2_wasm => vec.len * elem_ty.abiSize(zcu),
1088	.stage2_x86_64 => switch (elem_ty.toIntern()) {	1088	.stage2_x86_64 => switch (elem_ty.toIntern()) {
1089	.bool_type => std.math.divCeil(u64, vec.len, 8) catch unreachable,	1089	.bool_type => std.math.divCeil(u64, vec.len, 8) catch unreachable,
1090	else => vec.len * elem_ty.abiSize(zcu),	1090	else => vec.len * elem_ty.abiSize(zcu),

...	@@ -214,9 +214,9 @@ test "@abs floats" {	...	@@ -214,9 +214,9 @@ test "@abs floats" {
214	try comptime testAbsFloats(f64);	214	try comptime testAbsFloats(f64);
215	try testAbsFloats(f64);	215	try testAbsFloats(f64);
216	try comptime testAbsFloats(f80);	216	try comptime testAbsFloats(f80);
217	if (builtin.zig_backend != .stage2_wasm and builtin.zig_backend != .stage2_spirv and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f80);	217	if (builtin.zig_backend != .stage2_spirv and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f80);
218	try comptime testAbsFloats(f128);	218	try comptime testAbsFloats(f128);
219	if (builtin.zig_backend != .stage2_wasm and builtin.zig_backend != .stage2_spirv and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f128);	219	if (builtin.zig_backend != .stage2_spirv and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f128);
220	}	220	}
221		221
222	fn testAbsFloats(comptime T: type) !void {	222	fn testAbsFloats(comptime T: type) !void {
...	@@ -259,7 +259,6 @@ fn testAbsFloats(comptime T: type) !void {	...	@@ -259,7 +259,6 @@ fn testAbsFloats(comptime T: type) !void {
259	test "@abs int vectors" {	259	test "@abs int vectors" {
260	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	260	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
261	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO	261	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
262	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
263	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	262	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
264	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	263	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
265	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	264	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -326,7 +325,6 @@ fn testAbsIntVectors(comptime len: comptime_int) !void {	...	@@ -326,7 +325,6 @@ fn testAbsIntVectors(comptime len: comptime_int) !void {
326		325
327	test "@abs unsigned int vectors" {	326	test "@abs unsigned int vectors" {
328	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	327	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
329	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
330	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	328	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
331	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	329	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
332	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	330	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -385,7 +383,6 @@ fn testAbsUnsignedIntVectors(comptime len: comptime_int) !void {	...	@@ -385,7 +383,6 @@ fn testAbsUnsignedIntVectors(comptime len: comptime_int) !void {
385		383
386	test "@abs float vectors" {	384	test "@abs float vectors" {
387	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	385	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
388	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
389	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	386	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
390	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	387	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
391	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	388	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;

...	@@ -387,7 +387,6 @@ test "bitcast vector to integer and back" {	...	@@ -387,7 +387,6 @@ test "bitcast vector to integer and back" {
387	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	387	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
388	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	388	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
389	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO	389	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
390	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
391	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	390	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
392	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	391	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
393	if (builtin.cpu.arch.endian() == .big and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;	392	if (builtin.cpu.arch.endian() == .big and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
...	@@ -530,7 +529,6 @@ test "@bitCast of extern struct containing pointer" {	...	@@ -530,7 +529,6 @@ test "@bitCast of extern struct containing pointer" {
530	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	529	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
531	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	530	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
532	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO	531	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
533	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
534	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO	532	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
535		533
536	const S = struct {	534	const S = struct {

...	@@ -122,7 +122,6 @@ fn vector8() !void {	...	@@ -122,7 +122,6 @@ fn vector8() !void {
122		122
123	test "bitReverse vectors u8" {	123	test "bitReverse vectors u8" {
124	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	124	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
125	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
126	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	125	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
127	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	126	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
128	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	127	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -142,7 +141,6 @@ fn vector16() !void {	...	@@ -142,7 +141,6 @@ fn vector16() !void {
142		141
143	test "bitReverse vectors u16" {	142	test "bitReverse vectors u16" {
144	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	143	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
145	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
146	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	144	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
147	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	145	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
148	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	146	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -162,7 +160,6 @@ fn vector24() !void {	...	@@ -162,7 +160,6 @@ fn vector24() !void {
162		160
163	test "bitReverse vectors u24" {	161	test "bitReverse vectors u24" {
164	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	162	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
165	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
166	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	163	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
167	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	164	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
168	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	165	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -181,8 +178,6 @@ fn vector0() !void {	...	@@ -181,8 +178,6 @@ fn vector0() !void {
181	}	178	}
182		179
183	test "bitReverse vectors u0" {	180	test "bitReverse vectors u0" {
184	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
185
186	try comptime vector0();	181	try comptime vector0();
187	try vector0();	182	try vector0();
188	}	183	}

...	@@ -82,7 +82,6 @@ fn vector8() !void {	...	@@ -82,7 +82,6 @@ fn vector8() !void {
82		82
83	test "@byteSwap vectors u8" {	83	test "@byteSwap vectors u8" {
84	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	84	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
85	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
86	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	85	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
87	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	86	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
88	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	87	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -102,7 +101,6 @@ fn vector16() !void {	...	@@ -102,7 +101,6 @@ fn vector16() !void {
102		101
103	test "@byteSwap vectors u16" {	102	test "@byteSwap vectors u16" {
104	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	103	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
105	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
106	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	104	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
107	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	105	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
108	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	106	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -122,7 +120,6 @@ fn vector24() !void {	...	@@ -122,7 +120,6 @@ fn vector24() !void {
122		120
123	test "@byteSwap vectors u24" {	121	test "@byteSwap vectors u24" {
124	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	122	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
125	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
126	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	123	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
127	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	124	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
128	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	125	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -141,8 +138,6 @@ fn vector0() !void {	...	@@ -141,8 +138,6 @@ fn vector0() !void {
141	}	138	}
142		139
143	test "@byteSwap vectors u0" {	140	test "@byteSwap vectors u0" {
144	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
145
146	try comptime vector0();	141	try comptime vector0();
147	try vector0();	142	try vector0();
148	}	143	}

...	@@ -268,7 +268,6 @@ test "type coercion from int to float" {	...	@@ -268,7 +268,6 @@ test "type coercion from int to float" {
268	try check.value(c_longdouble, @as(u1, 0)); // Smoke test - size varies by target.	268	try check.value(c_longdouble, @as(u1, 0)); // Smoke test - size varies by target.
269		269
270	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	270	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
271	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
272		271
273	// Basic sanity check that the coercions work for vectors too.	272	// Basic sanity check that the coercions work for vectors too.
274	const int_vec: @Vector(2, u24) = @splat(123);	273	const int_vec: @Vector(2, u24) = @splat(123);
...	@@ -758,7 +757,6 @@ test "cast [1][]const u8 to []const ?[]const u8" {	...	@@ -758,7 +757,6 @@ test "cast [1][]const u8 to []const ?[]const u8" {
758		757
759	test "@intCast on vector" {	758	test "@intCast on vector" {
760	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	759	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
761	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
762	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	760	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
763	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	761	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
764	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	762	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -2145,7 +2143,6 @@ test "peer type resolution: array and vector with same child type" {	...	@@ -2145,7 +2143,6 @@ test "peer type resolution: array and vector with same child type" {
2145	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2143	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2146	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	2144	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2147	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO	2145	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
2148	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
2149		2146
2150	var arr: [2]u32 = .{ 0, 1 };	2147	var arr: [2]u32 = .{ 0, 1 };
2151	var vec: @Vector(2, u32) = .{ 2, 3 };	2148	var vec: @Vector(2, u32) = .{ 2, 3 };
...	@@ -2167,7 +2164,6 @@ test "peer type resolution: array and vector with same child type" {	...	@@ -2167,7 +2164,6 @@ test "peer type resolution: array and vector with same child type" {
2167	test "peer type resolution: array with smaller child type and vector with larger child type" {	2164	test "peer type resolution: array with smaller child type and vector with larger child type" {
2168	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2165	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2169	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2166	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2170	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2171	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2167	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2172	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2168	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2173		2169
...	@@ -2279,7 +2275,6 @@ test "peer type resolution: three-way resolution combines error set and optional	...	@@ -2279,7 +2275,6 @@ test "peer type resolution: three-way resolution combines error set and optional
2279	test "peer type resolution: vector and optional vector" {	2275	test "peer type resolution: vector and optional vector" {
2280	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2276	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2281	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2277	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2282	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2283	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2278	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2284	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO	2279	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
2285	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO	2280	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
...	@@ -2349,7 +2344,6 @@ test "peer type resolution: array and tuple" {	...	@@ -2349,7 +2344,6 @@ test "peer type resolution: array and tuple" {
2349	test "peer type resolution: vector and tuple" {	2344	test "peer type resolution: vector and tuple" {
2350	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2345	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2351	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2346	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2352	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2353	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2347	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2354		2348
2355	var vec: @Vector(3, i32) = .{ 1, 2, 3 };	2349	var vec: @Vector(3, i32) = .{ 1, 2, 3 };
...	@@ -2373,7 +2367,6 @@ test "peer type resolution: vector and tuple" {	...	@@ -2373,7 +2367,6 @@ test "peer type resolution: vector and tuple" {
2373	test "peer type resolution: vector and array and tuple" {	2367	test "peer type resolution: vector and array and tuple" {
2374	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2368	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2375	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2369	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2376	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2377	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2370	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2378	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	2371	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2379		2372
...	@@ -2816,7 +2809,6 @@ test "cast builtins can wrap result in error union and optional" {	...	@@ -2816,7 +2809,6 @@ test "cast builtins can wrap result in error union and optional" {
2816		2809
2817	test "@floatCast on vector" {	2810	test "@floatCast on vector" {
2818	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2811	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2819	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2820	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2812	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2821	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2813	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2822	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2814	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -2857,7 +2849,6 @@ test "@floatCast on vector" {	...	@@ -2857,7 +2849,6 @@ test "@floatCast on vector" {
2857		2849
2858	test "@ptrFromInt on vector" {	2850	test "@ptrFromInt on vector" {
2859	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2851	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2860	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2861	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2852	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2862	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2853	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2863	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2854	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -2882,7 +2873,6 @@ test "@ptrFromInt on vector" {	...	@@ -2882,7 +2873,6 @@ test "@ptrFromInt on vector" {
2882		2873
2883	test "@intFromPtr on vector" {	2874	test "@intFromPtr on vector" {
2884	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2875	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2885	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2886	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2876	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2887	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2877	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2888	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2878	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -2907,7 +2897,6 @@ test "@intFromPtr on vector" {	...	@@ -2907,7 +2897,6 @@ test "@intFromPtr on vector" {
2907		2897
2908	test "@floatFromInt on vector" {	2898	test "@floatFromInt on vector" {
2909	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2899	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2910	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2911	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2900	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2912	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2901	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2913	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2902	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -2927,7 +2916,6 @@ test "@floatFromInt on vector" {	...	@@ -2927,7 +2916,6 @@ test "@floatFromInt on vector" {
2927		2916
2928	test "@intFromFloat on vector" {	2917	test "@intFromFloat on vector" {
2929	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2918	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2930	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2931	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2919	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2932	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2920	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2933	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2921	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -2947,7 +2935,6 @@ test "@intFromFloat on vector" {	...	@@ -2947,7 +2935,6 @@ test "@intFromFloat on vector" {
2947		2935
2948	test "@intFromBool on vector" {	2936	test "@intFromBool on vector" {
2949	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2937	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2950	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2951	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2938	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2952	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2939	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2953	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2940	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -3023,7 +3010,6 @@ test "result information is preserved through many nested structures" {	...	@@ -3023,7 +3010,6 @@ test "result information is preserved through many nested structures" {
3023	test "@intCast vector of signed integer" {	3010	test "@intCast vector of signed integer" {
3024	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	3011	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
3025	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	3012	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
3026	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
3027	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	3013	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
3028	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	3014	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
3029	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	3015	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -3109,7 +3095,6 @@ test "@intFromFloat boundary cases" {	...	@@ -3109,7 +3095,6 @@ test "@intFromFloat boundary cases" {
3109	test "@intFromFloat vector boundary cases" {	3095	test "@intFromFloat vector boundary cases" {
3110	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	3096	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
3111	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	3097	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
3112	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
3113		3098
3114	const S = struct {	3099	const S = struct {
3115	fn case(comptime I: type, unshifted_inputs: [2]f32, expected: [2]I) !void {	3100	fn case(comptime I: type, unshifted_inputs: [2]f32, expected: [2]I) !void {

...	@@ -221,9 +221,7 @@ fn testCmp(comptime T: type) !void {	...	@@ -221,9 +221,7 @@ fn testCmp(comptime T: type) !void {
221		221
222	test "vector cmp f16" {	222	test "vector cmp f16" {
223	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	223	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
224	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
225	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	224	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
226	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
227	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	225	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
228	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;	226	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
229	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;	227	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
...	@@ -236,7 +234,6 @@ test "vector cmp f16" {	...	@@ -236,7 +234,6 @@ test "vector cmp f16" {
236	test "vector cmp f32" {	234	test "vector cmp f32" {
237	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	235	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
238	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	236	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
239	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
240	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	237	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
241	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	238	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
242	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;	239	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
...	@@ -249,7 +246,6 @@ test "vector cmp f32" {	...	@@ -249,7 +246,6 @@ test "vector cmp f32" {
249		246
250	test "vector cmp f64" {	247	test "vector cmp f64" {
251	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	248	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
252	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
253	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	249	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
254	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	250	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
255	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;	251	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
...	@@ -262,7 +258,6 @@ test "vector cmp f64" {	...	@@ -262,7 +258,6 @@ test "vector cmp f64" {
262		258
263	test "vector cmp f128" {	259	test "vector cmp f128" {
264	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	260	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
265	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
266	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	261	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
267	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;	262	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
268	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	263	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -281,7 +276,6 @@ test "vector cmp f80/c_longdouble" {	...	@@ -281,7 +276,6 @@ test "vector cmp f80/c_longdouble" {
281	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .powerpc64le) return error.SkipZigTest;	276	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .powerpc64le) return error.SkipZigTest;
282	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	277	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
283	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	278	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
284	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
285		279
286	try testCmpVector(f80);	280	try testCmpVector(f80);
287	try comptime testCmpVector(f80);	281	try comptime testCmpVector(f80);
...	@@ -477,7 +471,6 @@ fn testSqrt(comptime T: type) !void {	...	@@ -477,7 +471,6 @@ fn testSqrt(comptime T: type) !void {
477		471
478	test "@sqrt with vectors" {	472	test "@sqrt with vectors" {
479	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	473	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
480	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
481	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	474	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
482	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	475	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
483	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	476	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -546,7 +539,6 @@ fn testSin(comptime T: type) !void {	...	@@ -546,7 +539,6 @@ fn testSin(comptime T: type) !void {
546		539
547	test "@sin with vectors" {	540	test "@sin with vectors" {
548	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	541	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
549	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
550	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	542	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
551	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	543	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
552	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	544	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -615,7 +607,6 @@ fn testCos(comptime T: type) !void {	...	@@ -615,7 +607,6 @@ fn testCos(comptime T: type) !void {
615		607
616	test "@cos with vectors" {	608	test "@cos with vectors" {
617	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	609	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
618	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
619	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	610	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
620	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	611	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
621	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	612	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -684,7 +675,6 @@ fn testTan(comptime T: type) !void {	...	@@ -684,7 +675,6 @@ fn testTan(comptime T: type) !void {
684		675
685	test "@tan with vectors" {	676	test "@tan with vectors" {
686	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	677	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
687	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
688	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	678	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
689	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	679	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
690	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	680	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -757,7 +747,6 @@ fn testExp(comptime T: type) !void {	...	@@ -757,7 +747,6 @@ fn testExp(comptime T: type) !void {
757		747
758	test "@exp with vectors" {	748	test "@exp with vectors" {
759	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	749	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
760	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
761	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	750	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
762	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	751	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
763	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	752	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -825,7 +814,6 @@ fn testExp2(comptime T: type) !void {	...	@@ -825,7 +814,6 @@ fn testExp2(comptime T: type) !void {
825		814
826	test "@exp2 with @vectors" {	815	test "@exp2 with @vectors" {
827	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	816	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
828	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
829	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	817	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
830	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	818	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
831	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	819	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -893,7 +881,6 @@ fn testLog(comptime T: type) !void {	...	@@ -893,7 +881,6 @@ fn testLog(comptime T: type) !void {
893		881
894	test "@log with @vectors" {	882	test "@log with @vectors" {
895	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	883	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
896	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
897	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	884	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
898	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	885	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
899	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	886	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -959,7 +946,6 @@ fn testLog2(comptime T: type) !void {	...	@@ -959,7 +946,6 @@ fn testLog2(comptime T: type) !void {
959		946
960	test "@log2 with vectors" {	947	test "@log2 with vectors" {
961	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	948	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
962	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
963	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	949	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
964	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	950	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
965	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	951	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -1031,7 +1017,6 @@ fn testLog10(comptime T: type) !void {	...	@@ -1031,7 +1017,6 @@ fn testLog10(comptime T: type) !void {
1031		1017
1032	test "@log10 with vectors" {	1018	test "@log10 with vectors" {
1033	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1019	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1034	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1035	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1020	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1036	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1021	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1037	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	1022	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -1151,7 +1136,6 @@ fn testFabs(comptime T: type) !void {	...	@@ -1151,7 +1136,6 @@ fn testFabs(comptime T: type) !void {
1151	test "@abs with vectors" {	1136	test "@abs with vectors" {
1152	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1137	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1153	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1138	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1154	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1155	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1139	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1156		1140
1157	try testFabsWithVectors();	1141	try testFabsWithVectors();
...	@@ -1241,7 +1225,6 @@ fn testFloor(comptime T: type) !void {	...	@@ -1241,7 +1225,6 @@ fn testFloor(comptime T: type) !void {
1241	test "@floor with vectors" {	1225	test "@floor with vectors" {
1242	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1226	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1243	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1227	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1244	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1245	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1228	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1246		1229
1247	try testFloorWithVectors();	1230	try testFloorWithVectors();
...	@@ -1349,7 +1332,6 @@ fn testCeil(comptime T: type) !void {	...	@@ -1349,7 +1332,6 @@ fn testCeil(comptime T: type) !void {
1349	test "@ceil with vectors" {	1332	test "@ceil with vectors" {
1350	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1333	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1351	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1334	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1352	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1353	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1335	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1354		1336
1355	try testCeilWithVectors();	1337	try testCeilWithVectors();
...	@@ -1439,7 +1421,6 @@ fn testTrunc(comptime T: type) !void {	...	@@ -1439,7 +1421,6 @@ fn testTrunc(comptime T: type) !void {
1439	test "@trunc with vectors" {	1421	test "@trunc with vectors" {
1440	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1422	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1441	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1423	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1442	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1443	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1424	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1444		1425
1445	try testTruncWithVectors();	1426	try testTruncWithVectors();
...	@@ -1460,7 +1441,6 @@ test "neg f16" {	...	@@ -1460,7 +1441,6 @@ test "neg f16" {
1460	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1441	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1461	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1442	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1462	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1443	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1463	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
1464		1444
1465	if (builtin.os.tag == .freebsd) {	1445	if (builtin.os.tag == .freebsd) {
1466	// TODO file issue to track this failure	1446	// TODO file issue to track this failure
...	@@ -1486,7 +1466,6 @@ test "neg f80/f128/c_longdouble" {	...	@@ -1486,7 +1466,6 @@ test "neg f80/f128/c_longdouble" {
1486	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1466	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1487	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1467	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1488	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	1468	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1489	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
1490	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1469	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1491		1470
1492	try testNeg(f80);	1471	try testNeg(f80);
...	@@ -1741,7 +1720,6 @@ test "comptime calls are only memoized when float arguments are bit-for-bit equa	...	@@ -1741,7 +1720,6 @@ test "comptime calls are only memoized when float arguments are bit-for-bit equa
1741	}	1720	}
1742		1721
1743	test "result location forwarded through unary float builtins" {	1722	test "result location forwarded through unary float builtins" {
1744	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1745	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1723	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1746	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1724	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1747	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	1725	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;

...	@@ -100,7 +100,6 @@ fn testOneClz(comptime T: type, x: T) u32 {	...	@@ -100,7 +100,6 @@ fn testOneClz(comptime T: type, x: T) u32 {
100		100
101	test "@clz vectors" {	101	test "@clz vectors" {
102	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	102	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
103	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
104	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	103	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
105	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	104	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
106	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	105	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -184,7 +183,6 @@ fn testCtz128() !void {	...	@@ -184,7 +183,6 @@ fn testCtz128() !void {
184		183
185	test "@ctz vectors" {	184	test "@ctz vectors" {
186	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	185	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
187	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
188	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	186	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
189	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	187	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
190	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	188	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -584,7 +582,6 @@ test "large integer division" {	...	@@ -584,7 +582,6 @@ test "large integer division" {
584	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	582	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
585	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	583	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
586	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	584	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
587	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
588	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	585	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
589	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	586	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
590		587
...	@@ -2260,7 +2257,6 @@ fn testRound(comptime T: type, x: T) !void {	...	@@ -2260,7 +2257,6 @@ fn testRound(comptime T: type, x: T) !void {
2260		2257
2261	test "vector integer addition" {	2258	test "vector integer addition" {
2262	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2259	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2263	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2264	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2260	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2265	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2261	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2266	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2262	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -2322,7 +2318,6 @@ fn testNanEqNan(comptime F: type) !void {	...	@@ -2322,7 +2318,6 @@ fn testNanEqNan(comptime F: type) !void {
2322		2318
2323	test "vector comparison" {	2319	test "vector comparison" {
2324	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2320	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2325	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2326	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2321	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2327	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2322	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2328	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2323	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -2414,7 +2409,6 @@ test "mod lazy values" {	...	@@ -2414,7 +2409,6 @@ test "mod lazy values" {
2414		2409
2415	test "@clz works on both vector and scalar inputs" {	2410	test "@clz works on both vector and scalar inputs" {
2416	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2411	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2417	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2418	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2412	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2419	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2413	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2420	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2414	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -2489,7 +2483,6 @@ test "runtime int comparison to inf is comptime-known" {	...	@@ -2489,7 +2483,6 @@ test "runtime int comparison to inf is comptime-known" {
2489	}	2483	}
2490		2484
2491	test "float divide by zero" {	2485	test "float divide by zero" {
2492	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2493	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2486	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2494	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2487	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2495	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2488	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -2525,7 +2518,6 @@ test "float divide by zero" {	...	@@ -2525,7 +2518,6 @@ test "float divide by zero" {
2525		2518
2526	test "partially-runtime integer vector division would be illegal if vector elements were reordered" {	2519	test "partially-runtime integer vector division would be illegal if vector elements were reordered" {
2527	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2520	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2528	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2529	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2521	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2530	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2522	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2531	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2523	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -2554,7 +2546,6 @@ test "partially-runtime integer vector division would be illegal if vector eleme	...	@@ -2554,7 +2546,6 @@ test "partially-runtime integer vector division would be illegal if vector eleme
2554		2546
2555	test "float vector division of comptime zero by runtime nan is nan" {	2547	test "float vector division of comptime zero by runtime nan is nan" {
2556	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2548	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2557	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2558	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2549	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2559	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2550	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2560	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2551	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -2572,7 +2563,6 @@ test "float vector division of comptime zero by runtime nan is nan" {	...	@@ -2572,7 +2563,6 @@ test "float vector division of comptime zero by runtime nan is nan" {
2572		2563
2573	test "float vector multiplication of comptime zero by runtime nan is nan" {	2564	test "float vector multiplication of comptime zero by runtime nan is nan" {
2574	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	2565	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2575	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2576	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2566	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2577	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2567	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2578	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2568	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -2588,7 +2578,6 @@ test "float vector multiplication of comptime zero by runtime nan is nan" {	...	@@ -2588,7 +2578,6 @@ test "float vector multiplication of comptime zero by runtime nan is nan" {
2588	}	2578	}
2589		2579
2590	test "comptime float vector division of zero by nan is nan" {	2580	test "comptime float vector division of zero by nan is nan" {
2591	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2592	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2581	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2593	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2582	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2594	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2583	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -2603,7 +2592,6 @@ test "comptime float vector division of zero by nan is nan" {	...	@@ -2603,7 +2592,6 @@ test "comptime float vector division of zero by nan is nan" {
2603	}	2592	}
2604		2593
2605	test "comptime float vector multiplication of zero by nan is nan" {	2594	test "comptime float vector multiplication of zero by nan is nan" {
2606	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2607	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2595	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2608	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2596	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2609	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2597	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;

...	@@ -28,7 +28,6 @@ test "@max" {	...	@@ -28,7 +28,6 @@ test "@max" {
28		28
29	test "@max on vectors" {	29	test "@max on vectors" {
30	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	30	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
31	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
32	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	31	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
33	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	32	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
34	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	33	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -82,7 +81,6 @@ test "@min" {	...	@@ -82,7 +81,6 @@ test "@min" {
82		81
83	test "@min for vectors" {	82	test "@min for vectors" {
84	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	83	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
85	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
86	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	84	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
87	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	85	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
88	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	86	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -165,7 +163,6 @@ test "@min/@max more than two arguments" {	...	@@ -165,7 +163,6 @@ test "@min/@max more than two arguments" {
165		163
166	test "@min/@max more than two vector arguments" {	164	test "@min/@max more than two vector arguments" {
167	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	165	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
168	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
169	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	166	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
170	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	167	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
171	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	168	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -195,7 +192,6 @@ test "@min/@max notices bounds" {	...	@@ -195,7 +192,6 @@ test "@min/@max notices bounds" {
195		192
196	test "@min/@max notices vector bounds" {	193	test "@min/@max notices vector bounds" {
197	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	194	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
198	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
199	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	195	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
200	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	196	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
201	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	197	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -246,7 +242,6 @@ test "@min/@max notices bounds from types" {	...	@@ -246,7 +242,6 @@ test "@min/@max notices bounds from types" {
246		242
247	test "@min/@max notices bounds from vector types" {	243	test "@min/@max notices bounds from vector types" {
248	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	244	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
249	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
250	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	245	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
251	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	246	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
252	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	247	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -287,7 +282,6 @@ test "@min/@max notices bounds from types when comptime-known value is undef" {	...	@@ -287,7 +282,6 @@ test "@min/@max notices bounds from types when comptime-known value is undef" {
287		282
288	test "@min/@max notices bounds from vector types when element of comptime-known vector is undef" {	283	test "@min/@max notices bounds from vector types when element of comptime-known vector is undef" {
289	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	284	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
290	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
291	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	285	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
292	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	286	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
293	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	287	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -357,7 +351,6 @@ test "@min/@max with runtime signed and unsigned integers of same size" {	...	@@ -357,7 +351,6 @@ test "@min/@max with runtime signed and unsigned integers of same size" {
357		351
358	test "@min/@max with runtime vectors of signed and unsigned integers of same size" {	352	test "@min/@max with runtime vectors of signed and unsigned integers of same size" {
359	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	353	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
360	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
361	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	354	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
362	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	355	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
363	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	356	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;

...	@@ -6,7 +6,6 @@ test "memmove and memset intrinsics" {	...	@@ -6,7 +6,6 @@ test "memmove and memset intrinsics" {
6	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	6	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	8	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
9	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
10	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	9	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11		10
12	try testMemmoveMemset();	11	try testMemmoveMemset();
...	@@ -34,7 +33,6 @@ test "@memmove with both operands single-ptr-to-array, one is null-terminated" {	...	@@ -34,7 +33,6 @@ test "@memmove with both operands single-ptr-to-array, one is null-terminated" {
34	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	33	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
35	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	34	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
36	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	35	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
37	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
38	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	36	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
39		37
40	try testMemmoveBothSinglePtrArrayOneIsNullTerminated();	38	try testMemmoveBothSinglePtrArrayOneIsNullTerminated();
...	@@ -78,7 +76,6 @@ test "@memmove dest many pointer" {	...	@@ -78,7 +76,6 @@ test "@memmove dest many pointer" {
78	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	76	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
79	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	77	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
80	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	78	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
81	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
82	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	79	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
83		80
84	try testMemmoveDestManyPtr();	81	try testMemmoveDestManyPtr();
...	@@ -121,7 +118,6 @@ test "@memmove slice" {	...	@@ -121,7 +118,6 @@ test "@memmove slice" {
121	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	118	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
122	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	119	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
123	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	120	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
124	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
125	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	121	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
126		122
127	try testMemmoveSlice();	123	try testMemmoveSlice();

...	@@ -100,7 +100,6 @@ fn vector16() !void {	...	@@ -100,7 +100,6 @@ fn vector16() !void {
100		100
101	test "vector f16" {	101	test "vector f16" {
102	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	102	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
103	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
104	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	103	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
105	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	104	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
106	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	105	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -125,7 +124,6 @@ fn vector32() !void {	...	@@ -125,7 +124,6 @@ fn vector32() !void {
125		124
126	test "vector f32" {	125	test "vector f32" {
127	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	126	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
128	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
129	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	127	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
130	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	128	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
131	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	129	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -150,7 +148,6 @@ fn vector64() !void {	...	@@ -150,7 +148,6 @@ fn vector64() !void {
150		148
151	test "vector f64" {	149	test "vector f64" {
152	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	150	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
153	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
154	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	151	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
155	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	152	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
156	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	153	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -174,7 +171,6 @@ fn vector80() !void {	...	@@ -174,7 +171,6 @@ fn vector80() !void {
174		171
175	test "vector f80" {	172	test "vector f80" {
176	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	173	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
177	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
178	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	174	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
179	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	175	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
180	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	176	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...	@@ -200,7 +196,6 @@ fn vector128() !void {	...	@@ -200,7 +196,6 @@ fn vector128() !void {
200		196
201	test "vector f128" {	197	test "vector f128" {
202	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	198	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
203	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
204	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	199	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
205	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	200	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
206	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;	201	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;

...	@@ -5,7 +5,6 @@ const expect = std.testing.expect;	...	@@ -5,7 +5,6 @@ const expect = std.testing.expect;
5		5
6	test "@select vectors" {	6	test "@select vectors" {
7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
8	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	10	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -36,7 +35,6 @@ fn selectVectors() !void {	...	@@ -36,7 +35,6 @@ fn selectVectors() !void {
36		35
37	test "@select arrays" {	36	test "@select arrays" {
38	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	37	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
39	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
40	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	38	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
41	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	39	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
42	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	40	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -68,7 +66,6 @@ fn selectArrays() !void {	...	@@ -68,7 +66,6 @@ fn selectArrays() !void {
68	test "@select compare result" {	66	test "@select compare result" {
69	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	67	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
70	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	68	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
71	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
72	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;	69	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;
73		70
74	const S = struct {	71	const S = struct {

...	@@ -51,7 +51,6 @@ test "@shuffle int" {	...	@@ -51,7 +51,6 @@ test "@shuffle int" {
51		51
52	test "@shuffle int strange sizes" {	52	test "@shuffle int strange sizes" {
53	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	53	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
54	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
55	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	54	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
56	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	55	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
57	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	56	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -133,7 +132,6 @@ fn testShuffle(	...	@@ -133,7 +132,6 @@ fn testShuffle(
133		132
134	test "@shuffle bool 1" {	133	test "@shuffle bool 1" {
135	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	134	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
136	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
137	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	135	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
138	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	136	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
139	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	137	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	@@ -156,7 +154,6 @@ test "@shuffle bool 1" {	...	@@ -156,7 +154,6 @@ test "@shuffle bool 1" {
156		154
157	test "@shuffle bool 2" {	155	test "@shuffle bool 2" {
158	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	156	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
159	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
160	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	157	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
161	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	158	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
162	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	159	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;

stage2-wasm: vector, std tests