diff --git a/lib/compiler_rt/addf3_test.zig b/lib/compiler_rt/addf3_test.zig
index 2644bec558..1d046fbf7b 100644
--- a/lib/compiler_rt/addf3_test.zig
+++ b/lib/compiler_rt/addf3_test.zig
@@ -4,7 +4,6 @@
 // https://github.com/llvm/llvm-project/blob/02d85149a05cb1f6dc49f0ba7a2ceca53718ae17/compiler-rt/test/builtins/Unit/subtf3_test.c
 
 const std = @import("std");
-const builtin = @import("builtin");
 const math = std.math;
 const qnan128: f128 = @bitCast(@as(u128, 0x7fff800000000000) << 64);
 
@@ -35,8 +34,6 @@ fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
 }
 
 test "addtf3" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__addtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
 
     // NaN + any = NaN
@@ -76,9 +73,6 @@ fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
 }
 
 test "subtf3" {
-    if (builtin.zig_backend == .stage2_x86_64 and
-        !comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .bmi, .lzcnt })) return error.SkipZigTest;
-
     // qNaN - any = qNaN
     try test__subtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
 
@@ -109,8 +103,6 @@ fn test__addxf3(a: f80, b: f80, expected: u80) !void {
 }
 
 test "addxf3" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // NaN + any = NaN
     try test__addxf3(qnan80, 0x1.23456789abcdefp+5, @as(u80, @bitCast(qnan80)));
     try test__addxf3(@as(f80, @bitCast(@as(u80, 0x7fff_8000_8000_3000_0000))), 0x1.23456789abcdefp+5, @as(u80, @bitCast(qnan80)));
diff --git a/lib/compiler_rt/addoti4_test.zig b/lib/compiler_rt/addoti4_test.zig
index ee9c58518b..dd0f4e3d3c 100644
--- a/lib/compiler_rt/addoti4_test.zig
+++ b/lib/compiler_rt/addoti4_test.zig
@@ -23,8 +23,6 @@ fn simple_addoti4(a: i128, b: i128, overflow: *c_int) i128 {
 }
 
 test "addoti4" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const min: i128 = math.minInt(i128);
     const max: i128 = math.maxInt(i128);
     var i: i128 = 1;
diff --git a/lib/compiler_rt/comparef.zig b/lib/compiler_rt/comparef.zig
index bfb3c2248c..25b5401911 100644
--- a/lib/compiler_rt/comparef.zig
+++ b/lib/compiler_rt/comparef.zig
@@ -98,8 +98,6 @@ pub inline fn cmp_f80(comptime RT: type, a: f80, b: f80) RT {
 }
 
 test "cmp_f80" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     inline for (.{ LE, GE }) |RT| {
         try std.testing.expect(cmp_f80(RT, 1.0, 1.0) == RT.Equal);
         try std.testing.expect(cmp_f80(RT, 0.0, -0.0) == RT.Equal);
diff --git a/lib/compiler_rt/cos.zig b/lib/compiler_rt/cos.zig
index b3dbcc21f5..d299e682d7 100644
--- a/lib/compiler_rt/cos.zig
+++ b/lib/compiler_rt/cos.zig
@@ -1,4 +1,6 @@
 const std = @import("std");
+const builtin = @import("builtin");
+const arch = builtin.cpu.arch;
 const math = std.math;
 const expect = std.testing.expect;
 const common = @import("common.zig");
@@ -134,8 +136,6 @@ pub fn cosl(x: c_longdouble) callconv(.C) c_longdouble {
 }
 
 test "cos32" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const epsilon = 0.00001;
 
     try expect(math.approxEqAbs(f32, cosf(0.0), 1.0, epsilon));
diff --git a/lib/compiler_rt/divtf3_test.zig b/lib/compiler_rt/divtf3_test.zig
index 921ac93650..7639c7219d 100644
--- a/lib/compiler_rt/divtf3_test.zig
+++ b/lib/compiler_rt/divtf3_test.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const math = std.math;
 const testing = std.testing;
 
@@ -31,9 +30,6 @@ fn test__divtf3(a: f128, b: f128, expectedHi: u64, expectedLo: u64) !void {
 }
 
 test "divtf3" {
-    if (builtin.zig_backend == .stage2_x86_64 and
-        !comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .bmi, .lzcnt })) return error.SkipZigTest;
-
     // NaN / any = NaN
     try test__divtf3(math.nan(f128), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0);
     // inf / any(except inf and nan) = inf
diff --git a/lib/compiler_rt/divxf3_test.zig b/lib/compiler_rt/divxf3_test.zig
index 81a68a389d..0aec97b54d 100644
--- a/lib/compiler_rt/divxf3_test.zig
+++ b/lib/compiler_rt/divxf3_test.zig
@@ -39,8 +39,6 @@ fn test__divxf3(a: f80, b: f80) !void {
 }
 
 test "divxf3" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // NaN / any = NaN
     try expect__divxf3_result(math.nan(f80), 0x1.23456789abcdefp+5, 0x7fffC000000000000000);
     // inf / any(except inf and nan) = inf
diff --git a/lib/compiler_rt/float_from_int_test.zig b/lib/compiler_rt/float_from_int_test.zig
index 413d73f1e0..a06ba3a04e 100644
--- a/lib/compiler_rt/float_from_int_test.zig
+++ b/lib/compiler_rt/float_from_int_test.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const testing = std.testing;
 const math = std.math;
 
@@ -126,9 +125,6 @@ fn test__floatuntisf(a: u128, expected: f32) !void {
 }
 
 test "floattisf" {
-    if (builtin.zig_backend == .stage2_x86_64 and
-        !comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .bmi, .lzcnt })) return error.SkipZigTest;
-
     try test__floattisf(0, 0.0);
 
     try test__floattisf(1, 1.0);
@@ -175,9 +171,6 @@ test "floattisf" {
 }
 
 test "floatuntisf" {
-    if (builtin.zig_backend == .stage2_x86_64 and
-        !comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .bmi, .lzcnt })) return error.SkipZigTest;
-
     try test__floatuntisf(0, 0.0);
 
     try test__floatuntisf(1, 1.0);
@@ -374,9 +367,6 @@ fn test__floatuntidf(a: u128, expected: f64) !void {
 }
 
 test "floattidf" {
-    if (builtin.zig_backend == .stage2_x86_64 and
-        !comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .bmi, .lzcnt })) return error.SkipZigTest;
-
     try test__floattidf(0, 0.0);
 
     try test__floattidf(1, 1.0);
@@ -447,9 +437,6 @@ test "floattidf" {
 }
 
 test "floatuntidf" {
-    if (builtin.zig_backend == .stage2_x86_64 and
-        !comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .bmi, .lzcnt })) return error.SkipZigTest;
-
     try test__floatuntidf(0, 0.0);
 
     try test__floatuntidf(1, 1.0);
@@ -595,9 +582,6 @@ test "floatditf" {
 }
 
 test "floatunditf" {
-    if (builtin.zig_backend == .stage2_x86_64 and
-        !comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .bmi, .lzcnt })) return error.SkipZigTest;
-
     try test__floatunditf(0xffffffffffffffff, 0x403effffffffffff, 0xfffe000000000000);
     try test__floatunditf(0xfffffffffffffffe, 0x403effffffffffff, 0xfffc000000000000);
     try test__floatunditf(0x8000000000000000, 0x403e000000000000, 0x0);
@@ -619,9 +603,6 @@ fn test__floatuntitf(a: u128, expected: f128) !void {
 }
 
 test "floattitf" {
-    if (builtin.zig_backend == .stage2_x86_64 and
-        !comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .bmi, .lzcnt })) return error.SkipZigTest;
-
     try test__floattitf(0, 0.0);
 
     try test__floattitf(1, 1.0);
@@ -704,9 +685,6 @@ test "floattitf" {
 }
 
 test "floatuntitf" {
-    if (builtin.zig_backend == .stage2_x86_64 and
-        !comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .bmi, .lzcnt })) return error.SkipZigTest;
-
     try test__floatuntitf(0, 0.0);
 
     try test__floatuntitf(1, 1.0);
diff --git a/lib/compiler_rt/fma.zig b/lib/compiler_rt/fma.zig
index 9580f94fcb..5cda7e0a4d 100644
--- a/lib/compiler_rt/fma.zig
+++ b/lib/compiler_rt/fma.zig
@@ -343,9 +343,6 @@ test "64" {
 }
 
 test "128" {
-    if (builtin.zig_backend == .stage2_x86_64 and
-        !comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .bmi, .lzcnt })) return error.SkipZigTest;
-
     const epsilon = 0.000001;
 
     try expect(math.approxEqAbs(f128, fmaq(0.0, 5.0, 9.124), 9.124, epsilon));
diff --git a/lib/compiler_rt/fmodx_test.zig b/lib/compiler_rt/fmodx_test.zig
index d7020a50f2..4bb1b5654a 100644
--- a/lib/compiler_rt/fmodx_test.zig
+++ b/lib/compiler_rt/fmodx_test.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const fmod = @import("fmod.zig");
 const testing = std.testing;
 
@@ -23,9 +22,6 @@ fn test_fmodx_infs() !void {
 }
 
 test "fmodx" {
-    if (builtin.zig_backend == .stage2_x86_64 and
-        !comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .bmi, .lzcnt })) return error.SkipZigTest;
-
     try test_fmodx(6.4, 4.0, 2.4);
     try test_fmodx(6.4, -4.0, 2.4);
     try test_fmodx(-6.4, 4.0, -2.4);
diff --git a/lib/compiler_rt/int.zig b/lib/compiler_rt/int.zig
index 39ea914daf..c100b815a5 100644
--- a/lib/compiler_rt/int.zig
+++ b/lib/compiler_rt/int.zig
@@ -42,8 +42,6 @@ pub fn __divmodti4(a: i128, b: i128, rem: *i128) callconv(.C) i128 {
 }
 
 test "test_divmodti4" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const cases = [_][4]i128{
         [_]i128{ 0, 1, 0, 0 },
         [_]i128{ 0, -1, 0, 0 },
diff --git a/lib/compiler_rt/int_from_float_test.zig b/lib/compiler_rt/int_from_float_test.zig
index 7ea5cfae83..676c12e914 100644
--- a/lib/compiler_rt/int_from_float_test.zig
+++ b/lib/compiler_rt/int_from_float_test.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const testing = std.testing;
 const math = std.math;
 
@@ -41,8 +40,6 @@ fn test__fixunssfsi(a: f32, expected: u32) !void {
 }
 
 test "fixsfsi" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixsfsi(-math.floatMax(f32), math.minInt(i32));
 
     try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
@@ -106,8 +103,6 @@ test "fixsfsi" {
 }
 
 test "fixunssfsi" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixunssfsi(0.0, 0);
 
     try test__fixunssfsi(0.5, 0);
@@ -147,8 +142,6 @@ fn test__fixunssfdi(a: f32, expected: u64) !void {
 }
 
 test "fixsfdi" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixsfdi(-math.floatMax(f32), math.minInt(i64));
 
     try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
@@ -204,8 +197,6 @@ test "fixsfdi" {
 }
 
 test "fixunssfdi" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixunssfdi(0.0, 0);
 
     try test__fixunssfdi(0.5, 0);
@@ -244,8 +235,6 @@ fn test__fixunssfti(a: f32, expected: u128) !void {
 }
 
 test "fixsfti" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixsfti(-math.floatMax(f32), math.minInt(i128));
 
     try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
@@ -317,8 +306,6 @@ test "fixsfti" {
 }
 
 test "fixunssfti" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixunssfti(0.0, 0);
 
     try test__fixunssfti(0.5, 0);
@@ -365,8 +352,6 @@ fn test__fixunsdfsi(a: f64, expected: u32) !void {
 }
 
 test "fixdfsi" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixdfsi(-math.floatMax(f64), math.minInt(i32));
 
     try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
@@ -428,8 +413,6 @@ test "fixdfsi" {
 }
 
 test "fixunsdfsi" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixunsdfsi(0.0, 0);
 
     try test__fixunsdfsi(0.5, 0);
@@ -472,8 +455,6 @@ fn test__fixunsdfdi(a: f64, expected: u64) !void {
 }
 
 test "fixdfdi" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixdfdi(-math.floatMax(f64), math.minInt(i64));
 
     try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
@@ -527,8 +508,6 @@ test "fixdfdi" {
 }
 
 test "fixunsdfdi" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixunsdfdi(0.0, 0);
     try test__fixunsdfdi(0.5, 0);
     try test__fixunsdfdi(0.99, 0);
@@ -571,8 +550,6 @@ fn test__fixunsdfti(a: f64, expected: u128) !void {
 }
 
 test "fixdfti" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixdfti(-math.floatMax(f64), math.minInt(i128));
 
     try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
@@ -626,8 +603,6 @@ test "fixdfti" {
 }
 
 test "fixunsdfti" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixunsdfti(0.0, 0);
 
     try test__fixunsdfti(0.5, 0);
@@ -677,8 +652,6 @@ fn test__fixunstfsi(a: f128, expected: u32) !void {
 }
 
 test "fixtfsi" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixtfsi(-math.floatMax(f128), math.minInt(i32));
 
     try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
@@ -742,8 +715,6 @@ test "fixtfsi" {
 }
 
 test "fixunstfsi" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixunstfsi(math.inf(f128), 0xffffffff);
     try test__fixunstfsi(0, 0x0);
     try test__fixunstfsi(0x1.23456789abcdefp+5, 0x24);
@@ -767,8 +738,6 @@ fn test__fixunstfdi(a: f128, expected: u64) !void {
 }
 
 test "fixtfdi" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixtfdi(-math.floatMax(f128), math.minInt(i64));
 
     try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
@@ -832,8 +801,6 @@ test "fixtfdi" {
 }
 
 test "fixunstfdi" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixunstfdi(0.0, 0);
 
     try test__fixunstfdi(0.5, 0);
@@ -886,8 +853,6 @@ fn test__fixunstfti(a: f128, expected: u128) !void {
 }
 
 test "fixtfti" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixtfti(-math.floatMax(f128), math.minInt(i128));
 
     try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
@@ -969,8 +934,6 @@ fn test__fixunshfti(a: f16, expected: u128) !void {
 }
 
 test "fixunshfti for f16" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try test__fixunshfti(math.inf(f16), math.maxInt(u128));
     try test__fixunshfti(math.floatMax(f16), 65504);
 }
diff --git a/lib/compiler_rt/mulf3_test.zig b/lib/compiler_rt/mulf3_test.zig
index 224e79e231..e770ecaefc 100644
--- a/lib/compiler_rt/mulf3_test.zig
+++ b/lib/compiler_rt/mulf3_test.zig
@@ -3,7 +3,6 @@
 // https://github.com/llvm/llvm-project/blob/2ffb1b0413efa9a24eb3c49e710e36f92e2cb50b/compiler-rt/test/builtins/Unit/multf3_test.c
 
 const std = @import("std");
-const builtin = @import("builtin");
 const math = std.math;
 const qnan128: f128 = @bitCast(@as(u128, 0x7fff800000000000) << 64);
 const inf128: f128 = @bitCast(@as(u128, 0x7fff000000000000) << 64);
@@ -49,9 +48,6 @@ fn makeNaN128(rand: u64) f128 {
     return @bitCast(int_result);
 }
 test "multf3" {
-    if (builtin.zig_backend == .stage2_x86_64 and
-        !comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .bmi, .lzcnt })) return error.SkipZigTest;
-
     // qNaN * any = qNaN
     try test__multf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
 
diff --git a/lib/compiler_rt/negti2_test.zig b/lib/compiler_rt/negti2_test.zig
index a4f9a9a11f..014043b992 100644
--- a/lib/compiler_rt/negti2_test.zig
+++ b/lib/compiler_rt/negti2_test.zig
@@ -6,9 +6,7 @@ fn test__negti2(a: i128, expected: i128) !void {
     try testing.expectEqual(expected, result);
 }
 
-test "negti2" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
+test "negdi2" {
     // TODO ensuring that math.minInt(i128); returns error
 
     try test__negti2(-3, 3);
diff --git a/lib/compiler_rt/powiXf2_test.zig b/lib/compiler_rt/powiXf2_test.zig
index 50c8023e66..7014d2a227 100644
--- a/lib/compiler_rt/powiXf2_test.zig
+++ b/lib/compiler_rt/powiXf2_test.zig
@@ -3,10 +3,8 @@
 // powihf2 adapted from powisf2 tests
 
 const powiXf2 = @import("powiXf2.zig");
-const std = @import("std");
-const builtin = @import("builtin");
-const testing = std.testing;
-const math = std.math;
+const testing = @import("std").testing;
+const math = @import("std").math;
 
 fn test__powihf2(a: f16, b: i32, expected: f16) !void {
     var result = powiXf2.__powihf2(a, b);
@@ -34,9 +32,6 @@ fn test__powixf2(a: f80, b: i32, expected: f80) !void {
 }
 
 test "powihf2" {
-    if (builtin.zig_backend == .stage2_x86_64 and
-        !comptime std.Target.x86.featureSetHas(builtin.cpu.features, .f16c)) return error.SkipZigTest;
-
     const inf_f16 = math.inf(f16);
     try test__powisf2(0, 0, 1);
     try test__powihf2(1, 0, 1);
@@ -356,8 +351,6 @@ test "powidf2" {
 }
 
 test "powitf2" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const inf_f128 = math.inf(f128);
     try test__powitf2(0, 0, 1);
     try test__powitf2(1, 0, 1);
@@ -463,8 +456,6 @@ test "powitf2" {
 }
 
 test "powixf2" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const inf_f80 = math.inf(f80);
     try test__powixf2(0, 0, 1);
     try test__powixf2(1, 0, 1);
diff --git a/lib/compiler_rt/sin.zig b/lib/compiler_rt/sin.zig
index 6da5231792..b0180953e0 100644
--- a/lib/compiler_rt/sin.zig
+++ b/lib/compiler_rt/sin.zig
@@ -140,8 +140,6 @@ pub fn sinl(x: c_longdouble) callconv(.C) c_longdouble {
 }
 
 test "sin32" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const epsilon = 0.00001;
 
     try expect(math.approxEqAbs(f32, sinf(0.0), 0.0, epsilon));
diff --git a/lib/compiler_rt/suboti4_test.zig b/lib/compiler_rt/suboti4_test.zig
index 9b80a6cbb6..f42fe3edce 100644
--- a/lib/compiler_rt/suboti4_test.zig
+++ b/lib/compiler_rt/suboti4_test.zig
@@ -27,8 +27,6 @@ pub fn simple_suboti4(a: i128, b: i128, overflow: *c_int) i128 {
 }
 
 test "suboti3" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const min: i128 = math.minInt(i128);
     const max: i128 = math.maxInt(i128);
     var i: i128 = 1;
diff --git a/lib/compiler_rt/tan.zig b/lib/compiler_rt/tan.zig
index 3b4e732841..367883754f 100644
--- a/lib/compiler_rt/tan.zig
+++ b/lib/compiler_rt/tan.zig
@@ -131,8 +131,6 @@ test "tan" {
 }
 
 test "tan32" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const epsilon = 0.00001;
 
     try expect(math.approxEqAbs(f32, tanf(0.0), 0.0, epsilon));
@@ -144,8 +142,6 @@ test "tan32" {
 }
 
 test "tan64" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const epsilon = 0.000001;
 
     try expect(math.approxEqAbs(f64, tan(0.0), 0.0, epsilon));
diff --git a/lib/compiler_rt/udivmodei4.zig b/lib/compiler_rt/udivmodei4.zig
index 26b9a501fa..f222c13a4c 100644
--- a/lib/compiler_rt/udivmodei4.zig
+++ b/lib/compiler_rt/udivmodei4.zig
@@ -129,10 +129,7 @@ pub fn __umodei4(r_p: [*]u32, u_p: [*]const u32, v_p: [*]const u32, bits: usize)
 }
 
 test "__udivei4/__umodei4" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
 
     const RndGen = std.rand.DefaultPrng;
     var rnd = RndGen.init(42);
diff --git a/lib/std/Build/Cache.zig b/lib/std/Build/Cache.zig
index 5dcdeca079..b1ceaa1b09 100644
--- a/lib/std/Build/Cache.zig
+++ b/lib/std/Build/Cache.zig
@@ -1007,8 +1007,6 @@ test "cache file and then recall it" {
         return error.SkipZigTest;
     }
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = testing.tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1074,9 +1072,6 @@ test "check that changing a file makes cache fail" {
         // https://github.com/ziglang/zig/issues/5437
         return error.SkipZigTest;
     }
-
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = testing.tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1151,8 +1146,6 @@ test "no file inputs" {
         return error.SkipZigTest;
     }
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = testing.tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1200,9 +1193,6 @@ test "Manifest with files added after initial hash work" {
         // https://github.com/ziglang/zig/issues/5437
         return error.SkipZigTest;
     }
-
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = testing.tmpDir(.{});
     defer tmp.cleanup();
 
diff --git a/lib/std/Build/Step/Options.zig b/lib/std/Build/Step/Options.zig
index d3a7ab3c72..5c3ea6d30b 100644
--- a/lib/std/Build/Step/Options.zig
+++ b/lib/std/Build/Step/Options.zig
@@ -296,8 +296,6 @@ const Arg = struct {
 test Options {
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
     defer arena.deinit();
 
diff --git a/lib/std/Thread/Condition.zig b/lib/std/Thread/Condition.zig
index 549ea623dd..898fc14520 100644
--- a/lib/std/Thread/Condition.zig
+++ b/lib/std/Thread/Condition.zig
@@ -369,8 +369,6 @@ test "Condition - signal" {
         return error.SkipZigTest;
     }
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const num_threads = 4;
 
     const SignalTest = struct {
@@ -500,8 +498,6 @@ test "Condition - broadcasting" {
         return error.SkipZigTest;
     }
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const num_threads = 10;
 
     const BroadcastTest = struct {
@@ -569,8 +565,6 @@ test "Condition - broadcasting - wake all threads" {
         return error.SkipZigTest;
     }
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var num_runs: usize = 1;
     const num_threads = 10;
 
diff --git a/lib/std/Thread/Mutex.zig b/lib/std/Thread/Mutex.zig
index c6416113b5..0f618516b5 100644
--- a/lib/std/Thread/Mutex.zig
+++ b/lib/std/Thread/Mutex.zig
@@ -289,8 +289,6 @@ test "Mutex - many contended" {
         return error.SkipZigTest;
     }
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const num_threads = 4;
     const num_increments = 1000;
 
diff --git a/lib/std/Thread/RwLock.zig b/lib/std/Thread/RwLock.zig
index 2cd101f913..e77db10abb 100644
--- a/lib/std/Thread/RwLock.zig
+++ b/lib/std/Thread/RwLock.zig
@@ -297,8 +297,6 @@ test "RwLock - concurrent access" {
     if (builtin.single_threaded)
         return;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const num_writers: usize = 2;
     const num_readers: usize = 4;
     const num_writes: usize = 10000;
diff --git a/lib/std/Uri.zig b/lib/std/Uri.zig
index 21f05be2b8..6952839e71 100644
--- a/lib/std/Uri.zig
+++ b/lib/std/Uri.zig
@@ -685,8 +685,6 @@ test "Special test" {
 }
 
 test "URI escaping" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const input = "\\ö/ äöß ~~.adas-https://canvas:123/#ads&&sad";
     const expected = "%5C%C3%B6%2F%20%C3%A4%C3%B6%C3%9F%20~~.adas-https%3A%2F%2Fcanvas%3A123%2F%23ads%26%26sad";
 
diff --git a/lib/std/array_hash_map.zig b/lib/std/array_hash_map.zig
index 5090bc0d81..75a86f63f6 100644
--- a/lib/std/array_hash_map.zig
+++ b/lib/std/array_hash_map.zig
@@ -1,5 +1,4 @@
 const std = @import("std.zig");
-const builtin = @import("builtin");
 const debug = std.debug;
 const assert = debug.assert;
 const testing = std.testing;
@@ -2138,8 +2137,6 @@ test "ensure capacity leak" {
 }
 
 test "big map" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
     defer map.deinit();
 
@@ -2193,8 +2190,6 @@ test "big map" {
 }
 
 test "clone" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var original = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
     defer original.deinit();
 
@@ -2221,8 +2216,6 @@ test "clone" {
 }
 
 test "shrink" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
     defer map.deinit();
 
@@ -2263,8 +2256,6 @@ test "shrink" {
 }
 
 test "pop" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
     defer map.deinit();
 
@@ -2283,8 +2274,6 @@ test "pop" {
 }
 
 test "popOrNull" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
     defer map.deinit();
 
@@ -2305,8 +2294,6 @@ test "popOrNull" {
 }
 
 test "reIndex" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var map = ArrayHashMap(i32, i32, AutoContext(i32), true).init(std.testing.allocator);
     defer map.deinit();
 
@@ -2351,8 +2338,6 @@ test "auto store_hash" {
 }
 
 test "sort" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
     defer map.deinit();
 
diff --git a/lib/std/array_list.zig b/lib/std/array_list.zig
index 03e32278cf..e50eb92041 100644
--- a/lib/std/array_list.zig
+++ b/lib/std/array_list.zig
@@ -1,5 +1,4 @@
 const std = @import("std.zig");
-const builtin = @import("builtin");
 const debug = std.debug;
 const assert = debug.assert;
 const testing = std.testing;
@@ -1184,8 +1183,6 @@ test "std.ArrayList/ArrayListUnmanaged.initCapacity" {
 }
 
 test "std.ArrayList/ArrayListUnmanaged.clone" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const a = testing.allocator;
     {
         var array = ArrayList(i32).init(a);
@@ -1227,8 +1224,6 @@ test "std.ArrayList/ArrayListUnmanaged.clone" {
 }
 
 test "std.ArrayList/ArrayListUnmanaged.basic" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const a = testing.allocator;
     {
         var list = ArrayList(i32).init(a);
@@ -1513,8 +1508,6 @@ test "std.ArrayList/ArrayListUnmanaged.insert" {
 }
 
 test "std.ArrayList/ArrayListUnmanaged.insertSlice" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const a = testing.allocator;
     {
         var list = ArrayList(i32).init(a);
@@ -1561,8 +1554,6 @@ test "std.ArrayList/ArrayListUnmanaged.insertSlice" {
 }
 
 test "std.ArrayList/ArrayListUnmanaged.replaceRange" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var arena = std.heap.ArenaAllocator.init(testing.allocator);
     defer arena.deinit();
     const a = arena.allocator();
@@ -1734,8 +1725,6 @@ test "shrink still sets length when resizing is disabled" {
 }
 
 test "shrinkAndFree with a copy" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var failing_allocator = testing.FailingAllocator.init(testing.allocator, .{ .resize_fail_index = 0 });
     const a = failing_allocator.allocator();
 
diff --git a/lib/std/atomic/Atomic.zig b/lib/std/atomic/Atomic.zig
index 5c89d30fed..3cb7c8e60a 100644
--- a/lib/std/atomic/Atomic.zig
+++ b/lib/std/atomic/Atomic.zig
@@ -374,8 +374,6 @@ const atomic_rmw_orderings = [_]Ordering{
 };
 
 test "Atomic.swap" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     inline for (atomic_rmw_orderings) |ordering| {
         var x = Atomic(usize).init(5);
         try testing.expectEqual(x.swap(10, ordering), 5);
@@ -469,8 +467,6 @@ test "Atomic.fetchSub" {
 }
 
 test "Atomic.fetchMin" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     inline for (atomicIntTypes()) |Int| {
         inline for (atomic_rmw_orderings) |ordering| {
             var x = Atomic(Int).init(5);
diff --git a/lib/std/atomic/queue.zig b/lib/std/atomic/queue.zig
index c28daead1b..e8d37507d3 100644
--- a/lib/std/atomic/queue.zig
+++ b/lib/std/atomic/queue.zig
@@ -175,8 +175,6 @@ const puts_per_thread = 500;
 const put_thread_count = 3;
 
 test "std.atomic.Queue" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var plenty_of_memory = try std.heap.page_allocator.alloc(u8, 300 * 1024);
     defer std.heap.page_allocator.free(plenty_of_memory);
 
diff --git a/lib/std/base64.zig b/lib/std/base64.zig
index bfcdabaec5..26f1b1be61 100644
--- a/lib/std/base64.zig
+++ b/lib/std/base64.zig
@@ -1,6 +1,5 @@
 const std = @import("std.zig");
 const assert = std.debug.assert;
-const builtin = @import("builtin");
 const testing = std.testing;
 const mem = std.mem;
 
@@ -355,16 +354,12 @@ pub const Base64DecoderWithIgnore = struct {
 };
 
 test "base64" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     @setEvalBranchQuota(8000);
     try testBase64();
     try comptime testAllApis(standard, "comptime", "Y29tcHRpbWU=");
 }
 
 test "base64 padding dest overflow" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const input = "foo";
 
     var expect: [128]u8 = undefined;
@@ -379,8 +374,6 @@ test "base64 padding dest overflow" {
 }
 
 test "base64 url_safe_no_pad" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     @setEvalBranchQuota(8000);
     try testBase64UrlSafeNoPad();
     try comptime testAllApis(url_safe_no_pad, "comptime", "Y29tcHRpbWU");
diff --git a/lib/std/bit_set.zig b/lib/std/bit_set.zig
index f4bad13f8a..430f521eb6 100644
--- a/lib/std/bit_set.zig
+++ b/lib/std/bit_set.zig
@@ -33,7 +33,6 @@
 const std = @import("std.zig");
 const assert = std.debug.assert;
 const Allocator = std.mem.Allocator;
-const builtin = @import("builtin");
 
 /// Returns the optimal static bit set type for the specified number
 /// of elements: either `IntegerBitSet` or `ArrayBitSet`,
@@ -1637,10 +1636,7 @@ fn testStaticBitSet(comptime Set: type) !void {
 }
 
 test "IntegerBitSet" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest;
 
     try testStaticBitSet(IntegerBitSet(0));
     try testStaticBitSet(IntegerBitSet(1));
@@ -1653,11 +1649,6 @@ test "IntegerBitSet" {
 }
 
 test "ArrayBitSet" {
-    switch (builtin.zig_backend) {
-        .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
-
     inline for (.{ 0, 1, 2, 31, 32, 33, 63, 64, 65, 254, 500, 3000 }) |size| {
         try testStaticBitSet(ArrayBitSet(u8, size));
         try testStaticBitSet(ArrayBitSet(u16, size));
@@ -1668,8 +1659,6 @@ test "ArrayBitSet" {
 }
 
 test "DynamicBitSetUnmanaged" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const allocator = std.testing.allocator;
     var a = try DynamicBitSetUnmanaged.initEmpty(allocator, 300);
     try testing.expectEqual(@as(usize, 0), a.count());
@@ -1723,8 +1712,6 @@ test "DynamicBitSetUnmanaged" {
 }
 
 test "DynamicBitSet" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const allocator = std.testing.allocator;
     var a = try DynamicBitSet.initEmpty(allocator, 300);
     try testing.expectEqual(@as(usize, 0), a.count());
diff --git a/lib/std/compress/deflate/compressor.zig b/lib/std/compress/deflate/compressor.zig
index c50fee8f6c..72de63f162 100644
--- a/lib/std/compress/deflate/compressor.zig
+++ b/lib/std/compress/deflate/compressor.zig
@@ -1069,8 +1069,6 @@ var deflate_tests = [_]DeflateTest{
 };
 
 test "deflate" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     for (deflate_tests) |dt| {
         var output = ArrayList(u8).init(testing.allocator);
         defer output.deinit();
diff --git a/lib/std/compress/deflate/compressor_test.zig b/lib/std/compress/deflate/compressor_test.zig
index a363d170e6..5012bb3c07 100644
--- a/lib/std/compress/deflate/compressor_test.zig
+++ b/lib/std/compress/deflate/compressor_test.zig
@@ -154,8 +154,6 @@ fn testToFromWithLimit(input: []const u8, limit: [11]u32) !void {
 }
 
 test "deflate/inflate" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var limits = [_]u32{0} ** 11;
 
     var test0 = [_]u8{};
@@ -180,8 +178,6 @@ test "deflate/inflate" {
 }
 
 test "very long sparse chunk" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // A SparseReader returns a stream consisting of 0s ending with 65,536 (1<<16) 1s.
     // This tests missing hash references in a very large input.
     const SparseReader = struct {
@@ -243,8 +239,6 @@ test "very long sparse chunk" {
 }
 
 test "compressor reset" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     for (std.enums.values(deflate.Compression)) |c| {
         try testWriterReset(c, null);
         try testWriterReset(c, "dict");
@@ -295,8 +289,6 @@ fn testWriterReset(level: deflate.Compression, dict: ?[]const u8) !void {
 }
 
 test "decompressor dictionary" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const dict = "hello world"; // dictionary
     const text = "hello again world";
 
@@ -337,8 +329,6 @@ test "decompressor dictionary" {
 }
 
 test "compressor dictionary" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const dict = "hello world";
     const text = "hello again world";
 
@@ -385,8 +375,6 @@ test "compressor dictionary" {
 // Update the hash for best_speed only if d.index < d.maxInsertIndex
 // See https://golang.org/issue/2508
 test "Go non-regression test for 2508" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var comp = try compressor(
         testing.allocator,
         io.null_writer,
@@ -404,8 +392,6 @@ test "Go non-regression test for 2508" {
 }
 
 test "deflate/inflate string" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const StringTest = struct {
         filename: []const u8,
         limit: [11]u32,
@@ -453,8 +439,6 @@ test "deflate/inflate string" {
 }
 
 test "inflate reset" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const strings = [_][]const u8{
         "lorem ipsum izzle fo rizzle",
         "the quick brown fox jumped over",
@@ -501,8 +485,6 @@ test "inflate reset" {
 }
 
 test "inflate reset dictionary" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const dict = "the lorem fox";
     const strings = [_][]const u8{
         "lorem ipsum izzle fo rizzle",
diff --git a/lib/std/compress/deflate/deflate_fast.zig b/lib/std/compress/deflate/deflate_fast.zig
index 74982ee2b1..a11548fa1f 100644
--- a/lib/std/compress/deflate/deflate_fast.zig
+++ b/lib/std/compress/deflate/deflate_fast.zig
@@ -649,8 +649,6 @@ test "best speed shift offsets" {
 }
 
 test "best speed reset" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // test that encoding is consistent across a warparound of the table offset.
     // See https://github.com/golang/go/issues/34121
     const fmt = std.fmt;
diff --git a/lib/std/compress/deflate/deflate_fast_test.zig b/lib/std/compress/deflate/deflate_fast_test.zig
index b592bd07a7..08f6079aa5 100644
--- a/lib/std/compress/deflate/deflate_fast_test.zig
+++ b/lib/std/compress/deflate/deflate_fast_test.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const expect = std.testing.expect;
 const io = std.io;
 const mem = std.mem;
@@ -12,8 +11,6 @@ const inflate = @import("decompressor.zig");
 const deflate_const = @import("deflate_const.zig");
 
 test "best speed" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // Tests that round-tripping through deflate and then inflate recovers the original input.
     // The Write sizes are near the thresholds in the compressor.encSpeed method (0, 16, 128), as well
     // as near `deflate_const.max_store_block_size` (65535).
@@ -96,8 +93,6 @@ test "best speed" {
 }
 
 test "best speed max match offset" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const abc = "abcdefgh";
     const xyz = "stuvwxyz";
     const input_margin = 16 - 1;
diff --git a/lib/std/compress/deflate/huffman_bit_writer.zig b/lib/std/compress/deflate/huffman_bit_writer.zig
index f2ee8fd338..5204435106 100644
--- a/lib/std/compress/deflate/huffman_bit_writer.zig
+++ b/lib/std/compress/deflate/huffman_bit_writer.zig
@@ -845,8 +845,6 @@ const testing = std.testing;
 const ArrayList = std.ArrayList;
 
 test "writeBlockHuff" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // Tests huffman encoding against reference files to detect possible regressions.
     // If encoding/bit allocation changes you can regenerate these files
 
@@ -1571,8 +1569,6 @@ const TestType = enum {
 };
 
 test "writeBlock" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // tests if the writeBlock encoding has changed.
 
     const ttype: TestType = .write_block;
@@ -1588,8 +1584,6 @@ test "writeBlock" {
 }
 
 test "writeBlockDynamic" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // tests if the writeBlockDynamic encoding has changed.
 
     const ttype: TestType = .write_dyn_block;
diff --git a/lib/std/compress/deflate/huffman_code.zig b/lib/std/compress/deflate/huffman_code.zig
index 864da16e61..4fea45f863 100644
--- a/lib/std/compress/deflate/huffman_code.zig
+++ b/lib/std/compress/deflate/huffman_code.zig
@@ -360,8 +360,6 @@ fn byFreq(context: void, a: LiteralNode, b: LiteralNode) bool {
 }
 
 test "generate a Huffman code from an array of frequencies" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var freqs: [19]u16 = [_]u16{
         8, // 0
         1, // 1
diff --git a/lib/std/compress/gzip.zig b/lib/std/compress/gzip.zig
index b0928850e1..f6fb038ae3 100644
--- a/lib/std/compress/gzip.zig
+++ b/lib/std/compress/gzip.zig
@@ -174,8 +174,6 @@ fn testReader(data: []const u8, comptime expected: []const u8) !void {
 // https://tools.ietf.org/rfc/rfc1952.txt length=25037 bytes
 // SHA256=164ef0897b4cbec63abf1b57f069f3599bd0fb7c72c2a4dee21bd7e03ec9af67
 test "compressed data" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testReader(
         @embedFile("testdata/rfc1952.txt.gz"),
         @embedFile("testdata/rfc1952.txt"),
diff --git a/lib/std/compress/lzma/test.zig b/lib/std/compress/lzma/test.zig
index da0a8d61c3..bdfe2909d8 100644
--- a/lib/std/compress/lzma/test.zig
+++ b/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 {
@@ -23,8 +22,6 @@ fn testDecompressError(expected: anyerror, compressed: []const u8) !void {
 }
 
 test "LZMA: decompress empty world" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testDecompressEqual(
         "",
         &[_]u8{
@@ -35,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{
@@ -48,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{
@@ -61,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"),
@@ -70,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"),
@@ -79,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"),
@@ -88,8 +75,6 @@ test "LZMA: known size with end of payload marker" {
 }
 
 test "LZMA: too big uncompressed size in header" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testDecompressError(
         error.CorruptInput,
         @embedFile("testdata/bad-too_big_size-with_eopm.lzma"),
@@ -97,8 +82,6 @@ test "LZMA: too big uncompressed size in header" {
 }
 
 test "LZMA: too small uncompressed size in header" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testDecompressError(
         error.CorruptInput,
         @embedFile("testdata/bad-too_small_size-without_eopm-3.lzma"),
diff --git a/lib/std/compress/lzma/vec2d.zig b/lib/std/compress/lzma/vec2d.zig
index aa805ee521..1ea3d1e8d5 100644
--- a/lib/std/compress/lzma/vec2d.zig
+++ b/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);
diff --git a/lib/std/compress/xz/test.zig b/lib/std/compress/xz/test.zig
index fd960bc071..08180e45c0 100644
--- a/lib/std/compress/xz/test.zig
+++ b/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{
diff --git a/lib/std/compress/zlib.zig b/lib/std/compress/zlib.zig
index 8dd9853e27..5580192537 100644
--- a/lib/std/compress/zlib.zig
+++ b/lib/std/compress/zlib.zig
@@ -199,8 +199,6 @@ fn testDecompress(data: []const u8, expected: []const u8) !void {
 // https://tools.ietf.org/rfc/rfc1951.txt length=36944 bytes
 // SHA256=5ebf4b5b7fe1c3a0c0ab9aa3ac8c0f3853a7dc484905e76e03b0b0f301350009
 test "compressed data" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const rfc1951_txt = @embedFile("testdata/rfc1951.txt");
 
     // Compressed with compression level = 0
@@ -266,8 +264,6 @@ test "sanity checks" {
 }
 
 test "compress data" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const allocator = testing.allocator;
     const rfc1951_txt = @embedFile("testdata/rfc1951.txt");
 
diff --git a/lib/std/compress/zstandard.zig b/lib/std/compress/zstandard.zig
index ef2ccc2f1c..9603fb32f9 100644
--- a/lib/std/compress/zstandard.zig
+++ b/lib/std/compress/zstandard.zig
@@ -264,8 +264,6 @@ fn testReader(data: []const u8, comptime expected: []const u8) !void {
 }
 
 test "zstandard decompression" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const uncompressed = @embedFile("testdata/rfc8478.txt");
     const compressed3 = @embedFile("testdata/rfc8478.txt.zst.3");
     const compressed19 = @embedFile("testdata/rfc8478.txt.zst.19");
diff --git a/lib/std/crypto.zig b/lib/std/crypto.zig
index 8cb2cfd90d..c548f01c07 100644
--- a/lib/std/crypto.zig
+++ b/lib/std/crypto.zig
@@ -314,8 +314,6 @@ test "CSPRNG" {
 }
 
 test "issue #4532: no index out of bounds" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const types = [_]type{
         hash.Md5,
         hash.Sha1,
diff --git a/lib/std/crypto/25519/curve25519.zig b/lib/std/crypto/25519/curve25519.zig
index 5377a9d141..7c3343ba8c 100644
--- a/lib/std/crypto/25519/curve25519.zig
+++ b/lib/std/crypto/25519/curve25519.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const crypto = std.crypto;
 
 const IdentityElementError = crypto.errors.IdentityElementError;
@@ -112,8 +111,6 @@ pub const Curve25519 = struct {
 };
 
 test "curve25519" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var s = [32]u8{ 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8 };
     const p = try Curve25519.basePoint.clampedMul(s);
     try p.rejectIdentity();
@@ -128,8 +125,6 @@ test "curve25519" {
 }
 
 test "curve25519 small order check" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var s: [32]u8 = [_]u8{1} ++ [_]u8{0} ** 31;
     const small_order_ss: [7][32]u8 = .{
         .{
diff --git a/lib/std/crypto/25519/ed25519.zig b/lib/std/crypto/25519/ed25519.zig
index 43051fb5bf..fc123386f8 100644
--- a/lib/std/crypto/25519/ed25519.zig
+++ b/lib/std/crypto/25519/ed25519.zig
@@ -1,5 +1,5 @@
-const std = @import("std");
 const builtin = @import("builtin");
+const std = @import("std");
 const crypto = std.crypto;
 const debug = std.debug;
 const fmt = std.fmt;
@@ -484,8 +484,6 @@ pub const Ed25519 = struct {
 };
 
 test "ed25519 key pair creation" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var seed: [32]u8 = undefined;
     _ = try fmt.hexToBytes(seed[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166");
     const key_pair = try Ed25519.KeyPair.create(seed);
@@ -495,8 +493,6 @@ test "ed25519 key pair creation" {
 }
 
 test "ed25519 signature" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var seed: [32]u8 = undefined;
     _ = try fmt.hexToBytes(seed[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166");
     const key_pair = try Ed25519.KeyPair.create(seed);
@@ -509,8 +505,6 @@ test "ed25519 signature" {
 }
 
 test "ed25519 batch verification" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var i: usize = 0;
     while (i < 100) : (i += 1) {
         const key_pair = try Ed25519.KeyPair.create(null);
@@ -540,8 +534,6 @@ test "ed25519 batch verification" {
 }
 
 test "ed25519 test vectors" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Vec = struct {
         msg_hex: *const [64:0]u8,
         public_key_hex: *const [64:0]u8,
@@ -644,8 +636,6 @@ test "ed25519 test vectors" {
 }
 
 test "ed25519 with blind keys" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const BlindKeyPair = Ed25519.key_blinding.BlindKeyPair;
 
     // Create a standard Ed25519 key pair
@@ -669,8 +659,6 @@ test "ed25519 with blind keys" {
 }
 
 test "ed25519 signatures with streaming" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const kp = try Ed25519.KeyPair.create(null);
 
     var signer = try kp.signer(null);
@@ -687,8 +675,6 @@ test "ed25519 signatures with streaming" {
 }
 
 test "ed25519 key pair from secret key" {
-    if (builtin.zig_backend == .stage2_x86_64) 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());
diff --git a/lib/std/crypto/25519/edwards25519.zig b/lib/std/crypto/25519/edwards25519.zig
index 7e099fcf4c..0d42073705 100644
--- a/lib/std/crypto/25519/edwards25519.zig
+++ b/lib/std/crypto/25519/edwards25519.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const crypto = std.crypto;
 const debug = std.debug;
 const fmt = std.fmt;
@@ -495,8 +494,6 @@ pub const Edwards25519 = struct {
 const htest = @import("../test.zig");
 
 test "edwards25519 packing/unpacking" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const s = [_]u8{170} ++ [_]u8{0} ** 31;
     var b = Edwards25519.basePoint;
     const pk = try b.mul(s);
@@ -533,8 +530,6 @@ test "edwards25519 packing/unpacking" {
 }
 
 test "edwards25519 point addition/subtraction" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var s1: [32]u8 = undefined;
     var s2: [32]u8 = undefined;
     crypto.random.bytes(&s1);
@@ -549,8 +544,6 @@ test "edwards25519 point addition/subtraction" {
 }
 
 test "edwards25519 uniform-to-point" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var r = [32]u8{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 };
     var p = Edwards25519.fromUniform(r);
     try htest.assertEqual("0691eee3cf70a0056df6bfa03120635636581b5c4ea571dfc680f78c7e0b4137", p.toBytes()[0..]);
@@ -562,8 +555,6 @@ test "edwards25519 uniform-to-point" {
 
 // Test vectors from draft-irtf-cfrg-hash-to-curve-12
 test "edwards25519 hash-to-curve operation" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var p = Edwards25519.fromString(true, "QUUX-V01-CS02-with-edwards25519_XMD:SHA-512_ELL2_RO_", "abc");
     try htest.assertEqual("31558a26887f23fb8218f143e69d5f0af2e7831130bd5b432ef23883b895839a", p.toBytes()[0..]);
 
@@ -572,8 +563,6 @@ test "edwards25519 hash-to-curve operation" {
 }
 
 test "edwards25519 implicit reduction of invalid scalars" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const s = [_]u8{0} ** 31 ++ [_]u8{255};
     const p1 = try Edwards25519.basePoint.mulPublic(s);
     const p2 = try Edwards25519.basePoint.mul(s);
diff --git a/lib/std/crypto/25519/ristretto255.zig b/lib/std/crypto/25519/ristretto255.zig
index d3482f278f..d12a672e7d 100644
--- a/lib/std/crypto/25519/ristretto255.zig
+++ b/lib/std/crypto/25519/ristretto255.zig
@@ -168,8 +168,6 @@ pub const Ristretto255 = struct {
 };
 
 test "ristretto255" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const p = Ristretto255.basePoint;
     var buf: [256]u8 = undefined;
     try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&p.toBytes())}), "E2F2AE0A6ABC4E71A884A961C500515F58E30B6AA582DD8DB6A65945E08D2D76");
diff --git a/lib/std/crypto/25519/x25519.zig b/lib/std/crypto/25519/x25519.zig
index 7da73f2480..b746a51968 100644
--- a/lib/std/crypto/25519/x25519.zig
+++ b/lib/std/crypto/25519/x25519.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const crypto = std.crypto;
 const mem = std.mem;
 const fmt = std.fmt;
@@ -83,8 +82,6 @@ pub const X25519 = struct {
 const htest = @import("../test.zig");
 
 test "x25519 public key calculation from secret key" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var sk: [32]u8 = undefined;
     var pk_expected: [32]u8 = undefined;
     _ = try fmt.hexToBytes(sk[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166");
@@ -94,8 +91,6 @@ test "x25519 public key calculation from secret key" {
 }
 
 test "x25519 rfc7748 vector1" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const secret_key = [32]u8{ 0xa5, 0x46, 0xe3, 0x6b, 0xf0, 0x52, 0x7c, 0x9d, 0x3b, 0x16, 0x15, 0x4b, 0x82, 0x46, 0x5e, 0xdd, 0x62, 0x14, 0x4c, 0x0a, 0xc1, 0xfc, 0x5a, 0x18, 0x50, 0x6a, 0x22, 0x44, 0xba, 0x44, 0x9a, 0xc4 };
     const public_key = [32]u8{ 0xe6, 0xdb, 0x68, 0x67, 0x58, 0x30, 0x30, 0xdb, 0x35, 0x94, 0xc1, 0xa4, 0x24, 0xb1, 0x5f, 0x7c, 0x72, 0x66, 0x24, 0xec, 0x26, 0xb3, 0x35, 0x3b, 0x10, 0xa9, 0x03, 0xa6, 0xd0, 0xab, 0x1c, 0x4c };
 
@@ -106,8 +101,6 @@ test "x25519 rfc7748 vector1" {
 }
 
 test "x25519 rfc7748 vector2" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const secret_key = [32]u8{ 0x4b, 0x66, 0xe9, 0xd4, 0xd1, 0xb4, 0x67, 0x3c, 0x5a, 0xd2, 0x26, 0x91, 0x95, 0x7d, 0x6a, 0xf5, 0xc1, 0x1b, 0x64, 0x21, 0xe0, 0xea, 0x01, 0xd4, 0x2c, 0xa4, 0x16, 0x9e, 0x79, 0x18, 0xba, 0x0d };
     const public_key = [32]u8{ 0xe5, 0x21, 0x0f, 0x12, 0x78, 0x68, 0x11, 0xd3, 0xf4, 0xb7, 0x95, 0x9d, 0x05, 0x38, 0xae, 0x2c, 0x31, 0xdb, 0xe7, 0x10, 0x6f, 0xc0, 0x3c, 0x3e, 0xfc, 0x4c, 0xd5, 0x49, 0xc7, 0x15, 0xa4, 0x93 };
 
@@ -118,8 +111,6 @@ test "x25519 rfc7748 vector2" {
 }
 
 test "x25519 rfc7748 one iteration" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const initial_value = [32]u8{ 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
     const expected_output = [32]u8{ 0x42, 0x2c, 0x8e, 0x7a, 0x62, 0x27, 0xd7, 0xbc, 0xa1, 0x35, 0x0b, 0x3e, 0x2b, 0xb7, 0x27, 0x9f, 0x78, 0x97, 0xb8, 0x7b, 0xb6, 0x85, 0x4b, 0x78, 0x3c, 0x60, 0xe8, 0x03, 0x11, 0xae, 0x30, 0x79 };
 
@@ -137,8 +128,6 @@ test "x25519 rfc7748 one iteration" {
 }
 
 test "x25519 rfc7748 1,000 iterations" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // These iteration tests are slow so we always skip them. Results have been verified.
     if (true) {
         return error.SkipZigTest;
@@ -161,8 +150,6 @@ test "x25519 rfc7748 1,000 iterations" {
 }
 
 test "x25519 rfc7748 1,000,000 iterations" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     if (true) {
         return error.SkipZigTest;
     }
@@ -184,8 +171,6 @@ test "x25519 rfc7748 1,000,000 iterations" {
 }
 
 test "edwards25519 -> curve25519 map" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const ed_kp = try crypto.sign.Ed25519.KeyPair.create([_]u8{0x42} ** 32);
     const mont_kp = try X25519.KeyPair.fromEd25519(ed_kp);
     try htest.assertEqual("90e7595fc89e52fdfddce9c6a43d74dbf6047025ee0462d2d172e8b6a2841d6e", &mont_kp.secret_key);
diff --git a/lib/std/crypto/Certificate.zig b/lib/std/crypto/Certificate.zig
index 1b1d4812d3..f28894fc0d 100644
--- a/lib/std/crypto/Certificate.zig
+++ b/lib/std/crypto/Certificate.zig
@@ -624,8 +624,6 @@ pub fn parseTimeDigits(text: *const [2]u8, min: u8, max: u8) !u8 {
 }
 
 test parseTimeDigits {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const expectEqual = std.testing.expectEqual;
     try expectEqual(@as(u8, 0), try parseTimeDigits("00", 0, 99));
     try expectEqual(@as(u8, 99), try parseTimeDigits("99", 0, 99));
@@ -647,8 +645,6 @@ pub fn parseYear4(text: *const [4]u8) !u16 {
 }
 
 test parseYear4 {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const expectEqual = std.testing.expectEqual;
     try expectEqual(@as(u16, 0), try parseYear4("0000"));
     try expectEqual(@as(u16, 9999), try parseYear4("9999"));
@@ -1123,5 +1119,3 @@ pub const rsa = struct {
         return res;
     }
 };
-
-const builtin = @import("builtin");
diff --git a/lib/std/crypto/Certificate/Bundle.zig b/lib/std/crypto/Certificate/Bundle.zig
index 1bffa325bd..b5a3832115 100644
--- a/lib/std/crypto/Certificate/Bundle.zig
+++ b/lib/std/crypto/Certificate/Bundle.zig
@@ -318,8 +318,6 @@ const MapContext = struct {
 test "scan for OS-provided certificates" {
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var bundle: Bundle = .{};
     defer bundle.deinit(std.testing.allocator);
 
diff --git a/lib/std/crypto/aegis.zig b/lib/std/crypto/aegis.zig
index 5a7f2ec017..18047a13b5 100644
--- a/lib/std/crypto/aegis.zig
+++ b/lib/std/crypto/aegis.zig
@@ -17,7 +17,6 @@
 //! https://datatracker.ietf.org/doc/draft-irtf-cfrg-aegis-aead/
 
 const std = @import("std");
-const builtin = @import("builtin");
 const crypto = std.crypto;
 const mem = std.mem;
 const assert = std.debug.assert;
@@ -514,8 +513,6 @@ const htest = @import("test.zig");
 const testing = std.testing;
 
 test "Aegis128L test vector 1" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key: [Aegis128L.key_length]u8 = [_]u8{ 0x10, 0x01 } ++ [_]u8{0x00} ** 14;
     const nonce: [Aegis128L.nonce_length]u8 = [_]u8{ 0x10, 0x00, 0x02 } ++ [_]u8{0x00} ** 13;
     const ad = [8]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
@@ -539,8 +536,6 @@ test "Aegis128L test vector 1" {
 }
 
 test "Aegis128L test vector 2" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key: [Aegis128L.key_length]u8 = [_]u8{0x00} ** 16;
     const nonce: [Aegis128L.nonce_length]u8 = [_]u8{0x00} ** 16;
     const ad = [_]u8{};
@@ -558,8 +553,6 @@ test "Aegis128L test vector 2" {
 }
 
 test "Aegis128L test vector 3" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key: [Aegis128L.key_length]u8 = [_]u8{0x00} ** 16;
     const nonce: [Aegis128L.nonce_length]u8 = [_]u8{0x00} ** 16;
     const ad = [_]u8{};
@@ -576,8 +569,6 @@ test "Aegis128L test vector 3" {
 }
 
 test "Aegis256 test vector 1" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key: [Aegis256.key_length]u8 = [_]u8{ 0x10, 0x01 } ++ [_]u8{0x00} ** 30;
     const nonce: [Aegis256.nonce_length]u8 = [_]u8{ 0x10, 0x00, 0x02 } ++ [_]u8{0x00} ** 29;
     const ad = [8]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
@@ -601,8 +592,6 @@ test "Aegis256 test vector 1" {
 }
 
 test "Aegis256 test vector 2" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key: [Aegis256.key_length]u8 = [_]u8{0x00} ** 32;
     const nonce: [Aegis256.nonce_length]u8 = [_]u8{0x00} ** 32;
     const ad = [_]u8{};
@@ -620,8 +609,6 @@ test "Aegis256 test vector 2" {
 }
 
 test "Aegis256 test vector 3" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key: [Aegis256.key_length]u8 = [_]u8{0x00} ** 32;
     const nonce: [Aegis256.nonce_length]u8 = [_]u8{0x00} ** 32;
     const ad = [_]u8{};
@@ -638,8 +625,6 @@ test "Aegis256 test vector 3" {
 }
 
 test "Aegis MAC" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key = [_]u8{0x00} ** Aegis128LMac.key_length;
     var msg: [64]u8 = undefined;
     for (&msg, 0..) |*m, i| {
diff --git a/lib/std/crypto/aes.zig b/lib/std/crypto/aes.zig
index 875898d2e5..70246e6630 100644
--- a/lib/std/crypto/aes.zig
+++ b/lib/std/crypto/aes.zig
@@ -28,8 +28,6 @@ pub const Aes128 = impl.Aes128;
 pub const Aes256 = impl.Aes256;
 
 test "ctr" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // NIST SP 800-38A pp 55-58
     const ctr = @import("modes.zig").ctr;
 
@@ -55,8 +53,6 @@ test "ctr" {
 }
 
 test "encrypt" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // Appendix B
     {
         const key = [_]u8{ 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c };
@@ -86,8 +82,6 @@ test "encrypt" {
 }
 
 test "decrypt" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // Appendix B
     {
         const key = [_]u8{ 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c };
@@ -117,8 +111,6 @@ test "decrypt" {
 }
 
 test "expand 128-bit key" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key = [_]u8{ 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c };
     const exp_enc = [_]*const [32:0]u8{
         "2b7e151628aed2a6abf7158809cf4f3c", "a0fafe1788542cb123a339392a6c7605", "f2c295f27a96b9435935807a7359f67f", "3d80477d4716fe3e1e237e446d7a883b", "ef44a541a8525b7fb671253bdb0bad00", "d4d1c6f87c839d87caf2b8bc11f915bc", "6d88a37a110b3efddbf98641ca0093fd", "4e54f70e5f5fc9f384a64fb24ea6dc4f", "ead27321b58dbad2312bf5607f8d292f", "ac7766f319fadc2128d12941575c006e", "d014f9a8c9ee2589e13f0cc8b6630ca6",
@@ -141,8 +133,6 @@ test "expand 128-bit key" {
 }
 
 test "expand 256-bit key" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key = [_]u8{
         0x60, 0x3d, 0xeb, 0x10,
         0x15, 0xca, 0x71, 0xbe,
diff --git a/lib/std/crypto/aes_gcm.zig b/lib/std/crypto/aes_gcm.zig
index 1715636bed..fdc42997ad 100644
--- a/lib/std/crypto/aes_gcm.zig
+++ b/lib/std/crypto/aes_gcm.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const assert = std.debug.assert;
 const crypto = std.crypto;
 const debug = std.debug;
@@ -113,8 +112,6 @@ const htest = @import("test.zig");
 const testing = std.testing;
 
 test "Aes256Gcm - Empty message and no associated data" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key: [Aes256Gcm.key_length]u8 = [_]u8{0x69} ** Aes256Gcm.key_length;
     const nonce: [Aes256Gcm.nonce_length]u8 = [_]u8{0x42} ** Aes256Gcm.nonce_length;
     const ad = "";
@@ -127,8 +124,6 @@ test "Aes256Gcm - Empty message and no associated data" {
 }
 
 test "Aes256Gcm - Associated data only" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key: [Aes256Gcm.key_length]u8 = [_]u8{0x69} ** Aes256Gcm.key_length;
     const nonce: [Aes256Gcm.nonce_length]u8 = [_]u8{0x42} ** Aes256Gcm.nonce_length;
     const m = "";
@@ -141,8 +136,6 @@ test "Aes256Gcm - Associated data only" {
 }
 
 test "Aes256Gcm - Message only" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key: [Aes256Gcm.key_length]u8 = [_]u8{0x69} ** Aes256Gcm.key_length;
     const nonce: [Aes256Gcm.nonce_length]u8 = [_]u8{0x42} ** Aes256Gcm.nonce_length;
     const m = "Test with message only";
@@ -160,8 +153,6 @@ test "Aes256Gcm - Message only" {
 }
 
 test "Aes256Gcm - Message and associated data" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key: [Aes256Gcm.key_length]u8 = [_]u8{0x69} ** Aes256Gcm.key_length;
     const nonce: [Aes256Gcm.nonce_length]u8 = [_]u8{0x42} ** Aes256Gcm.nonce_length;
     const m = "Test with message";
diff --git a/lib/std/crypto/aes_ocb.zig b/lib/std/crypto/aes_ocb.zig
index 0209d07ec6..3f0a98a5d7 100644
--- a/lib/std/crypto/aes_ocb.zig
+++ b/lib/std/crypto/aes_ocb.zig
@@ -261,10 +261,7 @@ inline fn xorWith(x: *Block, y: Block) void {
 const hexToBytes = std.fmt.hexToBytes;
 
 test "AesOcb test vector 1" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     var k: [Aes128Ocb.key_length]u8 = undefined;
     var nonce: [Aes128Ocb.nonce_length]u8 = undefined;
@@ -283,10 +280,7 @@ test "AesOcb test vector 1" {
 }
 
 test "AesOcb test vector 2" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     var k: [Aes128Ocb.key_length]u8 = undefined;
     var nonce: [Aes128Ocb.nonce_length]u8 = undefined;
@@ -307,10 +301,7 @@ test "AesOcb test vector 2" {
 }
 
 test "AesOcb test vector 3" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     var k: [Aes128Ocb.key_length]u8 = undefined;
     var nonce: [Aes128Ocb.nonce_length]u8 = undefined;
@@ -334,10 +325,7 @@ test "AesOcb test vector 3" {
 }
 
 test "AesOcb test vector 4" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     var k: [Aes128Ocb.key_length]u8 = undefined;
     var nonce: [Aes128Ocb.nonce_length]u8 = undefined;
diff --git a/lib/std/crypto/argon2.zig b/lib/std/crypto/argon2.zig
index 05dd686aac..898bc24e6f 100644
--- a/lib/std/crypto/argon2.zig
+++ b/lib/std/crypto/argon2.zig
@@ -622,8 +622,6 @@ pub fn strVerify(
 }
 
 test "argon2d" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const password = [_]u8{0x01} ** 32;
     const salt = [_]u8{0x02} ** 16;
     const secret = [_]u8{0x03} ** 8;
@@ -649,8 +647,6 @@ test "argon2d" {
 }
 
 test "argon2i" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const password = [_]u8{0x01} ** 32;
     const salt = [_]u8{0x02} ** 16;
     const secret = [_]u8{0x03} ** 8;
@@ -676,8 +672,6 @@ test "argon2i" {
 }
 
 test "argon2id" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const password = [_]u8{0x01} ** 32;
     const salt = [_]u8{0x02} ** 16;
     const secret = [_]u8{0x03} ** 8;
@@ -703,8 +697,6 @@ test "argon2id" {
 }
 
 test "kdf" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const password = "password";
     const salt = "somesalt";
 
@@ -904,8 +896,6 @@ test "kdf" {
 }
 
 test "phc format hasher" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const allocator = std.testing.allocator;
     const password = "testpass";
 
@@ -921,8 +911,6 @@ test "phc format hasher" {
 }
 
 test "password hash and password verify" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const allocator = std.testing.allocator;
     const password = "testpass";
 
@@ -936,8 +924,6 @@ test "password hash and password verify" {
 }
 
 test "kdf derived key length" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const allocator = std.testing.allocator;
 
     const password = "testpass";
diff --git a/lib/std/crypto/bcrypt.zig b/lib/std/crypto/bcrypt.zig
index ce3a5aec79..87d2eef79a 100644
--- a/lib/std/crypto/bcrypt.zig
+++ b/lib/std/crypto/bcrypt.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const base64 = std.base64;
 const crypto = std.crypto;
 const debug = std.debug;
@@ -754,8 +753,6 @@ pub fn strVerify(
 }
 
 test "bcrypt codec" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var salt: [salt_length]u8 = undefined;
     crypto.random.bytes(&salt);
     var salt_str: [salt_str_length]u8 = undefined;
@@ -766,8 +763,6 @@ test "bcrypt codec" {
 }
 
 test "bcrypt crypt format" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var hash_options = HashOptions{
         .params = .{ .rounds_log = 5 },
         .encoding = .crypt,
@@ -808,8 +803,6 @@ test "bcrypt crypt format" {
 }
 
 test "bcrypt phc format" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var hash_options = HashOptions{
         .params = .{ .rounds_log = 5 },
         .encoding = .phc,
diff --git a/lib/std/crypto/blake3.zig b/lib/std/crypto/blake3.zig
index 08c38ec63b..fc1859b99d 100644
--- a/lib/std/crypto/blake3.zig
+++ b/lib/std/crypto/blake3.zig
@@ -200,7 +200,7 @@ const CompressGeneric = struct {
     }
 };
 
-const compress = if (builtin.cpu.arch == .x86_64 and builtin.zig_backend != .stage2_x86_64)
+const compress = if (builtin.cpu.arch == .x86_64)
     CompressVectorized.compress
 else
     CompressGeneric.compress;
@@ -682,8 +682,6 @@ fn testBlake3(hasher: *Blake3, input_len: usize, expected_hex: [262]u8) !void {
 }
 
 test "BLAKE3 reference test cases" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var hash_state = Blake3.init(.{});
     const hash = &hash_state;
     var keyed_hash_state = Blake3.init(.{ .key = reference_test.key.* });
diff --git a/lib/std/crypto/chacha20.zig b/lib/std/crypto/chacha20.zig
index c6a2ddafe7..b45d1c5295 100644
--- a/lib/std/crypto/chacha20.zig
+++ b/lib/std/crypto/chacha20.zig
@@ -499,8 +499,6 @@ fn ChaChaNonVecImpl(comptime rounds_nb: usize) type {
 fn ChaChaImpl(comptime rounds_nb: usize) type {
     switch (builtin.cpu.arch) {
         .x86_64 => {
-            if (builtin.zig_backend == .stage2_x86_64) return ChaChaNonVecImpl(rounds_nb);
-
             const has_avx2 = std.Target.x86.featureSetHas(builtin.cpu.features, .avx2);
             const has_avx512f = std.Target.x86.featureSetHas(builtin.cpu.features, .avx512f);
             if (has_avx512f) return ChaChaVecImpl(rounds_nb, 4);
@@ -759,8 +757,6 @@ fn XChaChaPoly1305(comptime rounds_nb: usize) type {
 }
 
 test "chacha20 AEAD API" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const aeads = [_]type{ ChaCha20Poly1305, XChaCha20Poly1305 };
     const m = "Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it.";
     const ad = "Additional data";
@@ -782,8 +778,6 @@ test "chacha20 AEAD API" {
 
 // https://tools.ietf.org/html/rfc7539#section-2.4.2
 test "crypto.chacha20 test vector sunscreen" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const expected_result = [_]u8{
         0x6e, 0x2e, 0x35, 0x9a, 0x25, 0x68, 0xf9, 0x80,
         0x41, 0xba, 0x07, 0x28, 0xdd, 0x0d, 0x69, 0x81,
@@ -825,8 +819,6 @@ test "crypto.chacha20 test vector sunscreen" {
 
 // https://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04#section-7
 test "crypto.chacha20 test vector 1" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const expected_result = [_]u8{
         0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90,
         0x40, 0x5d, 0x6a, 0xe5, 0x53, 0x86, 0xbd, 0x28,
@@ -861,8 +853,6 @@ test "crypto.chacha20 test vector 1" {
 }
 
 test "crypto.chacha20 test vector 2" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const expected_result = [_]u8{
         0x45, 0x40, 0xf0, 0x5a, 0x9f, 0x1f, 0xb2, 0x96,
         0xd7, 0x73, 0x6e, 0x7b, 0x20, 0x8e, 0x3c, 0x96,
@@ -897,8 +887,6 @@ test "crypto.chacha20 test vector 2" {
 }
 
 test "crypto.chacha20 test vector 3" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const expected_result = [_]u8{
         0xde, 0x9c, 0xba, 0x7b, 0xf3, 0xd6, 0x9e, 0xf5,
         0xe7, 0x86, 0xdc, 0x63, 0x97, 0x3f, 0x65, 0x3a,
@@ -933,8 +921,6 @@ test "crypto.chacha20 test vector 3" {
 }
 
 test "crypto.chacha20 test vector 4" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const expected_result = [_]u8{
         0xef, 0x3f, 0xdf, 0xd6, 0xc6, 0x15, 0x78, 0xfb,
         0xf5, 0xcf, 0x35, 0xbd, 0x3d, 0xd3, 0x3b, 0x80,
@@ -969,8 +955,6 @@ test "crypto.chacha20 test vector 4" {
 }
 
 test "crypto.chacha20 test vector 5" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const expected_result = [_]u8{
         0xf7, 0x98, 0xa1, 0x89, 0xf1, 0x95, 0xe6, 0x69,
         0x82, 0x10, 0x5f, 0xfb, 0x64, 0x0b, 0xb7, 0x75,
@@ -1043,8 +1027,6 @@ test "crypto.chacha20 test vector 5" {
 }
 
 test "seal" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     {
         const m = "";
         const ad = "";
@@ -1095,8 +1077,6 @@ test "seal" {
 }
 
 test "open" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     {
         const c = [_]u8{ 0xa0, 0x78, 0x4d, 0x7a, 0x47, 0x16, 0xf3, 0xfe, 0xb4, 0xf6, 0x4e, 0x7f, 0x4b, 0x39, 0xbf, 0x4 };
         const ad = "";
@@ -1161,8 +1141,6 @@ test "open" {
 }
 
 test "crypto.xchacha20" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key = [_]u8{69} ** 32;
     const nonce = [_]u8{42} ** 24;
     const m = "Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it.";
diff --git a/lib/std/crypto/cmac.zig b/lib/std/crypto/cmac.zig
index 5f2d332c01..fd00461858 100644
--- a/lib/std/crypto/cmac.zig
+++ b/lib/std/crypto/cmac.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const crypto = std.crypto;
 const mem = std.mem;
 
@@ -94,8 +93,6 @@ pub fn Cmac(comptime BlockCipher: type) type {
 const testing = std.testing;
 
 test "CmacAes128 - Example 1: len = 0" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key = [_]u8{
         0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
     };
@@ -109,8 +106,6 @@ test "CmacAes128 - Example 1: len = 0" {
 }
 
 test "CmacAes128 - Example 2: len = 16" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key = [_]u8{
         0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
     };
@@ -126,8 +121,6 @@ test "CmacAes128 - Example 2: len = 16" {
 }
 
 test "CmacAes128 - Example 3: len = 40" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key = [_]u8{
         0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
     };
@@ -145,8 +138,6 @@ test "CmacAes128 - Example 3: len = 40" {
 }
 
 test "CmacAes128 - Example 4: len = 64" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key = [_]u8{
         0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
     };
diff --git a/lib/std/crypto/ecdsa.zig b/lib/std/crypto/ecdsa.zig
index acb054d8cd..1a5335b07e 100644
--- a/lib/std/crypto/ecdsa.zig
+++ b/lib/std/crypto/ecdsa.zig
@@ -372,10 +372,7 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
 }
 
 test "ECDSA - Basic operations over EcdsaP384Sha384" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     const Scheme = EcdsaP384Sha384;
     const kp = try Scheme.KeyPair.create(null);
@@ -391,10 +388,7 @@ test "ECDSA - Basic operations over EcdsaP384Sha384" {
 }
 
 test "ECDSA - Basic operations over Secp256k1" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     const Scheme = EcdsaSecp256k1Sha256oSha256;
     const kp = try Scheme.KeyPair.create(null);
@@ -410,10 +404,7 @@ test "ECDSA - Basic operations over Secp256k1" {
 }
 
 test "ECDSA - Basic operations over EcdsaP384Sha256" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     const Scheme = Ecdsa(crypto.ecc.P384, crypto.hash.sha2.Sha256);
     const kp = try Scheme.KeyPair.create(null);
@@ -429,10 +420,7 @@ test "ECDSA - Basic operations over EcdsaP384Sha256" {
 }
 
 test "ECDSA - Verifying a existing signature with EcdsaP384Sha256" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     const Scheme = Ecdsa(crypto.ecc.P384, crypto.hash.sha2.Sha256);
     // zig fmt: off
@@ -476,10 +464,7 @@ const TestVector = struct {
 };
 
 test "ECDSA - Test vectors from Project Wycheproof" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     const vectors = [_]TestVector{
         .{ .key = "042927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e", .msg = "313233343030", .sig = "304402202ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e1802204cd60b855d442f5b3c7b11eb6c4e0ae7525fe710fab9aa7c77a67f79e6fadd76", .result = .valid },
@@ -893,10 +878,7 @@ fn tvTry(vector: TestVector) !void {
 }
 
 test "ECDSA - Sec1 encoding/decoding" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     const Scheme = EcdsaP384Sha384;
     const kp = try Scheme.KeyPair.create(null);
diff --git a/lib/std/crypto/ff.zig b/lib/std/crypto/ff.zig
index 037feae5ed..287d37544f 100644
--- a/lib/std/crypto/ff.zig
+++ b/lib/std/crypto/ff.zig
@@ -912,10 +912,7 @@ const ct_unprotected = struct {
 };
 
 test {
-    switch (@import("builtin").zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest;
 
     const M = Modulus(256);
     const m = try M.fromPrimitive(u256, 3429938563481314093726330772853735541133072814650493833233);
diff --git a/lib/std/crypto/ghash_polyval.zig b/lib/std/crypto/ghash_polyval.zig
index 3a78db6214..11379cc8e3 100644
--- a/lib/std/crypto/ghash_polyval.zig
+++ b/lib/std/crypto/ghash_polyval.zig
@@ -422,8 +422,6 @@ fn Hash(comptime endian: std.builtin.Endian, comptime shift_key: bool) type {
 const htest = @import("test.zig");
 
 test "ghash" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key = [_]u8{0x42} ** 16;
     const m = [_]u8{0x69} ** 256;
 
@@ -441,8 +439,6 @@ test "ghash" {
 }
 
 test "ghash2" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var key: [16]u8 = undefined;
     var i: usize = 0;
     while (i < key.len) : (i += 1) {
@@ -476,8 +472,6 @@ test "ghash2" {
 }
 
 test "polyval" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key = [_]u8{0x42} ** 16;
     const m = [_]u8{0x69} ** 256;
 
diff --git a/lib/std/crypto/hash_composition.zig b/lib/std/crypto/hash_composition.zig
index 234a990a83..1ffa3d4c47 100644
--- a/lib/std/crypto/hash_composition.zig
+++ b/lib/std/crypto/hash_composition.zig
@@ -65,8 +65,6 @@ pub const Sha384oSha384 = Composition(sha2.Sha384, sha2.Sha384);
 pub const Sha512oSha512 = Composition(sha2.Sha512, sha2.Sha512);
 
 test "Hash composition" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Sha256 = sha2.Sha256;
     const msg = "test";
 
diff --git a/lib/std/crypto/hkdf.zig b/lib/std/crypto/hkdf.zig
index f0865a9d5e..9163ba9d15 100644
--- a/lib/std/crypto/hkdf.zig
+++ b/lib/std/crypto/hkdf.zig
@@ -72,8 +72,6 @@ pub fn Hkdf(comptime Hmac: type) type {
 const htest = @import("test.zig");
 
 test "Hkdf" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const ikm = [_]u8{0x0b} ** 22;
     const salt = [_]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c };
     const context = [_]u8{ 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 };
diff --git a/lib/std/crypto/kyber_d00.zig b/lib/std/crypto/kyber_d00.zig
index fa1627dbd1..ba6ed67ec8 100644
--- a/lib/std/crypto/kyber_d00.zig
+++ b/lib/std/crypto/kyber_d00.zig
@@ -553,8 +553,6 @@ const inv_ntt_reductions = [_]i16{
 };
 
 test "invNTTReductions bounds" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // Checks whether the reductions proposed by invNTTReductions
     // don't overflow during invNTT().
     var xs = [_]i32{1} ** 256; // start at |x| ≤ q
@@ -658,8 +656,6 @@ fn montReduce(x: i32) i16 {
 }
 
 test "Test montReduce" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var rnd = RndGen.init(0);
     for (0..1000) |_| {
         const bound = comptime @as(i32, Q) * (1 << 15);
@@ -678,8 +674,6 @@ fn feToMont(x: i16) i16 {
 }
 
 test "Test feToMont" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var x: i32 = -(1 << 15);
     while (x < 1 << 15) : (x += 1) {
         const y = feToMont(@as(i16, @intCast(x)));
@@ -713,8 +707,6 @@ fn feBarrettReduce(x: i16) i16 {
 }
 
 test "Test Barrett reduction" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var x: i32 = -(1 << 15);
     while (x < 1 << 15) : (x += 1) {
         var y1 = feBarrettReduce(@as(i16, @intCast(x)));
@@ -735,8 +727,6 @@ fn csubq(x: i16) i16 {
 }
 
 test "Test csubq" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var x: i32 = -29439;
     while (x < 1 << 15) : (x += 1) {
         const y1 = csubq(@as(i16, @intCast(x)));
@@ -1476,8 +1466,6 @@ fn cmov(comptime len: usize, dst: *[len]u8, src: [len]u8, b: u1) void {
 }
 
 test "MulHat" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var rnd = RndGen.init(0);
 
     for (0..100) |_| {
@@ -1509,8 +1497,6 @@ test "MulHat" {
 }
 
 test "NTT" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var rnd = RndGen.init(0);
 
     for (0..1000) |_| {
@@ -1534,8 +1520,6 @@ test "NTT" {
 }
 
 test "Compression" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var rnd = RndGen.init(0);
     inline for (.{ 1, 4, 5, 10, 11 }) |d| {
         for (0..1000) |_| {
@@ -1548,8 +1532,6 @@ test "Compression" {
 }
 
 test "noise" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var seed: [32]u8 = undefined;
     for (&seed, 0..) |*s, i| {
         s.* = @as(u8, @intCast(i));
@@ -1596,8 +1578,6 @@ test "noise" {
 }
 
 test "uniform sampling" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var seed: [32]u8 = undefined;
     for (&seed, 0..) |*s, i| {
         s.* = @as(u8, @intCast(i));
@@ -1631,8 +1611,6 @@ test "uniform sampling" {
 }
 
 test "Polynomial packing" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var rnd = RndGen.init(0);
 
     for (0..1000) |_| {
@@ -1642,8 +1620,6 @@ test "Polynomial packing" {
 }
 
 test "Test inner PKE" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var seed: [32]u8 = undefined;
     var pt: [32]u8 = undefined;
     for (&seed, &pt, 0..) |*s, *p, i| {
@@ -1665,8 +1641,6 @@ test "Test inner PKE" {
 }
 
 test "Test happy flow" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var seed: [64]u8 = undefined;
     for (&seed, 0..) |*s, i| {
         s.* = @as(u8, @intCast(i));
@@ -1693,8 +1667,6 @@ test "Test happy flow" {
 const sha2 = crypto.hash.sha2;
 
 test "NIST KAT test" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     inline for (.{
         .{ Kyber512, "e9c2bd37133fcb40772f81559f14b1f58dccd1c816701be9ba6214d43baf4547" },
         .{ Kyber1024, "89248f2f33f7f4f7051729111f3049c409a933ec904aedadf035f30fa5646cd5" },
diff --git a/lib/std/crypto/pbkdf2.zig b/lib/std/crypto/pbkdf2.zig
index 126935f02c..2e0318369b 100644
--- a/lib/std/crypto/pbkdf2.zig
+++ b/lib/std/crypto/pbkdf2.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const mem = std.mem;
 const maxInt = std.math.maxInt;
 const OutputTooLongError = std.crypto.errors.OutputTooLongError;
@@ -152,8 +151,6 @@ const HmacSha1 = std.crypto.auth.hmac.HmacSha1;
 // RFC 6070 PBKDF2 HMAC-SHA1 Test Vectors
 
 test "RFC 6070 one iteration" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const p = "password";
     const s = "salt";
     const c = 1;
@@ -169,8 +166,6 @@ test "RFC 6070 one iteration" {
 }
 
 test "RFC 6070 two iterations" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const p = "password";
     const s = "salt";
     const c = 2;
@@ -186,8 +181,6 @@ test "RFC 6070 two iterations" {
 }
 
 test "RFC 6070 4096 iterations" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const p = "password";
     const s = "salt";
     const c = 4096;
@@ -203,8 +196,6 @@ test "RFC 6070 4096 iterations" {
 }
 
 test "RFC 6070 16,777,216 iterations" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // These iteration tests are slow so we always skip them. Results have been verified.
     if (true) {
         return error.SkipZigTest;
@@ -225,8 +216,6 @@ test "RFC 6070 16,777,216 iterations" {
 }
 
 test "RFC 6070 multi-block salt and password" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const p = "passwordPASSWORDpassword";
     const s = "saltSALTsaltSALTsaltSALTsaltSALTsalt";
     const c = 4096;
@@ -242,8 +231,6 @@ test "RFC 6070 multi-block salt and password" {
 }
 
 test "RFC 6070 embedded NUL" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const p = "pass\x00word";
     const s = "sa\x00lt";
     const c = 4096;
@@ -259,8 +246,6 @@ test "RFC 6070 embedded NUL" {
 }
 
 test "Very large dk_len" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // This test allocates 8GB of memory and is expected to take several hours to run.
     if (true) {
         return error.SkipZigTest;
diff --git a/lib/std/crypto/pcurves/p256.zig b/lib/std/crypto/pcurves/p256.zig
index 87c963f834..668c0115b2 100644
--- a/lib/std/crypto/pcurves/p256.zig
+++ b/lib/std/crypto/pcurves/p256.zig
@@ -478,7 +478,5 @@ pub const AffineCoordinates = struct {
 };
 
 test {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     _ = @import("tests/p256.zig");
 }
diff --git a/lib/std/crypto/pcurves/p384.zig b/lib/std/crypto/pcurves/p384.zig
index 44dd4e50b7..d5afd6eb4d 100644
--- a/lib/std/crypto/pcurves/p384.zig
+++ b/lib/std/crypto/pcurves/p384.zig
@@ -478,10 +478,7 @@ pub const AffineCoordinates = struct {
 };
 
 test {
-    switch (@import("builtin").zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest;
 
     _ = @import("tests/p384.zig");
 }
diff --git a/lib/std/crypto/pcurves/secp256k1.zig b/lib/std/crypto/pcurves/secp256k1.zig
index 6286b96249..cd7f1faf75 100644
--- a/lib/std/crypto/pcurves/secp256k1.zig
+++ b/lib/std/crypto/pcurves/secp256k1.zig
@@ -556,10 +556,7 @@ pub const AffineCoordinates = struct {
 };
 
 test {
-    switch (@import("builtin").zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest;
 
     _ = @import("tests/secp256k1.zig");
 }
diff --git a/lib/std/crypto/phc_encoding.zig b/lib/std/crypto/phc_encoding.zig
index 58757cec28..fecd7f1239 100644
--- a/lib/std/crypto/phc_encoding.zig
+++ b/lib/std/crypto/phc_encoding.zig
@@ -1,7 +1,6 @@
 // https://github.com/P-H-C/phc-string-format
 
 const std = @import("std");
-const builtin = @import("builtin");
 const fmt = std.fmt;
 const io = std.io;
 const mem = std.mem;
@@ -264,8 +263,6 @@ fn kvSplit(str: []const u8) !struct { key: []const u8, value: []const u8 } {
 }
 
 test "phc format - encoding/decoding" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Input = struct {
         str: []const u8,
         HashResult: type,
@@ -351,24 +348,18 @@ test "phc format - encoding/decoding" {
 }
 
 test "phc format - empty input string" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const s = "";
     const v = deserialize(struct { alg_id: []const u8 }, s);
     try std.testing.expectError(Error.InvalidEncoding, v);
 }
 
 test "phc format - hash without salt" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const s = "$scrypt";
     const v = deserialize(struct { alg_id: []const u8, hash: BinValue(16) }, s);
     try std.testing.expectError(Error.InvalidEncoding, v);
 }
 
 test "phc format - calcSize" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const s = "$scrypt$v=1$ln=15,r=8,p=1$c2FsdHNhbHQ$dGVzdHBhc3M";
     const v = try deserialize(struct {
         alg_id: []const u8,
diff --git a/lib/std/crypto/poly1305.zig b/lib/std/crypto/poly1305.zig
index 7bdbabae49..5bcb75169d 100644
--- a/lib/std/crypto/poly1305.zig
+++ b/lib/std/crypto/poly1305.zig
@@ -196,8 +196,6 @@ pub const Poly1305 = struct {
 };
 
 test "poly1305 rfc7439 vector1" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const expected_mac = "\xa8\x06\x1d\xc1\x30\x51\x36\xc6\xc2\x2b\x8b\xaf\x0c\x01\x27\xa9";
 
     const msg = "Cryptographic Forum Research Group";
diff --git a/lib/std/crypto/salsa20.zig b/lib/std/crypto/salsa20.zig
index a253bf5dd9..9d95331839 100644
--- a/lib/std/crypto/salsa20.zig
+++ b/lib/std/crypto/salsa20.zig
@@ -555,8 +555,6 @@ pub const SealedBox = struct {
 const htest = @import("test.zig");
 
 test "(x)salsa20" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key = [_]u8{0x69} ** 32;
     const nonce = [_]u8{0x42} ** 8;
     const msg = [_]u8{0} ** 20;
@@ -571,8 +569,6 @@ test "(x)salsa20" {
 }
 
 test "xsalsa20poly1305" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var msg: [100]u8 = undefined;
     var msg2: [msg.len]u8 = undefined;
     var c: [msg.len]u8 = undefined;
@@ -588,8 +584,6 @@ test "xsalsa20poly1305" {
 }
 
 test "xsalsa20poly1305 secretbox" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var msg: [100]u8 = undefined;
     var msg2: [msg.len]u8 = undefined;
     var key: [XSalsa20Poly1305.key_length]u8 = undefined;
@@ -604,8 +598,6 @@ test "xsalsa20poly1305 secretbox" {
 }
 
 test "xsalsa20poly1305 box" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var msg: [100]u8 = undefined;
     var msg2: [msg.len]u8 = undefined;
     var nonce: [Box.nonce_length]u8 = undefined;
@@ -620,8 +612,6 @@ test "xsalsa20poly1305 box" {
 }
 
 test "xsalsa20poly1305 sealedbox" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var msg: [100]u8 = undefined;
     var msg2: [msg.len]u8 = undefined;
     var boxed: [msg.len + SealedBox.seal_length]u8 = undefined;
@@ -633,8 +623,6 @@ test "xsalsa20poly1305 sealedbox" {
 }
 
 test "secretbox twoblocks" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const key = [_]u8{ 0xc9, 0xc9, 0x4d, 0xcf, 0x68, 0xbe, 0x00, 0xe4, 0x7f, 0xe6, 0x13, 0x26, 0xfc, 0xc4, 0x2f, 0xd0, 0xdb, 0x93, 0x91, 0x1c, 0x09, 0x94, 0x89, 0xe1, 0x1b, 0x88, 0x63, 0x18, 0x86, 0x64, 0x8b, 0x7b };
     const nonce = [_]u8{ 0xa4, 0x33, 0xe9, 0x0a, 0x07, 0x68, 0x6e, 0x9a, 0x2b, 0x6d, 0xd4, 0x59, 0x04, 0x72, 0x3e, 0xd3, 0x8a, 0x67, 0x55, 0xc7, 0x9e, 0x3e, 0x77, 0xdc };
     const msg = [_]u8{'a'} ** 97;
diff --git a/lib/std/crypto/scrypt.zig b/lib/std/crypto/scrypt.zig
index f830e8f120..8745a3b34e 100644
--- a/lib/std/crypto/scrypt.zig
+++ b/lib/std/crypto/scrypt.zig
@@ -3,7 +3,6 @@
 // https://github.com/Tarsnap/scrypt
 
 const std = @import("std");
-const builtin = @import("builtin");
 const crypto = std.crypto;
 const fmt = std.fmt;
 const io = std.io;
@@ -684,8 +683,6 @@ test "unix-scrypt" {
 }
 
 test "crypt format" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const str = "$7$C6..../....SodiumChloride$kBGj9fHznVYFQMEn/qDCfrDevf9YDtcDdKvEqHJLV8D";
     const params = try crypt_format.deserialize(crypt_format.HashResult(32), str);
     var buf: [str.len]u8 = undefined;
@@ -694,8 +691,6 @@ test "crypt format" {
 }
 
 test "kdf fast" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const TestVector = struct {
         password: []const u8,
         salt: []const u8,
diff --git a/lib/std/crypto/sha2.zig b/lib/std/crypto/sha2.zig
index 4f09294a30..f87ea90d92 100644
--- a/lib/std/crypto/sha2.zig
+++ b/lib/std/crypto/sha2.zig
@@ -238,7 +238,7 @@ fn Sha2x32(comptime params: Sha2Params32) type {
                         return;
                     },
                     // C backend doesn't currently support passing vectors to inline asm.
-                    .x86_64 => if (builtin.zig_backend != .stage2_c and builtin.zig_backend != .stage2_x86_64 and comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sha, .avx2 })) {
+                    .x86_64 => if (builtin.zig_backend != .stage2_c and comptime std.Target.x86.featureSetHasAll(builtin.cpu.features, .{ .sha, .avx2 })) {
                         var x: v4u32 = [_]u32{ d.s[5], d.s[4], d.s[1], d.s[0] };
                         var y: v4u32 = [_]u32{ d.s[7], d.s[6], d.s[3], d.s[2] };
                         const s_v = @as(*[16]v4u32, @ptrCast(&s));
@@ -406,16 +406,12 @@ fn Sha2x32(comptime params: Sha2Params32) type {
 }
 
 test "sha224 single" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try htest.assertEqualHash(Sha224, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f", "");
     try htest.assertEqualHash(Sha224, "23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7", "abc");
     try htest.assertEqualHash(Sha224, "c97ca9a559850ce97a04a96def6d99a9e0e0e2ab14e6b8df265fc0b3", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
 }
 
 test "sha224 streaming" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var h = Sha224.init(.{});
     var out: [28]u8 = undefined;
 
@@ -436,16 +432,12 @@ test "sha224 streaming" {
 }
 
 test "sha256 single" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try htest.assertEqualHash(Sha256, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "");
     try htest.assertEqualHash(Sha256, "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", "abc");
     try htest.assertEqualHash(Sha256, "cf5b16a778af8380036ce59e7b0492370b249b11e8f07a51afac45037afee9d1", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
 }
 
 test "sha256 streaming" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var h = Sha256.init(.{});
     var out: [32]u8 = undefined;
 
@@ -466,8 +458,6 @@ test "sha256 streaming" {
 }
 
 test "sha256 aligned final" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var block = [_]u8{0} ** Sha256.block_length;
     var out: [Sha256.digest_length]u8 = undefined;
 
diff --git a/lib/std/crypto/utils.zig b/lib/std/crypto/utils.zig
index 4eb7281bc8..ab1b6eab6a 100644
--- a/lib/std/crypto/utils.zig
+++ b/lib/std/crypto/utils.zig
@@ -149,8 +149,6 @@ test "crypto.utils.timingSafeEql" {
 }
 
 test "crypto.utils.timingSafeEql (vectors)" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a: [100]u8 = undefined;
     var b: [100]u8 = undefined;
     random.bytes(a[0..]);
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 9598e65b49..4af395beb4 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -2513,8 +2513,6 @@ pub fn dumpStackPointerAddr(prefix: []const u8) void {
 }
 
 test "manage resources correctly" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
     if (builtin.os.tag == .windows) {
diff --git a/lib/std/dwarf/expressions.zig b/lib/std/dwarf/expressions.zig
index e06aa941af..f89edc08a1 100644
--- a/lib/std/dwarf/expressions.zig
+++ b/lib/std/dwarf/expressions.zig
@@ -1054,8 +1054,6 @@ fn isOpcodeRegisterLocation(opcode: u8) bool {
 
 const testing = std.testing;
 test "DWARF expressions" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const allocator = std.testing.allocator;
 
     const options = ExpressionOptions{};
diff --git a/lib/std/fifo.zig b/lib/std/fifo.zig
index 72fd44e02d..5b19125e02 100644
--- a/lib/std/fifo.zig
+++ b/lib/std/fifo.zig
@@ -505,8 +505,6 @@ test "LinearFifo(u8, .Dynamic)" {
 }
 
 test "LinearFifo" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     inline for ([_]type{ u1, u8, u16, u64 }) |T| {
         inline for ([_]LinearFifoBufferType{ LinearFifoBufferType{ .Static = 32 }, .Slice, .Dynamic }) |bt| {
             const FifoType = LinearFifo(T, bt);
diff --git a/lib/std/fmt.zig b/lib/std/fmt.zig
index 611737161e..9538d91fa3 100644
--- a/lib/std/fmt.zig
+++ b/lib/std/fmt.zig
@@ -2129,8 +2129,6 @@ test "int.small" {
 }
 
 test "int.specifier" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     {
         const value: u8 = 'a';
         try expectFmt("u8: a\n", "u8: {c}\n", .{value});
@@ -2181,8 +2179,6 @@ test "int.padded" {
 }
 
 test "buffer" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     {
         var buf1: [32]u8 = undefined;
         var fbs = std.io.fixedBufferStream(&buf1);
@@ -2379,8 +2375,6 @@ test "float.scientific" {
 }
 
 test "float.scientific.precision" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try expectFmt("f64: 1.40971e-42", "f64: {e:.5}", .{@as(f64, 1.409706e-42)});
     try expectFmt("f64: 1.00000e-09", "f64: {e:.5}", .{@as(f64, @as(f32, @bitCast(@as(u32, 814313563))))});
     try expectFmt("f64: 7.81250e-03", "f64: {e:.5}", .{@as(f64, @as(f32, @bitCast(@as(u32, 1006632960))))});
@@ -2441,8 +2435,6 @@ test "float.hexadecimal" {
 }
 
 test "float.hexadecimal.precision" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try expectFmt("f16: 0x1.5p-2", "f16: {x:.1}", .{@as(f16, 1.0 / 3.0)});
     try expectFmt("f32: 0x1.555p-2", "f32: {x:.3}", .{@as(f32, 1.0 / 3.0)});
     try expectFmt("f64: 0x1.55555p-2", "f64: {x:.5}", .{@as(f64, 1.0 / 3.0)});
@@ -2457,8 +2449,6 @@ test "float.hexadecimal.precision" {
 }
 
 test "float.decimal" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try expectFmt("f64: 152314000000000000000000000000", "f64: {d}", .{@as(f64, 1.52314e+29)});
     try expectFmt("f32: 0", "f32: {d}", .{@as(f32, 0.0)});
     try expectFmt("f32: 0", "f32: {d:.0}", .{@as(f32, 0.0)});
@@ -2482,8 +2472,6 @@ test "float.decimal" {
 }
 
 test "float.libc.sanity" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try expectFmt("f64: 0.00001", "f64: {d:.5}", .{@as(f64, @as(f32, @bitCast(@as(u32, 916964781))))});
     try expectFmt("f64: 0.00001", "f64: {d:.5}", .{@as(f64, @as(f32, @bitCast(@as(u32, 925353389))))});
     try expectFmt("f64: 0.10000", "f64: {d:.5}", .{@as(f64, @as(f32, @bitCast(@as(u32, 1036831278))))});
@@ -2503,8 +2491,6 @@ test "float.libc.sanity" {
 }
 
 test "custom" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Vec2 = struct {
         const SelfType = @This();
         x: f32,
@@ -2683,8 +2669,6 @@ test "formatFloatValue with comptime_float" {
 }
 
 test "formatType max_depth" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Vec2 = struct {
         const SelfType = @This();
         x: f32,
@@ -2751,8 +2735,6 @@ test "formatType max_depth" {
 }
 
 test "positional" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try expectFmt("2 1 0", "{2} {1} {0}", .{ @as(usize, 0), @as(usize, 1), @as(usize, 2) });
     try expectFmt("2 1 0", "{2} {1} {}", .{ @as(usize, 0), @as(usize, 1), @as(usize, 2) });
     try expectFmt("0 0", "{0} {0}", .{@as(usize, 0)});
@@ -2761,20 +2743,14 @@ test "positional" {
 }
 
 test "positional with specifier" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try expectFmt("10.0", "{0d:.1}", .{@as(f64, 9.999)});
 }
 
 test "positional/alignment/width/precision" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try expectFmt("10.0", "{0d: >3.1}", .{@as(f64, 9.999)});
 }
 
 test "vector" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     if (builtin.target.cpu.arch == .riscv64) {
         // https://github.com/ziglang/zig/issues/4486
         return error.SkipZigTest;
diff --git a/lib/std/fmt/parse_float.zig b/lib/std/fmt/parse_float.zig
index b3ab3c9f5e..0e9af059d9 100644
--- a/lib/std/fmt/parse_float.zig
+++ b/lib/std/fmt/parse_float.zig
@@ -1,8 +1,8 @@
 pub const parseFloat = @import("parse_float/parse_float.zig").parseFloat;
 pub const ParseFloatError = @import("parse_float/parse_float.zig").ParseFloatError;
 
-const std = @import("std");
 const builtin = @import("builtin");
+const std = @import("std");
 const math = std.math;
 const testing = std.testing;
 const expect = testing.expect;
@@ -14,8 +14,6 @@ const epsilon = 1e-7;
 // See https://github.com/tiehuis/parse-number-fxx-test-data for a wider-selection of test-data.
 
 test "fmt.parseFloat" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     inline for ([_]type{ f16, f32, f64, f128 }) |T| {
         try testing.expectError(error.InvalidCharacter, parseFloat(T, ""));
         try testing.expectError(error.InvalidCharacter, parseFloat(T, "   1"));
@@ -72,8 +70,6 @@ test "fmt.parseFloat" {
 }
 
 test "fmt.parseFloat nan and inf" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     inline for ([_]type{ f16, f32, f64, f128 }) |T| {
         const Z = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);
 
@@ -84,22 +80,16 @@ test "fmt.parseFloat nan and inf" {
 }
 
 test "fmt.parseFloat #11169" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try expectEqual(try parseFloat(f128, "9007199254740993.0"), 9007199254740993.0);
 }
 
 test "fmt.parseFloat hex.special" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testing.expect(math.isNan(try parseFloat(f32, "nAn")));
     try testing.expect(math.isPositiveInf(try parseFloat(f32, "iNf")));
     try testing.expect(math.isPositiveInf(try parseFloat(f32, "+Inf")));
     try testing.expect(math.isNegativeInf(try parseFloat(f32, "-iNf")));
 }
 test "fmt.parseFloat hex.zero" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testing.expectEqual(@as(f32, 0.0), try parseFloat(f32, "0x0"));
     try testing.expectEqual(@as(f32, 0.0), try parseFloat(f32, "-0x0"));
     try testing.expectEqual(@as(f32, 0.0), try parseFloat(f32, "0x0p42"));
@@ -108,8 +98,6 @@ test "fmt.parseFloat hex.zero" {
 }
 
 test "fmt.parseFloat hex.f16" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testing.expectEqual(try parseFloat(f16, "0x1p0"), 1.0);
     try testing.expectEqual(try parseFloat(f16, "-0x1p-1"), -0.5);
     try testing.expectEqual(try parseFloat(f16, "0x10p+10"), 16384.0);
@@ -126,8 +114,6 @@ test "fmt.parseFloat hex.f16" {
 }
 
 test "fmt.parseFloat hex.f32" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testing.expectError(error.InvalidCharacter, parseFloat(f32, "0x"));
     try testing.expectEqual(try parseFloat(f32, "0x1p0"), 1.0);
     try testing.expectEqual(try parseFloat(f32, "-0x1p-1"), -0.5);
@@ -162,8 +148,6 @@ test "fmt.parseFloat hex.f64" {
     try testing.expectEqual(try parseFloat(f64, "-0x1p-1074"), -math.floatTrueMin(f64));
 }
 test "fmt.parseFloat hex.f128" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testing.expectEqual(try parseFloat(f128, "0x1p0"), 1.0);
     try testing.expectEqual(try parseFloat(f128, "-0x1p-1"), -0.5);
     try testing.expectEqual(try parseFloat(f128, "0x10p+10"), 16384.0);
diff --git a/lib/std/fs.zig b/lib/std/fs.zig
index cf58251c5a..6cda6716b7 100644
--- a/lib/std/fs.zig
+++ b/lib/std/fs.zig
@@ -3244,15 +3244,13 @@ fn copy_file(fd_in: os.fd_t, fd_out: os.fd_t, maybe_size: ?u64) CopyFileRawError
 }
 
 test {
-    if (builtin.zig_backend != .stage2_x86_64) {
-        if (builtin.os.tag != .wasi) {
-            _ = &makeDirAbsolute;
-            _ = &makeDirAbsoluteZ;
-            _ = &copyFileAbsolute;
-            _ = &updateFileAbsolute;
-        }
-        _ = &Dir.copyFile;
+    if (builtin.os.tag != .wasi) {
+        _ = &makeDirAbsolute;
+        _ = &makeDirAbsoluteZ;
+        _ = &copyFileAbsolute;
+        _ = &updateFileAbsolute;
     }
+    _ = &Dir.copyFile;
     _ = @import("fs/test.zig");
     _ = @import("fs/path.zig");
     _ = @import("fs/file.zig");
diff --git a/lib/std/fs/test.zig b/lib/std/fs/test.zig
index 2e18c50654..9a11c7cb29 100644
--- a/lib/std/fs/test.zig
+++ b/lib/std/fs/test.zig
@@ -124,8 +124,6 @@ fn testWithAllSupportedPathTypes(test_func: anytype) !void {
 }
 
 test "Dir.readLink" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             // Create some targets
@@ -163,8 +161,6 @@ fn testReadLink(dir: Dir, target_path: []const u8, symlink_path: []const u8) !vo
 }
 
 test "relative symlink to parent directory" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -182,8 +178,6 @@ test "relative symlink to parent directory" {
 }
 
 test "openDir" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             const allocator = ctx.arena.allocator();
@@ -202,8 +196,6 @@ test "openDir" {
 test "accessAbsolute" {
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -222,8 +214,6 @@ test "accessAbsolute" {
 test "openDirAbsolute" {
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -262,8 +252,6 @@ test "openDir non-cwd parent .." {
         else => {},
     }
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -285,8 +273,6 @@ test "openDir non-cwd parent .." {
 test "readLinkAbsolute" {
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -337,8 +323,6 @@ fn testReadLinkAbsolute(target_path: []const u8, symlink_path: []const u8) !void
 }
 
 test "Dir.Iterator" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp_dir = tmpIterableDir(.{});
     defer tmp_dir.cleanup();
 
@@ -369,8 +353,6 @@ test "Dir.Iterator" {
 }
 
 test "Dir.Iterator many entries" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp_dir = tmpIterableDir(.{});
     defer tmp_dir.cleanup();
 
@@ -406,8 +388,6 @@ test "Dir.Iterator many entries" {
 }
 
 test "Dir.Iterator twice" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp_dir = tmpIterableDir(.{});
     defer tmp_dir.cleanup();
 
@@ -441,8 +421,6 @@ test "Dir.Iterator twice" {
 }
 
 test "Dir.Iterator reset" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp_dir = tmpIterableDir(.{});
     defer tmp_dir.cleanup();
 
@@ -479,8 +457,6 @@ test "Dir.Iterator reset" {
 }
 
 test "Dir.Iterator but dir is deleted during iteration" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = std.testing.tmpDir(.{});
     defer tmp.cleanup();
 
@@ -523,8 +499,6 @@ fn contains(entries: *const std.ArrayList(IterableDir.Entry), el: IterableDir.En
 test "Dir.realpath smoke test" {
     if (!comptime std.os.isGetFdPathSupportedOnTarget(builtin.os)) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             const allocator = ctx.arena.allocator();
@@ -575,8 +549,6 @@ test "Dir.realpath smoke test" {
 }
 
 test "readAllAlloc" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp_dir = tmpDir(.{});
     defer tmp_dir.cleanup();
 
@@ -613,8 +585,6 @@ test "Dir.statFile" {
     // TODO: Re-enable once https://github.com/ziglang/zig/issues/17034 is solved
     if (builtin.os.tag == .linux and builtin.link_libc and builtin.abi == .gnu) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             const test_file_name = try ctx.transformPath("test_file");
@@ -630,8 +600,6 @@ test "Dir.statFile" {
 }
 
 test "directory operations on files" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             const test_file_name = try ctx.transformPath("test_file");
@@ -661,8 +629,6 @@ test "file operations on directories" {
     // TODO: fix this test on FreeBSD. https://github.com/ziglang/zig/issues/1759
     if (builtin.os.tag == .freebsd) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             const test_dir_name = try ctx.transformPath("test_dir");
@@ -710,8 +676,6 @@ test "makeOpenPath parent dirs do not exist" {
 }
 
 test "deleteDir" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             const test_dir_path = try ctx.transformPath("test_dir");
@@ -733,8 +697,6 @@ test "deleteDir" {
 }
 
 test "Dir.rename files" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             // Rename on Windows can hit intermittent AccessDenied errors
@@ -777,8 +739,6 @@ test "Dir.rename files" {
 }
 
 test "Dir.rename directories" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             // Rename on Windows can hit intermittent AccessDenied errors
@@ -820,8 +780,6 @@ test "Dir.rename directory onto empty dir" {
     // TODO: Fix on Windows, see https://github.com/ziglang/zig/issues/6364
     if (builtin.os.tag == .windows) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             const test_dir_path = try ctx.transformPath("test_dir");
@@ -843,8 +801,6 @@ test "Dir.rename directory onto non-empty dir" {
     // TODO: Fix on Windows, see https://github.com/ziglang/zig/issues/6364
     if (builtin.os.tag == .windows) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             const test_dir_path = try ctx.transformPath("test_dir");
@@ -871,8 +827,6 @@ test "Dir.rename file <-> dir" {
     // TODO: Fix on Windows, see https://github.com/ziglang/zig/issues/6364
     if (builtin.os.tag == .windows) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             const test_file_path = try ctx.transformPath("test_file");
@@ -888,8 +842,6 @@ test "Dir.rename file <-> dir" {
 }
 
 test "rename" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp_dir1 = tmpDir(.{});
     defer tmp_dir1.cleanup();
 
@@ -912,8 +864,6 @@ test "rename" {
 test "renameAbsolute" {
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp_dir = tmpDir(.{});
     defer tmp_dir.cleanup();
 
@@ -972,8 +922,6 @@ test "openSelfExe" {
 }
 
 test "makePath, put some files in it, deleteTree" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             const allocator = ctx.arena.allocator();
@@ -990,8 +938,6 @@ test "makePath, put some files in it, deleteTree" {
 }
 
 test "makePath, put some files in it, deleteTreeMinStackSize" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             const allocator = ctx.arena.allocator();
@@ -1010,8 +956,6 @@ test "makePath, put some files in it, deleteTreeMinStackSize" {
 test "makePath in a directory that no longer exists" {
     if (builtin.os.tag == .windows) return error.SkipZigTest; // Windows returns FileBusy if attempting to remove an open dir
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
     try tmp.parent_dir.deleteTree(&tmp.sub_path);
@@ -1043,8 +987,6 @@ fn testFilenameLimits(iterable_dir: IterableDir, maxed_filename: []const u8) !vo
 }
 
 test "max file name component lengths" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpIterableDir(.{});
     defer tmp.cleanup();
 
@@ -1066,8 +1008,6 @@ test "max file name component lengths" {
 }
 
 test "writev, readv" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1110,8 +1050,6 @@ test "writev, readv" {
 }
 
 test "pwritev, preadv" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1153,8 +1091,6 @@ test "pwritev, preadv" {
 }
 
 test "access file" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             const dir_path = try ctx.transformPath("os_test_tmp");
@@ -1171,8 +1107,6 @@ test "access file" {
 }
 
 test "sendfile" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1238,8 +1172,6 @@ test "sendfile" {
 }
 
 test "copyRangeAll" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1266,8 +1198,6 @@ test "copyRangeAll" {
 }
 
 test "copyFile" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             const data = "u6wj+JmdF3qHsFPE BUlH2g4gJCmEz0PP";
@@ -1298,8 +1228,6 @@ fn expectFileContents(dir: Dir, file_path: []const u8, data: []const u8) !void {
 }
 
 test "AtomicFile" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             const allocator = ctx.arena.allocator();
@@ -1326,8 +1254,6 @@ test "AtomicFile" {
 test "open file with exclusive nonblocking lock twice" {
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             const filename = try ctx.transformPath("file_nonblocking_lock_test.txt");
@@ -1344,8 +1270,6 @@ test "open file with exclusive nonblocking lock twice" {
 test "open file with shared and exclusive nonblocking lock" {
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             const filename = try ctx.transformPath("file_nonblocking_lock_test.txt");
@@ -1362,8 +1286,6 @@ test "open file with shared and exclusive nonblocking lock" {
 test "open file with exclusive and shared nonblocking lock" {
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testWithAllSupportedPathTypes(struct {
         fn impl(ctx: *TestContext) !void {
             const filename = try ctx.transformPath("file_nonblocking_lock_test.txt");
@@ -1378,8 +1300,6 @@ test "open file with exclusive and shared nonblocking lock" {
 }
 
 test "open file with exclusive lock twice, make sure second lock waits" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     if (builtin.single_threaded) return error.SkipZigTest;
 
     if (std.io.is_async) {
@@ -1430,8 +1350,6 @@ test "open file with exclusive lock twice, make sure second lock waits" {
 test "open file with exclusive nonblocking lock twice (absolute paths)" {
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var random_bytes: [12]u8 = undefined;
     std.crypto.random.bytes(&random_bytes);
 
@@ -1466,8 +1384,6 @@ test "open file with exclusive nonblocking lock twice (absolute paths)" {
 test "walker" {
     if (builtin.os.tag == .wasi and builtin.link_libc) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpIterableDir(.{});
     defer tmp.cleanup();
 
@@ -1521,8 +1437,6 @@ test "walker" {
 test "walker without fully iterating" {
     if (builtin.os.tag == .wasi and builtin.link_libc) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpIterableDir(.{});
     defer tmp.cleanup();
 
@@ -1546,8 +1460,6 @@ test "walker without fully iterating" {
 test ". and .. in fs.Dir functions" {
     if (builtin.os.tag == .wasi and builtin.link_libc) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     if (builtin.os.tag == .windows and builtin.cpu.arch == .aarch64) {
         // https://github.com/ziglang/zig/issues/17134
         return error.SkipZigTest;
@@ -1588,8 +1500,6 @@ test ". and .. in fs.Dir functions" {
 test ". and .. in absolute functions" {
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1635,8 +1545,6 @@ test "chmod" {
     if (builtin.os.tag == .windows or builtin.os.tag == .wasi)
         return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1659,8 +1567,6 @@ test "chown" {
     if (builtin.os.tag == .windows or builtin.os.tag == .wasi)
         return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1676,8 +1582,6 @@ test "chown" {
 }
 
 test "File.Metadata" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1696,8 +1600,6 @@ test "File.Permissions" {
     if (builtin.os.tag == .wasi)
         return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1724,8 +1626,6 @@ test "File.PermissionsUnix" {
     if (builtin.os.tag == .windows or builtin.os.tag == .wasi)
         return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1761,8 +1661,6 @@ test "delete a read-only file on windows" {
     if (builtin.os.tag != .windows)
         return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = testing.tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1793,8 +1691,6 @@ test "delete a read-only file on windows" {
 test "delete a setAsCwd directory on Windows" {
     if (builtin.os.tag != .windows) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     // Set tmp dir as current working directory.
     try tmp.dir.setAsCwd();
diff --git a/lib/std/hash/auto_hash.zig b/lib/std/hash/auto_hash.zig
index c9741c00a2..c5c6c585eb 100644
--- a/lib/std/hash/auto_hash.zig
+++ b/lib/std/hash/auto_hash.zig
@@ -1,6 +1,5 @@
 const std = @import("std");
 const assert = std.debug.assert;
-const builtin = @import("builtin");
 const mem = std.mem;
 const meta = std.meta;
 
@@ -253,8 +252,6 @@ test "typeContainsSlice" {
 }
 
 test "hash pointer" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const array = [_]u32{ 123, 123, 123 };
     const a = &array[0];
     const b = &array[1];
@@ -275,8 +272,6 @@ test "hash pointer" {
 }
 
 test "hash slice shallow" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // Allocate one array dynamically so that we're assured it is not merged
     // with the other by the optimization passes.
     const array1 = try std.testing.allocator.create([6]u32);
@@ -295,8 +290,6 @@ test "hash slice shallow" {
 }
 
 test "hash slice deep" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // Allocate one array dynamically so that we're assured it is not merged
     // with the other by the optimization passes.
     const array1 = try std.testing.allocator.create([6]u32);
@@ -313,8 +306,6 @@ test "hash slice deep" {
 }
 
 test "hash struct deep" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Foo = struct {
         a: u32,
         b: u16,
@@ -354,8 +345,6 @@ test "hash struct deep" {
 }
 
 test "testHash optional" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const a: ?u32 = 123;
     const b: ?u32 = null;
     try testing.expectEqual(testHash(a), testHash(@as(u32, 123)));
@@ -364,8 +353,6 @@ test "testHash optional" {
 }
 
 test "testHash array" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const a = [_]u32{ 1, 2, 3 };
     const h = testHash(a);
     var hasher = Wyhash.init(0);
@@ -382,8 +369,6 @@ test "testHash multi-dimensional array" {
 }
 
 test "testHash struct" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Foo = struct {
         a: u32 = 1,
         b: u32 = 2,
@@ -399,8 +384,6 @@ test "testHash struct" {
 }
 
 test "testHash union" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Foo = union(enum) {
         A: u32,
         B: bool,
@@ -425,8 +408,6 @@ test "testHash union" {
 }
 
 test "testHash vector" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const a: @Vector(4, u32) = [_]u32{ 1, 2, 3, 4 };
     const b: @Vector(4, u32) = [_]u32{ 1, 2, 3, 5 };
     try testing.expect(testHash(a) == testHash(a));
@@ -439,8 +420,6 @@ test "testHash vector" {
 }
 
 test "testHash error union" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Errors = error{Test};
     const Foo = struct {
         a: u32 = 1,
diff --git a/lib/std/hash/wyhash.zig b/lib/std/hash/wyhash.zig
index 9ddb50678a..91cdf5007f 100644
--- a/lib/std/hash/wyhash.zig
+++ b/lib/std/hash/wyhash.zig
@@ -242,8 +242,6 @@ test "smhasher" {
 }
 
 test "iterative api" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Test = struct {
         fn do() !void {
             try verify.iterativeApi(Wyhash);
diff --git a/lib/std/hash/xxhash.zig b/lib/std/hash/xxhash.zig
index 7454abd711..0c493c3ce8 100644
--- a/lib/std/hash/xxhash.zig
+++ b/lib/std/hash/xxhash.zig
@@ -803,8 +803,6 @@ fn testExpect(comptime H: type, seed: anytype, input: []const u8, expected: u64)
 }
 
 test "xxhash3" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const H = XxHash3;
     // Non-Seeded Tests
     try testExpect(H, 0, "", 0x2d06800538d394c2);
@@ -836,8 +834,6 @@ test "xxhash3" {
 }
 
 test "xxhash3 smhasher" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Test = struct {
         fn do() !void {
             try expectEqual(verify.smhasher(XxHash3.hash), 0x9a636405);
@@ -849,8 +845,6 @@ test "xxhash3 smhasher" {
 }
 
 test "xxhash3 iterative api" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Test = struct {
         fn do() !void {
             try verify.iterativeApi(XxHash3);
@@ -862,8 +856,6 @@ test "xxhash3 iterative api" {
 }
 
 test "xxhash64" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const H = XxHash64;
     try testExpect(H, 0, "", 0xef46db3751d8e999);
     try testExpect(H, 0, "a", 0xd24ec4f1a98c6e5b);
@@ -875,8 +867,6 @@ test "xxhash64" {
 }
 
 test "xxhash64 smhasher" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Test = struct {
         fn do() !void {
             try expectEqual(verify.smhasher(XxHash64.hash), 0x024B7CF4);
@@ -888,8 +878,6 @@ test "xxhash64 smhasher" {
 }
 
 test "xxhash64 iterative api" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Test = struct {
         fn do() !void {
             try verify.iterativeApi(XxHash64);
@@ -901,8 +889,6 @@ test "xxhash64 iterative api" {
 }
 
 test "xxhash32" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const H = XxHash32;
 
     try testExpect(H, 0, "", 0x02cc5d05);
@@ -915,8 +901,6 @@ test "xxhash32" {
 }
 
 test "xxhash32 smhasher" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Test = struct {
         fn do() !void {
             try expectEqual(verify.smhasher(XxHash32.hash), 0xBA88B743);
@@ -928,8 +912,6 @@ test "xxhash32 smhasher" {
 }
 
 test "xxhash32 iterative api" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Test = struct {
         fn do() !void {
             try verify.iterativeApi(XxHash32);
diff --git a/lib/std/hash_map.zig b/lib/std/hash_map.zig
index b2fe591a02..40a412bf3c 100644
--- a/lib/std/hash_map.zig
+++ b/lib/std/hash_map.zig
@@ -1873,8 +1873,6 @@ test "std.hash_map multiple removes on same metadata" {
 }
 
 test "std.hash_map put and remove loop in random order" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var map = AutoHashMap(u32, u32).init(std.testing.allocator);
     defer map.deinit();
 
diff --git a/lib/std/heap/general_purpose_allocator.zig b/lib/std/heap/general_purpose_allocator.zig
index 235c16ed96..6dc6df3998 100644
--- a/lib/std/heap/general_purpose_allocator.zig
+++ b/lib/std/heap/general_purpose_allocator.zig
@@ -1042,8 +1042,6 @@ const TraceKind = enum {
 const test_config = Config{};
 
 test "small allocations - free in same order" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var gpa = GeneralPurposeAllocator(test_config){};
     defer std.testing.expect(gpa.deinit() == .ok) catch @panic("leak");
     const allocator = gpa.allocator();
@@ -1063,8 +1061,6 @@ test "small allocations - free in same order" {
 }
 
 test "small allocations - free in reverse order" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var gpa = GeneralPurposeAllocator(test_config){};
     defer std.testing.expect(gpa.deinit() == .ok) catch @panic("leak");
     const allocator = gpa.allocator();
diff --git a/lib/std/http/Client.zig b/lib/std/http/Client.zig
index 1e244af15e..9e475df51b 100644
--- a/lib/std/http/Client.zig
+++ b/lib/std/http/Client.zig
@@ -1,7 +1,6 @@
 //! Connecting and opening requests are threadsafe. Individual requests are not.
 
 const std = @import("../std.zig");
-const builtin = @import("builtin");
 const testing = std.testing;
 const http = std.http;
 const mem = std.mem;
@@ -428,8 +427,6 @@ pub const Response = struct {
     }
 
     test parseInt3 {
-        if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
         const expectEqual = testing.expectEqual;
         try expectEqual(@as(u10, 0), parseInt3("000".*));
         try expectEqual(@as(u10, 418), parseInt3("418".*));
@@ -588,7 +585,7 @@ pub const Request = struct {
 
         if (!req.headers.contains("user-agent")) {
             try w.writeAll("User-Agent: zig/");
-            try w.writeAll(builtin.zig_version_string);
+            try w.writeAll(@import("builtin").zig_version_string);
             try w.writeAll(" (std.http)\r\n");
         }
 
@@ -1252,6 +1249,7 @@ pub fn fetch(client: *Client, allocator: Allocator, options: FetchOptions) !Fetc
 }
 
 test {
+    const builtin = @import("builtin");
     const native_endian = comptime builtin.cpu.arch.endian();
     if (builtin.zig_backend == .stage2_llvm and native_endian == .Big) {
         // https://github.com/ziglang/zig/issues/13782
@@ -1260,7 +1258,5 @@ test {
 
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     std.testing.refAllDecls(@This());
 }
diff --git a/lib/std/http/Server.zig b/lib/std/http/Server.zig
index 56d14fe7fc..a0c4774e06 100644
--- a/lib/std/http/Server.zig
+++ b/lib/std/http/Server.zig
@@ -725,8 +725,6 @@ test "HTTP server handles a chunked transfer coding request" {
         return error.SkipZigTest;
     }
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const native_endian = comptime builtin.cpu.arch.endian();
     if (builtin.zig_backend == .stage2_llvm and native_endian == .Big) {
         // https://github.com/ziglang/zig/issues/13782
diff --git a/lib/std/io/bit_reader.zig b/lib/std/io/bit_reader.zig
index 7b6842561d..7ea2ff5009 100644
--- a/lib/std/io/bit_reader.zig
+++ b/lib/std/io/bit_reader.zig
@@ -164,8 +164,6 @@ pub fn bitReader(
 }
 
 test "api coverage" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const mem_be = [_]u8{ 0b11001101, 0b00001011 };
     const mem_le = [_]u8{ 0b00011101, 0b10010101 };
 
diff --git a/lib/std/io/multi_writer.zig b/lib/std/io/multi_writer.zig
index 57d58d6713..9cd4600e63 100644
--- a/lib/std/io/multi_writer.zig
+++ b/lib/std/io/multi_writer.zig
@@ -36,7 +36,6 @@ pub fn multiWriter(streams: anytype) MultiWriter(@TypeOf(streams)) {
 const testing = std.testing;
 
 test "MultiWriter" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
     var tmp = testing.tmpDir(.{});
     defer tmp.cleanup();
     var f = try tmp.dir.createFile("t.txt", .{});
diff --git a/lib/std/io/test.zig b/lib/std/io/test.zig
index b51d8e8ede..dfff7b5896 100644
--- a/lib/std/io/test.zig
+++ b/lib/std/io/test.zig
@@ -15,8 +15,6 @@ const native_endian = builtin.target.cpu.arch.endian();
 const tmpDir = std.testing.tmpDir;
 
 test "write a file, read it, then delete it" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -63,8 +61,6 @@ test "write a file, read it, then delete it" {
 }
 
 test "BitStreams with File Stream" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -110,8 +106,6 @@ test "BitStreams with File Stream" {
 }
 
 test "File seek ops" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -139,8 +133,6 @@ test "File seek ops" {
 }
 
 test "setEndPos" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -167,8 +159,6 @@ test "setEndPos" {
 }
 
 test "updateTimes" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
diff --git a/lib/std/json.zig b/lib/std/json.zig
index 2073be5250..aa75d892da 100644
--- a/lib/std/json.zig
+++ b/lib/std/json.zig
@@ -9,7 +9,6 @@
 //! The low-level `writeStream` emits syntax-conformant JSON tokens to a `std.io.Writer`.
 //! The high-level `stringify` serializes a Zig or `Value` type into JSON.
 
-const builtin = @import("builtin");
 const testing = @import("std").testing;
 const ArrayList = @import("std").ArrayList;
 
@@ -24,8 +23,6 @@ test Scanner {
 }
 
 test parseFromSlice {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var parsed_str = try parseFromSlice([]const u8, testing.allocator, "\"a\\u0020b\"", .{});
     defer parsed_str.deinit();
     try testing.expectEqualSlices(u8, "a b", parsed_str.value);
@@ -38,16 +35,12 @@ test parseFromSlice {
 }
 
 test Value {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var parsed = try parseFromSlice(Value, testing.allocator, "{\"anything\": \"goes\"}", .{});
     defer parsed.deinit();
     try testing.expectEqualSlices(u8, "goes", parsed.value.object.get("anything").?.string);
 }
 
 test writeStream {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var out = ArrayList(u8).init(testing.allocator);
     defer out.deinit();
     var write_stream = writeStream(out.writer(), .{ .whitespace = .indent_2 });
@@ -65,8 +58,6 @@ test writeStream {
 }
 
 test stringify {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var out = ArrayList(u8).init(testing.allocator);
     defer out.deinit();
 
diff --git a/lib/std/json/JSONTestSuite_test.zig b/lib/std/json/JSONTestSuite_test.zig
index 97a00074d4..30c5907f8b 100644
--- a/lib/std/json/JSONTestSuite_test.zig
+++ b/lib/std/json/JSONTestSuite_test.zig
@@ -104,8 +104,6 @@ test "i_string_utf16LE_no_BOM.json" {
     try any("[\x00\"\x00\xe9\x00\"\x00]\x00");
 }
 test "i_structure_500_nested_arrays.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try any("[" ** 500 ++ "]" ** 500);
 }
 test "i_structure_UTF-8_BOM_empty_object.json" {
@@ -361,21 +359,15 @@ test "n_object_bracket_key.json" {
     try err("{[: \"x\"}\n");
 }
 test "n_object_comma_instead_of_colon.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"x\", null}");
 }
 test "n_object_double_colon.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"x\"::\"b\"}");
 }
 test "n_object_emoji.json" {
     try err("{\xf0\x9f\x87\xa8\xf0\x9f\x87\xad}");
 }
 test "n_object_garbage_at_end.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"a\":\"a\" 123}");
 }
 test "n_object_key_with_single_quotes.json" {
@@ -385,26 +377,18 @@ test "n_object_lone_continuation_byte_in_key_and_trailing_comma.json" {
     try err("{\"\xb9\":\"0\",}");
 }
 test "n_object_missing_colon.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"a\" b}");
 }
 test "n_object_missing_key.json" {
     try err("{:\"b\"}");
 }
 test "n_object_missing_semicolon.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"a\" \"b\"}");
 }
 test "n_object_missing_value.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"a\":");
 }
 test "n_object_no-colon.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"a\"");
 }
 test "n_object_non_string_key.json" {
@@ -417,59 +401,39 @@ test "n_object_repeated_null_null.json" {
     try err("{null:null,null:null}");
 }
 test "n_object_several_trailing_commas.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"id\":0,,,,,}");
 }
 test "n_object_single_quote.json" {
     try err("{'a':0}");
 }
 test "n_object_trailing_comma.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"id\":0,}");
 }
 test "n_object_trailing_comment.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"a\":\"b\"}/**/");
 }
 test "n_object_trailing_comment_open.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"a\":\"b\"}/**//");
 }
 test "n_object_trailing_comment_slash_open.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"a\":\"b\"}//");
 }
 test "n_object_trailing_comment_slash_open_incomplete.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"a\":\"b\"}/");
 }
 test "n_object_two_commas_in_a_row.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"a\":\"b\",,\"c\":\"d\"}");
 }
 test "n_object_unquoted_key.json" {
     try err("{a: \"b\"}");
 }
 test "n_object_unterminated-value.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"a\":\"a");
 }
 test "n_object_with_single_string.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{ \"foo\" : \"bar\", \"a\" }");
 }
 test "n_object_with_trailing_garbage.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"a\":\"b\"}#");
 }
 test "n_single_space.json" {
@@ -596,8 +560,6 @@ test "n_structure_close_unopened_array.json" {
     try err("1]");
 }
 test "n_structure_comma_instead_of_closing_brace.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"x\": true,");
 }
 test "n_structure_double_array.json" {
@@ -628,18 +590,12 @@ test "n_structure_object_followed_by_closing_object.json" {
     try err("{}}");
 }
 test "n_structure_object_unclosed_no_value.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"\":");
 }
 test "n_structure_object_with_comment.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"a\":/*comment*/\"b\"}");
 }
 test "n_structure_object_with_trailing_garbage.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"a\": true} \"x\"");
 }
 test "n_structure_open_array_apostrophe.json" {
@@ -649,8 +605,6 @@ test "n_structure_open_array_comma.json" {
     try err("[,");
 }
 test "n_structure_open_array_object.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("[{\"\":" ** 50000 ++ "\n");
 }
 test "n_structure_open_array_open_object.json" {
@@ -690,8 +644,6 @@ test "n_structure_single_star.json" {
     try err("*");
 }
 test "n_structure_trailing_#.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"a\":\"b\"}#{}");
 }
 test "n_structure_uescaped_LF_before_string.json" {
@@ -710,8 +662,6 @@ test "n_structure_unclosed_array_unfinished_true.json" {
     try err("[ false, tru");
 }
 test "n_structure_unclosed_object.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err("{\"asd\":\"asd\"");
 }
 test "n_structure_unicode-identifier.json" {
@@ -814,61 +764,39 @@ test "y_number_simple_real.json" {
     try ok("[123.456789]");
 }
 test "y_object.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try ok("{\"asd\":\"sdf\", \"dfg\":\"fgh\"}");
 }
 test "y_object_basic.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try ok("{\"asd\":\"sdf\"}");
 }
 test "y_object_duplicated_key.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try ok("{\"a\":\"b\",\"a\":\"c\"}");
 }
 test "y_object_duplicated_key_and_value.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try ok("{\"a\":\"b\",\"a\":\"b\"}");
 }
 test "y_object_empty.json" {
     try ok("{}");
 }
 test "y_object_empty_key.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try ok("{\"\":0}");
 }
 test "y_object_escaped_null_in_key.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try ok("{\"foo\\u0000bar\": 42}");
 }
 test "y_object_extreme_numbers.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try ok("{ \"min\": -1.0e+28, \"max\": 1.0e+28 }");
 }
 test "y_object_long_strings.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try ok("{\"x\":[{\"id\": \"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"}], \"id\": \"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"}");
 }
 test "y_object_simple.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try ok("{\"a\":[]}");
 }
 test "y_object_string_unicode.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try ok("{\"title\":\"\\u041f\\u043e\\u043b\\u0442\\u043e\\u0440\\u0430 \\u0417\\u0435\\u043c\\u043b\\u0435\\u043a\\u043e\\u043f\\u0430\" }");
 }
 test "y_object_with_newlines.json" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try ok("{\n\"a\": \"b\"\n}");
 }
 test "y_string_1_2_3_bytes_UTF-8_sequences.json" {
diff --git a/lib/std/json/dynamic_test.zig b/lib/std/json/dynamic_test.zig
index a3aa833abb..ad737502ed 100644
--- a/lib/std/json/dynamic_test.zig
+++ b/lib/std/json/dynamic_test.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const mem = std.mem;
 const testing = std.testing;
 const ArenaAllocator = std.heap.ArenaAllocator;
@@ -19,8 +18,6 @@ const jsonReader = @import("scanner.zig").reader;
 const JsonReader = @import("scanner.zig").Reader;
 
 test "json.parser.dynamic" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const s =
         \\{
         \\  "Image": {
@@ -75,8 +72,6 @@ test "json.parser.dynamic" {
 
 const writeStream = @import("./stringify.zig").writeStream;
 test "write json then parse it" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var out_buffer: [1000]u8 = undefined;
 
     var fixed_buffer_stream = std.io.fixedBufferStream(&out_buffer);
@@ -125,16 +120,12 @@ fn testParse(allocator: std.mem.Allocator, json_str: []const u8) !Value {
 }
 
 test "parsing empty string gives appropriate error" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
     defer arena_allocator.deinit();
     try testing.expectError(error.UnexpectedEndOfInput, testParse(arena_allocator.allocator(), ""));
 }
 
 test "Value.array allocator should still be usable after parsing" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var parsed = try parseFromSlice(Value, std.testing.allocator, "[]", .{});
     defer parsed.deinit();
 
@@ -147,8 +138,6 @@ test "Value.array allocator should still be usable after parsing" {
 }
 
 test "integer after float has proper type" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
     defer arena_allocator.deinit();
     const parsed = try testParse(arena_allocator.allocator(),
@@ -161,8 +150,6 @@ test "integer after float has proper type" {
 }
 
 test "escaped characters" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
     defer arena_allocator.deinit();
     const input =
@@ -195,8 +182,6 @@ test "escaped characters" {
 }
 
 test "Value.jsonStringify" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var vals = [_]Value{
         .{ .integer = 1 },
         .{ .integer = 2 },
@@ -244,8 +229,6 @@ test "Value.jsonStringify" {
 }
 
 test "parseFromValue(std.json.Value,...)" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const str =
         \\{
         \\  "int": 32,
@@ -263,8 +246,6 @@ test "parseFromValue(std.json.Value,...)" {
 }
 
 test "polymorphic parsing" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     if (true) return error.SkipZigTest; // See https://github.com/ziglang/zig/issues/16108
     const doc =
         \\{ "type": "div",
@@ -310,8 +291,6 @@ test "polymorphic parsing" {
 }
 
 test "long object value" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const value = "01234567890123456789";
     const doc = "{\"key\":\"" ++ value ++ "\"}";
     var fbs = std.io.fixedBufferStream(doc);
@@ -324,8 +303,6 @@ test "long object value" {
 }
 
 test "ParseOptions.max_value_len" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var arena = ArenaAllocator.init(testing.allocator);
     defer arena.deinit();
 
@@ -340,8 +317,6 @@ test "ParseOptions.max_value_len" {
 }
 
 test "many object keys" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const doc =
         \\{
         \\  "k1": "v1",
diff --git a/lib/std/json/hashmap_test.zig b/lib/std/json/hashmap_test.zig
index 1f71d91f7b..49d8caffae 100644
--- a/lib/std/json/hashmap_test.zig
+++ b/lib/std/json/hashmap_test.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const testing = std.testing;
 
 const ArrayHashMap = @import("hashmap.zig").ArrayHashMap;
@@ -19,8 +18,6 @@ const T = struct {
 };
 
 test "parse json hashmap" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const doc =
         \\{
         \\  "abc": {"i": 0, "s": "d"},
@@ -36,8 +33,6 @@ test "parse json hashmap" {
 }
 
 test "parse json hashmap while streaming" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const doc =
         \\{
         \\  "abc": {"i": 0, "s": "d"},
@@ -63,8 +58,6 @@ test "parse json hashmap while streaming" {
 }
 
 test "parse json hashmap duplicate fields" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
     defer arena.deinit();
 
@@ -93,8 +86,6 @@ test "parse json hashmap duplicate fields" {
 }
 
 test "stringify json hashmap" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var value = ArrayHashMap(T){};
     defer value.deinit(testing.allocator);
     {
@@ -132,8 +123,6 @@ test "stringify json hashmap" {
 }
 
 test "stringify json hashmap whitespace" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var value = ArrayHashMap(T){};
     defer value.deinit(testing.allocator);
     try value.map.put(testing.allocator, "abc", .{ .i = 0, .s = "d" });
@@ -158,8 +147,6 @@ test "stringify json hashmap whitespace" {
 }
 
 test "json parse from value hashmap" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const doc =
         \\{
         \\  "abc": {"i": 0, "s": "d"},
diff --git a/lib/std/json/static_test.zig b/lib/std/json/static_test.zig
index c977de88e8..82b0d89044 100644
--- a/lib/std/json/static_test.zig
+++ b/lib/std/json/static_test.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const testing = std.testing;
 const ArenaAllocator = std.heap.ArenaAllocator;
 const Allocator = std.mem.Allocator;
@@ -372,8 +371,6 @@ test "test all types" {
 }
 
 test "parse" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testing.expectEqual(false, try parseFromSliceLeaky(bool, testing.allocator, "false", .{}));
     try testing.expectEqual(true, try parseFromSliceLeaky(bool, testing.allocator, "true", .{}));
     try testing.expectEqual(@as(u1, 1), try parseFromSliceLeaky(u1, testing.allocator, "1", .{}));
@@ -392,8 +389,6 @@ test "parse" {
 }
 
 test "parse into enum" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const T = enum(u32) {
         Foo = 42,
         Bar,
@@ -407,8 +402,6 @@ test "parse into enum" {
 }
 
 test "parse into that allocates a slice" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     {
         // string as string
         const parsed = try parseFromSlice([]u8, testing.allocator, "\"foo\"", .{});
@@ -429,16 +422,12 @@ test "parse into that allocates a slice" {
 }
 
 test "parse into sentinel slice" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const parsed = try parseFromSlice([:0]const u8, testing.allocator, "\"\\n\"", .{});
     defer parsed.deinit();
     try testing.expect(std.mem.eql(u8, parsed.value, "\n"));
 }
 
 test "parse into tagged union" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const T = union(enum) {
         nothing,
         int: i32,
@@ -454,8 +443,6 @@ test "parse into tagged union" {
 }
 
 test "parse into tagged union errors" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const T = union(enum) {
         nothing,
         int: i32,
@@ -478,8 +465,6 @@ test "parse into tagged union errors" {
 }
 
 test "parse into struct with no fields" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const T = struct {};
     const parsed = try parseFromSlice(T, testing.allocator, "{}", .{});
     defer parsed.deinit();
@@ -489,8 +474,6 @@ test "parse into struct with no fields" {
 const test_const_value: usize = 123;
 
 test "parse into struct with default const pointer field" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const T = struct { a: *const usize = &test_const_value };
     const parsed = try parseFromSlice(T, testing.allocator, "{}", .{});
     defer parsed.deinit();
@@ -506,8 +489,6 @@ const test_default_str_slice: [2][]const u8 = [_][]const u8{
 };
 
 test "freeing parsed structs with pointers to default values" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const T = struct {
         int: *const usize = &test_default_usize,
         int_ptr: *allowzero align(1) const usize = test_default_usize_ptr,
@@ -521,15 +502,11 @@ test "freeing parsed structs with pointers to default values" {
 }
 
 test "parse into struct where destination and source lengths mismatch" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const T = struct { a: [2]u8 };
     try testing.expectError(error.LengthMismatch, parseFromSlice(T, testing.allocator, "{\"a\": \"bbb\"}", .{}));
 }
 
 test "parse into struct with misc fields" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const T = struct {
         int: i64,
         float: f64,
@@ -605,8 +582,6 @@ test "parse into struct with misc fields" {
 }
 
 test "parse into struct with strings and arrays with sentinels" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const T = struct {
         language: [:0]const u8,
         language_without_sentinel: []const u8,
@@ -635,8 +610,6 @@ test "parse into struct with strings and arrays with sentinels" {
 }
 
 test "parse into struct with duplicate field" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const options_first = ParseOptions{ .duplicate_field_behavior = .use_first };
     const options_last = ParseOptions{ .duplicate_field_behavior = .use_last };
 
@@ -656,8 +629,6 @@ test "parse into struct with duplicate field" {
 }
 
 test "parse into struct ignoring unknown fields" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const T = struct {
         int: i64,
         language: []const u8,
@@ -696,8 +667,6 @@ test "parse into struct ignoring unknown fields" {
 }
 
 test "parse into tuple" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Union = union(enum) {
         char: u8,
         float: f64,
@@ -753,8 +722,6 @@ const ParseIntoRecursiveUnionDefinitionValue = union(enum) {
 };
 
 test "parse into recursive union definition" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const T = struct {
         values: ParseIntoRecursiveUnionDefinitionValue,
     };
@@ -776,8 +743,6 @@ const ParseIntoDoubleRecursiveUnionValueSecond = union(enum) {
 };
 
 test "parse into double recursive union definition" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const T = struct {
         values: ParseIntoDoubleRecursiveUnionValueFirst,
     };
@@ -789,8 +754,6 @@ test "parse into double recursive union definition" {
 }
 
 test "parse exponential into int" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const T = struct { int: i64 };
     const r = try parseFromSliceLeaky(T, testing.allocator, "{ \"int\": 4.2e2 }", .{});
     try testing.expectEqual(@as(i64, 420), r.int);
@@ -799,8 +762,6 @@ test "parse exponential into int" {
 }
 
 test "parseFromTokenSource" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     {
         var scanner = JsonScanner.initCompleteInput(testing.allocator, "123");
         defer scanner.deinit();
@@ -820,14 +781,10 @@ test "parseFromTokenSource" {
 }
 
 test "max_value_len" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testing.expectError(error.ValueTooLong, parseFromSlice([]u8, testing.allocator, "\"0123456789\"", .{ .max_value_len = 5 }));
 }
 
 test "parse into vector" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const T = struct {
         vec_i32: @Vector(4, i32),
         vec_f32: @Vector(2, f32),
@@ -860,8 +817,6 @@ fn assertKey(
     }
 }
 test "json parse partial" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Inner = struct {
         num: u32,
         yes: bool,
@@ -917,8 +872,6 @@ test "json parse partial" {
 }
 
 test "json parse allocate when streaming" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const T = struct {
         not_const: []u8,
         is_const: []const u8,
@@ -949,8 +902,6 @@ test "json parse allocate when streaming" {
 }
 
 test "parse at comptime" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const doc =
         \\{
         \\    "vals": {
diff --git a/lib/std/json/stringify_test.zig b/lib/std/json/stringify_test.zig
index d2c4104316..9baeae9389 100644
--- a/lib/std/json/stringify_test.zig
+++ b/lib/std/json/stringify_test.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const mem = std.mem;
 const testing = std.testing;
 
@@ -16,8 +15,6 @@ const writeStreamMaxDepth = @import("stringify.zig").writeStreamMaxDepth;
 const writeStreamArbitraryDepth = @import("stringify.zig").writeStreamArbitraryDepth;
 
 test "json write stream" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var out_buf: [1024]u8 = undefined;
     var slice_stream = std.io.fixedBufferStream(&out_buf);
     const out = slice_stream.writer();
@@ -100,8 +97,6 @@ fn getJsonObject(allocator: std.mem.Allocator) !Value {
 }
 
 test "stringify null optional fields" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const MyStruct = struct {
         optional: ?[]const u8 = null,
         required: []const u8 = "something",
@@ -123,8 +118,6 @@ test "stringify null optional fields" {
 }
 
 test "stringify basic types" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testStringify("false", false, .{});
     try testStringify("true", true, .{});
     try testStringify("null", @as(?u8, null), .{});
@@ -141,8 +134,6 @@ test "stringify basic types" {
 }
 
 test "stringify string" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testStringify("\"hello\"", "hello", .{});
     try testStringify("\"with\\nescapes\\r\"", "with\nescapes\r", .{});
     try testStringify("\"with\\nescapes\\r\"", "with\nescapes\r", .{ .escape_unicode = true });
@@ -167,16 +158,12 @@ test "stringify string" {
 }
 
 test "stringify many-item sentinel-terminated string" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testStringify("\"hello\"", @as([*:0]const u8, "hello"), .{});
     try testStringify("\"with\\nescapes\\r\"", @as([*:0]const u8, "with\nescapes\r"), .{ .escape_unicode = true });
     try testStringify("\"with unicode\\u0001\"", @as([*:0]const u8, "with unicode\u{1}"), .{ .escape_unicode = true });
 }
 
 test "stringify enums" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const E = enum {
         foo,
         bar,
@@ -186,15 +173,11 @@ test "stringify enums" {
 }
 
 test "stringify enum literals" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testStringify("\"foo\"", .foo, .{});
     try testStringify("\"bar\"", .bar, .{});
 }
 
 test "stringify tagged unions" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const T = union(enum) {
         nothing,
         foo: u32,
@@ -206,16 +189,12 @@ test "stringify tagged unions" {
 }
 
 test "stringify struct" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testStringify("{\"foo\":42}", struct {
         foo: u32,
     }{ .foo = 42 }, .{});
 }
 
 test "emit_strings_as_arrays" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // Should only affect string values, not object keys.
     try testStringify("{\"foo\":\"bar\"}", .{ .foo = "bar" }, .{});
     try testStringify("{\"foo\":[98,97,114]}", .{ .foo = "bar" }, .{ .emit_strings_as_arrays = true });
@@ -230,8 +209,6 @@ test "emit_strings_as_arrays" {
 }
 
 test "stringify struct with indentation" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testStringify(
         \\{
         \\    "foo": 42,
@@ -277,8 +254,6 @@ test "stringify struct with indentation" {
 }
 
 test "stringify struct with void field" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testStringify("{\"foo\":42}", struct {
         foo: u32,
         bar: void = {},
@@ -286,8 +261,6 @@ test "stringify struct with void field" {
 }
 
 test "stringify array of structs" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const MyStruct = struct {
         foo: u32,
     };
@@ -299,8 +272,6 @@ test "stringify array of structs" {
 }
 
 test "stringify struct with custom stringifier" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testStringify("[\"something special\",42]", struct {
         foo: u32,
         const Self = @This();
@@ -315,16 +286,12 @@ test "stringify struct with custom stringifier" {
 }
 
 test "stringify vector" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testStringify("[1,1]", @as(@Vector(2, u32), @splat(1)), .{});
     try testStringify("\"AA\"", @as(@Vector(2, u8), @splat('A')), .{});
     try testStringify("[65,65]", @as(@Vector(2, u8), @splat('A')), .{ .emit_strings_as_arrays = true });
 }
 
 test "stringify tuple" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testStringify("[\"foo\",42]", std.meta.Tuple(&.{ []const u8, usize }){ "foo", 42 }, .{});
 }
 
@@ -411,8 +378,6 @@ fn testStringifyArbitraryDepth(expected: []const u8, value: anytype, options: St
 }
 
 test "stringify alloc" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const allocator = std.testing.allocator;
     const expected =
         \\{"foo":"bar","answer":42,"my_friend":"sammy"}
@@ -424,8 +389,6 @@ test "stringify alloc" {
 }
 
 test "comptime stringify" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     comptime testStringifyMaxDepth("false", false, .{}, null) catch unreachable;
     comptime testStringifyMaxDepth("false", false, .{}, 0) catch unreachable;
     comptime testStringifyArbitraryDepth("false", false, .{}) catch unreachable;
@@ -446,8 +409,6 @@ test "comptime stringify" {
 }
 
 test "print" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var out_buf: [1024]u8 = undefined;
     var slice_stream = std.io.fixedBufferStream(&out_buf);
     const out = slice_stream.writer();
@@ -479,8 +440,6 @@ test "print" {
 }
 
 test "nonportable numbers" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testStringify("9999999999999999", 9999999999999999, .{});
     try testStringify("\"9999999999999999\"", 9999999999999999, .{ .emit_nonportable_numbers_as_strings = true });
 }
diff --git a/lib/std/json/test.zig b/lib/std/json/test.zig
index 453a324b20..9530ab37a6 100644
--- a/lib/std/json/test.zig
+++ b/lib/std/json/test.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const testing = std.testing;
 const parseFromSlice = @import("./static.zig").parseFromSlice;
 const validate = @import("./scanner.zig").validate;
@@ -35,15 +34,11 @@ fn testHighLevelDynamicParser(s: []const u8) !void {
 
 // Additional tests not part of test JSONTestSuite.
 test "y_trailing_comma_after_empty" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try roundTrip(
         \\{"1":[],"2":{},"3":"4"}
     );
 }
 test "n_object_closed_missing_value" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try err(
         \\{"a":}
     );
diff --git a/lib/std/leb128.zig b/lib/std/leb128.zig
index 7cfbec0b97..f6e9b9ea60 100644
--- a/lib/std/leb128.zig
+++ b/lib/std/leb128.zig
@@ -215,8 +215,6 @@ fn test_read_uleb128_seq(comptime T: type, comptime N: usize, encoded: []const u
 }
 
 test "deserialize signed LEB128" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // Truncated
     try testing.expectError(error.EndOfStream, test_read_stream_ileb128(i64, "\x80"));
 
@@ -363,8 +361,6 @@ test "serialize unsigned LEB128" {
 }
 
 test "serialize signed LEB128" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // explicitly test i0 because starting `t` at 0
     // will break the while loop
     try test_write_leb128(@as(i0, 0));
diff --git a/lib/std/math.zig b/lib/std/math.zig
index 57376f4d61..817a98f314 100644
--- a/lib/std/math.zig
+++ b/lib/std/math.zig
@@ -492,13 +492,10 @@ pub fn shl(comptime T: type, a: T, shift_amt: anytype) T {
 }
 
 test "shl" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
         // https://github.com/ziglang/zig/issues/12012
         return error.SkipZigTest;
     }
-
     try testing.expect(shl(u8, 0b11111111, @as(usize, 3)) == 0b11111000);
     try testing.expect(shl(u8, 0b11111111, @as(usize, 8)) == 0);
     try testing.expect(shl(u8, 0b11111111, @as(usize, 9)) == 0);
@@ -539,13 +536,10 @@ pub fn shr(comptime T: type, a: T, shift_amt: anytype) T {
 }
 
 test "shr" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
         // https://github.com/ziglang/zig/issues/12012
         return error.SkipZigTest;
     }
-
     try testing.expect(shr(u8, 0b11111111, @as(usize, 3)) == 0b00011111);
     try testing.expect(shr(u8, 0b11111111, @as(usize, 8)) == 0);
     try testing.expect(shr(u8, 0b11111111, @as(usize, 9)) == 0);
@@ -587,13 +581,10 @@ pub fn rotr(comptime T: type, x: T, r: anytype) T {
 }
 
 test "rotr" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
         // https://github.com/ziglang/zig/issues/12012
         return error.SkipZigTest;
     }
-
     try testing.expect(rotr(u0, 0b0, @as(usize, 3)) == 0b0);
     try testing.expect(rotr(u5, 0b00001, @as(usize, 0)) == 0b00001);
     try testing.expect(rotr(u6, 0b000001, @as(usize, 7)) == 0b100000);
@@ -634,13 +625,10 @@ pub fn rotl(comptime T: type, x: T, r: anytype) T {
 }
 
 test "rotl" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
         // https://github.com/ziglang/zig/issues/12012
         return error.SkipZigTest;
     }
-
     try testing.expect(rotl(u0, 0b0, @as(usize, 3)) == 0b0);
     try testing.expect(rotl(u5, 0b00001, @as(usize, 0)) == 0b00001);
     try testing.expect(rotl(u6, 0b000001, @as(usize, 7)) == 0b000010);
@@ -764,8 +752,6 @@ pub fn divTrunc(comptime T: type, numerator: T, denominator: T) !T {
 }
 
 test "divTrunc" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testDivTrunc();
     try comptime testDivTrunc();
 }
@@ -790,8 +776,6 @@ pub fn divFloor(comptime T: type, numerator: T, denominator: T) !T {
 }
 
 test "divFloor" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testDivFloor();
     try comptime testDivFloor();
 }
@@ -829,8 +813,6 @@ pub fn divCeil(comptime T: type, numerator: T, denominator: T) !T {
 }
 
 test "divCeil" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testDivCeil();
     try comptime testDivCeil();
 }
@@ -875,8 +857,6 @@ pub fn divExact(comptime T: type, numerator: T, denominator: T) !T {
 }
 
 test "divExact" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testDivExact();
     try comptime testDivExact();
 }
@@ -907,8 +887,6 @@ test "mod" {
     try comptime testMod();
 }
 fn testMod() !void {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testing.expect((mod(i32, -5, 3) catch unreachable) == 1);
     try testing.expect((mod(i32, 5, 3) catch unreachable) == 2);
     try testing.expectError(error.NegativeDenominator, mod(i32, 10, -1));
@@ -931,8 +909,6 @@ pub fn rem(comptime T: type, numerator: T, denominator: T) !T {
 }
 
 test "rem" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testRem();
     try comptime testRem();
 }
@@ -1285,8 +1261,6 @@ pub fn lerp(a: anytype, b: anytype, t: anytype) @TypeOf(a, b, t) {
 }
 
 test "lerp" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testing.expectEqual(@as(f64, 75), lerp(50, 100, 0.5));
     try testing.expectEqual(@as(f32, 43.75), lerp(50, 25, 0.25));
     try testing.expectEqual(@as(f64, -31.25), lerp(-50, 25, 0.25));
diff --git a/lib/std/math/big/int_test.zig b/lib/std/math/big/int_test.zig
index d54c417dfb..668f07b32d 100644
--- a/lib/std/math/big/int_test.zig
+++ b/lib/std/math/big/int_test.zig
@@ -71,8 +71,6 @@ test "big.int set negative minimum" {
 }
 
 test "big.int set double-width maximum then zero" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, maxInt(DoubleLimb));
     defer a.deinit();
     try a.set(@as(DoubleLimb, 0));
@@ -246,8 +244,6 @@ test "big.int fits" {
 }
 
 test "big.int string set" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.init(testing.allocator);
     defer a.deinit();
 
@@ -264,8 +260,6 @@ test "big.int string negative" {
 }
 
 test "big.int string set number with underscores" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.init(testing.allocator);
     defer a.deinit();
 
@@ -274,8 +268,6 @@ test "big.int string set number with underscores" {
 }
 
 test "big.int string set case insensitive number" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.init(testing.allocator);
     defer a.deinit();
 
@@ -326,8 +318,6 @@ test "big.int twos complement limit set" {
 }
 
 test "big.int string to" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, 120317241209124781241290847124);
     defer a.deinit();
 
@@ -368,8 +358,6 @@ test "big.int string to base 16" {
 }
 
 test "big.int neg string to" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, -123907434);
     defer a.deinit();
 
@@ -392,8 +380,6 @@ test "big.int zero string to" {
 }
 
 test "big.int clone" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, 1234);
     defer a.deinit();
     var b = try a.clone();
@@ -531,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);
@@ -634,8 +618,6 @@ test "big.int addWrap single-single, unsigned" {
 }
 
 test "big.int subWrap single-single, unsigned" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, 0);
     defer a.deinit();
 
@@ -649,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();
 
@@ -703,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();
 
@@ -755,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();
 
@@ -842,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);
@@ -857,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;
 
@@ -943,10 +915,7 @@ 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;
 
     var op1: u256 = 0x998888efefefefefefefef;
     var op2: u256 = 0x333000abababababababab;
@@ -963,8 +932,6 @@ test "big.int mul multi-multi" {
 }
 
 test "big.int mul alias r with a" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, maxInt(Limb));
     defer a.deinit();
     var b = try Managed.initSet(testing.allocator, 2);
@@ -976,8 +943,6 @@ test "big.int mul alias r with a" {
 }
 
 test "big.int mul alias r with b" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, maxInt(Limb));
     defer a.deinit();
     var b = try Managed.initSet(testing.allocator, 2);
@@ -989,8 +954,6 @@ test "big.int mul alias r with b" {
 }
 
 test "big.int mul alias r with a and b" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, maxInt(Limb));
     defer a.deinit();
 
@@ -1026,8 +989,6 @@ test "big.int mul 0*0" {
 }
 
 test "big.int mul large" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initCapacity(testing.allocator, 50);
     defer a.deinit();
     var b = try Managed.initCapacity(testing.allocator, 100);
@@ -1075,10 +1036,7 @@ 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;
 
     var op1: u256 = 0x998888efefefefefefefef;
     var op2: u256 = 0x333000abababababababab;
@@ -1095,10 +1053,7 @@ test "big.int mulWrap multi-multi unsigned" {
 }
 
 test "big.int mulWrap multi-multi signed" {
-    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, maxInt(SignedDoubleLimb) - 1);
     defer a.deinit();
@@ -1113,8 +1068,6 @@ test "big.int mulWrap multi-multi signed" {
 }
 
 test "big.int mulWrap large" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initCapacity(testing.allocator, 50);
     defer a.deinit();
     var b = try Managed.initCapacity(testing.allocator, 100);
@@ -1171,8 +1124,6 @@ test "big.int div single-half with rem" {
 }
 
 test "big.int div single-single no rem" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // assumes usize is <= 64 bits.
     var a = try Managed.initSet(testing.allocator, 1 << 52);
     defer a.deinit();
@@ -1190,8 +1141,6 @@ test "big.int div single-single no rem" {
 }
 
 test "big.int div single-single with rem" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, (1 << 52) | (1 << 33));
     defer a.deinit();
     var b = try Managed.initSet(testing.allocator, (1 << 35));
@@ -1208,8 +1157,6 @@ test "big.int div single-single with rem" {
 }
 
 test "big.int div multi-single no rem" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var op1: u128 = 0xffffeeeeddddcccc;
     var op2: u128 = 34;
 
@@ -1229,8 +1176,6 @@ test "big.int div multi-single no rem" {
 }
 
 test "big.int div multi-single with rem" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var op1: u128 = 0xffffeeeeddddcccf;
     var op2: u128 = 34;
 
@@ -1250,8 +1195,6 @@ test "big.int div multi-single with rem" {
 }
 
 test "big.int div multi>2-single" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var op1: u128 = 0xfefefefefefefefefefefefefefefefe;
     var op2: u128 = 0xefab8;
 
@@ -1271,8 +1214,6 @@ test "big.int div multi>2-single" {
 }
 
 test "big.int div single-single q < r" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, 0x0078f432);
     defer a.deinit();
     var b = try Managed.initSet(testing.allocator, 0x01000000);
@@ -1317,10 +1258,7 @@ test "big.int div q=0 alias" {
 }
 
 test "big.int div multi-multi q < r" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     const op1 = 0x1ffffffff0078f432;
     const op2 = 0x1ffffffff01000000;
@@ -1436,8 +1374,6 @@ test "big.int div trunc single-single -/-" {
 }
 
 test "big.int divTrunc #15535" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var one = try Managed.initSet(testing.allocator, 1);
     defer one.deinit();
     var x = try Managed.initSet(testing.allocator, std.math.pow(u128, 2, 64));
@@ -1451,8 +1387,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();
 
@@ -1477,8 +1411,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();
 
@@ -1506,8 +1438,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();
 
@@ -1642,8 +1572,6 @@ test "big.int div floor single-single -/-" {
 }
 
 test "big.int div floor no remainder negative quotient" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const u: i32 = -0x80000000;
     const v: i32 = 1;
 
@@ -1701,10 +1629,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();
@@ -1722,10 +1647,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();
@@ -1743,10 +1665,7 @@ test "big.int div multi-multi no rem" {
 }
 
 test "big.int div multi-multi (2 branch)" {
-    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, 0x866666665555555588888887777777761111111111111111);
     defer a.deinit();
@@ -1764,10 +1683,7 @@ 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;
 
     var a = try Managed.initSet(testing.allocator, 0x11111111111111111111111111111111111111111111111111111111111111);
     defer a.deinit();
@@ -1785,10 +1701,7 @@ test "big.int div multi-multi (3.1/3.3 branch)" {
 }
 
 test "big.int div multi-single zero-limb trailing" {
-    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, 0x60000000000000000000000000000000000000000000000000000000000000000);
     defer a.deinit();
@@ -1808,10 +1721,7 @@ test "big.int div multi-single zero-limb trailing" {
 }
 
 test "big.int div multi-multi zero-limb trailing (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, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);
     defer a.deinit();
@@ -1832,10 +1742,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();
@@ -1856,10 +1763,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();
@@ -1882,8 +1786,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);
@@ -1908,8 +1810,6 @@ test "big.int div multi-multi fuzz case #1" {
 }
 
 test "big.int div multi-multi fuzz case #2" {
-    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);
@@ -1982,8 +1882,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();
 
@@ -1993,8 +1891,6 @@ test "big.int truncate multi to multi signed" {
 }
 
 test "big.int truncate negative multi to single" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, -@as(SignedDoubleLimb, maxInt(Limb) + 1));
     defer a.deinit();
 
@@ -2101,8 +1997,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);
@@ -2147,8 +2041,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);
@@ -2205,8 +2097,6 @@ test "big.int sat shift-left signed simple positive" {
 }
 
 test "big.int sat shift-left signed multi positive" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var x: SignedDoubleLimb = 1;
     const shift = @bitSizeOf(SignedDoubleLimb) - 1;
 
@@ -2218,8 +2108,6 @@ test "big.int sat shift-left signed multi positive" {
 }
 
 test "big.int sat shift-left signed multi negative" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var x: SignedDoubleLimb = -1;
     const shift = @bitSizeOf(SignedDoubleLimb) - 1;
 
@@ -2406,8 +2294,6 @@ test "big.int bitwise xor simple" {
 }
 
 test "big.int bitwise xor multi-limb" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var x: DoubleLimb = maxInt(Limb) + 1;
     var y: DoubleLimb = maxInt(Limb);
     var a = try Managed.initSet(testing.allocator, x);
@@ -2582,8 +2468,6 @@ test "big.int var args" {
 }
 
 test "big.int gcd non-one small" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, 17);
     defer a.deinit();
     var b = try Managed.initSet(testing.allocator, 97);
@@ -2597,8 +2481,6 @@ test "big.int gcd non-one small" {
 }
 
 test "big.int gcd non-one medium" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, 4864);
     defer a.deinit();
     var b = try Managed.initSet(testing.allocator, 3458);
@@ -2612,8 +2494,6 @@ test "big.int gcd non-one medium" {
 }
 
 test "big.int gcd non-one large" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, 0xffffffffffffffff);
     defer a.deinit();
     var b = try Managed.initSet(testing.allocator, 0xffffffffffffffff7777);
@@ -2627,10 +2507,7 @@ 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;
 
     var a = try Managed.initSet(testing.allocator, 0x12345678123456781234567812345678123456781234567812345678);
     defer a.deinit();
@@ -2646,8 +2523,6 @@ test "big.int gcd large multi-limb result" {
 }
 
 test "big.int gcd one large" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, 1897056385327307);
     defer a.deinit();
     var b = try Managed.initSet(testing.allocator, 2251799813685248);
@@ -2672,8 +2547,6 @@ test "big.int mutable to managed" {
 }
 
 test "big.int const to managed" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, 123423453456);
     defer a.deinit();
 
@@ -2684,8 +2557,6 @@ test "big.int const to managed" {
 }
 
 test "big.int pow" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     {
         var a = try Managed.initSet(testing.allocator, -3);
         defer a.deinit();
@@ -2741,8 +2612,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);
@@ -2773,8 +2642,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);
@@ -2789,8 +2656,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);
@@ -2805,8 +2670,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();
 
@@ -2887,8 +2750,6 @@ fn popCountTest(val: *const Managed, bit_count: usize, expected: usize) !void {
 }
 
 test "big int conversion read/write twos complement" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, (1 << 493) - 1);
     defer a.deinit();
     var b = try Managed.initSet(testing.allocator, (1 << 493) - 1);
@@ -2987,8 +2848,6 @@ test "big int write twos complement +/- zero" {
 }
 
 test "big int conversion write twos complement with padding" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Managed.initSet(testing.allocator, 0x01_ffffffff_ffffffff_ffffffff);
     defer a.deinit();
 
@@ -3172,8 +3031,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();
 
@@ -3218,8 +3075,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();
 
@@ -3236,8 +3091,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();
 
diff --git a/lib/std/math/big/rational.zig b/lib/std/math/big/rational.zig
index a7b2e0b52b..ee641adf50 100644
--- a/lib/std/math/big/rational.zig
+++ b/lib/std/math/big/rational.zig
@@ -1,5 +1,4 @@
 const std = @import("../../std.zig");
-const builtin = @import("builtin");
 const debug = std.debug;
 const math = std.math;
 const mem = std.mem;
@@ -494,8 +493,6 @@ fn extractLowBits(a: Int, comptime T: type) T {
 }
 
 test "big.rational extractLowBits" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Int.initSet(testing.allocator, 0x11112222333344441234567887654321);
     defer a.deinit();
 
@@ -516,8 +513,6 @@ test "big.rational extractLowBits" {
 }
 
 test "big.rational set" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Rational.init(testing.allocator);
     defer a.deinit();
 
@@ -547,8 +542,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();
 
@@ -574,8 +567,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();
 
@@ -587,8 +578,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();
 
@@ -602,8 +591,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);
@@ -617,8 +604,6 @@ test "big.rational set/to Float round-trip" {
 }
 
 test "big.rational copy" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Rational.init(testing.allocator);
     defer a.deinit();
 
@@ -649,8 +634,6 @@ test "big.rational copy" {
 }
 
 test "big.rational negate" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Rational.init(testing.allocator);
     defer a.deinit();
 
@@ -668,8 +651,6 @@ test "big.rational negate" {
 }
 
 test "big.rational abs" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Rational.init(testing.allocator);
     defer a.deinit();
 
@@ -687,8 +668,6 @@ test "big.rational abs" {
 }
 
 test "big.rational swap" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Rational.init(testing.allocator);
     defer a.deinit();
     var b = try Rational.init(testing.allocator);
@@ -713,8 +692,6 @@ test "big.rational swap" {
 }
 
 test "big.rational order" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Rational.init(testing.allocator);
     defer a.deinit();
     var b = try Rational.init(testing.allocator);
@@ -730,8 +707,6 @@ test "big.rational order" {
 }
 
 test "big.rational order/orderAbs with negative" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Rational.init(testing.allocator);
     defer a.deinit();
     var b = try Rational.init(testing.allocator);
@@ -744,8 +719,6 @@ test "big.rational order/orderAbs with negative" {
 }
 
 test "big.rational add single-limb" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Rational.init(testing.allocator);
     defer a.deinit();
     var b = try Rational.init(testing.allocator);
@@ -761,8 +734,6 @@ test "big.rational add single-limb" {
 }
 
 test "big.rational add" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Rational.init(testing.allocator);
     defer a.deinit();
     var b = try Rational.init(testing.allocator);
@@ -779,8 +750,6 @@ test "big.rational add" {
 }
 
 test "big.rational sub" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Rational.init(testing.allocator);
     defer a.deinit();
     var b = try Rational.init(testing.allocator);
@@ -797,8 +766,6 @@ test "big.rational sub" {
 }
 
 test "big.rational mul" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var a = try Rational.init(testing.allocator);
     defer a.deinit();
     var b = try Rational.init(testing.allocator);
@@ -815,8 +782,6 @@ test "big.rational mul" {
 }
 
 test "big.rational div" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     {
         var a = try Rational.init(testing.allocator);
         defer a.deinit();
diff --git a/lib/std/math/ilogb.zig b/lib/std/math/ilogb.zig
index f3cfc5f6fe..735a2250c9 100644
--- a/lib/std/math/ilogb.zig
+++ b/lib/std/math/ilogb.zig
@@ -6,7 +6,6 @@
 // https://git.musl-libc.org/cgit/musl/tree/src/math/ilogb.c
 
 const std = @import("../std.zig");
-const builtin = @import("builtin");
 const math = std.math;
 const expect = std.testing.expect;
 const maxInt = std.math.maxInt;
@@ -109,8 +108,6 @@ test "64" {
 }
 
 test "80" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try expect(ilogbX(f80, 0.0) == fp_ilogb0);
     try expect(ilogbX(f80, 0.5) == -1);
     try expect(ilogbX(f80, 0.8923) == -1);
@@ -125,8 +122,6 @@ test "80" {
 }
 
 test "128" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try expect(ilogbX(f128, 0.0) == fp_ilogb0);
     try expect(ilogbX(f128, 0.5) == -1);
     try expect(ilogbX(f128, 0.8923) == -1);
@@ -162,8 +157,6 @@ test "64 special" {
 }
 
 test "80 special" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try expect(ilogbX(f80, math.inf(f80)) == maxInt(i32));
     try expect(ilogbX(f80, -math.inf(f80)) == maxInt(i32));
     try expect(ilogbX(f80, 0.0) == minInt(i32));
@@ -171,8 +164,6 @@ test "80 special" {
 }
 
 test "128 special" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try expect(ilogbX(f128, math.inf(f128)) == maxInt(i32));
     try expect(ilogbX(f128, -math.inf(f128)) == maxInt(i32));
     try expect(ilogbX(f128, 0.0) == minInt(i32));
diff --git a/lib/std/math/ldexp.zig b/lib/std/math/ldexp.zig
index c42b5703e0..d32a8189b6 100644
--- a/lib/std/math/ldexp.zig
+++ b/lib/std/math/ldexp.zig
@@ -67,7 +67,6 @@ pub fn ldexp(x: anytype, n: i32) @TypeOf(x) {
 }
 
 test "math.ldexp" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
 
     // subnormals
     try expect(ldexp(@as(f16, 0x1.1FFp14), -14 - 9 - 15) == math.floatTrueMin(f16));
diff --git a/lib/std/math/log10.zig b/lib/std/math/log10.zig
index 7544c0f9cc..785f11771c 100644
--- a/lib/std/math/log10.zig
+++ b/lib/std/math/log10.zig
@@ -170,11 +170,11 @@ test "log10_int vs old implementation" {
 test "log10_int close to powers of 10" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_llvm and comptime builtin.target.isWasm()) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
 
     const int_types = .{ u8, u16, u32, u64, u128, u256, u512 };
     const max_log_values: [7]usize = .{ 2, 4, 9, 19, 38, 77, 154 };
diff --git a/lib/std/math/log_int.zig b/lib/std/math/log_int.zig
index 066f983f08..d73e273d71 100644
--- a/lib/std/math/log_int.zig
+++ b/lib/std/math/log_int.zig
@@ -56,8 +56,6 @@ pub fn log_int(comptime T: type, base: T, x: T) Log2Int(T) {
 }
 
 test "math.log_int" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // Test all unsigned integers with 2, 3, ..., 64 bits.
     // We cannot test 0 or 1 bits since base must be > 1.
     inline for (2..64 + 1) |bits| {
diff --git a/lib/std/math/nextafter.zig b/lib/std/math/nextafter.zig
index 56117b36d9..3a0b2d88a5 100644
--- a/lib/std/math/nextafter.zig
+++ b/lib/std/math/nextafter.zig
@@ -103,8 +103,6 @@ fn nextAfterFloat(comptime T: type, x: T, y: T) T {
 }
 
 test "math.nextAfter.int" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try expect(nextAfter(i0, 0, 0) == 0);
     try expect(nextAfter(u0, 0, 0) == 0);
     try expect(nextAfter(i1, 0, 0) == 0);
diff --git a/lib/std/math/scalbn.zig b/lib/std/math/scalbn.zig
index 4515cda5b0..2c8c3733fa 100644
--- a/lib/std/math/scalbn.zig
+++ b/lib/std/math/scalbn.zig
@@ -7,8 +7,6 @@ const expect = std.testing.expect;
 pub const scalbn = @import("ldexp.zig").ldexp;
 
 test "math.scalbn" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // Verify we are using base 2.
     try expect(scalbn(@as(f16, 1.5), 4) == 24.0);
     try expect(scalbn(@as(f32, 1.5), 4) == 24.0);
diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index cf9369fbe4..e9d957d387 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -315,8 +315,6 @@ pub fn zeroes(comptime T: type) T {
 }
 
 test "zeroes" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const C_struct = extern struct {
         x: u32,
         y: u32 align(128),
@@ -1025,8 +1023,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;
 
@@ -1741,8 +1737,6 @@ pub fn readIntSlice(comptime T: type, bytes: []const u8, endian: Endian) T {
 }
 
 test "comptime read/write int" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     comptime {
         var bytes: [2]u8 = undefined;
         writeIntLittle(u16, &bytes, 0x1234);
@@ -1758,10 +1752,7 @@ test "comptime read/write int" {
 }
 
 test "readIntBig and readIntLittle" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     try testing.expect(readIntSliceBig(u0, &[_]u8{}) == 0x0);
     try testing.expect(readIntSliceLittle(u0, &[_]u8{}) == 0x0);
@@ -2062,10 +2053,7 @@ pub fn writeVarPackedInt(bytes: []u8, bit_offset: usize, bit_count: usize, value
 }
 
 test "writeIntBig and writeIntLittle" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     var buf0: [0]u8 = undefined;
     var buf1: [1]u8 = undefined;
@@ -3309,8 +3297,6 @@ test "testStringEquality" {
 }
 
 test "testReadInt" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testReadIntImpl();
     try comptime testReadIntImpl();
 }
@@ -4664,10 +4650,8 @@ pub fn alignInSlice(slice: anytype, comptime new_alignment: usize) ?AlignedSlice
 }
 
 test "read/write(Var)PackedInt" {
-    switch (builtin.zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+
     switch (builtin.cpu.arch) {
         // This test generates too much code to execute on WASI.
         // LLVM backend fails with "too many locals: locals exceed maximum"
diff --git a/lib/std/multi_array_list.zig b/lib/std/multi_array_list.zig
index eca1301320..11dec78036 100644
--- a/lib/std/multi_array_list.zig
+++ b/lib/std/multi_array_list.zig
@@ -583,8 +583,6 @@ pub fn MultiArrayList(comptime T: type) type {
 }
 
 test "basic usage" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const ally = testing.allocator;
 
     const Foo = struct {
@@ -679,8 +677,6 @@ test "basic usage" {
 // This was observed to fail on aarch64 with LLVM 11, when the capacityInBytes
 // function used the @reduce code path.
 test "regression test for @reduce bug" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const ally = testing.allocator;
     var list = MultiArrayList(struct {
         tag: std.zig.Token.Tag,
@@ -758,8 +754,6 @@ test "regression test for @reduce bug" {
 }
 
 test "ensure capacity on empty list" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const ally = testing.allocator;
 
     const Foo = struct {
@@ -795,8 +789,6 @@ test "ensure capacity on empty list" {
 }
 
 test "insert elements" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const ally = testing.allocator;
 
     const Foo = struct {
@@ -816,8 +808,6 @@ test "insert elements" {
 }
 
 test "union" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const ally = testing.allocator;
 
     const Foo = union(enum) {
@@ -873,8 +863,6 @@ test "union" {
 }
 
 test "sorting a span" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var list: MultiArrayList(struct { score: u32, chr: u8 }) = .{};
     defer list.deinit(testing.allocator);
 
@@ -915,8 +903,6 @@ test "sorting a span" {
 }
 
 test "0 sized struct field" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const ally = testing.allocator;
 
     const Foo = struct {
@@ -944,8 +930,6 @@ test "0 sized struct field" {
 }
 
 test "0 sized struct" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const ally = testing.allocator;
 
     const Foo = struct {
diff --git a/lib/std/net/test.zig b/lib/std/net/test.zig
index 1bacfe867f..fd92c64f35 100644
--- a/lib/std/net/test.zig
+++ b/lib/std/net/test.zig
@@ -5,7 +5,6 @@ const mem = std.mem;
 const testing = std.testing;
 
 test "parse and render IPv6 addresses" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
     var buffer: [100]u8 = undefined;
@@ -71,7 +70,6 @@ test "invalid but parseable IPv6 scope ids" {
 }
 
 test "parse and render IPv4 addresses" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
     var buffer: [18]u8 = undefined;
@@ -111,8 +109,6 @@ test "parse and render UNIX addresses" {
 test "resolve DNS" {
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     if (builtin.os.tag == .windows) {
         _ = try std.os.windows.WSAStartup(2, 2);
     }
@@ -295,8 +291,6 @@ test "listen on a unix socket, send bytes, receive bytes" {
     if (builtin.single_threaded) return error.SkipZigTest;
     if (!net.has_unix_sockets) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     if (builtin.os.tag == .windows) {
         _ = try std.os.windows.WSAStartup(2, 2);
     }
diff --git a/lib/std/once.zig b/lib/std/once.zig
index 87f81ee59c..f012e017dd 100644
--- a/lib/std/once.zig
+++ b/lib/std/once.zig
@@ -46,8 +46,6 @@ fn incr() void {
 }
 
 test "Once executes its function just once" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     if (builtin.single_threaded) {
         global_once.call();
         global_once.call();
diff --git a/lib/std/os/linux/io_uring.zig b/lib/std/os/linux/io_uring.zig
index 91a9f1618c..7f7dd21f95 100644
--- a/lib/std/os/linux/io_uring.zig
+++ b/lib/std/os/linux/io_uring.zig
@@ -1741,8 +1741,6 @@ test "readv" {
 test "writev/fsync/readv" {
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var ring = IO_Uring.init(4, 0) catch |err| switch (err) {
         error.SystemOutdated => return error.SkipZigTest,
         error.PermissionDenied => return error.SkipZigTest,
@@ -1813,8 +1811,6 @@ test "writev/fsync/readv" {
 test "write/read" {
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var ring = IO_Uring.init(2, 0) catch |err| switch (err) {
         error.SystemOutdated => return error.SkipZigTest,
         error.PermissionDenied => return error.SkipZigTest,
@@ -1862,8 +1858,6 @@ test "write/read" {
 test "splice/read" {
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var ring = IO_Uring.init(4, 0) catch |err| switch (err) {
         error.SystemOutdated => return error.SkipZigTest,
         error.PermissionDenied => return error.SkipZigTest,
@@ -1935,8 +1929,6 @@ test "splice/read" {
 test "write_fixed/read_fixed" {
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var ring = IO_Uring.init(2, 0) catch |err| switch (err) {
         error.SystemOutdated => return error.SkipZigTest,
         error.PermissionDenied => return error.SkipZigTest,
@@ -2002,8 +1994,6 @@ test "write_fixed/read_fixed" {
 test "openat" {
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
         error.SystemOutdated => return error.SkipZigTest,
         error.PermissionDenied => return error.SkipZigTest,
@@ -2055,8 +2045,6 @@ test "openat" {
 test "close" {
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
         error.SystemOutdated => return error.SkipZigTest,
         error.PermissionDenied => return error.SkipZigTest,
@@ -2216,8 +2204,6 @@ test "sendmsg/recvmsg" {
 test "timeout (after a relative time)" {
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
         error.SystemOutdated => return error.SkipZigTest,
         error.PermissionDenied => return error.SkipZigTest,
@@ -2282,8 +2268,6 @@ test "timeout (after a number of completions)" {
 test "timeout_remove" {
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var ring = IO_Uring.init(2, 0) catch |err| switch (err) {
         error.SystemOutdated => return error.SkipZigTest,
         error.PermissionDenied => return error.SkipZigTest,
@@ -2392,8 +2376,6 @@ test "accept/connect/recv/link_timeout" {
 test "fallocate" {
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
         error.SystemOutdated => return error.SkipZigTest,
         error.PermissionDenied => return error.SkipZigTest,
@@ -2440,8 +2422,6 @@ test "fallocate" {
 test "statx" {
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
         error.SystemOutdated => return error.SkipZigTest,
         error.PermissionDenied => return error.SkipZigTest,
@@ -2698,8 +2678,6 @@ test "shutdown" {
 test "renameat" {
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
         error.SystemOutdated => return error.SkipZigTest,
         error.PermissionDenied => return error.SkipZigTest,
@@ -2769,8 +2747,6 @@ test "renameat" {
 test "unlinkat" {
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
         error.SystemOutdated => return error.SkipZigTest,
         error.PermissionDenied => return error.SkipZigTest,
@@ -2823,8 +2799,6 @@ test "unlinkat" {
 test "mkdirat" {
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
         error.SystemOutdated => return error.SkipZigTest,
         error.PermissionDenied => return error.SkipZigTest,
@@ -2869,8 +2843,6 @@ test "mkdirat" {
 test "symlinkat" {
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
         error.SystemOutdated => return error.SkipZigTest,
         error.PermissionDenied => return error.SkipZigTest,
@@ -2919,8 +2891,6 @@ test "symlinkat" {
 test "linkat" {
     if (builtin.os.tag != .linux) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var ring = IO_Uring.init(1, 0) catch |err| switch (err) {
         error.SystemOutdated => return error.SkipZigTest,
         error.PermissionDenied => return error.SkipZigTest,
diff --git a/lib/std/os/linux/test.zig b/lib/std/os/linux/test.zig
index 1c2ca643b2..170bde6334 100644
--- a/lib/std/os/linux/test.zig
+++ b/lib/std/os/linux/test.zig
@@ -8,8 +8,6 @@ const expectEqual = std.testing.expectEqual;
 const fs = std.fs;
 
 test "fallocate" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = std.testing.tmpDir(.{});
     defer tmp.cleanup();
 
@@ -71,8 +69,6 @@ test "timer" {
 }
 
 test "statx" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = std.testing.tmpDir(.{});
     defer tmp.cleanup();
 
@@ -111,8 +107,6 @@ test "user and group ids" {
 }
 
 test "fadvise" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = std.testing.tmpDir(.{});
     defer tmp.cleanup();
 
diff --git a/lib/std/os/test.zig b/lib/std/os/test.zig
index ca3de5f264..c74733cd93 100644
--- a/lib/std/os/test.zig
+++ b/lib/std/os/test.zig
@@ -88,8 +88,6 @@ test "chdir smoke test" {
 test "open smoke test" {
     if (native_os == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // TODO verify file attributes using `fstat`
 
     var tmp = tmpDir(.{});
@@ -144,8 +142,6 @@ test "open smoke test" {
 test "openat smoke test" {
     if (native_os == .wasi and builtin.link_libc) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // TODO verify file attributes using `fstatat`
 
     var tmp = tmpDir(.{});
@@ -280,8 +276,6 @@ test "link with relative paths" {
 test "linkat with different directories" {
     if (native_os == .wasi and builtin.link_libc) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     switch (native_os) {
         .wasi, .linux, .solaris, .illumos => {},
         else => return error.SkipZigTest,
@@ -327,8 +321,6 @@ test "fstatat" {
     // enable when `fstat` and `fstatat` are implemented on Windows
     if (native_os == .windows) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -348,8 +340,6 @@ test "fstatat" {
 }
 
 test "readlinkat" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -385,8 +375,6 @@ fn testThreadIdFn(thread_id: *Thread.Id) void {
 test "std.Thread.getCurrentId" {
     if (builtin.single_threaded) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var thread_current_id: Thread.Id = undefined;
     const thread = try Thread.spawn(.{}, testThreadIdFn, .{&thread_current_id});
     thread.join();
@@ -429,9 +417,6 @@ test "cpu count" {
 
 test "thread local storage" {
     if (builtin.single_threaded) return error.SkipZigTest;
-
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const thread1 = try Thread.spawn(.{}, testTls, .{});
     const thread2 = try Thread.spawn(.{}, testTls, .{});
     try testTls();
@@ -519,8 +504,6 @@ fn iter_fn(info: *dl_phdr_info, size: usize, counter: *usize) IterFnError!void {
 test "dl_iterate_phdr" {
     if (builtin.object_format != .elf) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var counter: usize = 0;
     try os.dl_iterate_phdr(&counter, IterFnError, iter_fn);
     try expect(counter != 0);
@@ -583,8 +566,6 @@ test "mmap" {
     if (native_os == .windows or native_os == .wasi)
         return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -695,8 +676,6 @@ test "fcntl" {
     if (native_os == .windows or native_os == .wasi)
         return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -737,8 +716,6 @@ test "sync" {
     if (native_os != .linux)
         return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -759,8 +736,6 @@ test "fsync" {
         else => return error.SkipZigTest,
     }
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -780,8 +755,6 @@ test "getrlimit and setrlimit" {
         return error.SkipZigTest;
     }
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     inline for (std.meta.fields(os.rlimit_resource)) |field| {
         const resource = @as(os.rlimit_resource, @enumFromInt(field.value));
         const limit = try os.getrlimit(resource);
@@ -824,8 +797,6 @@ test "sigaction" {
     if (native_os == .wasi or native_os == .windows)
         return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // https://github.com/ziglang/zig/issues/7427
     if (native_os == .linux and builtin.target.cpu.arch == .x86)
         return error.SkipZigTest;
@@ -903,8 +874,6 @@ test "dup & dup2" {
         else => return error.SkipZigTest,
     }
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -934,8 +903,6 @@ test "dup & dup2" {
 test "writev longer than IOV_MAX" {
     if (native_os == .windows or native_os == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -953,8 +920,6 @@ test "POSIX file locking with fcntl" {
         return error.SkipZigTest;
     }
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     if (true) {
         // https://github.com/ziglang/zig/issues/11074
         return error.SkipZigTest;
@@ -1017,8 +982,6 @@ test "POSIX file locking with fcntl" {
 test "rename smoke test" {
     if (native_os == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1075,8 +1038,6 @@ test "rename smoke test" {
 test "access smoke test" {
     if (native_os == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1141,8 +1102,6 @@ test "timerfd" {
 }
 
 test "isatty" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1155,8 +1114,6 @@ test "isatty" {
 test "read with empty buffer" {
     if (native_os == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1182,8 +1139,6 @@ test "read with empty buffer" {
 test "pread with empty buffer" {
     if (native_os == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1209,8 +1164,6 @@ test "pread with empty buffer" {
 test "write with empty buffer" {
     if (native_os == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1236,8 +1189,6 @@ test "write with empty buffer" {
 test "pwrite with empty buffer" {
     if (native_os == .wasi) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
@@ -1263,8 +1214,6 @@ test "pwrite with empty buffer" {
 test "fchmodat smoke test" {
     if (!std.fs.has_executable_bit) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index b426db968d..05b754de8d 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -2491,8 +2491,6 @@ pub fn ntToWin32Namespace(path: []const u16) !PathSpace {
 }
 
 test "ntToWin32Namespace" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const L = std.unicode.utf8ToUtf16LeStringLiteral;
 
     try testNtToWin32Namespace(L("UNC"), L("\\??\\UNC"));
diff --git a/lib/std/priority_dequeue.zig b/lib/std/priority_dequeue.zig
index b68bd97d05..31ae965286 100644
--- a/lib/std/priority_dequeue.zig
+++ b/lib/std/priority_dequeue.zig
@@ -705,8 +705,6 @@ test "std.PriorityDequeue: fromOwnedSlice trivial case 1" {
 }
 
 test "std.PriorityDequeue: fromOwnedSlice" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
     const queue_items = try testing.allocator.dupe(u32, items[0..]);
     var queue = PDQ.fromOwnedSlice(testing.allocator, queue_items[0..], {});
diff --git a/lib/std/priority_queue.zig b/lib/std/priority_queue.zig
index 84ee9d6cdf..a568eeadcf 100644
--- a/lib/std/priority_queue.zig
+++ b/lib/std/priority_queue.zig
@@ -385,8 +385,6 @@ test "std.PriorityQueue: fromOwnedSlice trivial case 1" {
 }
 
 test "std.PriorityQueue: fromOwnedSlice" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
     const heap_items = try testing.allocator.dupe(u32, items[0..]);
     var queue = PQlt.fromOwnedSlice(testing.allocator, heap_items[0..], {});
diff --git a/lib/std/rand/Xoshiro256.zig b/lib/std/rand/Xoshiro256.zig
index 29988f1166..c72d9ee1a2 100644
--- a/lib/std/rand/Xoshiro256.zig
+++ b/lib/std/rand/Xoshiro256.zig
@@ -90,10 +90,7 @@ pub fn fill(self: *Xoshiro256, buf: []u8) void {
 }
 
 test "xoroshiro sequence" {
-    switch (@import("builtin").zig_backend) {
-        .stage2_c, .stage2_x86_64 => return error.SkipZigTest,
-        else => {},
-    }
+    if (@import("builtin").zig_backend == .stage2_c) return error.SkipZigTest;
 
     var r = Xoshiro256.init(0);
 
diff --git a/lib/std/rand/test.zig b/lib/std/rand/test.zig
index 39b25eff15..551e47f8ff 100644
--- a/lib/std/rand/test.zig
+++ b/lib/std/rand/test.zig
@@ -1,5 +1,4 @@
 const std = @import("../std.zig");
-const builtin = @import("builtin");
 const math = std.math;
 const DefaultPrng = std.rand.DefaultPrng;
 const Random = std.rand.Random;
@@ -158,8 +157,6 @@ fn testRandomEnumValue() !void {
 }
 
 test "Random intLessThan" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     @setEvalBranchQuota(10000);
     try testRandomIntLessThan();
     try comptime testRandomIntLessThan();
@@ -202,8 +199,6 @@ fn testRandomIntLessThan() !void {
 }
 
 test "Random intAtMost" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     @setEvalBranchQuota(10000);
     try testRandomIntAtMost();
     try comptime testRandomIntAtMost();
@@ -244,8 +239,6 @@ fn testRandomIntAtMost() !void {
 }
 
 test "Random Biased" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var prng = DefaultPrng.init(0);
     const random = prng.random();
     // Not thoroughly checking the logic here.
@@ -443,8 +436,6 @@ fn testRangeBias(r: Random, start: i8, end: i8, biased: bool) !void {
 }
 
 test "CSPRNG" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var secret_seed: [DefaultCsprng.secret_seed_length]u8 = undefined;
     std.crypto.random.bytes(&secret_seed);
     var csprng = DefaultCsprng.init(secret_seed);
@@ -456,8 +447,6 @@ test "CSPRNG" {
 }
 
 test "Random weightedIndex" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     // Make sure weightedIndex works for various integers and floats
     inline for (.{ u64, i4, f32, f64 }) |T| {
         var prng = DefaultPrng.init(0);
diff --git a/lib/std/segmented_list.zig b/lib/std/segmented_list.zig
index 0c73fdc982..1c9cffa766 100644
--- a/lib/std/segmented_list.zig
+++ b/lib/std/segmented_list.zig
@@ -409,8 +409,6 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
 }
 
 test "SegmentedList basic usage" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testSegmentedList(0);
     try testSegmentedList(1);
     try testSegmentedList(2);
diff --git a/lib/std/simd.zig b/lib/std/simd.zig
index 7629dfac1a..93e8534f4a 100644
--- a/lib/std/simd.zig
+++ b/lib/std/simd.zig
@@ -196,13 +196,10 @@ pub fn extract(
 }
 
 test "vector patterns" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
         // https://github.com/ziglang/zig/issues/12012
         return error.SkipZigTest;
     }
-
     const base = @Vector(4, u32){ 10, 20, 30, 40 };
     const other_base = @Vector(4, u32){ 55, 66, 77, 88 };
 
@@ -272,8 +269,6 @@ pub fn reverseOrder(vec: anytype) @TypeOf(vec) {
 }
 
 test "vector shifting" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const base = @Vector(4, u32){ 10, 20, 30, 40 };
 
     try std.testing.expectEqual([4]u32{ 30, 40, 999, 999 }, shiftElementsLeft(base, 2, 999));
@@ -338,8 +333,6 @@ pub fn countElementsWithValue(vec: anytype, value: std.meta.Child(@TypeOf(vec)))
 }
 
 test "vector searching" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const base = @Vector(8, u32){ 6, 4, 7, 4, 4, 2, 3, 7 };
 
     try std.testing.expectEqual(@as(?u3, 1), firstIndexOfValue(base, 4));
@@ -431,8 +424,6 @@ 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 (comptime builtin.cpu.arch.isMIPS()) {
         return error.SkipZigTest;
     }
diff --git a/lib/std/sort.zig b/lib/std/sort.zig
index 149f632944..e110a8beb8 100644
--- a/lib/std/sort.zig
+++ b/lib/std/sort.zig
@@ -1,6 +1,5 @@
 const std = @import("std.zig");
 const assert = std.debug.assert;
-const builtin = @import("builtin");
 const testing = std.testing;
 const mem = std.mem;
 const math = std.math;
@@ -177,8 +176,6 @@ const IdAndValue = struct {
 };
 
 test "stable sort" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const expected = [_]IdAndValue{
         IdAndValue{ .id = 0, .value = 0 },
         IdAndValue{ .id = 1, .value = 0 },
@@ -226,8 +223,6 @@ test "stable sort" {
 }
 
 test "sort" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const u8cases = [_][]const []const u8{
         &[_][]const u8{
             "",
@@ -306,8 +301,6 @@ test "sort" {
 }
 
 test "sort descending" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const rev_cases = [_][]const []const i32{
         &[_][]const i32{
             &[_]i32{},
@@ -347,8 +340,6 @@ test "sort descending" {
 }
 
 test "sort with context in the middle of a slice" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const Context = struct {
         items: []i32,
 
@@ -388,8 +379,6 @@ test "sort with context in the middle of a slice" {
 }
 
 test "sort fuzz testing" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var prng = std.rand.DefaultPrng.init(0x12345678);
     const random = prng.random();
     const test_case_count = 10;
diff --git a/lib/std/time.zig b/lib/std/time.zig
index 1948decdf8..c078e97793 100644
--- a/lib/std/time.zig
+++ b/lib/std/time.zig
@@ -122,8 +122,6 @@ pub fn nanoTimestamp() i128 {
 }
 
 test "timestamp" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const margin = ns_per_ms * 50;
 
     const time_0 = milliTimestamp();
@@ -321,8 +319,6 @@ pub const Timer = struct {
 };
 
 test "Timer + Instant" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const margin = ns_per_ms * 150;
 
     var timer = try Timer.start();
diff --git a/lib/std/treap.zig b/lib/std/treap.zig
index f25ba527fe..383dc1802a 100644
--- a/lib/std/treap.zig
+++ b/lib/std/treap.zig
@@ -350,8 +350,6 @@ const TestTreap = Treap(u64, std.math.order);
 const TestNode = TestTreap.Node;
 
 test "std.Treap: insert, find, replace, remove" {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var treap = TestTreap{};
     var nodes: [10]TestNode = undefined;
 
diff --git a/lib/std/unicode.zig b/lib/std/unicode.zig
index b1a9b3db0b..e4a84b42c9 100644
--- a/lib/std/unicode.zig
+++ b/lib/std/unicode.zig
@@ -1,6 +1,5 @@
 const std = @import("./std.zig");
 const assert = std.debug.assert;
-const builtin = @import("builtin");
 const testing = std.testing;
 const mem = std.mem;
 
@@ -497,15 +496,11 @@ fn testUtf16CountCodepoints() !void {
 }
 
 test "utf16 count codepoints" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testUtf16CountCodepoints();
     try comptime testUtf16CountCodepoints();
 }
 
 test "utf8 encode" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try comptime testUtf8Encode();
     try testUtf8Encode();
 }
@@ -532,8 +527,6 @@ fn testUtf8Encode() !void {
 }
 
 test "utf8 encode error" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try comptime testUtf8EncodeError();
     try testUtf8EncodeError();
 }
@@ -550,8 +543,6 @@ fn testErrorEncode(codePoint: u21, array: []u8, expectedErr: anyerror) !void {
 }
 
 test "utf8 iterator on ascii" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try comptime testUtf8IteratorOnAscii();
     try testUtf8IteratorOnAscii();
 }
@@ -572,8 +563,6 @@ fn testUtf8IteratorOnAscii() !void {
 }
 
 test "utf8 view bad" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try comptime testUtf8ViewBad();
     try testUtf8ViewBad();
 }
@@ -584,8 +573,6 @@ fn testUtf8ViewBad() !void {
 }
 
 test "utf8 view ok" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try comptime testUtf8ViewOk();
     try testUtf8ViewOk();
 }
@@ -606,8 +593,6 @@ fn testUtf8ViewOk() !void {
 }
 
 test "validate slice" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try comptime testValidateSlice();
     try testValidateSlice();
 
@@ -648,8 +633,6 @@ fn testValidateSlice() !void {
 }
 
 test "valid utf8" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try comptime testValidUtf8();
     try testValidUtf8();
 }
@@ -669,8 +652,6 @@ fn testValidUtf8() !void {
 }
 
 test "invalid utf8 continuation bytes" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try comptime testInvalidUtf8ContinuationBytes();
     try testInvalidUtf8ContinuationBytes();
 }
@@ -703,8 +684,6 @@ fn testInvalidUtf8ContinuationBytes() !void {
 }
 
 test "overlong utf8 codepoint" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try comptime testOverlongUtf8Codepoint();
     try testOverlongUtf8Codepoint();
 }
@@ -718,8 +697,6 @@ fn testOverlongUtf8Codepoint() !void {
 }
 
 test "misc invalid utf8" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try comptime testMiscInvalidUtf8();
     try testMiscInvalidUtf8();
 }
@@ -735,8 +712,6 @@ fn testMiscInvalidUtf8() !void {
 }
 
 test "utf8 iterator peeking" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try comptime testUtf8Peeking();
     try testUtf8Peeking();
 }
@@ -821,8 +796,6 @@ pub fn utf16leToUtf8(utf8: []u8, utf16le: []const u16) !usize {
 }
 
 test "utf16leToUtf8" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var utf16le: [2]u16 = undefined;
     const utf16le_as_bytes = mem.sliceAsBytes(utf16le[0..]);
 
@@ -935,8 +908,6 @@ pub fn utf8ToUtf16Le(utf16le: []u16, utf8: []const u8) !usize {
 }
 
 test "utf8ToUtf16Le" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     var utf16le: [2]u16 = [_]u16{0} ** 2;
     {
         const length = try utf8ToUtf16Le(utf16le[0..], "𐐷");
@@ -955,8 +926,6 @@ test "utf8ToUtf16Le" {
 }
 
 test "utf8ToUtf16LeWithNull" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     {
         const utf16 = try utf8ToUtf16LeWithNull(testing.allocator, "𐐷");
         defer testing.allocator.free(utf16);
@@ -1015,8 +984,6 @@ fn testCalcUtf16LeLen() !void {
 }
 
 test "calculate utf16 string length of given utf8 string in u16" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testCalcUtf16LeLen();
     try comptime testCalcUtf16LeLen();
 }
@@ -1050,8 +1017,6 @@ pub fn fmtUtf16le(utf16le: []const u16) std.fmt.Formatter(formatUtf16le) {
 }
 
 test "fmtUtf16le" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const expectFmt = std.testing.expectFmt;
     try expectFmt("", "{}", .{fmtUtf16le(utf8ToUtf16LeStringLiteral(""))});
     try expectFmt("foo", "{}", .{fmtUtf16le(utf8ToUtf16LeStringLiteral("foo"))});
@@ -1065,8 +1030,6 @@ test "fmtUtf16le" {
 }
 
 test "utf8ToUtf16LeStringLiteral" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     {
         const bytes = [_:0]u16{
             mem.nativeToLittle(u16, 0x41),
@@ -1127,8 +1090,6 @@ fn testUtf8CountCodepoints() !void {
 }
 
 test "utf8 count codepoints" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testUtf8CountCodepoints();
     try comptime testUtf8CountCodepoints();
 }
@@ -1145,8 +1106,6 @@ fn testUtf8ValidCodepoint() !void {
 }
 
 test "utf8 valid codepoint" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testUtf8ValidCodepoint();
     try comptime testUtf8ValidCodepoint();
 }
diff --git a/lib/std/zig/CrossTarget.zig b/lib/std/zig/CrossTarget.zig
index 5a28ebda86..cf3d109edb 100644
--- a/lib/std/zig/CrossTarget.zig
+++ b/lib/std/zig/CrossTarget.zig
@@ -785,8 +785,6 @@ fn parseOs(result: *CrossTarget, diags: *ParseOptions.Diagnostics, text: []const
 }
 
 test "CrossTarget.parse" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     if (builtin.target.isGnuLibC()) {
         var cross_target = try CrossTarget.parse(.{});
         cross_target.setGnuLibCVersion(2, 1, 1);
diff --git a/lib/std/zig/Parse.zig b/lib/std/zig/Parse.zig
index 84c80214e5..0187c09108 100644
--- a/lib/std/zig/Parse.zig
+++ b/lib/std/zig/Parse.zig
@@ -4102,7 +4102,5 @@ const TokenIndex = Ast.TokenIndex;
 const Token = std.zig.Token;
 
 test {
-    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     _ = @import("parser_test.zig");
 }
diff --git a/lib/std/zig/fmt.zig b/lib/std/zig/fmt.zig
index 6804af466b..5375b93025 100644
--- a/lib/std/zig/fmt.zig
+++ b/lib/std/zig/fmt.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const mem = std.mem;
 
 /// Print the string as a Zig identifier escaping it with @"" syntax if needed.
@@ -96,8 +95,6 @@ pub fn fmtEscapes(bytes: []const u8) std.fmt.Formatter(stringEscape) {
 }
 
 test "escape invalid identifiers" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     const expectFmt = std.testing.expectFmt;
     try expectFmt("@\"while\"", "{}", .{fmtId("while")});
     try expectFmt("hello", "{}", .{fmtId("hello")});
diff --git a/lib/std/zig/tokenizer.zig b/lib/std/zig/tokenizer.zig
index 4cbcb3af72..72f65afb3a 100644
--- a/lib/std/zig/tokenizer.zig
+++ b/lib/std/zig/tokenizer.zig
@@ -1,5 +1,4 @@
 const std = @import("../std.zig");
-const builtin = @import("builtin");
 
 pub const Token = struct {
     tag: Tag,
@@ -1450,8 +1449,6 @@ test "chars" {
 }
 
 test "invalid token characters" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testTokenize("#", &.{.invalid});
     try testTokenize("`", &.{.invalid});
     try testTokenize("'c", &.{.invalid});
@@ -1481,8 +1478,6 @@ test "utf8" {
 }
 
 test "invalid utf8" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testTokenize("//\x80", &.{
         .invalid,
     });
@@ -1573,8 +1568,6 @@ test "pipe and then invalid" {
 }
 
 test "line comment and doc comment" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testTokenize("//", &.{});
     try testTokenize("// a / b", &.{});
     try testTokenize("// /", &.{});
@@ -1649,8 +1642,6 @@ test "range literals" {
 }
 
 test "number literals decimal" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testTokenize("0", &.{.number_literal});
     try testTokenize("1", &.{.number_literal});
     try testTokenize("2", &.{.number_literal});
@@ -1899,8 +1890,6 @@ test "invalid token with unfinished escape right before eof" {
 }
 
 test "saturating operators" {
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
-
     try testTokenize("<<", &.{.angle_bracket_angle_bracket_left});
     try testTokenize("<<|", &.{.angle_bracket_angle_bracket_left_pipe});
     try testTokenize("<<|=", &.{.angle_bracket_angle_bracket_left_pipe_equal});
diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig
index 02c7aaf20f..55e872d2fc 100644
--- a/src/arch/x86_64/CodeGen.zig
+++ b/src/arch/x86_64/CodeGen.zig
@@ -2895,16 +2895,13 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
         }.signedness;
 
         const src_mcv = try self.resolveInst(ty_op.operand);
-        const src_storage_bits: u16 = switch (src_mcv) {
+        const src_storage_bits = switch (src_mcv) {
             .register, .register_offset => 64,
-            .register_pair => 128,
-            .load_frame => |frame_addr| @intCast(self.getFrameAddrSize(frame_addr) * 8),
+            .load_frame => |frame_addr| self.getFrameAddrSize(frame_addr) * 8,
             else => src_int_info.bits,
         };
 
         const dst_mcv = if (dst_int_info.bits <= src_storage_bits and
-            std.math.divCeil(u16, dst_int_info.bits, 64) catch unreachable ==
-            std.math.divCeil(u32, src_storage_bits, 64) catch unreachable and
             self.reuseOperand(inst, ty_op.operand, 0, src_mcv)) src_mcv else dst: {
             const dst_mcv = try self.allocRegOrMem(inst, true);
             try self.genCopy(min_ty, dst_mcv, src_mcv);
@@ -2979,21 +2976,8 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
 
         const dst_mcv = if (src_mcv.isRegister() and self.reuseOperand(inst, ty_op.operand, 0, src_mcv))
             src_mcv
-        else if (dst_abi_size <= 8)
-            try self.copyToRegisterWithInstTracking(inst, dst_ty, src_mcv)
-        else if (dst_abi_size <= 16) dst: {
-            const dst_regs = try self.register_manager.allocRegs(
-                2,
-                .{ inst, inst },
-                abi.RegisterClass.gp,
-            );
-            const dst_mcv: MCValue = .{ .register_pair = dst_regs };
-            const dst_locks = self.register_manager.lockRegsAssumeUnused(2, dst_regs);
-            defer for (dst_locks) |lock| self.register_manager.unlockReg(lock);
-
-            try self.genCopy(dst_ty, dst_mcv, src_mcv);
-            break :dst dst_mcv;
-        } else return self.fail("TODO implement trunc from {} to {}", .{ src_ty.fmt(mod), dst_ty.fmt(mod) });
+        else
+            try self.copyToRegisterWithInstTracking(inst, dst_ty, src_mcv);
 
         if (dst_ty.zigTypeTag(mod) == .Vector) {
             assert(src_ty.zigTypeTag(mod) == .Vector and dst_ty.vectorLen(mod) == src_ty.vectorLen(mod));
@@ -3064,15 +3048,14 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
             break :result dst_mcv;
         }
 
+        if (dst_abi_size > 8) {
+            return self.fail("TODO implement trunc for abi sizes larger than 8", .{});
+        }
+
         // when truncating a `u16` to `u5`, for example, those top 3 bits in the result
         // have to be removed. this only happens if the dst if not a power-of-two size.
-        if (dst_abi_size <= 8) {
-            if (self.regExtraBits(dst_ty) > 0) try self.truncateRegister(dst_ty, dst_mcv.register.to64());
-        } else if (dst_abi_size <= 16) {
-            const dst_info = dst_ty.intInfo(mod);
-            const high_ty = try mod.intType(dst_info.signedness, dst_info.bits - 64);
-            if (self.regExtraBits(high_ty) > 0) try self.truncateRegister(high_ty, dst_mcv.register_pair[1].to64());
-        }
+        if (self.regExtraBits(dst_ty) > 0)
+            try self.truncateRegister(dst_ty, dst_mcv.register.to64());
 
         break :result dst_mcv;
     };
@@ -3395,7 +3378,7 @@ fn airMulSat(self: *Self, inst: Air.Inst.Index) !void {
     const cc: Condition = if (ty.isSignedInt(mod)) cc: {
         try self.genSetReg(limit_reg, ty, lhs_mcv);
         try self.genBinOpMir(.{ ._, .xor }, ty, limit_mcv, rhs_mcv);
-        try self.genShiftBinOpMir(.{ ._r, .sa }, ty, limit_mcv, .{ .immediate = reg_bits - 1 });
+        try self.genShiftBinOpMir(.{ ._, .sa }, ty, limit_mcv, .{ .immediate = reg_bits - 1 });
         try self.genBinOpMir(.{ ._, .xor }, ty, limit_mcv, .{
             .immediate = (@as(u64, 1) << @intCast(reg_bits - 1)) - 1,
         });
@@ -3663,10 +3646,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                 },
                 else => {
                     // For now, this is the only supported multiply that doesn't fit in a register.
-                    if (dst_info.bits > 128 or src_bits != 64)
-                        return self.fail("TODO implement airWithOverflow from {} to {}", .{
-                            src_ty.fmt(mod), dst_ty.fmt(mod),
-                        });
+                    assert(dst_info.bits <= 128 and src_bits == 64);
 
                     const frame_index =
                         try self.allocFrameIndex(FrameAlloc.initType(tuple_ty, mod));
@@ -3818,13 +3798,11 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) !void {
 }
 
 fn airOptionalPayload(self: *Self, inst: Air.Inst.Index) !void {
-    const mod = self.bin_file.options.module.?;
     const ty_op = self.air.instructions.items(.data)[inst].ty_op;
     const result: MCValue = result: {
         const pl_ty = self.typeOfIndex(inst);
-        if (!pl_ty.hasRuntimeBitsIgnoreComptime(mod)) break :result .none;
-
         const opt_mcv = try self.resolveInst(ty_op.operand);
+
         if (self.reuseOperand(inst, ty_op.operand, 0, opt_mcv)) {
             switch (opt_mcv) {
                 .register => |reg| try self.truncateRegister(pl_ty, reg),
@@ -4444,46 +4422,42 @@ fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
     // this is identical to the `airPtrElemPtr` codegen expect here an
     // additional `mov` is needed at the end to get the actual value
 
-    const result = result: {
-        const elem_ty = ptr_ty.elemType2(mod);
-        if (!elem_ty.hasRuntimeBitsIgnoreComptime(mod)) break :result .none;
-
-        const elem_abi_size: u32 = @intCast(elem_ty.abiSize(mod));
-        const index_ty = self.typeOf(bin_op.rhs);
-        const index_mcv = try self.resolveInst(bin_op.rhs);
-        const index_lock = switch (index_mcv) {
-            .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
-            else => null,
-        };
-        defer if (index_lock) |lock| self.register_manager.unlockReg(lock);
-
-        const offset_reg = try self.elemOffset(index_ty, index_mcv, elem_abi_size);
-        const offset_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
-        defer self.register_manager.unlockReg(offset_lock);
-
-        const ptr_mcv = try self.resolveInst(bin_op.lhs);
-        const elem_ptr_reg = if (ptr_mcv.isRegister() and self.liveness.operandDies(inst, 0))
-            ptr_mcv.register
-        else
-            try self.copyToTmpRegister(ptr_ty, ptr_mcv);
-        const elem_ptr_lock = self.register_manager.lockRegAssumeUnused(elem_ptr_reg);
-        defer self.register_manager.unlockReg(elem_ptr_lock);
-        try self.asmRegisterRegister(
-            .{ ._, .add },
-            elem_ptr_reg,
-            offset_reg,
-        );
-
-        const dst_mcv = try self.allocRegOrMem(inst, true);
-        const dst_lock = switch (dst_mcv) {
-            .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
-            else => null,
-        };
-        defer if (dst_lock) |lock| self.register_manager.unlockReg(lock);
-        try self.load(dst_mcv, ptr_ty, .{ .register = elem_ptr_reg });
-        break :result dst_mcv;
+    const elem_ty = ptr_ty.elemType2(mod);
+    const elem_abi_size: u32 = @intCast(elem_ty.abiSize(mod));
+    const index_ty = self.typeOf(bin_op.rhs);
+    const index_mcv = try self.resolveInst(bin_op.rhs);
+    const index_lock = switch (index_mcv) {
+        .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
+        else => null,
     };
-    return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
+    defer if (index_lock) |lock| self.register_manager.unlockReg(lock);
+
+    const offset_reg = try self.elemOffset(index_ty, index_mcv, elem_abi_size);
+    const offset_lock = self.register_manager.lockRegAssumeUnused(offset_reg);
+    defer self.register_manager.unlockReg(offset_lock);
+
+    const ptr_mcv = try self.resolveInst(bin_op.lhs);
+    const elem_ptr_reg = if (ptr_mcv.isRegister() and self.liveness.operandDies(inst, 0))
+        ptr_mcv.register
+    else
+        try self.copyToTmpRegister(ptr_ty, ptr_mcv);
+    const elem_ptr_lock = self.register_manager.lockRegAssumeUnused(elem_ptr_reg);
+    defer self.register_manager.unlockReg(elem_ptr_lock);
+    try self.asmRegisterRegister(
+        .{ ._, .add },
+        elem_ptr_reg,
+        offset_reg,
+    );
+
+    const dst_mcv = try self.allocRegOrMem(inst, true);
+    const dst_lock = switch (dst_mcv) {
+        .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
+        else => null,
+    };
+    defer if (dst_lock) |lock| self.register_manager.unlockReg(lock);
+    try self.load(dst_mcv, ptr_ty, .{ .register = elem_ptr_reg });
+
+    return self.finishAir(inst, dst_mcv, .{ bin_op.lhs, bin_op.rhs, .none });
 }
 
 fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
@@ -4963,7 +4937,7 @@ fn byteSwap(self: *Self, inst: Air.Inst.Index, src_ty: Type, src_mcv: MCValue, m
     const mod = self.bin_file.options.module.?;
     const ty_op = self.air.instructions.items(.data)[inst].ty_op;
 
-    if (src_ty.zigTypeTag(mod) == .Vector) return self.fail(
+    if (src_ty.zigTypeTag(mod) == .Vector or src_ty.abiSize(mod) > 8) return self.fail(
         "TODO implement byteSwap for {}",
         .{src_ty.fmt(mod)},
     );
@@ -5814,17 +5788,15 @@ fn packedLoad(self: *Self, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) Inn
     const ptr_info = ptr_ty.ptrInfo(mod);
 
     const val_ty = ptr_info.child.toType();
-    if (!val_ty.hasRuntimeBitsIgnoreComptime(mod)) return;
     const val_abi_size: u32 = @intCast(val_ty.abiSize(mod));
-
-    if (val_abi_size > 8) return self.fail("TODO implement packed load of {}", .{val_ty.fmt(mod)});
-
     const limb_abi_size: u32 = @min(val_abi_size, 8);
     const limb_abi_bits = limb_abi_size * 8;
     const val_byte_off: i32 = @intCast(ptr_info.packed_offset.bit_offset / limb_abi_bits * limb_abi_size);
     const val_bit_off = ptr_info.packed_offset.bit_offset % limb_abi_bits;
     const val_extra_bits = self.regExtraBits(val_ty);
 
+    if (val_abi_size > 8) return self.fail("TODO implement packed load of {}", .{val_ty.fmt(mod)});
+
     const ptr_reg = try self.copyToTmpRegister(ptr_ty, ptr_mcv);
     const ptr_lock = self.register_manager.lockRegAssumeUnused(ptr_reg);
     defer self.register_manager.unlockReg(ptr_lock);
@@ -5887,7 +5859,6 @@ fn packedLoad(self: *Self, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) Inn
 fn load(self: *Self, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerError!void {
     const mod = self.bin_file.options.module.?;
     const dst_ty = ptr_ty.childType(mod);
-    if (!dst_ty.hasRuntimeBitsIgnoreComptime(mod)) return;
     switch (ptr_mcv) {
         .none,
         .unreach,
@@ -5964,7 +5935,6 @@ fn packedStore(self: *Self, ptr_ty: Type, ptr_mcv: MCValue, src_mcv: MCValue) In
     const mod = self.bin_file.options.module.?;
     const ptr_info = ptr_ty.ptrInfo(mod);
     const src_ty = ptr_ty.childType(mod);
-    if (!src_ty.hasRuntimeBitsIgnoreComptime(mod)) return;
 
     const limb_abi_size: u16 = @min(ptr_info.packed_offset.host_size, 8);
     const limb_abi_bits = limb_abi_size * 8;
@@ -6036,7 +6006,6 @@ fn packedStore(self: *Self, ptr_ty: Type, ptr_mcv: MCValue, src_mcv: MCValue) In
 fn store(self: *Self, ptr_ty: Type, ptr_mcv: MCValue, src_mcv: MCValue) InnerError!void {
     const mod = self.bin_file.options.module.?;
     const src_ty = ptr_ty.childType(mod);
-    if (!src_ty.hasRuntimeBitsIgnoreComptime(mod)) return;
     switch (ptr_mcv) {
         .none,
         .unreach,
@@ -10507,44 +10476,39 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
             },
             else => return self.fail("invalid constraint: '{s}'", .{constraint}),
         };
-        const arg_mcv: MCValue = arg_mcv: {
-            const arg_maybe_reg: ?Register = if (mem.eql(u8, constraint[1..], "r"))
-                self.register_manager.tryAllocReg(maybe_inst, self.regClassForType(ty)) orelse
-                    return self.fail("ran out of registers lowering inline asm", .{})
-            else if (mem.eql(u8, constraint[1..], "m"))
-                if (output != .none) null else return self.fail(
-                    "memory constraint unsupported for asm result: '{s}'",
-                    .{constraint},
-                )
-            else if (mem.eql(u8, constraint[1..], "g") or
-                mem.eql(u8, constraint[1..], "rm") or mem.eql(u8, constraint[1..], "mr") or
-                mem.eql(u8, constraint[1..], "r,m") or mem.eql(u8, constraint[1..], "m,r"))
-                self.register_manager.tryAllocReg(maybe_inst, self.regClassForType(ty)) orelse
-                    if (output != .none)
-                    null
-                else
-                    return self.fail("ran out of registers lowering inline asm", .{})
-            else if (mem.startsWith(u8, constraint[1..], "{") and mem.endsWith(u8, constraint[1..], "}"))
-                parseRegName(constraint[1 + "{".len .. constraint.len - "}".len]) orelse
-                    return self.fail("invalid register constraint: '{s}'", .{constraint})
-            else if (constraint.len == 2 and std.ascii.isDigit(constraint[1])) {
-                const index = std.fmt.charToDigit(constraint[0], 10) catch unreachable;
-                if (index >= args.items.len) return self.fail("constraint out of bounds: '{s}'", .{constraint});
-                break :arg_mcv args.items[index];
-            } else return self.fail("invalid constraint: '{s}'", .{constraint});
-            break :arg_mcv if (arg_maybe_reg) |reg| .{ .register = reg } else arg: {
-                const ptr_mcv = try self.resolveInst(output);
-                switch (ptr_mcv) {
-                    .immediate => |addr| if (math.cast(i32, @as(i64, @bitCast(addr)))) |_|
-                        break :arg ptr_mcv.deref(),
-                    .register, .register_offset, .lea_frame => break :arg ptr_mcv.deref(),
-                    else => {},
-                }
-                break :arg .{ .indirect = .{ .reg = try self.copyToTmpRegister(Type.usize, ptr_mcv) } };
-            };
+        const arg_maybe_reg: ?Register = if (mem.eql(u8, constraint[1..], "r"))
+            self.register_manager.tryAllocReg(maybe_inst, self.regClassForType(ty)) orelse
+                return self.fail("ran out of registers lowering inline asm", .{})
+        else if (mem.eql(u8, constraint[1..], "m"))
+            if (output != .none) null else return self.fail(
+                "memory constraint unsupported for asm result: '{s}'",
+                .{constraint},
+            )
+        else if (mem.eql(u8, constraint[1..], "g") or
+            mem.eql(u8, constraint[1..], "rm") or mem.eql(u8, constraint[1..], "mr") or
+            mem.eql(u8, constraint[1..], "r,m") or mem.eql(u8, constraint[1..], "m,r"))
+            self.register_manager.tryAllocReg(maybe_inst, self.regClassForType(ty)) orelse
+                if (output != .none)
+                null
+            else
+                return self.fail("ran out of registers lowering inline asm", .{})
+        else if (mem.startsWith(u8, constraint[1..], "{") and mem.endsWith(u8, constraint[1..], "}"))
+            parseRegName(constraint[1 + "{".len .. constraint.len - "}".len]) orelse
+                return self.fail("invalid register constraint: '{s}'", .{constraint})
+        else
+            return self.fail("invalid constraint: '{s}'", .{constraint});
+        const arg_mcv: MCValue = if (arg_maybe_reg) |reg| .{ .register = reg } else arg: {
+            const ptr_mcv = try self.resolveInst(output);
+            switch (ptr_mcv) {
+                .immediate => |addr| if (math.cast(i32, @as(i64, @bitCast(addr)))) |_|
+                    break :arg ptr_mcv.deref(),
+                .register, .register_offset, .lea_frame => break :arg ptr_mcv.deref(),
+                else => {},
+            }
+            break :arg .{ .indirect = .{ .reg = try self.copyToTmpRegister(Type.usize, ptr_mcv) } };
         };
         if (arg_mcv.getReg()) |reg| if (RegisterManager.indexOfRegIntoTracked(reg)) |_| {
-            _ = self.register_manager.lockReg(reg);
+            _ = self.register_manager.lockRegAssumeUnused(reg);
         };
         if (!mem.eql(u8, name, "_"))
             arg_map.putAssumeCapacityNoClobber(name, @intCast(args.items.len));
@@ -10606,10 +10570,6 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
             try self.register_manager.getReg(reg, null);
             try self.genSetReg(reg, ty, input_mcv);
             break :arg .{ .register = reg };
-        } else if (constraint.len == 1 and std.ascii.isDigit(constraint[0])) arg: {
-            const index = std.fmt.charToDigit(constraint[0], 10) catch unreachable;
-            if (index >= args.items.len) return self.fail("constraint out of bounds: '{s}'", .{constraint});
-            break :arg args.items[index];
         } else return self.fail("invalid constraint: '{s}'", .{constraint});
         if (arg_mcv.getReg()) |reg| if (RegisterManager.indexOfRegIntoTracked(reg)) |_| {
             _ = self.register_manager.lockReg(reg);
@@ -10735,7 +10695,7 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
                 mnem_name[mnem_prefix.len .. mnem_name.len - mnem_suffix.len],
             ) orelse continue };
         } else {
-            assert(prefix != .none); // no combination of fixes produced a known mnemonic
+            assert(prefix != .none);
             return self.fail("invalid prefix for mnemonic: '{s} {s}'", .{
                 @tagName(prefix), mnem_str,
             });
@@ -10966,7 +10926,6 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
 
         if (output == .none) continue;
         if (arg_mcv != .register) continue;
-        if (constraint.len == 2 and std.ascii.isDigit(constraint[1])) continue;
         try self.store(self.typeOf(output), .{ .air_ref = output }, arg_mcv);
     }
 
@@ -11060,7 +11019,6 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {
             else => {},
         },
         .Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
-            .Bool => return .{ .move = .{ ._, .mov } },
             .Int => switch (ty.childType(mod).intInfo(mod).bits) {
                 8 => switch (ty.vectorLen(mod)) {
                     1 => if (self.hasFeature(.avx)) return .{ .vex_insert_extract = .{
@@ -11326,6 +11284,7 @@ fn genSetReg(self: *Self, dst_reg: Register, ty: Type, src_mcv: MCValue) InnerEr
         .none,
         .unreach,
         .dead,
+        .register_pair,
         .register_overflow,
         .reserved_frame,
         => unreachable,
@@ -11429,7 +11388,6 @@ fn genSetReg(self: *Self, dst_reg: Register, ty: Type, src_mcv: MCValue) InnerEr
             },
             .x87, .mmx => unreachable,
         },
-        .register_pair => |src_regs| try self.genSetReg(dst_reg, ty, .{ .register = src_regs[0] }),
         .register_offset,
         .indirect,
         .load_frame,
@@ -11563,13 +11521,10 @@ fn genSetMem(self: *Self, base: Memory.Base, disp: i32, ty: Type, src_mcv: MCVal
         .undef => {},
         .immediate => |imm| switch (abi_size) {
             1, 2, 4 => {
-                const immediate = switch (if (ty.isAbiInt(mod))
-                    ty.intInfo(mod).signedness
+                const immediate = if (ty.isSignedInt(mod))
+                    Immediate.s(@truncate(@as(i64, @bitCast(imm))))
                 else
-                    .unsigned) {
-                    .signed => Immediate.s(@truncate(@as(i64, @bitCast(imm)))),
-                    .unsigned => Immediate.u(@as(u32, @intCast(imm))),
-                };
+                    Immediate.u(@as(u32, @intCast(imm)));
                 try self.asmMemoryImmediate(
                     .{ ._, .mov },
                     Memory.sib(Memory.PtrSize.fromSize(abi_size), .{ .base = base, .disp = disp }),
@@ -11631,35 +11586,19 @@ fn genSetMem(self: *Self, base: Memory.Base, disp: i32, ty: Type, src_mcv: MCVal
                 .{ .base = base, .disp = disp + @as(i32, @intCast(src_reg_i * 8)) },
             ), registerAlias(src_reg, part_size));
         },
-        .register_overflow => |ro| switch (ty.zigTypeTag(mod)) {
-            .Struct => {
-                try self.genSetMem(
-                    base,
-                    disp + @as(i32, @intCast(ty.structFieldOffset(0, mod))),
-                    ty.structFieldType(0, mod),
-                    .{ .register = ro.reg },
-                );
-                try self.genSetMem(
-                    base,
-                    disp + @as(i32, @intCast(ty.structFieldOffset(1, mod))),
-                    ty.structFieldType(1, mod),
-                    .{ .eflags = ro.eflags },
-                );
-            },
-            .Optional => {
-                assert(!ty.optionalReprIsPayload(mod));
-                const child_ty = ty.optionalChild(mod);
-                try self.genSetMem(base, disp, child_ty, .{ .register = ro.reg });
-                try self.genSetMem(
-                    base,
-                    disp + @as(i32, @intCast(child_ty.abiSize(mod))),
-                    Type.bool,
-                    .{ .eflags = ro.eflags },
-                );
-            },
-            else => return self.fail("TODO implement genSetMem for {s} of {}", .{
-                @tagName(src_mcv), ty.fmt(mod),
-            }),
+        .register_overflow => |ro| {
+            try self.genSetMem(
+                base,
+                disp + @as(i32, @intCast(ty.structFieldOffset(0, mod))),
+                ty.structFieldType(0, mod),
+                .{ .register = ro.reg },
+            );
+            try self.genSetMem(
+                base,
+                disp + @as(i32, @intCast(ty.structFieldOffset(1, mod))),
+                ty.structFieldType(1, mod),
+                .{ .eflags = ro.eflags },
+            );
         },
         .register_offset,
         .memory,
diff --git a/src/arch/x86_64/Encoding.zig b/src/arch/x86_64/Encoding.zig
index 3ef835aa18..7b621e9551 100644
--- a/src/arch/x86_64/Encoding.zig
+++ b/src/arch/x86_64/Encoding.zig
@@ -232,7 +232,7 @@ pub const Mnemonic = enum {
     cmp,
     cmps, cmpsb, cmpsd, cmpsq, cmpsw,
     cmpxchg, cmpxchg8b, cmpxchg16b,
-    cpuid, cqo, cwd, cwde,
+    cqo, cwd, cwde,
     div,
     idiv, imul, int3,
     ja, jae, jb, jbe, jc, jrcxz, je, jg, jge, jl, jle, jna, jnae, jnb, jnbe,
@@ -246,7 +246,7 @@ pub const Mnemonic = enum {
     movsx, movsxd, movzx, mul,
     neg, nop, not,
     @"or",
-    pause, pop, popcnt, push,
+    pop, popcnt, push,
     rcl, rcr, ret, rol, ror,
     sal, sar, sbb,
     scas, scasb, scasd, scasq, scasw,
@@ -258,7 +258,7 @@ pub const Mnemonic = enum {
     stos, stosb, stosd, stosq, stosw,
     @"test", tzcnt,
     ud2,
-    xadd, xchg, xgetbv, xor,
+    xadd, xchg, xor,
     // X87
     fabs, fchs, ffree, fisttp, fld, fst, fstp,
     // MMX
diff --git a/src/arch/x86_64/Mir.zig b/src/arch/x86_64/Mir.zig
index 23bef3c03b..0e2a4cca6d 100644
--- a/src/arch/x86_64/Mir.zig
+++ b/src/arch/x86_64/Mir.zig
@@ -327,8 +327,6 @@ pub const Inst = struct {
         /// Compare and exchange
         /// Compare and exchange bytes
         cmpxchg,
-        /// CPU identification
-        cpuid,
         /// Convert doubleword to quadword
         cqo,
         /// Convert word to doubleword
@@ -388,8 +386,6 @@ pub const Inst = struct {
         /// Bitwise logical or of packed single-precision floating-point values
         /// Bitwise logical or of packed double-precision floating-point values
         @"or",
-        /// Spin loop hint
-        pause,
         /// Pop
         pop,
         /// Return the count of number of bits set to 1
@@ -441,8 +437,6 @@ pub const Inst = struct {
         xadd,
         /// Exchange register/memory with register
         xchg,
-        /// Get value of extended control register
-        xgetbv,
         /// Logical exclusive-or
         /// Bitwise logical xor of packed single-precision floating-point values
         /// Bitwise logical xor of packed double-precision floating-point values
diff --git a/src/arch/x86_64/encodings.zig b/src/arch/x86_64/encodings.zig
index d6efb4cfc7..a4a21061eb 100644
--- a/src/arch/x86_64/encodings.zig
+++ b/src/arch/x86_64/encodings.zig
@@ -266,8 +266,6 @@ pub const table = [_]Entry{
     .{ .cmpxchg8b,  .m, &.{ .m64  }, &.{ 0x0f, 0xc7 }, 1, .none, .none },
     .{ .cmpxchg16b, .m, &.{ .m128 }, &.{ 0x0f, 0xc7 }, 1, .long, .none },
 
-    .{ .cpuid, .np, &.{}, &.{ 0x0f, 0xa2 }, 0, .none, .none },
-
     .{ .div, .m, &.{ .rm8  }, &.{ 0xf6 }, 6, .none,  .none },
     .{ .div, .m, &.{ .rm8  }, &.{ 0xf6 }, 6, .rex,   .none },
     .{ .div, .m, &.{ .rm16 }, &.{ 0xf7 }, 6, .short, .none },
@@ -471,8 +469,6 @@ pub const table = [_]Entry{
     .{ .@"or", .rm, &.{ .r32,  .rm32   }, &.{ 0x0b }, 0, .none,  .none },
     .{ .@"or", .rm, &.{ .r64,  .rm64   }, &.{ 0x0b }, 0, .long,  .none },
 
-    .{ .pause, .np, &.{}, &.{ 0xf3, 0x90 }, 0, .none, .none },
-
     .{ .pop, .o, &.{ .r16  }, &.{ 0x58 }, 0, .short, .none },
     .{ .pop, .o, &.{ .r64  }, &.{ 0x58 }, 0, .none,  .none },
     .{ .pop, .m, &.{ .rm16 }, &.{ 0x8f }, 0, .short, .none },
@@ -809,8 +805,6 @@ pub const table = [_]Entry{
     .{ .xchg, .rm, &.{ .r32,  .rm32 }, &.{ 0x87 }, 0, .none,  .none },
     .{ .xchg, .rm, &.{ .r64,  .rm64 }, &.{ 0x87 }, 0, .long,  .none },
 
-    .{ .xgetbv, .np, &.{}, &.{ 0x0f, 0x01 }, 0, .none, .none },
-
     .{ .xor, .zi, &.{ .al,   .imm8   }, &.{ 0x34 }, 0, .none,  .none },
     .{ .xor, .zi, &.{ .ax,   .imm16  }, &.{ 0x35 }, 0, .short, .none },
     .{ .xor, .zi, &.{ .eax,  .imm32  }, &.{ 0x35 }, 0, .none,  .none },
diff --git a/src/codegen.zig b/src/codegen.zig
index 8405f59b54..fe948d18bd 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -545,7 +545,7 @@ pub fn generateSymbol(
 
             if (layout.payload_size == 0) {
                 return generateSymbol(bin_file, src_loc, .{
-                    .ty = typed_value.ty.unionTagTypeSafety(mod).?,
+                    .ty = typed_value.ty.unionTagType(mod).?,
                     .val = un.tag.toValue(),
                 }, code, debug_output, reloc_info);
             }
@@ -553,7 +553,7 @@ pub fn generateSymbol(
             // Check if we should store the tag first.
             if (layout.tag_size > 0 and layout.tag_align.compare(.gte, layout.payload_align)) {
                 switch (try generateSymbol(bin_file, src_loc, .{
-                    .ty = typed_value.ty.unionTagTypeSafety(mod).?,
+                    .ty = typed_value.ty.unionTagType(mod).?,
                     .val = un.tag.toValue(),
                 }, code, debug_output, reloc_info)) {
                     .ok => {},
diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
index 30b6286658..3b27e93402 100644
--- a/test/behavior/basic.zig
+++ b/test/behavior/basic.zig
@@ -745,12 +745,12 @@ test "auto created variables have correct alignment" {
 
 test "extern variable with non-pointer opaque type" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
 
     @export(var_to_export, .{ .name = "opaque_extern_var" });
     try expect(@as(*align(1) u32, @ptrCast(&opaque_extern_var)).* == 42);
diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig
index 2f49283fb1..e21ae2b20c 100644
--- a/test/behavior/bitcast.zig
+++ b/test/behavior/bitcast.zig
@@ -411,9 +411,8 @@ test "bitcast nan float does not modify signaling bit" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
-
     // TODO: https://github.com/ziglang/zig/issues/14366
     if (builtin.zig_backend == .stage2_llvm and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
 
diff --git a/test/behavior/bugs/6781.zig b/test/behavior/bugs/6781.zig
index eb1f9766d1..aac0c31a11 100644
--- a/test/behavior/bugs/6781.zig
+++ b/test/behavior/bugs/6781.zig
@@ -64,11 +64,11 @@ pub const JournalHeader = packed struct {
 test "fixed" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
 
     var buffer align(@alignOf(JournalHeader)) = [_]u8{0} ** 65536;
     var entry = std.mem.bytesAsValue(JournalHeader, buffer[0..@sizeOf(JournalHeader)]);
diff --git a/test/behavior/bugs/920.zig b/test/behavior/bugs/920.zig
index bf74180515..e4439df89c 100644
--- a/test/behavior/bugs/920.zig
+++ b/test/behavior/bugs/920.zig
@@ -57,11 +57,11 @@ const NormalDist = blk: {
 };
 
 test "bug 920 fixed" {
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
 
     const NormalDist1 = blk: {
         break :blk ZigTableGen(true, norm_r, norm_v, norm_f, norm_f_inv, norm_zero_case);
diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig
index a7029bf0b7..91e2812591 100644
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -1606,8 +1606,8 @@ test "peer type resolution: const sentinel slice and mutable non-sentinel slice"
 test "peer type resolution: float and comptime-known fixed-width integer" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
 
     const i: u8 = 100;
     var f: f32 = 1.234;
@@ -2372,7 +2372,7 @@ test "@intFromBool on vector" {
 }
 
 test "numeric coercions with undefined" {
-    if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
 
     const from: i32 = undefined;
     var to: f32 = from;
@@ -2383,6 +2383,7 @@ test "numeric coercions with undefined" {
 
 test "15-bit int to float" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
 
     var a: u15 = 42;
     var b: f32 = @floatFromInt(a);
@@ -2390,11 +2391,11 @@ test "15-bit int to float" {
 }
 
 test "@as does not corrupt values with incompatible representations" {
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
 
     const x: f32 = @as(f16, blk: {
         if (false) {
diff --git a/test/behavior/cast_int.zig b/test/behavior/cast_int.zig
index 723691ab08..5232c828d0 100644
--- a/test/behavior/cast_int.zig
+++ b/test/behavior/cast_int.zig
@@ -199,6 +199,7 @@ test "load non byte-sized value in union" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
 
     // note: this bug is triggered by the == operator, expectEqual will hide it
diff --git a/test/behavior/fn.zig b/test/behavior/fn.zig
index 859be1efda..aad7f57590 100644
--- a/test/behavior/fn.zig
+++ b/test/behavior/fn.zig
@@ -425,8 +425,8 @@ test "implicit cast function to function ptr" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
 
     const S1 = struct {
         export fn someFunctionThatReturnsAValue() c_int {
diff --git a/test/behavior/int128.zig b/test/behavior/int128.zig
index 01e6bc42ac..2413ab65ed 100644
--- a/test/behavior/int128.zig
+++ b/test/behavior/int128.zig
@@ -66,6 +66,7 @@ test "int128" {
 
 test "truncate int128" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig
index 39dc9977c9..8f89ab748e 100644
--- a/test/behavior/packed-struct.zig
+++ b/test/behavior/packed-struct.zig
@@ -659,12 +659,12 @@ test "optional pointer in packed struct" {
 test "nested packed struct field access test" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO packed structs larger than 64 bits
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
-
+    //
     const Vec2 = packed struct {
         x: f32,
         y: f32,
diff --git a/test/behavior/translate_c_macros.zig b/test/behavior/translate_c_macros.zig
index c1689285f4..68d30f1036 100644
--- a/test/behavior/translate_c_macros.zig
+++ b/test/behavior/translate_c_macros.zig
@@ -151,11 +151,11 @@ test "string and char literals that are not UTF-8 encoded. Issue #12784" {
 
 test "Macro that uses division operator. Issue #13162" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
 
     try expectEqual(@as(c_int, 42), h.DIVIDE_CONSTANT(@as(c_int, 42_000)));
     try expectEqual(@as(c_uint, 42), h.DIVIDE_CONSTANT(@as(c_uint, 42_000)));
diff --git a/test/behavior/tuple.zig b/test/behavior/tuple.zig
index 63e2cde46e..8580123a6e 100644
--- a/test/behavior/tuple.zig
+++ b/test/behavior/tuple.zig
@@ -370,8 +370,8 @@ test "tuple initialized with a runtime known value" {
 test "tuple of struct concatenation and coercion to array" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
 
     const StructWithDefault = struct { value: f32 = 42 };
     const SomeStruct = struct { array: [4]StructWithDefault };
diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig
index 8bcf219c4d..e9d7bade24 100644
--- a/test/behavior/vector.zig
+++ b/test/behavior/vector.zig
@@ -1329,8 +1329,8 @@ test "store to vector in slice" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
 
     var v = [_]@Vector(3, f32){
         .{ 1, 1, 1 },
diff --git a/test/tests.zig b/test/tests.zig
index d393c39a08..88ab31aabd 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -985,9 +985,7 @@ pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step {
             continue;
 
         // TODO get compiler-rt tests passing for self-hosted backends.
-        if ((test_target.target.getCpuArch() != .x86_64 or
-            test_target.target.getObjectFormat() != .elf) and
-            test_target.use_llvm == false and mem.eql(u8, options.name, "compiler-rt"))
+        if (test_target.use_llvm == false and mem.eql(u8, options.name, "compiler-rt"))
             continue;
 
         // TODO get compiler-rt tests passing for wasm32-wasi
@@ -1004,10 +1002,8 @@ pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step {
             test_target.use_llvm == false and mem.eql(u8, options.name, "universal-libc"))
             continue;
 
-        // TODO get std lib tests passing for other self-hosted backends.
-        if ((test_target.target.getCpuArch() != .x86_64 or
-            test_target.target.getObjectFormat() != .elf) and
-            test_target.use_llvm == false and mem.eql(u8, options.name, "std"))
+        // TODO get std lib tests passing for self-hosted backends.
+        if (test_target.use_llvm == false and mem.eql(u8, options.name, "std"))
             continue;
 
         const want_this_mode = for (options.optimize_modes) |m| {
diff --git a/tools/lldb_pretty_printers.py b/tools/lldb_pretty_printers.py
index 975edb7d0e..acd158b7b5 100644
--- a/tools/lldb_pretty_printers.py
+++ b/tools/lldb_pretty_printers.py
@@ -355,28 +355,17 @@ class Module_Decl__Module_Decl_Index_SynthProvider:
     def __init__(self, value, _=None): self.value = value
     def update(self):
         try:
-            ip = InternPool_Find(self.value.thread)
-            if not ip: return
-            self.ptr = ip.GetChildMemberWithName('allocated_decls').GetChildAtIndex(self.value.unsigned).address_of.Clone('decl')
+            for frame in self.value.thread:
+                mod = frame.FindVariable('mod') or frame.FindVariable('module')
+                if mod: break
+            else: return
+            self.ptr = mod.GetChildMemberWithName('allocated_decls').GetChildAtIndex(self.value.unsigned).address_of.Clone('decl')
         except: pass
     def has_children(self): return True
     def num_children(self): return 1
     def get_child_index(self, name): return 0 if name == 'decl' else -1
     def get_child_at_index(self, index): return self.ptr if index == 0 else None
 
-class Module_Namespace__Module_Namespace_Index_SynthProvider:
-    def __init__(self, value, _=None): self.value = value
-    def update(self):
-        try:
-            ip = InternPool_Find(self.value.thread)
-            if not ip: return
-            self.ptr = ip.GetChildMemberWithName('allocated_namespaces').GetChildAtIndex(self.value.unsigned).address_of.Clone('namespace')
-        except: pass
-    def has_children(self): return True
-    def num_children(self): return 1
-    def get_child_index(self, name): return 0 if name == 'namespace' else -1
-    def get_child_at_index(self, index): return self.ptr if index == 0 else None
-
 class TagOrPayloadPtr_SynthProvider:
     def __init__(self, value, _=None): self.value = value
     def update(self):
@@ -451,9 +440,10 @@ class InternPool_Index_SynthProvider:
             for encoding_field in encoding_type.fields:
                 if encoding_field.name == 'data':
                     if encoding_field.type.IsPointerType():
+                        data_type = encoding_field.type.GetPointeeType()
                         extra_index = data.unsigned
-                        self.data = extra.GetChildAtIndex(extra_index).address_of.Cast(encoding_field.type).deref.Clone('data')
-                        extra_index += encoding_field.type.GetPointeeType().num_fields
+                        self.data = extra.GetChildAtIndex(extra_index).Cast(data_type).Clone('data')
+                        extra_index += data_type.num_fields
                     else:
                         self.data = data.Cast(encoding_field.type).Clone('data')
                 elif encoding_field.name == 'trailing':
@@ -710,7 +700,6 @@ def __lldb_init_module(debugger, _=None):
     add(debugger, category='zig.stage2', regex=True, type=MultiArrayList_Entry('Air\\.Inst'), identifier='TagAndPayload', synth=True, inline_children=True, summary=True)
     add(debugger, category='zig.stage2', regex=True, type='^Air\\.Inst\\.Data\\.Data__struct_[1-9][0-9]*$', inline_children=True, summary=True)
     add(debugger, category='zig.stage2', type='Module.Decl::Module.Decl.Index', synth=True)
-    add(debugger, category='zig.stage2', type='Module.Namespace::Module.Namespace.Index', synth=True)
     add(debugger, category='zig.stage2', type='Module.LazySrcLoc', identifier='zig_TaggedUnion', synth=True)
     add(debugger, category='zig.stage2', type='InternPool.Index', synth=True)
     add(debugger, category='zig.stage2', type='InternPool.NullTerminatedString', summary=True)