Merge pull request #24536 from jacobly0/aarch64

aarch64: add new from scratch self-hosted backend

Author: andrewrk

CMakeLists.txt

@@ -550,6 +550,14 @@ set(ZIG_STAGE2_SOURCES
     src/clang_options.zig
     src/clang_options_data.zig
     src/codegen.zig
+    src/codegen/aarch64.zig
+    src/codegen/aarch64/abi.zig
+    src/codegen/aarch64/Assemble.zig
+    src/codegen/aarch64/Disassemble.zig
+    src/codegen/aarch64/encoding.zig
+    src/codegen/aarch64/instructions.zon
+    src/codegen/aarch64/Mir.zig
+    src/codegen/aarch64/Select.zig
     src/codegen/c.zig
     src/codegen/c/Type.zig
     src/codegen/llvm.zig

lib/compiler/test_runner.zig

@@ -16,6 +16,7 @@ var stdin_buffer: [4096]u8 = undefined;
 var stdout_buffer: [4096]u8 = undefined;
 
 const crippled = switch (builtin.zig_backend) {
+    .stage2_aarch64,
     .stage2_powerpc,
     .stage2_riscv64,
     => true,
@@ -287,13 +288,14 @@ pub fn log(
 /// work-in-progress backends can handle it.
 pub fn mainSimple() anyerror!void {
     @disableInstrumentation();
-    // is the backend capable of printing to stderr?
-    const enable_print = switch (builtin.zig_backend) {
+    // is the backend capable of calling `std.fs.File.writeAll`?
+    const enable_write = switch (builtin.zig_backend) {
+        .stage2_aarch64, .stage2_riscv64 => true,
         else => false,
     };
-    // is the backend capable of using std.fmt.format to print a summary at the end?
-    const print_summary = switch (builtin.zig_backend) {
-        .stage2_riscv64 => true,
+    // is the backend capable of calling `std.Io.Writer.print`?
+    const enable_print = switch (builtin.zig_backend) {
+        .stage2_aarch64, .stage2_riscv64 => true,
         else => false,
     };
 
@@ -302,34 +304,31 @@ pub fn mainSimple() anyerror!void {
     var failed: u64 = 0;
 
     // we don't want to bring in File and Writer if the backend doesn't support it
-    const stderr = if (comptime enable_print) std.fs.File.stderr() else {};
+    const stdout = if (enable_write) std.fs.File.stdout() else {};
 
     for (builtin.test_functions) |test_fn| {
+        if (enable_write) {
+            stdout.writeAll(test_fn.name) catch {};
+            stdout.writeAll("... ") catch {};
+        }
         if (test_fn.func()) |_| {
-            if (enable_print) {
-                stderr.writeAll(test_fn.name) catch {};
-                stderr.writeAll("... ") catch {};
-                stderr.writeAll("PASS\n") catch {};
-            }
+            if (enable_write) stdout.writeAll("PASS\n") catch {};
         } else |err| {
-            if (enable_print) {
-                stderr.writeAll(test_fn.name) catch {};
-                stderr.writeAll("... ") catch {};
-            }
             if (err != error.SkipZigTest) {
-                if (enable_print) stderr.writeAll("FAIL\n") catch {};
+                if (enable_write) stdout.writeAll("FAIL\n") catch {};
                 failed += 1;
-                if (!enable_print) return err;
+                if (!enable_write) return err;
                 continue;
             }
-            if (enable_print) stderr.writeAll("SKIP\n") catch {};
+            if (enable_write) stdout.writeAll("SKIP\n") catch {};
             skipped += 1;
             continue;
         }
         passed += 1;
     }
-    if (enable_print and print_summary) {
-        stderr.deprecatedWriter().print("{} passed, {} skipped, {} failed\n", .{ passed, skipped, failed }) catch {};
+    if (enable_print) {
+        var stdout_writer = stdout.writer(&.{});
+        stdout_writer.interface.print("{} passed, {} skipped, {} failed\n", .{ passed, skipped, failed }) catch {};
     }
     if (failed != 0) std.process.exit(1);
 }

lib/compiler_rt.zig

@@ -240,7 +240,7 @@ comptime {
     _ = @import("compiler_rt/udivmodti4.zig");
 
     // extra
-    _ = @import("compiler_rt/os_version_check.zig");
+    if (builtin.zig_backend != .stage2_aarch64) _ = @import("compiler_rt/os_version_check.zig");
     _ = @import("compiler_rt/emutls.zig");
     _ = @import("compiler_rt/arm.zig");
     _ = @import("compiler_rt/aulldiv.zig");
@@ -249,12 +249,12 @@ comptime {
     _ = @import("compiler_rt/hexagon.zig");
 
     if (@import("builtin").object_format != .c) {
-        _ = @import("compiler_rt/atomics.zig");
+        if (builtin.zig_backend != .stage2_aarch64) _ = @import("compiler_rt/atomics.zig");
         _ = @import("compiler_rt/stack_probe.zig");
 
         // macOS has these functions inside libSystem.
         if (builtin.cpu.arch.isAARCH64() and !builtin.os.tag.isDarwin()) {
-            _ = @import("compiler_rt/aarch64_outline_atomics.zig");
+            if (builtin.zig_backend != .stage2_aarch64) _ = @import("compiler_rt/aarch64_outline_atomics.zig");
         }
 
         _ = @import("compiler_rt/memcpy.zig");

lib/compiler_rt/addo.zig

@@ -1,6 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
-const is_test = builtin.is_test;
 const common = @import("./common.zig");
 pub const panic = @import("common.zig").panic;
 
@@ -16,7 +14,7 @@ comptime {
 // - addoXi4_generic as default
 
 inline fn addoXi4_generic(comptime ST: type, a: ST, b: ST, overflow: *c_int) ST {
-    @setRuntimeSafety(builtin.is_test);
+    @setRuntimeSafety(common.test_safety);
     overflow.* = 0;
     const sum: ST = a +% b;
     // Hackers Delight: section Overflow Detection, subsection Signed Add/Subtract

lib/compiler_rt/addoti4_test.zig

@@ -1,4 +1,5 @@
 const addv = @import("addo.zig");
+const builtin = @import("builtin");
 const std = @import("std");
 const testing = std.testing;
 const math = std.math;
@@ -23,6 +24,8 @@ fn simple_addoti4(a: i128, b: i128, overflow: *c_int) i128 {
 }
 
 test "addoti4" {
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+
     const min: i128 = math.minInt(i128);
     const max: i128 = math.maxInt(i128);
     var i: i128 = 1;

lib/compiler_rt/clear_cache.zig

@@ -97,8 +97,7 @@ fn clear_cache(start: usize, end: usize) callconv(.c) void {
             .nbytes = end - start,
             .whichcache = 3, // ICACHE | DCACHE
         };
-        asm volatile (
-            \\ syscall
+        asm volatile ("syscall"
             :
             : [_] "{$2}" (165), // nr = SYS_sysarch
               [_] "{$4}" (0), // op = MIPS_CACHEFLUSH
@@ -116,11 +115,8 @@ fn clear_cache(start: usize, end: usize) callconv(.c) void {
     } else if (arm64 and !apple) {
         // Get Cache Type Info.
         // TODO memoize this?
-        var ctr_el0: u64 = 0;
-        asm volatile (
-            \\mrs %[x], ctr_el0
-            \\
-            : [x] "=r" (ctr_el0),
+        const ctr_el0 = asm volatile ("mrs %[ctr_el0], ctr_el0"
+            : [ctr_el0] "=r" (-> u64),
         );
         // The DC and IC instructions must use 64-bit registers so we don't use
         // uintptr_t in case this runs in an IPL32 environment.
@@ -187,9 +183,7 @@ fn clear_cache(start: usize, end: usize) callconv(.c) void {
         exportIt();
     } else if (os == .linux and loongarch) {
         // See: https://github.com/llvm/llvm-project/blob/cf54cae26b65fc3201eff7200ffb9b0c9e8f9a13/compiler-rt/lib/builtins/clear_cache.c#L94-L95
-        asm volatile (
-            \\ ibar 0
-        );
+        asm volatile ("ibar 0");
         exportIt();
     }
 

lib/compiler_rt/cmp.zig

@@ -1,6 +1,5 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const is_test = builtin.is_test;
 const common = @import("common.zig");
 
 pub const panic = common.panic;

lib/compiler_rt/common.zig

@@ -102,9 +102,14 @@ pub const gnu_f16_abi = switch (builtin.cpu.arch) {
 
 pub const want_sparc_abi = builtin.cpu.arch.isSPARC();
 
+pub const test_safety = switch (builtin.zig_backend) {
+    .stage2_aarch64 => false,
+    else => builtin.is_test,
+};
+
 // Avoid dragging in the runtime safety mechanisms into this .o file, unless
 // we're trying to test compiler-rt.
-pub const panic = if (builtin.is_test) std.debug.FullPanic(std.debug.defaultPanic) else std.debug.no_panic;
+pub const panic = if (test_safety) std.debug.FullPanic(std.debug.defaultPanic) else std.debug.no_panic;
 
 /// This seems to mostly correspond to `clang::TargetInfo::HasFloat16`.
 pub fn F16T(comptime OtherType: type) type {

lib/compiler_rt/comparedf2_test.zig

@@ -4,7 +4,6 @@
 
 const std = @import("std");
 const builtin = @import("builtin");
-const is_test = builtin.is_test;
 
 const __eqdf2 = @import("./cmpdf2.zig").__eqdf2;
 const __ledf2 = @import("./cmpdf2.zig").__ledf2;

lib/compiler_rt/comparesf2_test.zig

@@ -4,7 +4,6 @@
 
 const std = @import("std");
 const builtin = @import("builtin");
-const is_test = builtin.is_test;
 
 const __eqsf2 = @import("./cmpsf2.zig").__eqsf2;
 const __lesf2 = @import("./cmpsf2.zig").__lesf2;