Commit b0cf620fe3

Jacob Young <jacobly0@users.noreply.github.com>
2023-10-27 07:40:14
x86_64: fix `cond_br`
master
1 parent 42bca3e
Changed files (11)
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
zig
parser_test.zig
mem.zig
simd.zig
src
arch
x86_64
CodeGen.zig
lib/std/compress/deflate/compressor_test.zig
@@ -238,8 +238,6 @@ test "very long sparse chunk" {
 }
 
 test "compressor reset" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     for (std.enums.values(deflate.Compression)) |c| {
         try testWriterReset(c, null);
         try testWriterReset(c, "dict");
lib/std/compress/lzma/test.zig
@@ -1,5 +1,4 @@
 const std = @import("../../std.zig");
-const builtin = @import("builtin");
 const lzma = @import("../lzma.zig");
 
 fn testDecompress(compressed: []const u8) ![]u8 {
@@ -33,8 +32,6 @@ test "LZMA: decompress empty world" {
 }
 
 test "LZMA: decompress hello world" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testDecompressEqual(
         "Hello world\n",
         &[_]u8{
@@ -46,8 +43,6 @@ test "LZMA: decompress hello world" {
 }
 
 test "LZMA: decompress huge dict" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testDecompressEqual(
         "Hello world\n",
         &[_]u8{
@@ -59,8 +54,6 @@ test "LZMA: decompress huge dict" {
 }
 
 test "LZMA: unknown size with end of payload marker" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testDecompressEqual(
         "Hello\nWorld!\n",
         @embedFile("testdata/good-unknown_size-with_eopm.lzma"),
@@ -68,8 +61,6 @@ test "LZMA: unknown size with end of payload marker" {
 }
 
 test "LZMA: known size without end of payload marker" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testDecompressEqual(
         "Hello\nWorld!\n",
         @embedFile("testdata/good-known_size-without_eopm.lzma"),
@@ -77,8 +68,6 @@ test "LZMA: known size without end of payload marker" {
 }
 
 test "LZMA: known size with end of payload marker" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testDecompressEqual(
         "Hello\nWorld!\n",
         @embedFile("testdata/good-known_size-with_eopm.lzma"),
lib/std/compress/lzma/vec2d.zig
@@ -50,8 +50,6 @@ const expectEqualSlices = std.testing.expectEqualSlices;
 const expectError = std.testing.expectError;
 
 test "Vec2D.init" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const allocator = testing.allocator;
     var vec2d = try Vec2D(i32).init(allocator, 1, .{ 2, 3 });
     defer vec2d.deinit(allocator);
lib/std/compress/xz/test.zig
@@ -19,8 +19,6 @@ fn testReader(data: []const u8, comptime expected: []const u8) !void {
 }
 
 test "compressed data" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testReader(@embedFile("testdata/good-0-empty.xz"), "");
 
     inline for ([_][]const u8{
lib/std/crypto/25519/ed25519.zig
@@ -685,9 +685,6 @@ test "ed25519 signatures with streaming" {
 }
 
 test "ed25519 key pair from secret key" {
-    if (builtin.zig_backend == .stage2_x86_64 and
-        !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .avx)) return error.SkipZigTest;
-
     const kp = try Ed25519.KeyPair.create(null);
     const kp2 = try Ed25519.KeyPair.fromSecretKey(kp.secret_key);
     try std.testing.expectEqualSlices(u8, &kp.secret_key.toBytes(), &kp2.secret_key.toBytes());
lib/std/math/big/int_test.zig
@@ -517,8 +517,6 @@ test "big.int add multi-single" {
 }
 
 test "big.int add multi-multi" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var op1: u128 = 0xefefefef7f7f7f7f;
     var op2: u128 = 0xfefefefe9f9f9f9f;
     var a = try Managed.initSet(testing.allocator, op1);
@@ -633,8 +631,6 @@ test "big.int subWrap single-single, unsigned" {
 }
 
 test "big.int addWrap multi-multi, unsigned, limb aligned" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, maxInt(DoubleLimb));
     defer a.deinit();
 
@@ -687,8 +683,6 @@ test "big.int subWrap single-single, signed" {
 }
 
 test "big.int addWrap multi-multi, signed, limb aligned" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, maxInt(SignedDoubleLimb));
     defer a.deinit();
 
@@ -739,8 +733,6 @@ test "big.int subSat single-single, unsigned" {
 }
 
 test "big.int addSat multi-multi, unsigned, limb aligned" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, maxInt(DoubleLimb));
     defer a.deinit();
 
@@ -826,8 +818,6 @@ test "big.int sub single-single" {
 }
 
 test "big.int sub multi-single" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, maxInt(Limb) + 1);
     defer a.deinit();
     var b = try Managed.initSet(testing.allocator, 1);
@@ -841,8 +831,6 @@ test "big.int sub multi-single" {
 }
 
 test "big.int sub multi-multi" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var op1: u128 = 0xefefefefefefefefefefefef;
     var op2: u128 = 0xabababababababababababab;
 
@@ -927,10 +915,8 @@ test "big.int mul multi-single" {
 }
 
 test "big.int mul multi-multi" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
 
     var op1: u256 = 0x998888efefefefefefefef;
     var op2: u256 = 0x333000abababababababab;
@@ -1053,10 +1039,8 @@ test "big.int mulWrap single-single signed" {
 }
 
 test "big.int mulWrap multi-multi unsigned" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
 
     var op1: u256 = 0x998888efefefefefefefef;
     var op2: u256 = 0x333000abababababababab;
@@ -1412,8 +1396,6 @@ test "big.int divTrunc #15535" {
 }
 
 test "big.int divFloor #10932" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.init(testing.allocator);
     defer a.deinit();
 
@@ -1438,8 +1420,6 @@ test "big.int divFloor #10932" {
 }
 
 test "big.int divFloor #11166" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.init(testing.allocator);
     defer a.deinit();
 
@@ -1467,8 +1447,6 @@ test "big.int divFloor #11166" {
 }
 
 test "big.int gcd #10932" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.init(testing.allocator);
     defer a.deinit();
 
@@ -1660,10 +1638,7 @@ test "big.int div floor positive close to zero" {
 }
 
 test "big.int div multi-multi with rem" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     var a = try Managed.initSet(testing.allocator, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999);
     defer a.deinit();
@@ -1681,10 +1656,7 @@ test "big.int div multi-multi with rem" {
 }
 
 test "big.int div multi-multi no rem" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     var a = try Managed.initSet(testing.allocator, 0x8888999911110000ffffeeeedb4fec200ee3a4286361);
     defer a.deinit();
@@ -1720,10 +1692,8 @@ test "big.int div multi-multi (2 branch)" {
 }
 
 test "big.int div multi-multi (3.1/3.3 branch)" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
 
     var a = try Managed.initSet(testing.allocator, 0x11111111111111111111111111111111111111111111111111111111111111);
     defer a.deinit();
@@ -1782,10 +1752,7 @@ test "big.int div multi-multi zero-limb trailing (with rem)" {
 }
 
 test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count > divisor zero-limb count" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     var a = try Managed.initSet(testing.allocator, 0x8666666655555555888888877777777611111111111111110000000000000000);
     defer a.deinit();
@@ -1806,10 +1773,7 @@ test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-li
 }
 
 test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count < divisor zero-limb count" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     var a = try Managed.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);
     defer a.deinit();
@@ -1832,8 +1796,6 @@ test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-li
 }
 
 test "big.int div multi-multi fuzz case #1" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.init(testing.allocator);
     defer a.deinit();
     var b = try Managed.init(testing.allocator);
@@ -1930,8 +1892,6 @@ test "big.int truncate multi to multi unsigned" {
 }
 
 test "big.int truncate multi to multi signed" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, 3 << @bitSizeOf(Limb));
     defer a.deinit();
 
@@ -2047,8 +2007,6 @@ test "big.int shift-right multi" {
 }
 
 test "big.int shift-left single" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, 0xffff);
     defer a.deinit();
     try a.shiftLeft(&a, 16);
@@ -2093,8 +2051,6 @@ test "big.int sat shift-left simple unsigned" {
 }
 
 test "big.int sat shift-left simple unsigned no sat" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, 1);
     defer a.deinit();
     try a.shiftLeftSat(&a, 16, .unsigned, 21);
@@ -2565,10 +2521,8 @@ test "big.int gcd non-one large" {
 }
 
 test "big.int gcd large multi-limb result" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
 
     var a = try Managed.initSet(testing.allocator, 0x12345678123456781234567812345678123456781234567812345678);
     defer a.deinit();
@@ -2675,8 +2629,6 @@ test "big.int pow" {
 }
 
 test "big.int sqrt" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var r = try Managed.init(testing.allocator);
     defer r.deinit();
     var a = try Managed.init(testing.allocator);
@@ -2707,8 +2659,6 @@ test "big.int sqrt" {
 }
 
 test "big.int regression test for 1 limb overflow with alias" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // Note these happen to be two consecutive Fibonacci sequence numbers, the
     // first two whose sum exceeds 2**64.
     var a = try Managed.initSet(testing.allocator, 7540113804746346429);
@@ -2723,8 +2673,6 @@ test "big.int regression test for 1 limb overflow with alias" {
 }
 
 test "big.int regression test for realloc with alias" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // Note these happen to be two consecutive Fibonacci sequence numbers, the
     // second of which is the first such number to exceed 2**192.
     var a = try Managed.initSet(testing.allocator, 5611500259351924431073312796924978741056961814867751431689);
@@ -2739,8 +2687,6 @@ test "big.int regression test for realloc with alias" {
 }
 
 test "big int popcount" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.init(testing.allocator);
     defer a.deinit();
 
@@ -3106,8 +3052,6 @@ fn byteSwapTest(comptime T: type, comptime input: comptime_int, comptime expecte
 }
 
 test "big int byte swap" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, 0x01_ffffffff_ffffffff_ffffffff);
     defer a.deinit();
 
@@ -3152,8 +3096,6 @@ test "big int byte swap" {
 }
 
 test "big.int mul multi-multi alias r with a and b" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, 2 * maxInt(Limb));
     defer a.deinit();
 
@@ -3170,8 +3112,6 @@ test "big.int mul multi-multi alias r with a and b" {
 }
 
 test "big.int sqr multi alias r with a" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, 2 * maxInt(Limb));
     defer a.deinit();
lib/std/math/big/rational.zig
@@ -543,8 +543,6 @@ test "big.rational set" {
 }
 
 test "big.rational setFloat" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Rational.init(testing.allocator);
     defer a.deinit();
 
@@ -570,8 +568,6 @@ test "big.rational setFloat" {
 }
 
 test "big.rational setFloatString" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Rational.init(testing.allocator);
     defer a.deinit();
 
@@ -583,8 +579,6 @@ test "big.rational setFloatString" {
 }
 
 test "big.rational toFloat" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Rational.init(testing.allocator);
     defer a.deinit();
 
@@ -598,8 +592,6 @@ test "big.rational toFloat" {
 }
 
 test "big.rational set/to Float round-trip" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Rational.init(testing.allocator);
     defer a.deinit();
     var prng = std.rand.DefaultPrng.init(0x5EED);
lib/std/zig/parser_test.zig
@@ -2086,8 +2086,6 @@ test "zig fmt: multiline string with backslash at end of line" {
 }
 
 test "zig fmt: multiline string parameter in fn call with trailing comma" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testCanonical(
         \\fn foo() void {
         \\    try stdout.print(
@@ -4605,8 +4603,6 @@ test "zig fmt: allow line break before field access" {
 }
 
 test "zig fmt: Indent comma correctly after multiline string literals in arg list (trailing comma)" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testCanonical(
         \\fn foo() void {
         \\    z.display_message_dialog(
lib/std/mem.zig
@@ -1025,8 +1025,6 @@ pub fn indexOfSentinel(comptime T: type, comptime sentinel: T, p: [*:sentinel]co
 }
 
 test "indexOfSentinel vector paths" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Types = [_]type{ u8, u16, u32, u64 };
     const allocator = std.testing.allocator;
lib/std/simd.zig
@@ -436,7 +436,7 @@ pub fn prefixScan(comptime op: std.builtin.ReduceOp, comptime hop: isize, vec: a
 }
 
 test "vector prefix scan" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
 
     if (comptime builtin.cpu.arch.isMIPS()) {
         return error.SkipZigTest;
src/arch/x86_64/CodeGen.zig
@@ -10627,8 +10627,6 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
     const else_body = self.air.extra[extra.end + then_body.len ..][0..extra.data.else_body_len];
     const liveness_cond_br = self.liveness.getCondBr(inst);
 
-    const reloc = try self.genCondBrMir(cond_ty, cond);
-
     // If the condition dies here in this condbr instruction, process
     // that death now instead of later as this has an effect on
     // whether it needs to be spilled in the branches
@@ -10638,6 +10636,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
 
     self.scope_generation += 1;
     const state = try self.saveState();
+    const reloc = try self.genCondBrMir(cond_ty, cond);
 
     for (liveness_cond_br.then_deaths) |death| try self.processDeath(death);
     try self.genBody(then_body);