diff --git a/lib/std/http/test.zig b/lib/std/http/test.zig
index 39f2063f65d7c1b175ce0750e9512abaee3f2c20..e7a37daa68de6751d5762b7639e25bd1401a37c0 100644
--- a/lib/std/http/test.zig
+++ b/lib/std/http/test.zig
@@ -1,5 +1,4 @@
 const builtin = @import("builtin");
-const native_endian = builtin.cpu.arch.endian();
 
 const std = @import("std");
 const http = std.http;
@@ -34,7 +33,6 @@ test "content length reader state update" {
 }
 
 test "trailers" {
-    if (builtin.cpu.arch.isPowerPC64() and builtin.mode != .debug) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/194257
     if (builtin.os.tag == .openbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/30806
 
     const io = std.testing.io;
@@ -121,7 +119,6 @@ test "trailers" {
 }
 
 test "HTTP server handles a chunked transfer coding request" {
-    if (builtin.cpu.arch.isPowerPC64() and builtin.mode != .debug) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/194257
     if (builtin.os.tag == .openbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/30806
 
     const io = std.testing.io;
@@ -190,7 +187,6 @@ test "HTTP server handles a chunked transfer coding request" {
 }
 
 test "echo content server" {
-    if (builtin.cpu.arch.isPowerPC64() and builtin.mode != .debug) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/194257
     if (builtin.os.tag == .openbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/30806
 
     const io = std.testing.io;
@@ -281,12 +277,11 @@ test "echo content server" {
 }
 
 test "Server.Request.respondStreaming non-chunked, unknown content-length" {
-    if (builtin.cpu.arch.isPowerPC64() and builtin.mode != .debug) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/194257
     if (builtin.os.tag == .openbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/30806
 
     const io = std.testing.io;
 
-    if (builtin.os.tag == .windows) {
+    if (builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) {
         // https://github.com/ziglang/zig/issues/21457
         return error.SkipZigTest;
     }
@@ -360,7 +355,6 @@ test "Server.Request.respondStreaming non-chunked, unknown content-length" {
 }
 
 test "receiving arbitrary http headers from the client" {
-    if (builtin.cpu.arch.isPowerPC64() and builtin.mode != .debug) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/194257
     if (builtin.os.tag == .openbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/30806
 
     const io = std.testing.io;
@@ -426,16 +420,10 @@ test "receiving arbitrary http headers from the client" {
 }
 
 test "general client/server API coverage" {
-    if (builtin.cpu.arch.isPowerPC64() and builtin.mode != .debug) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/194257
     if (builtin.os.tag == .openbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/30806
 
     const io = std.testing.io;
 
-    if (builtin.os.tag == .windows) {
-        // This test was never passing on Windows.
-        return error.SkipZigTest;
-    }
-
     const test_server = try createTestServer(io, struct {
         fn run(test_server: *TestServer) anyerror!void {
             const net_server = &test_server.net_server;
@@ -922,7 +910,6 @@ test "general client/server API coverage" {
 }
 
 test "Server streams both reading and writing" {
-    if (builtin.cpu.arch.isPowerPC64() and builtin.mode != .debug) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/194257
     if (builtin.os.tag == .openbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/30806
 
     const io = std.testing.io;
@@ -1162,10 +1149,6 @@ const TestServer = struct {
 
 fn createTestServer(io: Io, S: type) !*TestServer {
     if (builtin.single_threaded) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_llvm and native_endian == .big) {
-        // https://github.com/ziglang/zig/issues/13782
-        return error.SkipZigTest;
-    }
 
     const address = try net.IpAddress.parse("127.0.0.1", 0);
 
@@ -1192,7 +1175,6 @@ fn createTestServer(io: Io, S: type) !*TestServer {
 }
 
 test "redirect to different connection" {
-    if (builtin.cpu.arch.isPowerPC64() and builtin.mode != .debug) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/194257
     if (builtin.os.tag == .openbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/30806
 
     const io = std.testing.io;
@@ -1280,7 +1262,6 @@ test "redirect to different connection" {
 }
 
 test "boot failed connections from the pool" {
-    if (builtin.cpu.arch.isPowerPC64() and builtin.mode != .debug) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/194257
     if (builtin.os.tag == .openbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/30806
 
     const io = std.testing.io;
diff --git a/lib/std/math.zig b/lib/std/math.zig
index ae644d6fceff795c5cb1864acada365867a19521..27d5e0d584dca43e838d31eabec11ca2134045d9 100644
--- a/lib/std/math.zig
+++ b/lib/std/math.zig
@@ -461,7 +461,7 @@ pub fn wrap(x: anytype, r: anytype) @TypeOf(x) {
     }
 }
 test wrap {
-    if (builtin.os.tag == .windows and builtin.cpu.arch == .x86) {
+    if (builtin.os.tag == .windows and builtin.cpu.arch == .x86 and builtin.abi == .msvc) {
         // https://codeberg.org/ziglang/zig/issues/35520
         return error.SkipZigTest;
     }
diff --git a/lib/std/math/acos.zig b/lib/std/math/acos.zig
index 285190227c75b5780d3b2678656272b2e01d068a..d79c36182e0aa6ebd784c45f56c0232905a9c1a2 100644
--- a/lib/std/math/acos.zig
+++ b/lib/std/math/acos.zig
@@ -337,8 +337,6 @@ fn acosBinary128(x: f128) f128 {
 }
 
 test "acosBinary16.special" {
-    if (builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .macos) return error.SkipZigTest;
-
     try testing.expectApproxEqAbs(0x1.92p0, acosBinary16(0x0p+0), math.floatEpsAt(f16, 0x1.92p0));
     try testing.expectApproxEqAbs(0x1.92p1, acosBinary16(-0x1p+0), math.floatEpsAt(f16, 0x1.92p1));
     try testing.expectEqual(0x0p+0, acosBinary16(0x1p+0));
@@ -350,8 +348,6 @@ test "acosBinary16.special" {
 }
 
 test "acosBinary16" {
-    if (builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .macos) return error.SkipZigTest;
-
     try testing.expectApproxEqAbs(0x1.834p0, acosBinary16(0x1.db4p-5), math.floatEpsAt(f16, 0x1.834p0));
     try testing.expectApproxEqAbs(0x1.d48p0, acosBinary16(-0x1.068p-2), math.floatEpsAt(f16, 0x1.d48p0));
     try testing.expectApproxEqAbs(0x1.b7cp0, acosBinary16(-0x1.2c4p-3), math.floatEpsAt(f16, 0x1.b7cp0));
diff --git a/lib/std/math/asin.zig b/lib/std/math/asin.zig
index 68efd182aaf93db9ba5824cd76be55854c5c5f40..dfd3f063954c68d25230993b0875873273eb9ff8 100644
--- a/lib/std/math/asin.zig
+++ b/lib/std/math/asin.zig
@@ -326,8 +326,6 @@ fn asinBinary128(x: f128) f128 {
 }
 
 test "asinBinary16.special" {
-    if (builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .macos) return error.SkipZigTest;
-
     try testing.expectApproxEqAbs(0x1.92p0, asinBinary16(0x1p+0), math.floatEpsAt(f16, 0x1.92p0));
     try testing.expectApproxEqAbs(-0x1.92p0, asinBinary16(-0x1p+0), math.floatEpsAt(f16, -0x1.92p0));
     try testing.expectEqual(0x0p+0, asinBinary16(0x0p+0));
@@ -340,8 +338,6 @@ test "asinBinary16.special" {
 }
 
 test "asinBinary16" {
-    if (builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .macos) return error.SkipZigTest;
-
     try testing.expectApproxEqAbs(-0x1.e4cp-6, asinBinary16(-0x1.e4cp-6), math.floatEpsAt(f16, -0x1.e4cp-6));
     try testing.expectApproxEqAbs(0x1.2a8p0, asinBinary16(0x1.d68p-1), math.floatEpsAt(f16, 0x1.2a8p0));
     try testing.expectApproxEqAbs(-0x1.eep-1, asinBinary16(-0x1.a4cp-1), math.floatEpsAt(f16, -0x1.eep-1));
diff --git a/lib/std/math/atan.zig b/lib/std/math/atan.zig
index 2d55b8bc1343d95f6671a96636d55b2b4a269c8e..75dab1b0c19732b229000d62634e7944491db254 100644
--- a/lib/std/math/atan.zig
+++ b/lib/std/math/atan.zig
@@ -481,8 +481,6 @@ fn atanBinary128(x: f128) f128 {
 }
 
 test "atanBinary16.special" {
-    if (builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .macos) return error.SkipZigTest;
-
     try testing.expectEqual(0x0p+0, atanBinary16(0x0p+0));
     try testing.expectEqual(-0x0p+0, atanBinary16(-0x0p+0));
     try testing.expectApproxEqAbs(0x1.92p-1, atanBinary16(0x1p+0), math.floatEpsAt(f16, 0x1.92p-1));
@@ -493,8 +491,6 @@ test "atanBinary16.special" {
 }
 
 test "atanBinary16" {
-    if (builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .macos) return error.SkipZigTest;
-
     try testing.expectApproxEqAbs(-0x1.74cp-2, atanBinary16(-0x1.864p-2), math.floatEpsAt(f16, -0x1.74cp-2));
     try testing.expectApproxEqAbs(-0x1.374p0, atanBinary16(-0x1.59cp1), math.floatEpsAt(f16, -0x1.374p0));
     try testing.expectApproxEqAbs(-0x1.11cp0, atanBinary16(-0x1.d2cp0), math.floatEpsAt(f16, -0x1.11cp0));
diff --git a/lib/std/math/hypot.zig b/lib/std/math/hypot.zig
index ef3fc97af3d3ea21b7cb525c616d248ffc20da7d..99da74c335c342a277778f79bafe53e7fb2d7766 100644
--- a/lib/std/math/hypot.zig
+++ b/lib/std/math/hypot.zig
@@ -1,4 +1,3 @@
-const builtin = @import("builtin");
 const std = @import("../std.zig");
 const math = std.math;
 const expect = std.testing.expect;
@@ -93,14 +92,10 @@ const hypot_test_cases = .{
 };
 
 test hypot {
-    if (builtin.cpu.arch.isPowerPC() and builtin.mode != .debug) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/171869
     try expect(hypot(0.3, 0.4) == 0.5);
 }
 
 test "hypot.correct" {
-    if (builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .macos) return error.SkipZigTest;
-    if (builtin.cpu.arch.isPowerPC() and builtin.mode != .debug) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/171869
-
     inline for (.{ f16, f32, f64, f128 }) |T| {
         inline for (hypot_test_cases) |v| {
             const a: T, const b: T, const c: T = v;
@@ -110,9 +105,6 @@ test "hypot.correct" {
 }
 
 test "hypot.precise" {
-    if (builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .macos) return error.SkipZigTest;
-    if (builtin.cpu.arch.isPowerPC() and builtin.mode != .debug) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/171869
-
     inline for (.{ f16, f32, f64 }) |T| { // f128 seems to be 5 ulp
         inline for (hypot_test_cases) |v| {
             const a: T, const b: T, const c: T = v;
@@ -122,7 +114,6 @@ test "hypot.precise" {
 }
 
 test "hypot.special" {
-    if (builtin.cpu.arch.isPowerPC() and builtin.mode != .debug) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/171869
     @setEvalBranchQuota(2000);
     inline for (.{ f16, f32, f64, f128 }) |T| {
         try expect(math.isNan(hypot(nan(T), 0.0)));
diff --git a/lib/std/math/isnan.zig b/lib/std/math/isnan.zig
index bf2af9be1db7472aaceae82c3d052e606ce454b7..cfbe172ecdbe22890c9e928103b328f7fe23a256 100644
--- a/lib/std/math/isnan.zig
+++ b/lib/std/math/isnan.zig
@@ -27,13 +27,6 @@ test isNan {
 }
 
 test isSignalNan {
-    if (builtin.zig_backend == .stage2_x86_64 and builtin.object_format == .coff and builtin.abi != .gnu) return error.SkipZigTest;
-
-    if (builtin.os.tag == .windows) {
-        // https://codeberg.org/ziglang/zig/issues/35519
-        return error.SkipZigTest;
-    }
-
     inline for ([_]type{ f16, f32, f64, f80, f128, c_longdouble }) |T| {
         // TODO: Signalling NaN values get converted to quiet NaN values in
         //       some cases where they shouldn't such that this can fail.
@@ -43,6 +36,7 @@ test isSignalNan {
             builtin.cpu.arch != .hexagon and
             !builtin.cpu.arch.isMIPS32() and
             !builtin.cpu.arch.isPowerPC() and
+            !(builtin.cpu.arch.isX86() and builtin.os.tag == .windows and builtin.abi == .msvc) and // https://codeberg.org/ziglang/zig/issues/35519
             builtin.zig_backend != .stage2_c)
         {
             try expect(isSignalNan(math.snan(T)));
diff --git a/lib/std/math/modf.zig b/lib/std/math/modf.zig
index 15515cde204a727d0191db34ace8adc68feb39e3..ea0433906958619572ad604d113f149c6fada392 100644
--- a/lib/std/math/modf.zig
+++ b/lib/std/math/modf.zig
@@ -1,5 +1,4 @@
 const std = @import("../std.zig");
-const builtin = @import("builtin");
 const math = std.math;
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
@@ -85,9 +84,6 @@ fn ModfTests(comptime T: type) type {
             try expectApproxEqAbs(expected_c, r.fpart, epsilon);
         }
         test "vector" {
-            if (builtin.os.tag.isDarwin() and builtin.cpu.arch == .aarch64) return error.SkipZigTest;
-            if (builtin.cpu.arch == .s390x) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/194256
-
             const widths = [_]comptime_int{ 1, 2, 3, 4, 8, 16 };
 
             inline for (widths) |len| {
diff --git a/lib/std/os/linux/IoUring/test.zig b/lib/std/os/linux/IoUring/test.zig
index 40429fbaab1cb7fb35a90427c69c2640ad907ed6..891ce5a397f61e2b6c655192d714e35d21f7e32c 100644
--- a/lib/std/os/linux/IoUring/test.zig
+++ b/lib/std/os/linux/IoUring/test.zig
@@ -1836,8 +1836,6 @@ test "accept/connect/send_zc/recv" {
 }
 
 test "accept_direct" {
-    if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/30854
-
     try skipKernelLessThan(.{ .major = 5, .minor = 19, .patch = 0 });
 
     var ring = IoUring.init(1, 0) catch |err| switch (err) {
@@ -1925,11 +1923,6 @@ test "accept_direct" {
 test "accept_multishot_direct" {
     try skipKernelLessThan(.{ .major = 5, .minor = 19, .patch = 0 });
 
-    if (builtin.cpu.arch == .riscv64) {
-        // https://github.com/ziglang/zig/issues/25734
-        return error.SkipZigTest;
-    }
-
     var ring = IoUring.init(1, 0) catch |err| switch (err) {
         error.SystemOutdated => return error.SkipZigTest,
         error.PermissionDenied => return error.SkipZigTest,
diff --git a/test/behavior/align.zig b/test/behavior/align.zig
index d79d2d07ba75c4660478753dc4d9a23d48fdfe2c..c9294e953b8d2c907a8b86e2c6b5916b1d75941a 100644
--- a/test/behavior/align.zig
+++ b/test/behavior/align.zig
@@ -569,7 +569,6 @@ test "sub-aligned pointer field access" {
 }
 
 test "alignment of zero-bit types is respected" {
-    if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
index 964de5d20ff8754e81d3c0deae59fd44a672b6f8..d1acfb366dbfe0620409a81ef565b0902237a81b 100644
--- a/test/behavior/basic.zig
+++ b/test/behavior/basic.zig
@@ -1397,7 +1397,6 @@ test "allocation and looping over 3-byte integer" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_llvm and builtin.os.tag.isDarwin()) return error.SkipZigTest; // TODO
 
     try expect(@sizeOf(u24) == 4);
     try expect(@sizeOf([1]u24) == 4);
diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig
index 697da63db23d14bb9e583745c80c8aca350d8a8d..077d3faeddc080357b48304a3f46240ad83e1fdd 100644
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -1719,7 +1719,6 @@ test "cast f16 to wider types" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .macos) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1828,11 +1827,6 @@ test "coerce between pointers of compatible differently-named floats" {
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) {
-        // https://github.com/ziglang/zig/issues/12396
-        return error.SkipZigTest;
-    }
-
     const F = switch (@typeInfo(c_longdouble).float.bits) {
         64 => f64,
         80 => f80,
diff --git a/test/behavior/field_parent_ptr.zig b/test/behavior/field_parent_ptr.zig
index c3d0c0087cc7eb9694310d5f8ff3755e35ca8077..8694f366a586cd4a756f7f1acb7862c656b04f02 100644
--- a/test/behavior/field_parent_ptr.zig
+++ b/test/behavior/field_parent_ptr.zig
@@ -1895,7 +1895,6 @@ test "@fieldParentPtr packed union" {
 }
 
 test "@fieldParentPtr tagged union all zero-bit fields" {
-    if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig
index ea01c8a88fe3ebf590d71027a7a5516cd57eeedb..583b6bf6aba3f0596a452e5f311bc1a388cd4691 100644
--- a/test/behavior/floatop.zig
+++ b/test/behavior/floatop.zig
@@ -216,7 +216,6 @@ test "vector cmp f16" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;
 
     try testCmpVector(f16);
@@ -378,11 +377,6 @@ test "@sqrt f80/f128/c_longdouble" {
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
 
-    if (builtin.os.tag == .freebsd) {
-        // TODO https://github.com/ziglang/zig/issues/10875
-        return error.SkipZigTest;
-    }
-
     try testSqrt(f80);
     try comptime testSqrt(f80);
     try testSqrt(f128);
@@ -943,7 +937,7 @@ test "@log2 with vectors" {
         builtin.cpu.arch == .aarch64 and
         builtin.os.tag == .windows) return error.SkipZigTest;
 
-    if (builtin.os.tag == .windows and builtin.cpu.arch == .x86) {
+    if (builtin.os.tag == .windows and builtin.cpu.arch == .x86 and builtin.abi == .msvc) {
         // https://codeberg.org/ziglang/zig/issues/35518
         return error.SkipZigTest;
     }
@@ -1411,11 +1405,6 @@ test "neg f16" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
-    if (builtin.os.tag == .freebsd) {
-        // TODO file issue to track this failure
-        return error.SkipZigTest;
-    }
-
     try testNeg(f16);
     try comptime testNeg(f16);
 }
diff --git a/test/behavior/threadlocal.zig b/test/behavior/threadlocal.zig
index cb4480f759af537ee0824d400fda530eb21a69b7..ec1ce0b62677b9cbb4988814e4c69f94ae65548c 100644
--- a/test/behavior/threadlocal.zig
+++ b/test/behavior/threadlocal.zig
@@ -9,11 +9,6 @@ test "thread local variable" {
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
 
-    if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag.isDarwin()) {
-        // Fails due to register hazards.
-        return error.SkipZigTest;
-    }
-
     const S = struct {
         threadlocal var t: i32 = 1234;
     };
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index 8ed483d02278160bc13f52b60a6b5cf5344eb40e..0ba364aabe557a0bac5832d285cc4595dc9cec25 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -1609,6 +1609,10 @@ fn littleToNativeEndian(comptime T: type, v: T) T {
 }
 
 test "reinterpret extern union" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isRiscv32() and builtin.link_libc) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isWasm()) return error.SkipZigTest;
+
     if (true) {
         // https://github.com/ziglang/zig/issues/19389
         return error.SkipZigTest;
@@ -1676,8 +1680,6 @@ test "reinterpret extern union" {
     };
 
     try comptime S.doTheTest();
-
-    if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // TODO
     try S.doTheTest();
 }
 
diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig
index 861b2e77db418adbb23343bf0a90db3733ad82f6..1b7d354e19c92996c8b6f30dde1acc2ad5914a4a 100644
--- a/test/behavior/vector.zig
+++ b/test/behavior/vector.zig
@@ -129,12 +129,6 @@ test "vector float operators" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
-        // Triggers an assertion with LLVM 18:
-        // https://github.com/ziglang/zig/issues/20680
-        return error.SkipZigTest;
-    }
-
     const S = struct {
         fn doTheTest(T: type) !void {
             var v: @Vector(4, T) = .{ 10, 20, 30, 40 };
@@ -279,7 +273,6 @@ test "array to vector with element type coercion" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .macos) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
diff --git a/test/behavior/widening.zig b/test/behavior/widening.zig
index c6571319d4fbb3a2265dd48fd31e67a9061e2055..6277c3acf6790cd769ac86dc885959e8281e7a71 100644
--- a/test/behavior/widening.zig
+++ b/test/behavior/widening.zig
@@ -41,7 +41,6 @@ test "float widening" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .macos) return error.SkipZigTest;
 
     var a: f16 = 12.34;
     var b: f32 = a;