wasm linker: aggressive rewrite towards Data-Oriented Design

CMakeLists.txt

@@ -643,9 +643,8 @@ set(ZIG_STAGE2_SOURCES
     src/link/StringTable.zig
     src/link/Wasm.zig
     src/link/Wasm/Archive.zig
+    src/link/Wasm/Flush.zig
     src/link/Wasm/Object.zig
-    src/link/Wasm/Symbol.zig
-    src/link/Wasm/ZigObject.zig
     src/link/aarch64.zig
     src/link/riscv.zig
     src/link/table_section.zig

build.zig

@@ -447,6 +447,7 @@ pub fn build(b: *std.Build) !void {
         .skip_single_threaded = skip_single_threaded,
         .skip_non_native = skip_non_native,
         .skip_libc = skip_libc,
+        .use_llvm = use_llvm,
         .max_rss = 1 * 1024 * 1024 * 1024,
     }));
 
@@ -462,6 +463,7 @@ pub fn build(b: *std.Build) !void {
         .skip_single_threaded = true,
         .skip_non_native = skip_non_native,
         .skip_libc = skip_libc,
+        .use_llvm = use_llvm,
     }));
 
     test_modules_step.dependOn(tests.addModuleTests(b, .{
@@ -476,6 +478,7 @@ pub fn build(b: *std.Build) !void {
         .skip_single_threaded = true,
         .skip_non_native = skip_non_native,
         .skip_libc = true,
+        .use_llvm = use_llvm,
         .no_builtin = true,
     }));
 
@@ -491,6 +494,7 @@ pub fn build(b: *std.Build) !void {
         .skip_single_threaded = true,
         .skip_non_native = skip_non_native,
         .skip_libc = true,
+        .use_llvm = use_llvm,
         .no_builtin = true,
     }));
 
@@ -506,6 +510,7 @@ pub fn build(b: *std.Build) !void {
         .skip_single_threaded = skip_single_threaded,
         .skip_non_native = skip_non_native,
         .skip_libc = skip_libc,
+        .use_llvm = use_llvm,
         // I observed a value of 4572626944 on the M2 CI.
         .max_rss = 5029889638,
     }));

lib/std/Build/Step/CheckObject.zig

@@ -2424,7 +2424,22 @@ const WasmDumper = struct {
         }
 
         var output = std.ArrayList(u8).init(gpa);
-        errdefer output.deinit();
+        defer output.deinit();
+        parseAndDumpInner(step, check, bytes, &fbs, &output) catch |err| switch (err) {
+            error.EndOfStream => try output.appendSlice("\n<UnexpectedEndOfStream>"),
+            else => |e| return e,
+        };
+        return output.toOwnedSlice();
+    }
+
+    fn parseAndDumpInner(
+        step: *Step,
+        check: Check,
+        bytes: []const u8,
+        fbs: *std.io.FixedBufferStream([]const u8),
+        output: *std.ArrayList(u8),
+    ) !void {
+        const reader = fbs.reader();
         const writer = output.writer();
 
         switch (check.kind) {
@@ -2442,8 +2457,6 @@ const WasmDumper = struct {
 
             else => return step.fail("invalid check kind for Wasm file format: {s}", .{@tagName(check.kind)}),
         }
-
-        return output.toOwnedSlice();
     }
 
     fn parseAndDumpSection(
@@ -2682,7 +2695,7 @@ const WasmDumper = struct {
             else => unreachable,
         }
         const end_opcode = try std.leb.readUleb128(u8, reader);
-        if (end_opcode != std.wasm.opcode(.end)) {
+        if (end_opcode != @intFromEnum(std.wasm.Opcode.end)) {
             return step.fail("expected 'end' opcode in init expression", .{});
         }
     }

lib/std/Target.zig

@@ -1219,6 +1219,12 @@ pub const Cpu = struct {
                 } else true;
             }
 
+            pub fn count(set: Set) std.math.IntFittingRange(0, needed_bit_count) {
+                var sum: usize = 0;
+                for (set.ints) |x| sum += @popCount(x);
+                return @intCast(sum);
+            }
+
             pub fn isEnabled(set: Set, arch_feature_index: Index) bool {
                 const usize_index = arch_feature_index / @bitSizeOf(usize);
                 const bit_index: ShiftInt = @intCast(arch_feature_index % @bitSizeOf(usize));

lib/std/Thread.zig

@@ -1018,12 +1018,15 @@ const WasiThreadImpl = struct {
         return .{ .thread = &instance.thread };
     }
 
-    /// Bootstrap procedure, called by the host environment after thread creation.
-    export fn wasi_thread_start(tid: i32, arg: *Instance) void {
-        if (builtin.single_threaded) {
-            // ensure function is not analyzed in single-threaded mode
-            return;
+    comptime {
+        if (!builtin.single_threaded) {
+            @export(wasi_thread_start, .{ .name = "wasi_thread_start" });
         }
+    }
+
+    /// Called by the host environment after thread creation.
+    fn wasi_thread_start(tid: i32, arg: *Instance) callconv(.c) void {
+        comptime assert(!builtin.single_threaded);
         __set_stack_pointer(arg.thread.memory.ptr + arg.stack_offset);
         __wasm_init_tls(arg.thread.memory.ptr + arg.tls_offset);
         @atomicStore(u32, &WasiThreadImpl.tls_thread_id, @intCast(tid), .seq_cst);

lib/std/array_hash_map.zig

@@ -641,10 +641,13 @@ pub fn ArrayHashMapUnmanaged(
             return self;
         }
 
+        /// An empty `value_list` may be passed, in which case the values array becomes `undefined`.
         pub fn reinit(self: *Self, gpa: Allocator, key_list: []const K, value_list: []const V) Oom!void {
             try self.entries.resize(gpa, key_list.len);
             @memcpy(self.keys(), key_list);
-            if (@sizeOf(V) != 0) {
+            if (value_list.len == 0) {
+                @memset(self.values(), undefined);
+            } else {
                 assert(key_list.len == value_list.len);
                 @memcpy(self.values(), value_list);
             }

lib/std/array_list.zig

@@ -267,8 +267,7 @@ pub fn ArrayListAligned(comptime T: type, comptime alignment: ?u29) type {
         /// Never invalidates element pointers.
         /// Asserts that the list can hold one additional item.
         pub fn appendAssumeCapacity(self: *Self, item: T) void {
-            const new_item_ptr = self.addOneAssumeCapacity();
-            new_item_ptr.* = item;
+            self.addOneAssumeCapacity().* = item;
         }
 
         /// Remove the element at index `i`, shift elements after index
@@ -879,8 +878,7 @@ pub fn ArrayListAlignedUnmanaged(comptime T: type, comptime alignment: ?u29) typ
         /// Never invalidates element pointers.
         /// Asserts that the list can hold one additional item.
         pub fn appendAssumeCapacity(self: *Self, item: T) void {
-            const new_item_ptr = self.addOneAssumeCapacity();
-            new_item_ptr.* = item;
+            self.addOneAssumeCapacity().* = item;
         }
 
         /// Remove the element at index `i` from the list and return its value.

lib/std/io.zig

@@ -16,10 +16,6 @@ const Allocator = std.mem.Allocator;
 
 fn getStdOutHandle() posix.fd_t {
     if (is_windows) {
-        if (builtin.zig_backend == .stage2_aarch64) {
-            // TODO: this is just a temporary workaround until we advance aarch64 backend further along.
-            return windows.GetStdHandle(windows.STD_OUTPUT_HANDLE) catch windows.INVALID_HANDLE_VALUE;
-        }
         return windows.peb().ProcessParameters.hStdOutput;
     }
 
@@ -36,10 +32,6 @@ pub fn getStdOut() File {
 
 fn getStdErrHandle() posix.fd_t {
     if (is_windows) {
-        if (builtin.zig_backend == .stage2_aarch64) {
-            // TODO: this is just a temporary workaround until we advance aarch64 backend further along.
-            return windows.GetStdHandle(windows.STD_ERROR_HANDLE) catch windows.INVALID_HANDLE_VALUE;
-        }
         return windows.peb().ProcessParameters.hStdError;
     }
 
@@ -56,10 +48,6 @@ pub fn getStdErr() File {
 
 fn getStdInHandle() posix.fd_t {
     if (is_windows) {
-        if (builtin.zig_backend == .stage2_aarch64) {
-            // TODO: this is just a temporary workaround until we advance aarch64 backend further along.
-            return windows.GetStdHandle(windows.STD_INPUT_HANDLE) catch windows.INVALID_HANDLE_VALUE;
-        }
         return windows.peb().ProcessParameters.hStdInput;
     }