stage2 AArch64: complete genTypedValue

29 files changed, 0 insertions, 63 deletions

diff --git a/test/behavior/align.zig b/test/behavior/align.zig
index 6a819b4a7d..2c0893074e 100644
--- a/test/behavior/align.zig
+++ b/test/behavior/align.zig
@@ -7,7 +7,6 @@ var foo: u8 align(4) = 100;
 
 test "global variable alignment" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     comptime try expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4);
diff --git a/test/behavior/array.zig b/test/behavior/array.zig
index 728e05271a..93de42df67 100644
--- a/test/behavior/array.zig
+++ b/test/behavior/array.zig
@@ -95,8 +95,6 @@ test "array literal with specified size" {
 }
 
 test "array len field" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-
     var arr = [4]u8{ 0, 0, 0, 0 };
     var ptr = &arr;
     try expect(arr.len == 4);
@@ -217,8 +215,6 @@ fn doSomeMangling(array: *[4]u8) void {
 }
 
 test "implicit cast zero sized array ptr to slice" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-
     {
         var b = "".*;
         const c: []const u8 = &b;
diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
index adcba8721d..ac9e776c76 100644
--- a/test/behavior/basic.zig
+++ b/test/behavior/basic.zig
@@ -362,7 +362,6 @@ fn testMemcpyMemset() !void {
 }
 
 test "variable is allowed to be a pointer to an opaque type" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
 
@@ -611,7 +610,6 @@ test "self reference through fn ptr field" {
 }
 
 test "global variable initialized to global variable array element" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
     try expect(global_ptr == &gdt[0]);
@@ -677,7 +675,6 @@ test "explicit cast optional pointers" {
 }
 
 test "pointer comparison" {
-    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;
 
diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig
index c571851fe4..e851d7de09 100644
--- a/test/behavior/bitcast.zig
+++ b/test/behavior/bitcast.zig
@@ -7,7 +7,6 @@ const minInt = std.math.minInt;
 const native_endian = builtin.target.cpu.arch.endian();
 
 test "@bitCast iX -> uX (32, 64)" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
     const bit_values = [_]usize{ 32, 64 };
diff --git a/test/behavior/bitreverse.zig b/test/behavior/bitreverse.zig
index 36a3d3475c..821bc21f27 100644
--- a/test/behavior/bitreverse.zig
+++ b/test/behavior/bitreverse.zig
@@ -158,7 +158,6 @@ test "bitReverse vectors u0" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     comptime try vector0();
     try vector0();
diff --git a/test/behavior/bugs/11165.zig b/test/behavior/bugs/11165.zig
index cf2f9698f9..b3c4a32ec4 100644
--- a/test/behavior/bugs/11165.zig
+++ b/test/behavior/bugs/11165.zig
@@ -2,7 +2,6 @@ const builtin = @import("builtin");
 
 test "bytes" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     const S = struct {
         a: u32,
@@ -25,7 +24,6 @@ test "bytes" {
 
 test "aggregate" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     const S = struct {
         a: u32,
diff --git a/test/behavior/bugs/11181.zig b/test/behavior/bugs/11181.zig
index 738bd4e3e7..67d26d6b4e 100644
--- a/test/behavior/bugs/11181.zig
+++ b/test/behavior/bugs/11181.zig
@@ -2,7 +2,6 @@ const builtin = @import("builtin");
 
 test "const inferred array of slices" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     const T = struct { v: bool };
 
@@ -16,7 +15,6 @@ test "const inferred array of slices" {
 
 test "var inferred array of slices" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     const T = struct { v: bool };
 
diff --git a/test/behavior/bugs/11213.zig b/test/behavior/bugs/11213.zig
index d4e3580c07..f238eb5aab 100644
--- a/test/behavior/bugs/11213.zig
+++ b/test/behavior/bugs/11213.zig
@@ -4,7 +4,6 @@ const testing = std.testing;
 
 test {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const g: error{Test}!void = error.Test;
diff --git a/test/behavior/bugs/1421.zig b/test/behavior/bugs/1421.zig
index e4e42bd21b..d6ea8a2bad 100644
--- a/test/behavior/bugs/1421.zig
+++ b/test/behavior/bugs/1421.zig
@@ -9,7 +9,6 @@ const S = struct {
 };
 
 test "functions with return type required to be comptime are generic" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     const ti = S.method();
diff --git a/test/behavior/bugs/394.zig b/test/behavior/bugs/394.zig
index e7d6e80936..9f5165d1ba 100644
--- a/test/behavior/bugs/394.zig
+++ b/test/behavior/bugs/394.zig
@@ -11,7 +11,6 @@ const expect = @import("std").testing.expect;
 const builtin = @import("builtin");
 
 test "fixed" {
-    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;
     const x = S{
diff --git a/test/behavior/bugs/4560.zig b/test/behavior/bugs/4560.zig
index 30d3677920..ea40e55da3 100644
--- a/test/behavior/bugs/4560.zig
+++ b/test/behavior/bugs/4560.zig
@@ -2,8 +2,6 @@ const std = @import("std");
 const builtin = @import("builtin");
 
 test "fixed" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-
     var s: S = .{
         .a = 1,
         .b = .{
diff --git a/test/behavior/bugs/7187.zig b/test/behavior/bugs/7187.zig
index 86f5aa6706..9ce63ad4cd 100644
--- a/test/behavior/bugs/7187.zig
+++ b/test/behavior/bugs/7187.zig
@@ -3,7 +3,6 @@ const builtin = @import("builtin");
 const expect = std.testing.expect;
 
 test "miscompilation with bool return type" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
     var x: usize = 1;
diff --git a/test/behavior/byteswap.zig b/test/behavior/byteswap.zig
index 6e317b7fc2..13cc823e9d 100644
--- a/test/behavior/byteswap.zig
+++ b/test/behavior/byteswap.zig
@@ -118,7 +118,6 @@ test "@byteSwap vectors u0" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     comptime try vector0();
     try vector0();
diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig
index 58b458ad1e..4ff2c78d47 100644
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -843,7 +843,6 @@ test "peer cast *[0]T to []const T" {
 }
 
 test "peer cast *[N]T to [*]T" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
 
     var array = [4:99]i32{ 1, 2, 3, 4 };
@@ -1116,7 +1115,6 @@ fn incrementVoidPtrArray(array: ?*anyopaque, len: usize) void {
 test "compile time int to ptr of function" {
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_aarch64) 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
 
diff --git a/test/behavior/comptime_memory.zig b/test/behavior/comptime_memory.zig
index 17cee27771..1a3e9ef606 100644
--- a/test/behavior/comptime_memory.zig
+++ b/test/behavior/comptime_memory.zig
@@ -5,7 +5,6 @@ const ptr_size = @sizeOf(usize);
 
 test "type pun signed and unsigned as single pointer" {
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     comptime {
@@ -18,7 +17,6 @@ test "type pun signed and unsigned as single pointer" {
 
 test "type pun signed and unsigned as many pointer" {
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     comptime {
         var x: u32 = 0;
@@ -30,7 +28,6 @@ test "type pun signed and unsigned as many pointer" {
 
 test "type pun signed and unsigned as array pointer" {
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     comptime {
         var x: u32 = 0;
@@ -74,7 +71,6 @@ test "type pun signed and unsigned as array pointer" {
 
 test "type pun value and struct" {
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     comptime {
         const StructOfU32 = extern struct { x: u32 };
diff --git a/test/behavior/error.zig b/test/behavior/error.zig
index 312ab1524a..b735d70d73 100644
--- a/test/behavior/error.zig
+++ b/test/behavior/error.zig
@@ -119,7 +119,6 @@ test "widen cast integer payload of error union function call" {
 
 test "debug info for optional error set" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     const SomeError = error{ Hello, Hello2 };
     var a_local_variable: ?SomeError = null;
diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig
index 4609b58ddb..f14a25451d 100644
--- a/test/behavior/eval.zig
+++ b/test/behavior/eval.zig
@@ -406,8 +406,6 @@ var st_init_str_foo = StInitStrFoo{
 };
 
 test "inline for with same type but different values" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-
     var res: usize = 0;
     inline for ([_]type{ [2]u8, [1]u8, [2]u8 }) |T| {
         var a: T = undefined;
@@ -487,7 +485,6 @@ test "comptime bitwise operators" {
 
 test "comptime shlWithOverflow" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     const ct_shifted: u64 = comptime amt: {
         var amt = @as(u64, 0);
@@ -559,8 +556,6 @@ pub fn vec3(x: f32, y: f32, z: f32) Vec3 {
 }
 
 test "inlined loop has array literal with elided runtime scope on first iteration but not second iteration" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-
     var runtime = [1]i32{3};
     comptime var i: usize = 0;
     inline while (i < 2) : (i += 1) {
@@ -611,7 +606,6 @@ const hi1 = "hi";
 const hi2 = hi1;
 test "const global shares pointer with other same one" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     try assertEqualPtrs(&hi1[0], &hi2[0]);
     comptime try expect(&hi1[0] == &hi2[0]);
@@ -982,7 +976,6 @@ test "closure capture type of runtime-known parameter" {
 
 test "comptime break passing through runtime condition converted to runtime break" {
     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
 
     const S = struct {
diff --git a/test/behavior/fn.zig b/test/behavior/fn.zig
index 26185f6ac1..324a2ad247 100644
--- a/test/behavior/fn.zig
+++ b/test/behavior/fn.zig
@@ -184,8 +184,6 @@ test "function with complex callconv and return type expressions" {
 }
 
 test "pass by non-copying value" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-
     try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);
 }
 
@@ -211,8 +209,6 @@ fn addPointCoordsVar(pt: anytype) !i32 {
 }
 
 test "pass by non-copying value as method" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-
     var pt = Point2{ .x = 1, .y = 2 };
     try expect(pt.addPointCoords() == 3);
 }
@@ -227,8 +223,6 @@ const Point2 = struct {
 };
 
 test "pass by non-copying value as method, which is generic" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-
     var pt = Point3{ .x = 1, .y = 2 };
     try expect(pt.addPointCoords(i32) == 3);
 }
@@ -244,8 +238,6 @@ const Point3 = struct {
 };
 
 test "pass by non-copying value as method, at comptime" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-
     comptime {
         var pt = Point2{ .x = 1, .y = 2 };
         try expect(pt.addPointCoords() == 3);
@@ -409,7 +401,6 @@ test "ability to give comptime types and non comptime types to same parameter" {
 
 test "function with inferred error set but returning no error" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     const S = struct {
         fn foo() !void {}
diff --git a/test/behavior/fn_delegation.zig b/test/behavior/fn_delegation.zig
index eee8f52490..25ec3dea1b 100644
--- a/test/behavior/fn_delegation.zig
+++ b/test/behavior/fn_delegation.zig
@@ -32,7 +32,6 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 {
 }
 
 test "fn delegation" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const foo = Foo{};
diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig
index 2a18135fe0..cd4e018be3 100644
--- a/test/behavior/generics.zig
+++ b/test/behavior/generics.zig
@@ -206,7 +206,6 @@ fn foo2(arg: anytype) bool {
 
 test "generic struct" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     var a1 = GenNode(i32){
         .value = 13,
         .next = null,
diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig
index 6219a6a5be..4e5eb5061c 100644
--- a/test/behavior/optional.zig
+++ b/test/behavior/optional.zig
@@ -33,8 +33,6 @@ test "optional pointer to size zero struct" {
 }
 
 test "equality compare optional pointers" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-
     try testNullPtrsEql();
     comptime try testNullPtrsEql();
 }
diff --git a/test/behavior/pointers.zig b/test/behavior/pointers.zig
index 07bab40135..a47d931883 100644
--- a/test/behavior/pointers.zig
+++ b/test/behavior/pointers.zig
@@ -85,7 +85,6 @@ test "assigning integer to C pointer" {
 test "C pointer comparison and arithmetic" {
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -477,7 +476,6 @@ test "element pointer arithmetic to slice" {
 }
 
 test "array slicing to slice" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const S = struct {
diff --git a/test/behavior/sizeof_and_typeof.zig b/test/behavior/sizeof_and_typeof.zig
index 4421b59f96..6c7e16b502 100644
--- a/test/behavior/sizeof_and_typeof.zig
+++ b/test/behavior/sizeof_and_typeof.zig
@@ -19,7 +19,6 @@ test "@sizeOf on compile-time types" {
 
 test "@TypeOf() with multiple arguments" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     {
diff --git a/test/behavior/slice.zig b/test/behavior/slice.zig
index 18c769f27c..e2694759bb 100644
--- a/test/behavior/slice.zig
+++ b/test/behavior/slice.zig
@@ -207,7 +207,6 @@ test "slice string literal has correct type" {
 }
 
 test "result location zero sized array inside struct field implicit cast to slice" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
 
     const E = struct {
@@ -509,7 +508,6 @@ test "slice pointer-to-array null terminated" {
 test "slice pointer-to-array zero length" {
     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_arm) return error.SkipZigTest; // TODO
 
     comptime {
diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
index 8370cd763e..5cbb8e973e 100644
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -168,14 +168,12 @@ const MemberFnTestFoo = struct {
 };
 
 test "call member function directly" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     const instance = MemberFnTestFoo{ .x = 1234 };
     const result = MemberFnTestFoo.member(instance);
     try expect(result == 1234);
 }
 
 test "store member function in variable" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     const instance = MemberFnTestFoo{ .x = 1234 };
     const memberFn = MemberFnTestFoo.member;
     const result = memberFn(instance);
@@ -1000,8 +998,6 @@ test "tuple element initialized with fn call" {
 }
 
 test "struct with union field" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-
     const Value = struct {
         ref: u32 = 2,
         kind: union(enum) {
diff --git a/test/behavior/type.zig b/test/behavior/type.zig
index c543d4f969..f4a32e5df0 100644
--- a/test/behavior/type.zig
+++ b/test/behavior/type.zig
@@ -473,7 +473,6 @@ test "Type.Union" {
 test "Type.Union from Type.Enum" {
     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
 
     const Tag = @Type(.{
         .Enum = .{
@@ -503,7 +502,6 @@ test "Type.Union from Type.Enum" {
 test "Type.Union from regular enum" {
     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
 
     const E = enum { working_as_expected };
     const T = @Type(.{
diff --git a/test/behavior/type_info.zig b/test/behavior/type_info.zig
index 32b9671f96..7bbfbbc1ab 100644
--- a/test/behavior/type_info.zig
+++ b/test/behavior/type_info.zig
@@ -381,7 +381,6 @@ extern fn foo(a: usize, b: bool, ...) callconv(.C) usize;
 extern fn fooAligned(a: usize, b: bool, ...) align(4) callconv(.C) usize;
 
 test "type info: generic function types" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     if (builtin.zig_backend != .stage1) {
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index 7f17ff50c6..4daa9c1ee5 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -1111,7 +1111,6 @@ test "union enum type gets a separate scope" {
 test "global variable struct contains union initialized to non-most-aligned field" {
     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
 
     const T = struct {
         const U = union(enum) {
diff --git a/test/behavior/void.zig b/test/behavior/void.zig
index fc1972c506..66b969d0bf 100644
--- a/test/behavior/void.zig
+++ b/test/behavior/void.zig
@@ -42,8 +42,6 @@ test "void optional" {
 }
 
 test "void array as a local variable initializer" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-
     var x = [_]void{{}} ** 1004;
     _ = x[0];
 }