Commit b0cf620fe3032d485b581c8ab6239f719ef2cada | zig

author	Jacob Young <jacobly@ziglang.org> 2023-10-27 01:40:14-04:00
committer	Jacob Young <jacobly@ziglang.org> 2023-10-27 03:33:49-04:00
log	b0cf620fe3032d485b581c8ab6239f719ef2cada
tree	ebfe07c173767ce05ad52a90dbb0fe0e1b5a0925
parent	42bca3e2ee3adcfcdb7282c6eaa60f93ad6625cd

x86_64: fix `cond_br`

11 files changed, 14 insertions(+), 109 deletions(-)

lib
- std
  - compress
    deflate
    compressor_test.zig
    lzma
    test.zig
    vec2d.zig
    xz
    test.zig
  - crypto
    25519
    ed25519.zig
  - math
    big
    int_test.zig
    rational.zig
  - mem.zig
  - simd.zig
  - zig
    parser_test.zig
src
- arch
  - x86_64
    CodeGen.zig

lib/std/compress/deflate/compressor_test.zig-2

...	...	@@ -238,8 +238,6 @@ test "very long sparse chunk" {
238	238	}
239	239
240	240	test "compressor reset" {
241		if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
242
243	241	for (std.enums.values(deflate.Compression)) \|c\| {
244	242	try testWriterReset(c, null);
245	243	try testWriterReset(c, "dict");

lib/std/compress/lzma/test.zig-11

...	...	@@ -1,5 +1,4 @@
1	1	const std = @import("../../std.zig");
2		const builtin = @import("builtin");
3	2	const lzma = @import("../lzma.zig");
4	3
5	4	fn testDecompress(compressed: []const u8) ![]u8 {
...	...	@@ -33,8 +32,6 @@ test "LZMA: decompress empty world" {
33	32	}
34	33
35	34	test "LZMA: decompress hello world" {
36		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
37
38	35	try testDecompressEqual(
39	36	"Hello world\n",
40	37	&[_]u8{
...	...	@@ -46,8 +43,6 @@ test "LZMA: decompress hello world" {
46	43	}
47	44
48	45	test "LZMA: decompress huge dict" {
49		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
50
51	46	try testDecompressEqual(
52	47	"Hello world\n",
53	48	&[_]u8{
...	...	@@ -59,8 +54,6 @@ test "LZMA: decompress huge dict" {
59	54	}
60	55
61	56	test "LZMA: unknown size with end of payload marker" {
62		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
63
64	57	try testDecompressEqual(
65	58	"Hello\nWorld!\n",
66	59	@embedFile("testdata/good-unknown_size-with_eopm.lzma"),
...	...	@@ -68,8 +61,6 @@ test "LZMA: unknown size with end of payload marker" {
68	61	}
69	62
70	63	test "LZMA: known size without end of payload marker" {
71		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
72
73	64	try testDecompressEqual(
74	65	"Hello\nWorld!\n",
75	66	@embedFile("testdata/good-known_size-without_eopm.lzma"),
...	...	@@ -77,8 +68,6 @@ test "LZMA: known size without end of payload marker" {
77	68	}
78	69
79	70	test "LZMA: known size with end of payload marker" {
80		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
81
82	71	try testDecompressEqual(
83	72	"Hello\nWorld!\n",
84	73	@embedFile("testdata/good-known_size-with_eopm.lzma"),

lib/std/compress/lzma/vec2d.zig-2

...	...	@@ -50,8 +50,6 @@ const expectEqualSlices = std.testing.expectEqualSlices;
50	50	const expectError = std.testing.expectError;
51	51
52	52	test "Vec2D.init" {
53		if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
54
55	53	const allocator = testing.allocator;
56	54	var vec2d = try Vec2D(i32).init(allocator, 1, .{ 2, 3 });
57	55	defer vec2d.deinit(allocator);

lib/std/compress/xz/test.zig-2

...	...	@@ -19,8 +19,6 @@ fn testReader(data: []const u8, comptime expected: []const u8) !void {
19	19	}
20	20
21	21	test "compressed data" {
22		if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
23
24	22	try testReader(@embedFile("testdata/good-0-empty.xz"), "");
25	23
26	24	inline for ([_][]const u8{

lib/std/crypto/25519/ed25519.zig-3

...	...	@@ -685,9 +685,6 @@ test "ed25519 signatures with streaming" {
685	685	}
686	686
687	687	test "ed25519 key pair from secret key" {
688		if (builtin.zig_backend == .stage2_x86_64 and
689		!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .avx)) return error.SkipZigTest;
690
691	688	const kp = try Ed25519.KeyPair.create(null);
692	689	const kp2 = try Ed25519.KeyPair.fromSecretKey(kp.secret_key);
693	690	try std.testing.expectEqualSlices(u8, &kp.secret_key.toBytes(), &kp2.secret_key.toBytes());

lib/std/math/big/int_test.zig+12-72

...	...	@@ -517,8 +517,6 @@ test "big.int add multi-single" {
517	517	}
518	518
519	519	test "big.int add multi-multi" {
520		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
521
522	520	var op1: u128 = 0xefefefef7f7f7f7f;
523	521	var op2: u128 = 0xfefefefe9f9f9f9f;
524	522	var a = try Managed.initSet(testing.allocator, op1);
...	...	@@ -633,8 +631,6 @@ test "big.int subWrap single-single, unsigned" {
633	631	}
634	632
635	633	test "big.int addWrap multi-multi, unsigned, limb aligned" {
636		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
637
638	634	var a = try Managed.initSet(testing.allocator, maxInt(DoubleLimb));
639	635	defer a.deinit();
640	636
...	...	@@ -687,8 +683,6 @@ test "big.int subWrap single-single, signed" {
687	683	}
688	684
689	685	test "big.int addWrap multi-multi, signed, limb aligned" {
690		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
691
692	686	var a = try Managed.initSet(testing.allocator, maxInt(SignedDoubleLimb));
693	687	defer a.deinit();
694	688
...	...	@@ -739,8 +733,6 @@ test "big.int subSat single-single, unsigned" {
739	733	}
740	734
741	735	test "big.int addSat multi-multi, unsigned, limb aligned" {
742		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
743
744	736	var a = try Managed.initSet(testing.allocator, maxInt(DoubleLimb));
745	737	defer a.deinit();
746	738
...	...	@@ -826,8 +818,6 @@ test "big.int sub single-single" {
826	818	}
827	819
828	820	test "big.int sub multi-single" {
829		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
830
831	821	var a = try Managed.initSet(testing.allocator, maxInt(Limb) + 1);
832	822	defer a.deinit();
833	823	var b = try Managed.initSet(testing.allocator, 1);
...	...	@@ -841,8 +831,6 @@ test "big.int sub multi-single" {
841	831	}
842	832
843	833	test "big.int sub multi-multi" {
844		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
845
846	834	var op1: u128 = 0xefefefefefefefefefefefef;
847	835	var op2: u128 = 0xabababababababababababab;
848	836
...	...	@@ -927,10 +915,8 @@ test "big.int mul multi-single" {
927	915	}
928	916
929	917	test "big.int mul multi-multi" {
930		switch (builtin.zig_backend) {
931		.stage2_c, .stage2_x86_64 => return error.SkipZigTest,
932		else => {},
933		}
	918	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
	919	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
934	920
935	921	var op1: u256 = 0x998888efefefefefefefef;
936	922	var op2: u256 = 0x333000abababababababab;
...	...	@@ -1053,10 +1039,8 @@ test "big.int mulWrap single-single signed" {
1053	1039	}
1054	1040
1055	1041	test "big.int mulWrap multi-multi unsigned" {
1056		switch (builtin.zig_backend) {
1057		.stage2_c, .stage2_x86_64 => return error.SkipZigTest,
1058		else => {},
1059		}
	1042	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
	1043	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1060	1044
1061	1045	var op1: u256 = 0x998888efefefefefefefef;
1062	1046	var op2: u256 = 0x333000abababababababab;
...	...	@@ -1412,8 +1396,6 @@ test "big.int divTrunc #15535" {
1412	1396	}
1413	1397
1414	1398	test "big.int divFloor #10932" {
1415		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1416
1417	1399	var a = try Managed.init(testing.allocator);
1418	1400	defer a.deinit();
1419	1401
...	...	@@ -1438,8 +1420,6 @@ test "big.int divFloor #10932" {
1438	1420	}
1439	1421
1440	1422	test "big.int divFloor #11166" {
1441		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1442
1443	1423	var a = try Managed.init(testing.allocator);
1444	1424	defer a.deinit();
1445	1425
...	...	@@ -1467,8 +1447,6 @@ test "big.int divFloor #11166" {
1467	1447	}
1468	1448
1469	1449	test "big.int gcd #10932" {
1470		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1471
1472	1450	var a = try Managed.init(testing.allocator);
1473	1451	defer a.deinit();
1474	1452
...	...	@@ -1660,10 +1638,7 @@ test "big.int div floor positive close to zero" {
1660	1638	}
1661	1639
1662	1640	test "big.int div multi-multi with rem" {
1663		switch (builtin.zig_backend) {
1664		.stage2_c, .stage2_x86_64 => return error.SkipZigTest,
1665		else => {},
1666		}
	1641	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
1667	1642
1668	1643	var a = try Managed.initSet(testing.allocator, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999);
1669	1644	defer a.deinit();
...	...	@@ -1681,10 +1656,7 @@ test "big.int div multi-multi with rem" {
1681	1656	}
1682	1657
1683	1658	test "big.int div multi-multi no rem" {
1684		switch (builtin.zig_backend) {
1685		.stage2_c, .stage2_x86_64 => return error.SkipZigTest,
1686		else => {},
1687		}
	1659	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
1688	1660
1689	1661	var a = try Managed.initSet(testing.allocator, 0x8888999911110000ffffeeeedb4fec200ee3a4286361);
1690	1662	defer a.deinit();
...	...	@@ -1720,10 +1692,8 @@ test "big.int div multi-multi (2 branch)" {
1720	1692	}
1721	1693
1722	1694	test "big.int div multi-multi (3.1/3.3 branch)" {
1723		switch (builtin.zig_backend) {
1724		.stage2_c, .stage2_x86_64 => return error.SkipZigTest,
1725		else => {},
1726		}
	1695	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
	1696	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1727	1697
1728	1698	var a = try Managed.initSet(testing.allocator, 0x11111111111111111111111111111111111111111111111111111111111111);
1729	1699	defer a.deinit();
...	...	@@ -1782,10 +1752,7 @@ test "big.int div multi-multi zero-limb trailing (with rem)" {
1782	1752	}
1783	1753
1784	1754	test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count > divisor zero-limb count" {
1785		switch (builtin.zig_backend) {
1786		.stage2_c, .stage2_x86_64 => return error.SkipZigTest,
1787		else => {},
1788		}
	1755	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
1789	1756
1790	1757	var a = try Managed.initSet(testing.allocator, 0x8666666655555555888888877777777611111111111111110000000000000000);
1791	1758	defer a.deinit();
...	...	@@ -1806,10 +1773,7 @@ test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-li
1806	1773	}
1807	1774
1808	1775	test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count < divisor zero-limb count" {
1809		switch (builtin.zig_backend) {
1810		.stage2_c, .stage2_x86_64 => return error.SkipZigTest,
1811		else => {},
1812		}
	1776	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
1813	1777
1814	1778	var a = try Managed.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);
1815	1779	defer a.deinit();
...	...	@@ -1832,8 +1796,6 @@ test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-li
1832	1796	}
1833	1797
1834	1798	test "big.int div multi-multi fuzz case #1" {
1835		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1836
1837	1799	var a = try Managed.init(testing.allocator);
1838	1800	defer a.deinit();
1839	1801	var b = try Managed.init(testing.allocator);
...	...	@@ -1930,8 +1892,6 @@ test "big.int truncate multi to multi unsigned" {
1930	1892	}
1931	1893
1932	1894	test "big.int truncate multi to multi signed" {
1933		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1934
1935	1895	var a = try Managed.initSet(testing.allocator, 3 << @bitSizeOf(Limb));
1936	1896	defer a.deinit();
1937	1897
...	...	@@ -2047,8 +2007,6 @@ test "big.int shift-right multi" {
2047	2007	}
2048	2008
2049	2009	test "big.int shift-left single" {
2050		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
2051
2052	2010	var a = try Managed.initSet(testing.allocator, 0xffff);
2053	2011	defer a.deinit();
2054	2012	try a.shiftLeft(&a, 16);
...	...	@@ -2093,8 +2051,6 @@ test "big.int sat shift-left simple unsigned" {
2093	2051	}
2094	2052
2095	2053	test "big.int sat shift-left simple unsigned no sat" {
2096		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
2097
2098	2054	var a = try Managed.initSet(testing.allocator, 1);
2099	2055	defer a.deinit();
2100	2056	try a.shiftLeftSat(&a, 16, .unsigned, 21);
...	...	@@ -2565,10 +2521,8 @@ test "big.int gcd non-one large" {
2565	2521	}
2566	2522
2567	2523	test "big.int gcd large multi-limb result" {
2568		switch (builtin.zig_backend) {
2569		.stage2_c, .stage2_x86_64 => return error.SkipZigTest,
2570		else => {},
2571		}
	2524	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
	2525	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
2572	2526
2573	2527	var a = try Managed.initSet(testing.allocator, 0x12345678123456781234567812345678123456781234567812345678);
2574	2528	defer a.deinit();
...	...	@@ -2675,8 +2629,6 @@ test "big.int pow" {
2675	2629	}
2676	2630
2677	2631	test "big.int sqrt" {
2678		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
2679
2680	2632	var r = try Managed.init(testing.allocator);
2681	2633	defer r.deinit();
2682	2634	var a = try Managed.init(testing.allocator);
...	...	@@ -2707,8 +2659,6 @@ test "big.int sqrt" {
2707	2659	}
2708	2660
2709	2661	test "big.int regression test for 1 limb overflow with alias" {
2710		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
2711
2712	2662	// Note these happen to be two consecutive Fibonacci sequence numbers, the
2713	2663	// first two whose sum exceeds 2**64.
2714	2664	var a = try Managed.initSet(testing.allocator, 7540113804746346429);
...	...	@@ -2723,8 +2673,6 @@ test "big.int regression test for 1 limb overflow with alias" {
2723	2673	}
2724	2674
2725	2675	test "big.int regression test for realloc with alias" {
2726		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
2727
2728	2676	// Note these happen to be two consecutive Fibonacci sequence numbers, the
2729	2677	// second of which is the first such number to exceed 2**192.
2730	2678	var a = try Managed.initSet(testing.allocator, 5611500259351924431073312796924978741056961814867751431689);
...	...	@@ -2739,8 +2687,6 @@ test "big.int regression test for realloc with alias" {
2739	2687	}
2740	2688
2741	2689	test "big int popcount" {
2742		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
2743
2744	2690	var a = try Managed.init(testing.allocator);
2745	2691	defer a.deinit();
2746	2692
...	...	@@ -3106,8 +3052,6 @@ fn byteSwapTest(comptime T: type, comptime input: comptime_int, comptime expecte
3106	3052	}
3107	3053
3108	3054	test "big int byte swap" {
3109		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
3110
3111	3055	var a = try Managed.initSet(testing.allocator, 0x01_ffffffff_ffffffff_ffffffff);
3112	3056	defer a.deinit();
3113	3057
...	...	@@ -3152,8 +3096,6 @@ test "big int byte swap" {
3152	3096	}
3153	3097
3154	3098	test "big.int mul multi-multi alias r with a and b" {
3155		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
3156
3157	3099	var a = try Managed.initSet(testing.allocator, 2 * maxInt(Limb));
3158	3100	defer a.deinit();
3159	3101
...	...	@@ -3170,8 +3112,6 @@ test "big.int mul multi-multi alias r with a and b" {
3170	3112	}
3171	3113
3172	3114	test "big.int sqr multi alias r with a" {
3173		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
3174
3175	3115	var a = try Managed.initSet(testing.allocator, 2 * maxInt(Limb));
3176	3116	defer a.deinit();
3177	3117

lib/std/math/big/rational.zig-8

...	...	@@ -543,8 +543,6 @@ test "big.rational set" {
543	543	}
544	544
545	545	test "big.rational setFloat" {
546		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
547
548	546	var a = try Rational.init(testing.allocator);
549	547	defer a.deinit();
550	548
...	...	@@ -570,8 +568,6 @@ test "big.rational setFloat" {
570	568	}
571	569
572	570	test "big.rational setFloatString" {
573		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
574
575	571	var a = try Rational.init(testing.allocator);
576	572	defer a.deinit();
577	573
...	...	@@ -583,8 +579,6 @@ test "big.rational setFloatString" {
583	579	}
584	580
585	581	test "big.rational toFloat" {
586		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
587
588	582	var a = try Rational.init(testing.allocator);
589	583	defer a.deinit();
590	584
...	...	@@ -598,8 +592,6 @@ test "big.rational toFloat" {
598	592	}
599	593
600	594	test "big.rational set/to Float round-trip" {
601		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
602
603	595	var a = try Rational.init(testing.allocator);
604	596	defer a.deinit();
605	597	var prng = std.rand.DefaultPrng.init(0x5EED);

lib/std/mem.zig-2

...	...	@@ -1025,8 +1025,6 @@ pub fn indexOfSentinel(comptime T: type, comptime sentinel: T, p: [*:sentinel]co
1025	1025	}
1026	1026
1027	1027	test "indexOfSentinel vector paths" {
1028		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1029
1030	1028	const Types = [_]type{ u8, u16, u32, u64 };
1031	1029	const allocator = std.testing.allocator;
1032	1030

lib/std/simd.zig+1-1

...	...	@@ -436,7 +436,7 @@ pub fn prefixScan(comptime op: std.builtin.ReduceOp, comptime hop: isize, vec: a
436	436	}
437	437
438	438	test "vector prefix scan" {
439		if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
	439	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
440	440
441	441	if (comptime builtin.cpu.arch.isMIPS()) {
442	442	return error.SkipZigTest;

lib/std/zig/parser_test.zig-4

...	...	@@ -2086,8 +2086,6 @@ test "zig fmt: multiline string with backslash at end of line" {
2086	2086	}
2087	2087
2088	2088	test "zig fmt: multiline string parameter in fn call with trailing comma" {
2089		if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
2090
2091	2089	try testCanonical(
2092	2090	\\fn foo() void {
2093	2091	\\ try stdout.print(
...	...	@@ -4605,8 +4603,6 @@ test "zig fmt: allow line break before field access" {
4605	4603	}
4606	4604
4607	4605	test "zig fmt: Indent comma correctly after multiline string literals in arg list (trailing comma)" {
4608		if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
4609
4610	4606	try testCanonical(
4611	4607	\\fn foo() void {
4612	4608	\\ z.display_message_dialog(

src/arch/x86_64/CodeGen.zig+1-2

...	...	@@ -10627,8 +10627,6 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
10627	10627	const else_body = self.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len];
10628	10628	const liveness_cond_br = self.liveness.getCondBr(inst);
10629	10629
10630		const reloc = try self.genCondBrMir(cond_ty, cond);
10631
10632	10630	// If the condition dies here in this condbr instruction, process
10633	10631	// that death now instead of later as this has an effect on
10634	10632	// whether it needs to be spilled in the branches
...	...	@@ -10638,6 +10636,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
10638	10636
10639	10637	self.scope_generation += 1;
10640	10638	const state = try self.saveState();
	10639	const reloc = try self.genCondBrMir(cond_ty, cond);
10641	10640
10642	10641	for (liveness_cond_br.then_deaths) \|death\| try self.processDeath(death);
10643	10642	try self.genBody(then_body);