Merge pull request #14157 from Luukdegram/wasm-linker-misc

wasm-linker: various fixes & improvements

Author: Luukdegram

src/link/Wasm.zig

@@ -90,24 +90,26 @@ pub fn getFirst(atom: *Atom) *Atom {
     return tmp;
 }
 
-/// Unlike `getFirst` this returns the first `*Atom` that was
-/// produced from Zig code, rather than an object file.
-/// This is useful for debug sections where we want to extend
-/// the bytes, and don't want to overwrite existing Atoms.
-pub fn getFirstZigAtom(atom: *Atom) *Atom {
-    if (atom.file == null) return atom;
-    var tmp = atom;
-    return while (tmp.prev) |prev| {
-        if (prev.file == null) break prev;
-        tmp = prev;
-    } else unreachable; // must allocate an Atom first!
-}
-
 /// Returns the location of the symbol that represents this `Atom`
 pub fn symbolLoc(atom: Atom) Wasm.SymbolLoc {
     return .{ .file = atom.file, .index = atom.sym_index };
 }
 
+/// Returns the virtual address of the `Atom`. This is the address starting
+/// from the first entry within a section.
+pub fn getVA(atom: Atom, wasm: *const Wasm, symbol: *const Symbol) u32 {
+    if (symbol.tag == .function) return atom.offset;
+    std.debug.assert(symbol.tag == .data);
+    const merge_segment = wasm.base.options.output_mode != .Obj;
+    const segment_info = if (atom.file) |object_index| blk: {
+        break :blk wasm.objects.items[object_index].segment_info;
+    } else wasm.segment_info.values();
+    const segment_name = segment_info[symbol.index].outputName(merge_segment);
+    const segment_index = wasm.data_segments.get(segment_name).?;
+    const segment = wasm.segments.items[segment_index];
+    return segment.offset + atom.offset;
+}
+
 /// Resolves the relocations within the atom, writing the new value
 /// at the calculated offset.
 pub fn resolveRelocs(atom: *Atom, wasm_bin: *const Wasm) void {
@@ -159,7 +161,7 @@ pub fn resolveRelocs(atom: *Atom, wasm_bin: *const Wasm) void {
 /// The final value must be casted to the correct size.
 fn relocationValue(atom: Atom, relocation: types.Relocation, wasm_bin: *const Wasm) u64 {
     const target_loc = (Wasm.SymbolLoc{ .file = atom.file, .index = relocation.index }).finalLoc(wasm_bin);
-    const symbol = target_loc.getSymbol(wasm_bin).*;
+    const symbol = target_loc.getSymbol(wasm_bin);
     switch (relocation.relocation_type) {
         .R_WASM_FUNCTION_INDEX_LEB => return symbol.index,
         .R_WASM_TABLE_NUMBER_LEB => return symbol.index,
@@ -190,17 +192,9 @@ fn relocationValue(atom: Atom, relocation: types.Relocation, wasm_bin: *const Wa
             if (symbol.isUndefined()) {
                 return 0;
             }
-
-            const merge_segment = wasm_bin.base.options.output_mode != .Obj;
             const target_atom = wasm_bin.symbol_atom.get(target_loc).?;
-            const segment_info = if (target_atom.file) |object_index| blk: {
-                break :blk wasm_bin.objects.items[object_index].segment_info;
-            } else wasm_bin.segment_info.values();
-            const segment_name = segment_info[symbol.index].outputName(merge_segment);
-            const segment_index = wasm_bin.data_segments.get(segment_name).?;
-            const segment = wasm_bin.segments.items[segment_index];
-            const rel_value = @intCast(i32, target_atom.offset + segment.offset) + relocation.addend;
-            return @intCast(u32, rel_value);
+            const va = @intCast(i32, target_atom.getVA(wasm_bin, symbol));
+            return @intCast(u32, va + relocation.addend);
         },
         .R_WASM_EVENT_INDEX_LEB => return symbol.index,
         .R_WASM_SECTION_OFFSET_I32 => {

src/link/Wasm/Atom.zig

@@ -139,12 +139,10 @@ pub fn isNoStrip(symbol: Symbol) bool {
     return symbol.flags & @enumToInt(Flag.WASM_SYM_NO_STRIP) != 0;
 }
 
-pub fn isExported(symbol: Symbol) bool {
+pub fn isExported(symbol: Symbol, is_dynamic: bool) bool {
     if (symbol.isUndefined() or symbol.isLocal()) return false;
-    if (symbol.isHidden()) return false;
-    if (symbol.hasFlag(.WASM_SYM_EXPORTED)) return true;
-    if (symbol.hasFlag(.WASM_SYM_BINDING_WEAK)) return false;
-    return true;
+    if (is_dynamic and symbol.isVisible()) return true;
+    return symbol.hasFlag(.WASM_SYM_EXPORTED);
 }
 
 pub fn isWeak(symbol: Symbol) bool {

src/link/Wasm/Symbol.zig

@@ -42,6 +42,16 @@ fn addWasmCases(cases: *tests.StandaloneContext) void {
         .requires_stage2 = true,
     });
 
+    cases.addBuildFile("test/link/wasm/export/build.zig", .{
+        .build_modes = true,
+        .requires_stage2 = true,
+    });
+
+    // TODO: Fix open handle in wasm-linker refraining rename from working on Windows.
+    if (builtin.os.tag != .windows) {
+        cases.addBuildFile("test/link/wasm/export-data/build.zig", .{});
+    }
+
     cases.addBuildFile("test/link/wasm/extern/build.zig", .{
         .build_modes = true,
         .requires_stage2 = true,
@@ -53,6 +63,11 @@ fn addWasmCases(cases: *tests.StandaloneContext) void {
         .requires_stage2 = true,
     });
 
+    cases.addBuildFile("test/link/wasm/function-table/build.zig", .{
+        .build_modes = true,
+        .requires_stage2 = true,
+    });
+
     cases.addBuildFile("test/link/wasm/infer-features/build.zig", .{
         .requires_stage2 = true,
     });

test/link.zig

@@ -26,8 +26,7 @@ pub fn build(b: *Builder) void {
     check_lib.checkNext("name memory"); // as per linker specification
 
     // since we are importing memory, ensure it's not exported
-    check_lib.checkStart("Section export");
-    check_lib.checkNext("entries 1"); // we're exporting function 'foo' so only 1 entry
+    check_lib.checkNotPresent("Section export");
 
     // validate the name of the stack pointer
     check_lib.checkStart("Section custom");

test/link/wasm/bss/build.zig

@@ -0,0 +1,39 @@
+const std = @import("std");
+const Builder = std.build.Builder;
+
+pub fn build(b: *Builder) void {
+    const test_step = b.step("test", "Test");
+    test_step.dependOn(b.getInstallStep());
+
+    const lib = b.addSharedLibrary("lib", "lib.zig", .unversioned);
+    lib.setBuildMode(.ReleaseSafe); // to make the output deterministic in address positions
+    lib.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    lib.use_lld = false;
+    lib.export_symbol_names = &.{ "foo", "bar" };
+    lib.global_base = 0; // put data section at address 0 to make data symbols easier to parse
+
+    const check_lib = lib.checkObject(.wasm);
+
+    check_lib.checkStart("Section global");
+    check_lib.checkNext("entries 3");
+    check_lib.checkNext("type i32"); // stack pointer so skip other fields
+    check_lib.checkNext("type i32");
+    check_lib.checkNext("mutable false");
+    check_lib.checkNext("i32.const {foo_address}");
+    check_lib.checkNext("type i32");
+    check_lib.checkNext("mutable false");
+    check_lib.checkNext("i32.const {bar_address}");
+    check_lib.checkComputeCompare("foo_address", .{ .op = .eq, .value = .{ .literal = 0 } });
+    check_lib.checkComputeCompare("bar_address", .{ .op = .eq, .value = .{ .literal = 4 } });
+
+    check_lib.checkStart("Section export");
+    check_lib.checkNext("entries 3");
+    check_lib.checkNext("name foo");
+    check_lib.checkNext("kind global");
+    check_lib.checkNext("index 1");
+    check_lib.checkNext("name bar");
+    check_lib.checkNext("kind global");
+    check_lib.checkNext("index 2");
+
+    test_step.dependOn(&check_lib.step);
+}

test/link/wasm/export-data/build.zig

@@ -0,0 +1,2 @@
+export const foo: u32 = 0xbbbbbbbb;
+export const bar: u32 = 0xbbbbbbbb;

test/link/wasm/export-data/lib.zig

@@ -0,0 +1,48 @@
+const std = @import("std");
+
+pub fn build(b: *std.build.Builder) void {
+    const mode = b.standardReleaseOptions();
+
+    const no_export = b.addSharedLibrary("no-export", "main.zig", .unversioned);
+    no_export.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    no_export.setBuildMode(mode);
+    no_export.use_llvm = false;
+    no_export.use_lld = false;
+
+    const dynamic_export = b.addSharedLibrary("dynamic", "main.zig", .unversioned);
+    dynamic_export.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    dynamic_export.setBuildMode(mode);
+    dynamic_export.rdynamic = true;
+    dynamic_export.use_llvm = false;
+    dynamic_export.use_lld = false;
+
+    const force_export = b.addSharedLibrary("force", "main.zig", .unversioned);
+    force_export.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    force_export.setBuildMode(mode);
+    force_export.export_symbol_names = &.{"foo"};
+    force_export.use_llvm = false;
+    force_export.use_lld = false;
+
+    const check_no_export = no_export.checkObject(.wasm);
+    check_no_export.checkStart("Section export");
+    check_no_export.checkNext("entries 1");
+    check_no_export.checkNext("name memory");
+    check_no_export.checkNext("kind memory");
+
+    const check_dynamic_export = dynamic_export.checkObject(.wasm);
+    check_dynamic_export.checkStart("Section export");
+    check_dynamic_export.checkNext("entries 2");
+    check_dynamic_export.checkNext("name foo");
+    check_dynamic_export.checkNext("kind function");
+
+    const check_force_export = force_export.checkObject(.wasm);
+    check_force_export.checkStart("Section export");
+    check_force_export.checkNext("entries 2");
+    check_force_export.checkNext("name foo");
+    check_force_export.checkNext("kind function");
+
+    const test_step = b.step("test", "Run linker test");
+    test_step.dependOn(&check_no_export.step);
+    test_step.dependOn(&check_dynamic_export.step);
+    test_step.dependOn(&check_force_export.step);
+}

test/link/wasm/export/build.zig

@@ -0,0 +1 @@
+export fn foo() void {}

test/link/wasm/export/main.zig

@@ -0,0 +1,63 @@
+const std = @import("std");
+const Builder = std.build.Builder;
+
+pub fn build(b: *Builder) void {
+    const mode = b.standardReleaseOptions();
+
+    const test_step = b.step("test", "Test");
+    test_step.dependOn(b.getInstallStep());
+
+    const import_table = b.addSharedLibrary("lib", "lib.zig", .unversioned);
+    import_table.setBuildMode(mode);
+    import_table.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    import_table.use_llvm = false;
+    import_table.use_lld = false;
+    import_table.import_table = true;
+
+    const export_table = b.addSharedLibrary("lib", "lib.zig", .unversioned);
+    export_table.setBuildMode(mode);
+    export_table.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    export_table.use_llvm = false;
+    export_table.use_lld = false;
+    export_table.export_table = true;
+
+    const regular_table = b.addSharedLibrary("lib", "lib.zig", .unversioned);
+    regular_table.setBuildMode(mode);
+    regular_table.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    regular_table.use_llvm = false;
+    regular_table.use_lld = false;
+
+    const check_import = import_table.checkObject(.wasm);
+    const check_export = export_table.checkObject(.wasm);
+    const check_regular = regular_table.checkObject(.wasm);
+
+    check_import.checkStart("Section import");
+    check_import.checkNext("entries 1");
+    check_import.checkNext("module env");
+    check_import.checkNext("name __indirect_function_table");
+    check_import.checkNext("kind table");
+    check_import.checkNext("type funcref");
+    check_import.checkNext("min 1"); // 1 function pointer
+    check_import.checkNotPresent("max"); // when importing, we do not provide a max
+    check_import.checkNotPresent("Section table"); // we're importing it
+
+    check_export.checkStart("Section export");
+    check_export.checkNext("entries 2");
+    check_export.checkNext("name __indirect_function_table"); // as per linker specification
+    check_export.checkNext("kind table");
+
+    check_regular.checkStart("Section table");
+    check_regular.checkNext("entries 1");
+    check_regular.checkNext("type funcref");
+    check_regular.checkNext("min 2"); // index starts at 1 & 1 function pointer = 2.
+    check_regular.checkNext("max 2");
+    check_regular.checkStart("Section element");
+    check_regular.checkNext("entries 1");
+    check_regular.checkNext("table index 0");
+    check_regular.checkNext("i32.const 1"); // we want to start function indexes at 1
+    check_regular.checkNext("indexes 1"); // 1 function pointer
+
+    test_step.dependOn(&check_import.step);
+    test_step.dependOn(&check_export.step);
+    test_step.dependOn(&check_regular.step);
+}