Merge pull request #11192 from joachimschmidt557/stage2-arm

stage2 ARM: misc improvements

20 files changed, 0 insertions, 41 deletions

diff --git a/test/behavior/array.zig b/test/behavior/array.zig
index 4561db792f..67776f2db4 100644
--- a/test/behavior/array.zig
+++ b/test/behavior/array.zig
@@ -202,7 +202,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;
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
     {
         var b = "".*;
diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig
index a881f98e3d..99451e8442 100644
--- a/test/behavior/bitcast.zig
+++ b/test/behavior/bitcast.zig
@@ -269,7 +269,6 @@ test "bitcast passed as tuple element" {
 
 test "triple level result location with bitcast sandwich passed as tuple element" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
     const S = struct {
         fn foo(args: anytype) !void {
diff --git a/test/behavior/bugs/11181.zig b/test/behavior/bugs/11181.zig
index f7baed5774..738bd4e3e7 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_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     const T = struct { v: bool };
@@ -17,7 +16,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_arm) 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/1421.zig b/test/behavior/bugs/1421.zig
index e8aceeecaf..e4e42bd21b 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_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/bugs/2692.zig b/test/behavior/bugs/2692.zig
index af53888a17..36fd763ebd 100644
--- a/test/behavior/bugs/2692.zig
+++ b/test/behavior/bugs/2692.zig
@@ -6,7 +6,6 @@ fn foo(a: []u8) void {
 
 test "address of 0 length array" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     var pt: [0]u8 = undefined;
diff --git a/test/behavior/bugs/5474.zig b/test/behavior/bugs/5474.zig
index 1ee5b99d79..62d7a52a3f 100644
--- a/test/behavior/bugs/5474.zig
+++ b/test/behavior/bugs/5474.zig
@@ -49,15 +49,11 @@ fn constant() !void {
 }
 
 test "pointer-to-array constness for zero-size elements, var" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-
     try mutable();
     comptime try mutable();
 }
 
 test "pointer-to-array constness for zero-size elements, const" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-
     try constant();
     comptime try constant();
 }
diff --git a/test/behavior/bugs/828.zig b/test/behavior/bugs/828.zig
index a8253e0c4c..220d98ce09 100644
--- a/test/behavior/bugs/828.zig
+++ b/test/behavior/bugs/828.zig
@@ -30,7 +30,6 @@ fn constCount(comptime cb: *const CountBy, comptime unused: u32) void {
 }
 
 test "comptime struct return should not return the same instance" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     //the first parameter must be passed by reference to trigger the bug
diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig
index 764e3b77b4..9639f9eef8 100644
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -1080,7 +1080,6 @@ test "compile time int to ptr of function" {
 
     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_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
 
@@ -1129,7 +1128,6 @@ fn returnNullLitFromOptionalTypeErrorRef() anyerror!?*A {
 test "peer type resolution: [0]u8 and []const u8" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
     try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
@@ -1278,8 +1276,6 @@ test "assignment to optional pointer result loc" {
 }
 
 test "cast between *[N]void and []void" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-
     var a: [4]void = undefined;
     var b: []void = &a;
     try expect(b.len == 4);
diff --git a/test/behavior/fn.zig b/test/behavior/fn.zig
index c6b5a4efc9..ed71bf3d59 100644
--- a/test/behavior/fn.zig
+++ b/test/behavior/fn.zig
@@ -389,7 +389,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
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const S = struct {
         fn foo() !void {}
diff --git a/test/behavior/math.zig b/test/behavior/math.zig
index 5b91ceed47..8fae2114d8 100644
--- a/test/behavior/math.zig
+++ b/test/behavior/math.zig
@@ -367,7 +367,6 @@ test "binary not" {
     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
 
     try expect(comptime x: {
         break :x ~@as(u16, 0b1010101010101010) == 0b0101010101010101;
@@ -488,7 +487,6 @@ fn mod(comptime T: type, a: T, b: T) T {
 test "unsigned wrapping" {
     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
 
     try testUnsignedWrappingEval(maxInt(u32));
     comptime try testUnsignedWrappingEval(maxInt(u32));
@@ -503,7 +501,6 @@ fn testUnsignedWrappingEval(x: u32) !void {
 test "signed wrapping" {
     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
 
     try testSignedWrappingEval(maxInt(i32));
     comptime try testSignedWrappingEval(maxInt(i32));
@@ -518,7 +515,6 @@ fn testSignedWrappingEval(x: i32) !void {
 test "signed negation wrapping" {
     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
 
     try testSignedNegationWrappingEval(minInt(i16));
     comptime try testSignedNegationWrappingEval(minInt(i16));
@@ -532,7 +528,6 @@ fn testSignedNegationWrappingEval(x: i16) !void {
 test "unsigned negation wrapping" {
     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
 
     try testUnsignedNegationWrappingEval(1);
     comptime try testUnsignedNegationWrappingEval(1);
@@ -868,7 +863,6 @@ test "quad hex float literal parsing accurate" {
 
 test "truncating shift left" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     try testShlTrunc(maxInt(u16));
@@ -881,7 +875,6 @@ fn testShlTrunc(x: u16) !void {
 
 test "exact shift left" {
     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
 
     try testShlExact(0b00110101);
@@ -894,7 +887,6 @@ fn testShlExact(x: u8) !void {
 
 test "exact shift right" {
     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
 
     try testShrExact(0b10110100);
diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig
index 6cc174dbba..08adda259d 100644
--- a/test/behavior/optional.zig
+++ b/test/behavior/optional.zig
@@ -26,7 +26,6 @@ pub const EmptyStruct = struct {};
 
 test "optional pointer to size zero struct" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     var e = EmptyStruct{};
     var o: ?*EmptyStruct = &e;
diff --git a/test/behavior/ptrcast.zig b/test/behavior/ptrcast.zig
index 81bf479363..c1fc8ad2de 100644
--- a/test/behavior/ptrcast.zig
+++ b/test/behavior/ptrcast.zig
@@ -59,7 +59,6 @@ fn testReinterpretStructWrappedBytesAsInteger() !void {
 }
 
 test "reinterpret bytes of an array into an extern struct" {
-    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
 
diff --git a/test/behavior/sizeof_and_typeof.zig b/test/behavior/sizeof_and_typeof.zig
index 5b532761f3..5db56243af 100644
--- a/test/behavior/sizeof_and_typeof.zig
+++ b/test/behavior/sizeof_and_typeof.zig
@@ -186,7 +186,6 @@ test "@sizeOf(T) == 0 doesn't force resolving struct size" {
 }
 
 test "@TypeOf() has no runtime side effects" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     const S = struct {
diff --git a/test/behavior/slice.zig b/test/behavior/slice.zig
index d36e9815eb..613493e690 100644
--- a/test/behavior/slice.zig
+++ b/test/behavior/slice.zig
@@ -70,7 +70,6 @@ test "comptime slice of undefined pointer of length 0" {
 test "implicitly cast array of size 0 to slice" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
     var msg = [_]u8{};
     try assertLenIsZero(&msg);
@@ -206,7 +205,6 @@ const y = x[0x100..];
 test "compile time slice of pointer to hard coded address" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage1) 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_wasm) return error.SkipZigTest;
 
diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
index 1d52900796..2cda0ca3bd 100644
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -926,7 +926,6 @@ test "anonymous struct literal syntax" {
 
 test "fully anonymous struct" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const S = struct {
         fn doTheTest() !void {
@@ -951,7 +950,6 @@ test "fully anonymous struct" {
 
 test "fully anonymous list literal" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const S = struct {
         fn doTheTest() !void {
diff --git a/test/behavior/struct_contains_null_ptr_itself.zig b/test/behavior/struct_contains_null_ptr_itself.zig
index ce4f63f976..7a2e32b2c2 100644
--- a/test/behavior/struct_contains_null_ptr_itself.zig
+++ b/test/behavior/struct_contains_null_ptr_itself.zig
@@ -3,7 +3,6 @@ const expect = std.testing.expect;
 const builtin = @import("builtin");
 
 test "struct contains null pointer which contains original struct" {
-    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/type.zig b/test/behavior/type.zig
index 9d236071f2..04409852c1 100644
--- a/test/behavior/type.zig
+++ b/test/behavior/type.zig
@@ -468,7 +468,6 @@ test "Type.Union from Type.Enum" {
     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
 
     const Tag = @Type(.{
@@ -500,7 +499,6 @@ test "Type.Union from regular enum" {
     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
 
     const E = enum { working_as_expected };
diff --git a/test/behavior/type_info.zig b/test/behavior/type_info.zig
index 1789bf13ca..6d52b4da42 100644
--- a/test/behavior/type_info.zig
+++ b/test/behavior/type_info.zig
@@ -385,7 +385,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_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
diff --git a/test/behavior/var_args.zig b/test/behavior/var_args.zig
index 5cb498d169..21085dd92e 100644
--- a/test/behavior/var_args.zig
+++ b/test/behavior/var_args.zig
@@ -14,7 +14,6 @@ fn add(args: anytype) i32 {
 
 test "add arbitrary args" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     try expect(add(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
     try expect(add(.{@as(i32, 1234)}) == 1234);
@@ -27,14 +26,12 @@ fn readFirstVarArg(args: anytype) void {
 
 test "send void arg to var args" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     readFirstVarArg(.{{}});
 }
 
 test "pass args directly" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     try expect(addSomeStuff(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
@@ -89,7 +86,6 @@ fn foo2(args: anytype) bool {
 
 test "array of var args functions" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     try expect(foos[0](.{}));
     try expect(!foos[1](.{}));
@@ -97,7 +93,6 @@ test "array of var args functions" {
 
 test "pass zero length array to var args param" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     doNothingWithFirstArg(.{""});
 }
diff --git a/test/behavior/void.zig b/test/behavior/void.zig
index b1efda23e4..fc1972c506 100644
--- a/test/behavior/void.zig
+++ b/test/behavior/void.zig
@@ -19,7 +19,6 @@ test "compare void with void compile time known" {
 }
 
 test "iterate over a void slice" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     var j: usize = 0;