aarch64: implement some safety checks

Closes #24553

Author: jacobly0

src/Compilation.zig

@@ -1816,10 +1816,12 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
             if (options.skip_linker_dependencies) break :s .none;
             const want = options.want_compiler_rt orelse is_exe_or_dyn_lib;
             if (!want) break :s .none;
-            if (have_zcu) {
+            if (have_zcu and target_util.canBuildLibCompilerRt(target, use_llvm, build_options.have_llvm and use_llvm)) {
                 if (output_mode == .Obj) break :s .zcu;
-                if (target.ofmt == .coff and target_util.zigBackend(target, use_llvm) == .stage2_x86_64)
-                    break :s if (is_exe_or_dyn_lib) .dyn_lib else .zcu;
+                if (switch (target_util.zigBackend(target, use_llvm)) {
+                    else => false,
+                    .stage2_aarch64, .stage2_x86_64 => target.ofmt == .coff,
+                }) break :s if (is_exe_or_dyn_lib) .dyn_lib else .zcu;
             }
             if (is_exe_or_dyn_lib) break :s .lib;
             break :s .obj;
@@ -1854,7 +1856,7 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
             const want_ubsan_rt = options.want_ubsan_rt orelse (can_build_ubsan_rt and any_sanitize_c == .full and is_exe_or_dyn_lib);
             if (!want_ubsan_rt) break :s .none;
             if (options.skip_linker_dependencies) break :s .none;
-            if (have_zcu) break :s .zcu;
+            if (have_zcu and target_util.canBuildLibUbsanRt(target, use_llvm, build_options.have_llvm and use_llvm)) break :s .zcu;
             if (is_exe_or_dyn_lib) break :s .lib;
             break :s .obj;
         };

src/arch/x86_64/CodeGen.zig

@@ -168141,7 +168141,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .cc = .b }, .unused },
+                    .dst_temps = .{ .{ .cc = .be }, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp1p, .lea(.tmp0), ._, ._ },
@@ -168165,7 +168165,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .cc = .b }, .unused },
+                    .dst_temps = .{ .{ .cc = .be }, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp1p, .lea(.tmp0), ._, ._ },
@@ -168189,7 +168189,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                         .unused,
                         .unused,
                     },
-                    .dst_temps = .{ .{ .cc = .b }, .unused },
+                    .dst_temps = .{ .{ .cc = .be }, .unused },
                     .clobbers = .{ .eflags = true },
                     .each = .{ .once = &.{
                         .{ ._, ._, .lea, .tmp1p, .lea(.tmp0), ._, ._ },

src/arch/x86_64/Emit.zig

@@ -168,11 +168,12 @@ pub fn emitMir(emit: *Emit) Error!void {
                         else if (emit.bin_file.cast(.macho)) |macho_file|
                             macho_file.getZigObject().?.getOrCreateMetadataForLazySymbol(macho_file, emit.pt, lazy_sym) catch |err|
                                 return emit.fail("{s} creating lazy symbol", .{@errorName(err)})
-                        else if (emit.bin_file.cast(.coff)) |coff_file| sym_index: {
-                            const atom = coff_file.getOrCreateAtomForLazySymbol(emit.pt, lazy_sym) catch |err|
-                                return emit.fail("{s} creating lazy symbol", .{@errorName(err)});
-                            break :sym_index coff_file.getAtom(atom).getSymbolIndex().?;
-                        } else if (emit.bin_file.cast(.plan9)) |p9_file|
+                        else if (emit.bin_file.cast(.coff)) |coff_file|
+                            if (coff_file.getOrCreateAtomForLazySymbol(emit.pt, lazy_sym)) |atom|
+                                coff_file.getAtom(atom).getSymbolIndex().?
+                            else |err|
+                                return emit.fail("{s} creating lazy symbol", .{@errorName(err)})
+                        else if (emit.bin_file.cast(.plan9)) |p9_file|
                             p9_file.getOrCreateAtomForLazySymbol(emit.pt, lazy_sym) catch |err|
                                 return emit.fail("{s} creating lazy symbol", .{@errorName(err)})
                         else

src/codegen/aarch64.zig

@@ -47,6 +47,7 @@ pub fn generate(
         .literals = .empty,
         .nav_relocs = .empty,
         .uav_relocs = .empty,
+        .lazy_relocs = .empty,
         .global_relocs = .empty,
         .literal_relocs = .empty,
 
@@ -101,8 +102,8 @@ pub fn generate(
         };
         switch (passed_vi.parent(&isel)) {
             .unallocated => if (!mod.strip) {
-                var part_it = arg_vi.parts(&isel);
-                const first_passed_part_vi = part_it.next() orelse passed_vi;
+                var part_it = passed_vi.parts(&isel);
+                const first_passed_part_vi = part_it.next().?;
                 const hint_ra = first_passed_part_vi.hint(&isel).?;
                 passed_vi.setParent(&isel, .{ .stack_slot = if (hint_ra.isVector())
                     isel.va_list.__vr_top.withOffset(@as(i8, -16) *
@@ -167,13 +168,15 @@ pub fn generate(
         .literals = &.{},
         .nav_relocs = &.{},
         .uav_relocs = &.{},
+        .lazy_relocs = &.{},
         .global_relocs = &.{},
         .literal_relocs = &.{},
     };
     errdefer mir.deinit(gpa);
     mir.literals = try isel.literals.toOwnedSlice(gpa);
     mir.nav_relocs = try isel.nav_relocs.toOwnedSlice(gpa);
     mir.uav_relocs = try isel.uav_relocs.toOwnedSlice(gpa);
+    mir.lazy_relocs = try isel.lazy_relocs.toOwnedSlice(gpa);
     mir.global_relocs = try isel.global_relocs.toOwnedSlice(gpa);
     mir.literal_relocs = try isel.literal_relocs.toOwnedSlice(gpa);
     return mir;

src/codegen/aarch64/Assemble.zig

@@ -6,14 +6,19 @@ pub const Operand = union(enum) {
 };
 
 pub fn nextInstruction(as: *Assemble) !?Instruction {
-    @setEvalBranchQuota(37_000);
+    @setEvalBranchQuota(42_000);
     comptime var ct_token_buf: [token_buf_len]u8 = undefined;
     var token_buf: [token_buf_len]u8 = undefined;
     const original_source = while (true) {
         const original_source = as.source;
         const source_token = try as.nextToken(&token_buf, .{});
-        if (source_token.len == 0) return null;
-        if (source_token[0] != '\n') break original_source;
+        switch (source_token.len) {
+            0 => return null,
+            else => switch (source_token[0]) {
+                else => break original_source,
+                '\n', ';' => {},
+            },
+        }
     };
     log.debug(
         \\.
@@ -52,7 +57,13 @@ pub fn nextInstruction(as: *Assemble) !?Instruction {
                     std.zig.fmtString(source_token),
                 });
                 if (pattern_token.len == 0) {
-                    if (source_token.len > 0 and source_token[0] != '\n') break :next_pattern;
+                    switch (source_token.len) {
+                        0 => {},
+                        else => switch (source_token[0]) {
+                            else => break :next_pattern,
+                            '\n', ';' => {},
+                        },
+                    }
                     const encode = @field(Instruction, @tagName(instruction.encode[0]));
                     const Encode = @TypeOf(encode);
                     var args: std.meta.ArgsTuple(Encode) = undefined;
@@ -65,7 +76,7 @@ pub fn nextInstruction(as: *Assemble) !?Instruction {
                     const symbol = &@field(symbols, symbol_name);
                     symbol.* = zonCast(SymbolSpec, @field(instruction.symbols, symbol_name), .{}).parse(source_token) orelse break :next_pattern;
                     log.debug("{s} = {any}", .{ symbol_name, symbol.* });
-                } else if (!std.ascii.eqlIgnoreCase(pattern_token, source_token)) break :next_pattern;
+                } else if (!toUpperEqlAssertUpper(source_token, pattern_token)) break :next_pattern;
             }
         }
         log.debug("'{s}' not matched...", .{instruction.pattern});
@@ -125,6 +136,15 @@ fn zonCast(comptime Result: type, zon_value: anytype, symbols: anytype) Result {
     }
 }
 
+fn toUpperEqlAssertUpper(lhs: []const u8, rhs: []const u8) bool {
+    if (lhs.len != rhs.len) return false;
+    for (lhs, rhs) |l, r| {
+        assert(!std.ascii.isLower(r));
+        if (std.ascii.toUpper(l) != r) return false;
+    }
+    return true;
+}
+
 const token_buf_len = "v31.b[15]".len;
 fn nextToken(as: *Assemble, buf: *[token_buf_len]u8, comptime opts: struct {
     operands: bool = false,
@@ -134,7 +154,7 @@ fn nextToken(as: *Assemble, buf: *[token_buf_len]u8, comptime opts: struct {
     while (true) c: switch (as.source[0]) {
         0 => return as.source[0..0],
         '\t', '\n' + 1...'\r', ' ' => as.source = as.source[1..],
-        '\n', '!', '#', ',', '[', ']' => {
+        '\n', '!', '#', ',', ';', '[', ']' => {
             defer as.source = as.source[1..];
             return as.source[0..1];
         },

src/codegen/aarch64/Mir.zig

@@ -4,6 +4,7 @@ epilogue: []const Instruction,
 literals: []const u32,
 nav_relocs: []const Reloc.Nav,
 uav_relocs: []const Reloc.Uav,
+lazy_relocs: []const Reloc.Lazy,
 global_relocs: []const Reloc.Global,
 literal_relocs: []const Reloc.Literal,
 
@@ -21,8 +22,13 @@ pub const Reloc = struct {
         reloc: Reloc,
     };
 
+    pub const Lazy = struct {
+        symbol: link.File.LazySymbol,
+        reloc: Reloc,
+    };
+
     pub const Global = struct {
-        global: [*:0]const u8,
+        name: [*:0]const u8,
         reloc: Reloc,
     };
 
@@ -38,6 +44,7 @@ pub fn deinit(mir: *Mir, gpa: std.mem.Allocator) void {
     gpa.free(mir.literals);
     gpa.free(mir.nav_relocs);
     gpa.free(mir.uav_relocs);
+    gpa.free(mir.lazy_relocs);
     gpa.free(mir.global_relocs);
     gpa.free(mir.literal_relocs);
     mir.* = undefined;
@@ -119,16 +126,37 @@ pub fn emit(
         body_end - Instruction.size * (1 + uav_reloc.reloc.label),
         uav_reloc.reloc.addend,
     );
+    for (mir.lazy_relocs) |lazy_reloc| try emitReloc(
+        lf,
+        zcu,
+        func.owner_nav,
+        if (lf.cast(.elf)) |ef|
+            ef.zigObjectPtr().?.getOrCreateMetadataForLazySymbol(ef, pt, lazy_reloc.symbol) catch |err|
+                return zcu.codegenFail(func.owner_nav, "{s} creating lazy symbol", .{@errorName(err)})
+        else if (lf.cast(.macho)) |mf|
+            mf.getZigObject().?.getOrCreateMetadataForLazySymbol(mf, pt, lazy_reloc.symbol) catch |err|
+                return zcu.codegenFail(func.owner_nav, "{s} creating lazy symbol", .{@errorName(err)})
+        else if (lf.cast(.coff)) |cf|
+            if (cf.getOrCreateAtomForLazySymbol(pt, lazy_reloc.symbol)) |atom|
+                cf.getAtom(atom).getSymbolIndex().?
+            else |err|
+                return zcu.codegenFail(func.owner_nav, "{s} creating lazy symbol", .{@errorName(err)})
+        else
+            return zcu.codegenFail(func.owner_nav, "external symbols unimplemented for {s}", .{@tagName(lf.tag)}),
+        mir.body[lazy_reloc.reloc.label],
+        body_end - Instruction.size * (1 + lazy_reloc.reloc.label),
+        lazy_reloc.reloc.addend,
+    );
     for (mir.global_relocs) |global_reloc| try emitReloc(
         lf,
         zcu,
         func.owner_nav,
         if (lf.cast(.elf)) |ef|
-            try ef.getGlobalSymbol(std.mem.span(global_reloc.global), null)
+            try ef.getGlobalSymbol(std.mem.span(global_reloc.name), null)
         else if (lf.cast(.macho)) |mf|
-            try mf.getGlobalSymbol(std.mem.span(global_reloc.global), null)
+            try mf.getGlobalSymbol(std.mem.span(global_reloc.name), null)
         else if (lf.cast(.coff)) |cf|
-            try cf.getGlobalSymbol(std.mem.span(global_reloc.global), "compiler_rt")
+            try cf.getGlobalSymbol(std.mem.span(global_reloc.name), "compiler_rt")
         else
             return zcu.codegenFail(func.owner_nav, "external symbols unimplemented for {s}", .{@tagName(lf.tag)}),
         mir.body[global_reloc.reloc.label],
@@ -172,35 +200,6 @@ fn emitReloc(
     const gpa = zcu.gpa;
     switch (instruction.decode()) {
         else => unreachable,
-        .branch_exception_generating_system => |decoded| if (lf.cast(.elf)) |ef| {
-            const zo = ef.zigObjectPtr().?;
-            const atom = zo.symbol(try zo.getOrCreateMetadataForNav(zcu, owner_nav)).atom(ef).?;
-            const r_type: std.elf.R_AARCH64 = switch (decoded.decode().unconditional_branch_immediate.group.op) {
-                .b => .JUMP26,
-                .bl => .CALL26,
-            };
-            try atom.addReloc(gpa, .{
-                .r_offset = offset,
-                .r_info = @as(u64, sym_index) << 32 | @intFromEnum(r_type),
-                .r_addend = @bitCast(addend),
-            }, zo);
-        } else if (lf.cast(.macho)) |mf| {
-            const zo = mf.getZigObject().?;
-            const atom = zo.symbols.items[try zo.getOrCreateMetadataForNav(mf, owner_nav)].getAtom(mf).?;
-            try atom.addReloc(mf, .{
-                .tag = .@"extern",
-                .offset = offset,
-                .target = sym_index,
-                .addend = @bitCast(addend),
-                .type = .branch,
-                .meta = .{
-                    .pcrel = true,
-                    .has_subtractor = false,
-                    .length = 2,
-                    .symbolnum = @intCast(sym_index),
-                },
-            });
-        },
         .data_processing_immediate => |decoded| if (lf.cast(.elf)) |ef| {
             const zo = ef.zigObjectPtr().?;
             const atom = zo.symbol(try zo.getOrCreateMetadataForNav(zcu, owner_nav)).atom(ef).?;
@@ -259,6 +258,80 @@ fn emitReloc(
                 },
             }
         },
+        .branch_exception_generating_system => |decoded| if (lf.cast(.elf)) |ef| {
+            const zo = ef.zigObjectPtr().?;
+            const atom = zo.symbol(try zo.getOrCreateMetadataForNav(zcu, owner_nav)).atom(ef).?;
+            const r_type: std.elf.R_AARCH64 = switch (decoded.decode().unconditional_branch_immediate.group.op) {
+                .b => .JUMP26,
+                .bl => .CALL26,
+            };
+            try atom.addReloc(gpa, .{
+                .r_offset = offset,
+                .r_info = @as(u64, sym_index) << 32 | @intFromEnum(r_type),
+                .r_addend = @bitCast(addend),
+            }, zo);
+        } else if (lf.cast(.macho)) |mf| {
+            const zo = mf.getZigObject().?;
+            const atom = zo.symbols.items[try zo.getOrCreateMetadataForNav(mf, owner_nav)].getAtom(mf).?;
+            try atom.addReloc(mf, .{
+                .tag = .@"extern",
+                .offset = offset,
+                .target = sym_index,
+                .addend = @bitCast(addend),
+                .type = .branch,
+                .meta = .{
+                    .pcrel = true,
+                    .has_subtractor = false,
+                    .length = 2,
+                    .symbolnum = @intCast(sym_index),
+                },
+            });
+        },
+        .load_store => |decoded| if (lf.cast(.elf)) |ef| {
+            const zo = ef.zigObjectPtr().?;
+            const atom = zo.symbol(try zo.getOrCreateMetadataForNav(zcu, owner_nav)).atom(ef).?;
+            const r_type: std.elf.R_AARCH64 = switch (decoded.decode().register_unsigned_immediate.decode()) {
+                .integer => |integer| switch (integer.decode()) {
+                    .unallocated, .prfm => unreachable,
+                    .strb, .ldrb, .ldrsb => .LDST8_ABS_LO12_NC,
+                    .strh, .ldrh, .ldrsh => .LDST16_ABS_LO12_NC,
+                    .ldrsw => .LDST32_ABS_LO12_NC,
+                    inline .str, .ldr => |encoded| switch (encoded.sf) {
+                        .word => .LDST32_ABS_LO12_NC,
+                        .doubleword => .LDST64_ABS_LO12_NC,
+                    },
+                },
+                .vector => |vector| switch (vector.group.opc1.decode(vector.group.size)) {
+                    .byte => .LDST8_ABS_LO12_NC,
+                    .half => .LDST16_ABS_LO12_NC,
+                    .single => .LDST32_ABS_LO12_NC,
+                    .double => .LDST64_ABS_LO12_NC,
+                    .quad => .LDST128_ABS_LO12_NC,
+                    .scalable, .predicate => unreachable,
+                },
+            };
+            try atom.addReloc(gpa, .{
+                .r_offset = offset,
+                .r_info = @as(u64, sym_index) << 32 | @intFromEnum(r_type),
+                .r_addend = @bitCast(addend),
+            }, zo);
+        } else if (lf.cast(.macho)) |mf| {
+            const zo = mf.getZigObject().?;
+            const atom = zo.symbols.items[try zo.getOrCreateMetadataForNav(mf, owner_nav)].getAtom(mf).?;
+            try atom.addReloc(mf, .{
+                .tag = .@"extern",
+                .offset = offset,
+                .target = sym_index,
+                .addend = @bitCast(addend),
+                .type = .pageoff,
+                .meta = .{
+                    .pcrel = false,
+                    .has_subtractor = false,
+                    .length = 2,
+                    .symbolnum = @intCast(sym_index),
+                },
+            });
+        },
     }
 }