overhaul elf csu (c-runtime startup) logic

- more support for linux, android, freebsd, netbsd, openbsd, dragonfly
- centralize musl utils; musl logic is no longer intertwined with csu
- fix musl compilation to build crti/crtn for full archs list
- fix openbsd to support `zig build-lib -dynamic`
- initial dragonfly linking success (with a warning)

ancillary:

- fix emutls (openbsd) tests to use `try`

Author: mikdusan

lib/std/Thread.zig

@@ -576,6 +576,9 @@ pub fn getCurrentThreadId() u64 {
             assert(c.pthread_threadid_np(null, &thread_id) == 0);
             return thread_id;
         },
+        .dragonfly => {
+            return @bitCast(u32, c.lwp_gettid());
+        },
         .netbsd => {
             return @bitCast(u32, c._lwp_self());
         },

lib/std/c/dragonfly.zig

@@ -18,6 +18,8 @@ pub extern "c" fn pipe2(fds: *[2]fd_t, flags: u32) c_int;
 pub const dl_iterate_phdr_callback = fn (info: *dl_phdr_info, size: usize, data: ?*c_void) callconv(.C) c_int;
 pub extern "c" fn dl_iterate_phdr(callback: dl_iterate_phdr_callback, data: ?*c_void) c_int;
 
+pub extern "c" fn lwp_gettid() c_int;
+
 pub extern "c" fn posix_memalign(memptr: *?*c_void, alignment: usize, size: usize) c_int;
 
 pub const pthread_mutex_t = extern struct {
@@ -31,3 +33,5 @@ pub const pthread_attr_t = extern struct { // copied from freebsd
     __size: [56]u8,
     __align: c_long,
 };
+
+pub const sem_t = ?*opaque {};

lib/std/child_process.zig

@@ -203,6 +203,10 @@ pub const ChildProcess = struct {
         // of space an ArrayList will allocate grows exponentially.
         const bump_amt = 512;
 
+        // TODO https://github.com/ziglang/zig/issues/8724
+        // parent process does not receive POLLHUP events
+        const dragonfly_workaround = builtin.os.tag == .dragonfly;
+
         while (dead_fds < poll_fds.len) {
             const events = try os.poll(&poll_fds, std.math.maxInt(i32));
             if (events == 0) continue;
@@ -215,15 +219,23 @@ pub const ChildProcess = struct {
                 try stdout.ensureCapacity(new_capacity);
                 const buf = stdout.unusedCapacitySlice();
                 if (buf.len == 0) return error.StdoutStreamTooLong;
-                stdout.items.len += try os.read(poll_fds[0].fd, buf);
+                const nread = try os.read(poll_fds[0].fd, buf);
+                stdout.items.len += nread;
+
+                // insert POLLHUP event because dragonfly fails to do so
+                if (dragonfly_workaround and nread == 0) poll_fds[0].revents |= os.POLLHUP;
             }
             if (poll_fds[1].revents & os.POLLIN != 0) {
                 // stderr is ready.
                 const new_capacity = std.math.min(stderr.items.len + bump_amt, max_output_bytes);
                 try stderr.ensureCapacity(new_capacity);
                 const buf = stderr.unusedCapacitySlice();
                 if (buf.len == 0) return error.StderrStreamTooLong;
-                stderr.items.len += try os.read(poll_fds[1].fd, buf);
+                const nread = try os.read(poll_fds[1].fd, buf);
+                stderr.items.len += nread;
+
+                // insert POLLHUP event because dragonfly fails to do so
+                if (dragonfly_workaround and nread == 0) poll_fds[1].revents |= os.POLLHUP;
             }
 
             // Exclude the fds that signaled an error.

lib/std/os/bits/dragonfly.zig

@@ -774,3 +774,29 @@ pub const rlimit = extern struct {
     /// Hard limit
     max: rlim_t,
 };
+
+pub const SHUT_RD = 0;
+pub const SHUT_WR = 1;
+pub const SHUT_RDWR = 2;
+
+pub const nfds_t = u32;
+
+pub const pollfd = extern struct {
+    fd: fd_t,
+    events: i16,
+    revents: i16,
+};
+
+/// Requestable events.
+pub const POLLIN = 0x0001;
+pub const POLLPRI = 0x0002;
+pub const POLLOUT = 0x0004;
+pub const POLLRDNORM = 0x0040;
+pub const POLLWRNORM = POLLOUT;
+pub const POLLRDBAND = 0x0080;
+pub const POLLWRBAND = 0x0100;
+
+/// These events are set if they occur regardless of whether they were requested.
+pub const POLLERR = 0x0008;
+pub const POLLHUP = 0x0010;
+pub const POLLNVAL = 0x0020;

lib/std/special/compiler_rt/emutls.zig

@@ -376,19 +376,19 @@ test "__emutls_get_address with default_value" {
 
 test "test default_value with differents sizes" {
     const testType = struct {
-        fn _testType(comptime T: type, value: T) void {
+        fn _testType(comptime T: type, value: T) !void {
             var def: T = value;
             var ctl = emutls_control.init(T, &def);
             var x = ctl.get_typed_pointer(T);
             try expect(x.* == value);
         }
     }._testType;
 
-    testType(usize, 1234);
-    testType(u32, 1234);
-    testType(i16, -12);
-    testType(f64, -12.0);
-    testType(
+    try testType(usize, 1234);
+    try testType(u32, 1234);
+    try testType(i16, -12);
+    try testType(f64, -12.0);
+    try testType(
         @TypeOf("012345678901234567890123456789"),
         "012345678901234567890123456789",
     );

src/Compilation.zig

@@ -1285,7 +1285,7 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
         }
         if (comp.wantBuildMuslFromSource()) {
             try comp.work_queue.ensureUnusedCapacity(6);
-            if (target_util.libc_needs_crti_crtn(comp.getTarget())) {
+            if (musl.libc_needs_crti_crtn(comp.getTarget())) {
                 comp.work_queue.writeAssumeCapacity(&[_]Job{
                     .{ .musl_crt_file = .crti_o },
                     .{ .musl_crt_file = .crtn_o },
@@ -2904,7 +2904,7 @@ fn detectLibCIncludeDirs(
         const generic_name = target_util.libCGenericName(target);
         // Some architectures are handled by the same set of headers.
         const arch_name = if (target.abi.isMusl())
-            target_util.archMuslName(target.cpu.arch)
+            musl.archMuslName(target.cpu.arch)
         else if (target.cpu.arch.isThumb())
             // ARM headers are valid for Thumb too.
             switch (target.cpu.arch) {
@@ -3009,7 +3009,7 @@ fn addBuildingGLibCJobs(comp: *Compilation) !void {
     });
 }
 
-fn wantBuildLibCFromSource(comp: Compilation) bool {
+pub fn wantBuildLibCFromSource(comp: Compilation) bool {
     const is_exe_or_dyn_lib = switch (comp.bin_file.options.output_mode) {
         .Obj => false,
         .Lib => comp.bin_file.options.link_mode == .Dynamic,
@@ -3019,16 +3019,16 @@ fn wantBuildLibCFromSource(comp: Compilation) bool {
         comp.bin_file.options.libc_installation == null;
 }
 
-fn wantBuildGLibCFromSource(comp: Compilation) bool {
+pub fn wantBuildGLibCFromSource(comp: Compilation) bool {
     return comp.wantBuildLibCFromSource() and comp.getTarget().isGnuLibC();
 }
 
-fn wantBuildMuslFromSource(comp: Compilation) bool {
+pub fn wantBuildMuslFromSource(comp: Compilation) bool {
     return comp.wantBuildLibCFromSource() and comp.getTarget().isMusl() and
         !comp.getTarget().isWasm();
 }
 
-fn wantBuildMinGWFromSource(comp: Compilation) bool {
+pub fn wantBuildMinGWFromSource(comp: Compilation) bool {
     return comp.wantBuildLibCFromSource() and comp.getTarget().isMinGW();
 }
 

src/libc_installation.zig

@@ -195,8 +195,8 @@ pub const LibCInstallation = struct {
                 errdefer batch.wait() catch {};
                 batch.add(&async self.findNativeIncludeDirPosix(args));
                 switch (Target.current.os.tag) {
-                    .freebsd, .netbsd, .openbsd => self.crt_dir = try std.mem.dupeZ(args.allocator, u8, "/usr/lib"),
-                    .linux, .dragonfly => batch.add(&async self.findNativeCrtDirPosix(args)),
+                    .freebsd, .netbsd, .openbsd, .dragonfly => self.crt_dir = try std.mem.dupeZ(args.allocator, u8, "/usr/lib"),
+                    .linux => batch.add(&async self.findNativeCrtDirPosix(args)),
                     .haiku => self.crt_dir = try std.mem.dupeZ(args.allocator, u8, "/system/develop/lib"),
                     else => {},
                 }
@@ -524,7 +524,7 @@ pub const CCPrintFileNameOptions = struct {
 };
 
 /// caller owns returned memory
-fn ccPrintFileName(args: CCPrintFileNameOptions) ![:0]u8 {
+pub fn ccPrintFileName(args: CCPrintFileNameOptions) ![:0]u8 {
     const allocator = args.allocator;
 
     const cc_exe = std.os.getenvZ("CC") orelse default_cc_exe;