self-host dynamic linker detection

Author: andrewrk

lib/std/os.zig

@@ -2974,18 +2974,26 @@ pub fn nanosleep(seconds: u64, nanoseconds: u64) void {
 }
 
 pub fn dl_iterate_phdr(
-    comptime T: type,
-    callback: extern fn (info: *dl_phdr_info, size: usize, data: ?*T) i32,
-    data: ?*T,
-) isize {
+    context: var,
+    comptime Error: type,
+    comptime callback: fn (info: *dl_phdr_info, size: usize, context: @TypeOf(context)) Error!void,
+) Error!void {
+    const Context = @TypeOf(context);
+
     if (builtin.object_format != .elf)
         @compileError("dl_iterate_phdr is not available for this target");
 
     if (builtin.link_libc) {
-        return system.dl_iterate_phdr(
-            @ptrCast(std.c.dl_iterate_phdr_callback, callback),
-            @ptrCast(?*c_void, data),
-        );
+        switch (system.dl_iterate_phdr(struct {
+            fn callbackC(info: *dl_phdr_info, size: usize, data: ?*c_void) callconv(.C) c_int {
+                const context_ptr = @ptrCast(*const Context, @alignCast(@alignOf(*const Context), data));
+                callback(info, size, context_ptr.*) catch |err| return @errorToInt(err);
+                return 0;
+            }
+        }.callbackC, @intToPtr(?*c_void, @ptrToInt(&context)))) {
+            0 => return,
+            else => |err| return @errSetCast(Error, @intToError(@intCast(u16, err))), // TODO don't hardcode u16
+        }
     }
 
     const elf_base = std.process.getBaseAddress();
@@ -3007,11 +3015,10 @@ pub fn dl_iterate_phdr(
             .dlpi_phnum = ehdr.e_phnum,
         };
 
-        return callback(&info, @sizeOf(dl_phdr_info), data);
+        return callback(&info, @sizeOf(dl_phdr_info), context);
     }
 
     // Last return value from the callback function
-    var last_r: isize = 0;
     while (it.next()) |entry| {
         var dlpi_phdr: [*]elf.Phdr = undefined;
         var dlpi_phnum: u16 = undefined;
@@ -3033,11 +3040,8 @@ pub fn dl_iterate_phdr(
             .dlpi_phnum = dlpi_phnum,
         };
 
-        last_r = callback(&info, @sizeOf(dl_phdr_info), data);
-        if (last_r != 0) break;
+        try callback(&info, @sizeOf(dl_phdr_info), context);
     }
-
-    return last_r;
 }
 
 pub const ClockGetTimeError = error{UnsupportedClock} || UnexpectedError;

lib/std/process.zig

@@ -613,3 +613,59 @@ pub fn getBaseAddress() usize {
         else => @compileError("Unsupported OS"),
     }
 }
+
+/// Caller owns the result value and each inner slice.
+pub fn getSelfExeSharedLibPaths(allocator: *Allocator) error{OutOfMemory}![][:0]u8 {
+    switch (builtin.link_mode) {
+        .Static => return &[_][:0]u8{},
+        .Dynamic => {},
+    }
+    const List = std.ArrayList([:0]u8);
+    switch (builtin.os) {
+        .linux,
+        .freebsd,
+        .netbsd,
+        .dragonfly,
+        => {
+            var paths = List.init(allocator);
+            errdefer {
+                const slice = paths.toOwnedSlice();
+                for (slice) |item| {
+                    allocator.free(item);
+                }
+                allocator.free(slice);
+            }
+            try os.dl_iterate_phdr(&paths, error{OutOfMemory}, struct {
+                fn callback(info: *os.dl_phdr_info, size: usize, list: *List) !void {
+                    const name = info.dlpi_name orelse return;
+                    if (name[0] == '/') {
+                        const item = try mem.dupeZ(list.allocator, u8, mem.toSliceConst(u8, name));
+                        errdefer list.allocator.free(item);
+                        try list.append(item);
+                    }
+                }
+            }.callback);
+            return paths.toOwnedSlice();
+        },
+        .macosx, .ios, .watchos, .tvos => {
+            var paths = List.init(allocator);
+            errdefer {
+                const slice = paths.toOwnedSlice();
+                for (slice) |item| {
+                    allocator.free(item);
+                }
+                allocator.free(slice);
+            }
+            const img_count = std.c._dyld_image_count();
+            var i: u32 = 0;
+            while (i < img_count) : (i += 1) {
+                const name = std.c._dyld_get_image_name(i);
+                const item = try mem.dupeZ(allocator, u8, mem.toSliceConst(u8, name));
+                errdefer allocator.free(item);
+                try paths.append(item);
+            }
+            return paths.toOwnedSlice();
+        },
+        else => return error.UnimplementedSelfExeSharedPaths,
+    }
+}

lib/std/target.zig

@@ -1037,6 +1037,13 @@ pub const Target = union(enum) {
         };
     }
 
+    pub fn isAndroid(self: Target) bool {
+        return switch (self.getAbi()) {
+            .android => true,
+            else => false,
+        };
+    }
+
     pub fn isDragonFlyBSD(self: Target) bool {
         return switch (self.getOs()) {
             .dragonfly => true,
@@ -1196,6 +1203,136 @@ pub const Target = union(enum) {
 
         return .unavailable;
     }
+
+    pub const FloatAbi = enum {
+        hard,
+        soft,
+        soft_fp,
+    };
+
+    pub fn getFloatAbi(self: Target) FloatAbi {
+        return switch (self.getAbi()) {
+            .gnueabihf,
+            .eabihf,
+            .musleabihf,
+            => .hard,
+            else => .soft,
+        };
+    }
+
+    /// Caller owns returned memory.
+    pub fn getStandardDynamicLinkerPath(
+        self: Target,
+        allocator: *mem.Allocator,
+    ) error{
+        OutOfMemory,
+        UnknownDynamicLinkerPath,
+    }![:0]u8 {
+        const a = allocator;
+        if (self.isAndroid()) {
+            return mem.dupeZ(a, u8, if (self.getArchPtrBitWidth() == 64)
+                "/system/bin/linker64"
+            else
+                "/system/bin/linker");
+        }
+
+        if (self.isMusl()) {
+            var result = try std.Buffer.init(allocator, "/lib/ld-musl-");
+            defer result.deinit();
+
+            var is_arm = false;
+            switch (self.getArch()) {
+                .arm, .thumb => {
+                    try result.append("arm");
+                    is_arm = true;
+                },
+                .armeb, .thumbeb => {
+                    try result.append("armeb");
+                    is_arm = true;
+                },
+                else => |arch| try result.append(@tagName(arch)),
+            }
+            if (is_arm and self.getFloatAbi() == .hard) {
+                try result.append("hf");
+            }
+            try result.append(".so.1");
+            return result.toOwnedSlice();
+        }
+
+        switch (self.getOs()) {
+            .freebsd => return mem.dupeZ(a, u8, "/libexec/ld-elf.so.1"),
+            .netbsd => return mem.dupeZ(a, u8, "/libexec/ld.elf_so"),
+            .dragonfly => return mem.dupeZ(a, u8, "/libexec/ld-elf.so.2"),
+            .linux => switch (self.getArch()) {
+                .i386,
+                .sparc,
+                .sparcel,
+                => return mem.dupeZ(a, u8, "/lib/ld-linux.so.2"),
+
+                .aarch64 => return mem.dupeZ(a, u8, "/lib/ld-linux-aarch64.so.1"),
+                .aarch64_be => return mem.dupeZ(a, u8, "/lib/ld-linux-aarch64_be.so.1"),
+                .aarch64_32 => return mem.dupeZ(a, u8, "/lib/ld-linux-aarch64_32.so.1"),
+
+                .arm,
+                .armeb,
+                .thumb,
+                .thumbeb,
+                => return mem.dupeZ(a, u8, switch (self.getFloatAbi()) {
+                    .hard => "/lib/ld-linux-armhf.so.3",
+                    else => "/lib/ld-linux.so.3",
+                }),
+
+                .mips,
+                .mipsel,
+                .mips64,
+                .mips64el,
+                => return error.UnknownDynamicLinkerPath,
+
+                .powerpc => return mem.dupeZ(a, u8, "/lib/ld.so.1"),
+                .powerpc64, .powerpc64le => return mem.dupeZ(a, u8, "/lib64/ld64.so.2"),
+                .s390x => return mem.dupeZ(a, u8, "/lib64/ld64.so.1"),
+                .sparcv9 => return mem.dupeZ(a, u8, "/lib64/ld-linux.so.2"),
+                .x86_64 => return mem.dupeZ(a, u8, switch (self.getAbi()) {
+                    .gnux32 => "/libx32/ld-linux-x32.so.2",
+                    else => "/lib64/ld-linux-x86-64.so.2",
+                }),
+
+                .riscv32 => return mem.dupeZ(a, u8, "/lib/ld-linux-riscv32-ilp32.so.1"),
+                .riscv64 => return mem.dupeZ(a, u8, "/lib/ld-linux-riscv64-lp64.so.1"),
+
+                .arc,
+                .avr,
+                .bpfel,
+                .bpfeb,
+                .hexagon,
+                .msp430,
+                .r600,
+                .amdgcn,
+                .tce,
+                .tcele,
+                .xcore,
+                .nvptx,
+                .nvptx64,
+                .le32,
+                .le64,
+                .amdil,
+                .amdil64,
+                .hsail,
+                .hsail64,
+                .spir,
+                .spir64,
+                .kalimba,
+                .shave,
+                .lanai,
+                .wasm32,
+                .wasm64,
+                .renderscript32,
+                .renderscript64,
+                => return error.UnknownDynamicLinkerPath,
+            },
+            else => return error.UnknownDynamicLinkerPath,
+        }
+    }
 };
 
 test "parseCpuFeatureSet" {

src-self-hosted/introspect.zig

@@ -6,6 +6,14 @@ const fs = std.fs;
 
 const warn = std.debug.warn;
 
+pub fn detectDynamicLinker(allocator: *mem.Allocator, target: std.Target) ![:0]u8 {
+    if (target == .Native) {
+        return @import("libc_installation.zig").detectNativeDynamicLinker(allocator);
+    } else {
+        return target.getStandardDynamicLinkerPath(allocator);
+    }
+}
+
 /// Caller must free result
 pub fn testZigInstallPrefix(allocator: *mem.Allocator, test_path: []const u8) ![]u8 {
     const test_zig_dir = try fs.path.join(allocator, &[_][]const u8{ test_path, "lib", "zig" });

src-self-hosted/libc_installation.zig

@@ -492,7 +492,7 @@ pub const LibCInstallation = struct {
 const default_cc_exe = if (is_windows) "cc.exe" else "cc";
 
 /// caller owns returned memory
-pub fn ccPrintFileName(
+fn ccPrintFileName(
     allocator: *Allocator,
     o_file: []const u8,
     want_dirname: enum { full_path, only_dir },
@@ -535,6 +535,43 @@ pub fn ccPrintFileName(
     }
 }
 
+/// Caller owns returned memory.
+pub fn detectNativeDynamicLinker(allocator: *Allocator) ![:0]u8 {
+    const standard_ld_path = try std.Target.current.getStandardDynamicLinkerPath(allocator);
+    var standard_ld_path_resource: ?[:0]u8 = standard_ld_path; // Set to null to avoid freeing it.
+    defer if (standard_ld_path_resource) |s| allocator.free(s);
+
+    const standard_ld_basename = fs.path.basename(standard_ld_path);
+
+    {
+        // Best case scenario: the current executable is dynamically linked, and we can iterate
+        // over our own shared objects and find a dynamic linker.
+        const lib_paths = try std.process.getSelfExeSharedLibPaths(allocator);
+        defer allocator.free(lib_paths);
+
+        for (lib_paths) |lib_path| {
+            if (std.mem.endsWith(u8, lib_path, standard_ld_basename)) {
+                return std.mem.dupeZ(allocator, u8, lib_path);
+            }
+        }
+    }
+
+    // If Zig is statically linked, such as via distributed binary static builds, the above
+    // trick won't work. What are we left with? Try to run the system C compiler and get
+    // it to tell us the dynamic linker path.
+    return ccPrintFileName(allocator, standard_ld_basename, .full_path) catch |err| switch (err) {
+        error.OutOfMemory => return error.OutOfMemory,
+        error.LibCRuntimeNotFound,
+        error.CCompilerExitCode,
+        error.CCompilerCrashed,
+        error.UnableToSpawnCCompiler,
+        => {
+            standard_ld_path_resource = null; // Prevent freeing standard_ld_path.
+            return standard_ld_path;
+        },
+    };
+}
+
 const Search = struct {
     path: []const u8,
     version: []const u8,