Commit 758ec9bdd4585b28f50cb7beb01b1cfc4e3cf1a9 | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-04-27 17:24:36-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-04-27 17:24:36-07:00
log	758ec9bdd4585b28f50cb7beb01b1cfc4e3cf1a9
tree	ae1116e81a731304c08bb4944e54a38e1eeb8807
parent	09f1d62bdfb5794534b21d1cd9dafc4822697d60

enable newly passing behavior tests

closes #11030

4 files changed, 147 insertions(+), 97 deletions(-)

src
- value.zig
test
- behavior

src/value.zig-1

...	...	@@ -4510,7 +4510,6 @@ pub const Value = extern union {
4510	4510	}
4511	4511	}
4512	4512
4513
4514	4513	pub fn exp(val: Value, float_type: Type, arena: Allocator, target: Target) Allocator.Error!Value {
4515	4514	if (float_type.zigTypeTag() == .Vector) {
4516	4515	const result_data = try arena.alloc(Value, float_type.vectorLen());

test/behavior/floatop.zig+5-15

...	...	@@ -609,16 +609,11 @@ test "negation f64" {
609	609	}
610	610
611	611	test "negation f80" {
612		if (builtin.zig_backend != .stage1) {
613		// This test case exercises @intToFloat f80 in the compiler implementation.
614		// https://github.com/ziglang/zig/issues/11030
615		return error.SkipZigTest;
616		}
617
618		if (builtin.os.tag == .freebsd) {
619		// TODO file issue to track this failure
620		return error.SkipZigTest;
621		}
	612	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	613	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	614	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	615	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	616	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
622	617
623	618	const S = struct {
624	619	fn doTheTest() !void {
...	...	@@ -641,11 +636,6 @@ test "negation f128" {
641	636	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
642	637	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
643	638
644		if (builtin.os.tag == .freebsd) {
645		// TODO file issue to track this failure
646		return error.SkipZigTest;
647		}
648
649	639	const S = struct {
650	640	fn doTheTest() !void {
651	641	var a: f128 = 1;

test/behavior/math.zig+129-73

...	...	@@ -910,32 +910,52 @@ test "comptime float rem int" {
910	910	}
911	911
912	912	test "remainder division" {
913		if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	913	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	914	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	915	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	916	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	917	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
914	918
915	919	comptime try remdiv(f16);
916	920	comptime try remdiv(f32);
917	921	comptime try remdiv(f64);
	922	comptime try remdiv(f80);
918	923	comptime try remdiv(f128);
919	924	try remdiv(f16);
920	925	try remdiv(f64);
	926	try remdiv(f80);
921	927	try remdiv(f128);
922	928	}
923	929
924	930	fn remdiv(comptime T: type) !void {
925	931	try expect(@as(T, 1) == @as(T, 1) % @as(T, 2));
	932	try remdivOne(T, 1, 1, 2);
	933
926	934	try expect(@as(T, 1) == @as(T, 7) % @as(T, 3));
	935	try remdivOne(T, 1, 7, 3);
	936	}
	937
	938	fn remdivOne(comptime T: type, a: T, b: T, c: T) !void {
	939	try expect(a == @rem(b, c));
	940	try expect(a == @mod(b, c));
927	941	}
928	942
929	943	test "float remainder division using @rem" {
930		if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	944	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	945	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	946	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	947	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	948	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
931	949
932	950	comptime try frem(f16);
933	951	comptime try frem(f32);
934	952	comptime try frem(f64);
	953	comptime try frem(f80);
935	954	comptime try frem(f128);
936	955	try frem(f16);
937	956	try frem(f32);
938	957	try frem(f64);
	958	try frem(f80);
939	959	try frem(f128);
940	960	}
941	961
...	...	@@ -944,29 +964,40 @@ fn frem(comptime T: type) !void {
944	964	f16 => 1.0,
945	965	f32 => 0.001,
946	966	f64 => 0.00001,
	967	f80 => 0.000001,
947	968	f128 => 0.0000001,
948	969	else => unreachable,
949	970	};
950	971
951		try expect(@fabs(@rem(@as(T, 6.9), @as(T, 4.0)) - @as(T, 2.9)) < epsilon);
952		try expect(@fabs(@rem(@as(T, -6.9), @as(T, 4.0)) - @as(T, -2.9)) < epsilon);
953		try expect(@fabs(@rem(@as(T, -5.0), @as(T, 3.0)) - @as(T, -2.0)) < epsilon);
954		try expect(@fabs(@rem(@as(T, 3.0), @as(T, 2.0)) - @as(T, 1.0)) < epsilon);
955		try expect(@fabs(@rem(@as(T, 1.0), @as(T, 2.0)) - @as(T, 1.0)) < epsilon);
956		try expect(@fabs(@rem(@as(T, 0.0), @as(T, 1.0)) - @as(T, 0.0)) < epsilon);
957		try expect(@fabs(@rem(@as(T, -0.0), @as(T, 1.0)) - @as(T, -0.0)) < epsilon);
	972	try fremOne(T, 6.9, 4.0, 2.9, epsilon);
	973	try fremOne(T, -6.9, 4.0, -2.9, epsilon);
	974	try fremOne(T, -5.0, 3.0, -2.0, epsilon);
	975	try fremOne(T, 3.0, 2.0, 1.0, epsilon);
	976	try fremOne(T, 1.0, 2.0, 1.0, epsilon);
	977	try fremOne(T, 0.0, 1.0, 0.0, epsilon);
	978	try fremOne(T, -0.0, 1.0, -0.0, epsilon);
	979	}
	980
	981	fn fremOne(comptime T: type, a: T, b: T, c: T, epsilon: T) !void {
	982	try expect(@fabs(@rem(a, b) - c) < epsilon);
958	983	}
959	984
960	985	test "float modulo division using @mod" {
961		if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	986	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	987	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	988	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	989	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	990	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
962	991
963	992	comptime try fmod(f16);
964	993	comptime try fmod(f32);
965	994	comptime try fmod(f64);
	995	comptime try fmod(f80);
966	996	comptime try fmod(f128);
967	997	try fmod(f16);
968	998	try fmod(f32);
969	999	try fmod(f64);
	1000	try fmod(f80);
970	1001	try fmod(f128);
971	1002	}
972	1003
...	...	@@ -975,17 +1006,22 @@ fn fmod(comptime T: type) !void {
975	1006	f16 => 1.0,
976	1007	f32 => 0.001,
977	1008	f64 => 0.00001,
	1009	f80 => 0.000001,
978	1010	f128 => 0.0000001,
979	1011	else => unreachable,
980	1012	};
981	1013
982		try expect(@fabs(@mod(@as(T, 6.9), @as(T, 4.0)) - @as(T, 2.9)) < epsilon);
983		try expect(@fabs(@mod(@as(T, -6.9), @as(T, 4.0)) - @as(T, 1.1)) < epsilon);
984		try expect(@fabs(@mod(@as(T, -5.0), @as(T, 3.0)) - @as(T, 1.0)) < epsilon);
985		try expect(@fabs(@mod(@as(T, 3.0), @as(T, 2.0)) - @as(T, 1.0)) < epsilon);
986		try expect(@fabs(@mod(@as(T, 1.0), @as(T, 2.0)) - @as(T, 1.0)) < epsilon);
987		try expect(@fabs(@mod(@as(T, 0.0), @as(T, 1.0)) - @as(T, 0.0)) < epsilon);
988		try expect(@fabs(@mod(@as(T, -0.0), @as(T, 1.0)) - @as(T, -0.0)) < epsilon);
	1014	try fmodOne(T, 6.9, 4.0, 2.9, epsilon);
	1015	try fmodOne(T, -6.9, 4.0, 1.1, epsilon);
	1016	try fmodOne(T, -5.0, 3.0, 1.0, epsilon);
	1017	try fmodOne(T, 3.0, 2.0, 1.0, epsilon);
	1018	try fmodOne(T, 1.0, 2.0, 1.0, epsilon);
	1019	try fmodOne(T, 0.0, 1.0, 0.0, epsilon);
	1020	try fmodOne(T, -0.0, 1.0, -0.0, epsilon);
	1021	}
	1022
	1023	fn fmodOne(comptime T: type, a: T, b: T, c: T, epsilon: T) !void {
	1024	try expect(@fabs(@mod(@as(T, a), @as(T, b)) - @as(T, c)) < epsilon);
989	1025	}
990	1026
991	1027	test "@sqrt" {
...	...	@@ -1037,10 +1073,11 @@ test "@fabs" {
1037	1073	}
1038	1074
1039	1075	test "@fabs f80" {
1040		if (true) {
1041		// https://github.com/ziglang/zig/issues/11030
1042		return error.SkipZigTest;
1043		}
	1076	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1077	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1078	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1079	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1080	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1044	1081
1045	1082	try testFabs(f80, 12.0);
1046	1083	comptime try testFabs(f80, 12.0);
...	...	@@ -1053,7 +1090,11 @@ fn testFabs(comptime T: type, x: T) !void {
1053	1090	}
1054	1091
1055	1092	test "@floor" {
1056		if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	1093	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1094	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1095	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1096	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1097	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1057	1098
1058	1099	try testFloor(f64, 12.0);
1059	1100	comptime try testFloor(f64, 12.0);
...	...	@@ -1069,23 +1110,24 @@ test "@floor" {
1069	1110	}
1070	1111
1071	1112	test "@floor f80" {
1072		if (true) {
1073		// https://github.com/ziglang/zig/issues/11030
1074		return error.SkipZigTest;
1075		}
	1113	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1114	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1115	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1116	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1117	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	1118
1076	1119	try testFloor(f80, 12.0);
1077	1120	comptime try testFloor(f80, 12.0);
1078	1121	}
1079	1122
1080	1123	test "@floor f128" {
1081		if (builtin.zig_backend == .stage1) {
1082		// Fails because it incorrectly lowers to a floorl function call.
1083		return error.SkipZigTest;
1084		}
1085
1086		if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	1124	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1125	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1126	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1127	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1128	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1087	1129
1088		testFloor(f128, 12.0);
	1130	try testFloor(f128, 12.0);
1089	1131	comptime try testFloor(f128, 12.0);
1090	1132	}
1091	1133
...	...	@@ -1096,7 +1138,11 @@ fn testFloor(comptime T: type, x: T) !void {
1096	1138	}
1097	1139
1098	1140	test "@ceil" {
1099		if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	1141	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1142	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1143	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1144	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1145	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1100	1146
1101	1147	try testCeil(f64, 12.0);
1102	1148	comptime try testCeil(f64, 12.0);
...	...	@@ -1112,24 +1158,24 @@ test "@ceil" {
1112	1158	}
1113	1159
1114	1160	test "@ceil f80" {
1115		if (true) {
1116		// https://github.com/ziglang/zig/issues/11030
1117		return error.SkipZigTest;
1118		}
	1161	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1162	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1163	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1164	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1165	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1119	1166
1120	1167	try testCeil(f80, 12.0);
1121	1168	comptime try testCeil(f80, 12.0);
1122	1169	}
1123	1170
1124	1171	test "@ceil f128" {
1125		if (builtin.zig_backend == .stage1) {
1126		// Fails because it incorrectly lowers to a ceill function call.
1127		return error.SkipZigTest;
1128		}
1129
1130		if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	1172	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1173	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1174	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1175	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1176	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1131	1177
1132		testCeil(f128, 12.0);
	1178	try testCeil(f128, 12.0);
1133	1179	comptime try testCeil(f128, 12.0);
1134	1180	}
1135	1181
...	...	@@ -1140,7 +1186,11 @@ fn testCeil(comptime T: type, x: T) !void {
1140	1186	}
1141	1187
1142	1188	test "@trunc" {
1143		if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	1189	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1190	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1191	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1192	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1193	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1144	1194
1145	1195	try testTrunc(f64, 12.0);
1146	1196	comptime try testTrunc(f64, 12.0);
...	...	@@ -1156,10 +1206,11 @@ test "@trunc" {
1156	1206	}
1157	1207
1158	1208	test "@trunc f80" {
1159		if (true) {
1160		// https://github.com/ziglang/zig/issues/11030
1161		return error.SkipZigTest;
1162		}
	1209	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1210	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1211	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1212	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1213	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1163	1214
1164	1215	try testTrunc(f80, 12.0);
1165	1216	comptime try testTrunc(f80, 12.0);
...	...	@@ -1172,14 +1223,13 @@ test "@trunc f80" {
1172	1223	}
1173	1224
1174	1225	test "@trunc f128" {
1175		if (builtin.zig_backend == .stage1) {
1176		// Fails because it incorrectly lowers to a truncl function call.
1177		return error.SkipZigTest;
1178		}
1179
1180		if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	1226	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1227	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1228	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1229	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1230	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1181	1231
1182		testTrunc(f128, 12.0);
	1232	try testTrunc(f128, 12.0);
1183	1233	comptime try testTrunc(f128, 12.0);
1184	1234	}
1185	1235
...	...	@@ -1198,7 +1248,11 @@ fn testTrunc(comptime T: type, x: T) !void {
1198	1248	}
1199	1249
1200	1250	test "@round" {
1201		if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	1251	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1252	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1253	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1254	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1255	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1202	1256
1203	1257	try testRound(f64, 12.0);
1204	1258	comptime try testRound(f64, 12.0);
...	...	@@ -1214,24 +1268,24 @@ test "@round" {
1214	1268	}
1215	1269
1216	1270	test "@round f80" {
1217		if (true) {
1218		// https://github.com/ziglang/zig/issues/11030
1219		return error.SkipZigTest;
1220		}
	1271	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1272	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1273	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1274	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1275	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1221	1276
1222	1277	try testRound(f80, 12.0);
1223	1278	comptime try testRound(f80, 12.0);
1224	1279	}
1225	1280
1226	1281	test "@round f128" {
1227		if (builtin.zig_backend == .stage1) {
1228		// Fails because it incorrectly lowers to a roundl function call.
1229		return error.SkipZigTest;
1230		}
1231
1232		if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	1282	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1283	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1284	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1285	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1286	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1233	1287
1234		testRound(f128, 12.0);
	1288	try testRound(f128, 12.0);
1235	1289	comptime try testRound(f128, 12.0);
1236	1290	}
1237	1291
...	...	@@ -1280,10 +1334,12 @@ test "NaN comparison" {
1280	1334	}
1281	1335
1282	1336	test "NaN comparison f80" {
1283		if (true) {
1284		// https://github.com/ziglang/zig/issues/11030
1285		return error.SkipZigTest;
1286		}
	1337	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	1338	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1339	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1340	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1341	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1342
1287	1343	try testNanEqNan(f80);
1288	1344	comptime try testNanEqNan(f80);
1289	1345	}

test/behavior/muladd.zig+13-8

...	...	@@ -32,6 +32,7 @@ test "@mulAdd f16" {
32	32	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
33	33	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
34	34	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	35
35	36	comptime try testMulAdd16();
36	37	try testMulAdd16();
37	38	}
...	...	@@ -44,10 +45,12 @@ fn testMulAdd16() !void {
44	45	}
45	46
46	47	test "@mulAdd f80" {
47		if (true) {
48		// https://github.com/ziglang/zig/issues/11030
49		return error.SkipZigTest;
50		}
	48	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	49	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	50	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	51	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	52	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	53	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
51	54
52	55	comptime try testMulAdd80();
53	56	try testMulAdd80();
...	...	@@ -173,10 +176,12 @@ fn vector80() !void {
173	176	}
174	177
175	178	test "vector f80" {
176		if (true) {
177		// https://github.com/ziglang/zig/issues/11030
178		return error.SkipZigTest;
179		}
	179	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
	180	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	181	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	182	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	183	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	184	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
180	185
181	186	comptime try vector80();
182	187	try vector80();