Commit 4ba0ad295f2b3ff9cc28fd45939f849c3ace5dda | zig

author	Luuk de Gram <luuk@degram.dev> 2022-08-31 13:44:06+02:00
committer	GitHub <noreply@github.com> 2022-08-31 13:44:06+02:00
log	4ba0ad295f2b3ff9cc28fd45939f849c3ace5dda
tree	bfd4f18623b20b582fd97dd5885d7e57e397cfba
parent	9f9e51eb110289850ee30c0b4ca895a8861f4c40
parent	8627858bbc2fee848e2f3e3ca64dc944f39591e5
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #12687 from Luukdegram/wasm-extern-globals

wasm-linker: implement non-function extern variables

8 files changed, 73 insertions(+), 22 deletions(-)

src
- arch
  - wasm
    CodeGen.zig
- link
  - Wasm.zig
  - Wasm
    Atom.zig
    Symbol.zig
test
- link.zig
- link
  - wasm
    extern
    build.zig
    foo.c
    main.zig

src/arch/wasm/CodeGen.zig-2

...	@@ -2394,9 +2394,7 @@ fn lowerConstant(self: *Self, val: Value, ty: Type) InnerError!WValue {	...	@@ -2394,9 +2394,7 @@ fn lowerConstant(self: *Self, val: Value, ty: Type) InnerError!WValue {
2394	const decl_index = decl_ref_mut.data.decl_index;	2394	const decl_index = decl_ref_mut.data.decl_index;
2395	return self.lowerDeclRefValue(.{ .ty = ty, .val = val }, decl_index);	2395	return self.lowerDeclRefValue(.{ .ty = ty, .val = val }, decl_index);
2396	}	2396	}
2397
2398	const target = self.target;	2397	const target = self.target;
2399
2400	switch (ty.zigTypeTag()) {	2398	switch (ty.zigTypeTag()) {
2401	.Void => return WValue{ .none = {} },	2399	.Void => return WValue{ .none = {} },
2402	.Int => {	2400	.Int => {

src/link/Wasm.zig+34-11

 @@ -607,6 +607,24 @@ fn resolveSymbolsInArchives(self: *Wasm) !void {
     }
 }
+fn checkUndefinedSymbols(self: *const Wasm) !void {
+    var found_undefined_symbols = false;
+    for (self.undefs.values()) |undef| {
+        const symbol = undef.getSymbol(self);
+        if (symbol.tag == .data) {
+            found_undefined_symbols = true;
+            const file_name = if (undef.file) |file_index| name: {
+                break :name self.objects.items[file_index].name;
+            } else self.name;
+            log.err("could not resolve undefined symbol '{s}'", .{undef.getName(self)});
+            log.err("  defined in '{s}'", .{file_name});
+        }
+    }
+    if (found_undefined_symbols) {
+        return error.UndefinedSymbol;
+    }
+}
 pub fn deinit(self: *Wasm) void {
     const gpa = self.base.allocator;
     if (build_options.have_llvm) {
 @@ -783,15 +801,17 @@ pub fn updateDecl(self: *Wasm, mod: *Module, decl_index: Module.Decl.Index) !voi
     decl.link.wasm.clear();
-    if (decl.isExtern()) {
-        return;
-    }
     if (decl.val.castTag(.function)) |_| {
         return;
     } else if (decl.val.castTag(.extern_fn)) |_| {
         return;
     }
+    if (decl.isExtern()) {
+        const variable = decl.getVariable().?;
+        const name = mem.sliceTo(decl.name, 0);
+        return self.addOrUpdateImport(name, decl.link.wasm.sym_index, variable.lib_name, null);
+    }
     const val = if (decl.val.castTag(.variable)) |payload| payload.data.init else decl.val;
     var code_writer = std.ArrayList(u8).init(self.base.allocator);
 @@ -834,19 +854,18 @@ pub fn updateDeclLineNumber(self: *Wasm, mod: *Module, decl: *const Module.Decl)
 }
 fn finishUpdateDecl(self: *Wasm, decl: *Module.Decl, code: []const u8) !void {
-    if (code.len == 0) return;
     const mod = self.base.options.module.?;
     const atom: *Atom = &decl.link.wasm;
-    atom.size = @intCast(u32, code.len);
-    atom.alignment = decl.ty.abiAlignment(self.base.options.target);
     const symbol = &self.symbols.items[atom.sym_index];
     const full_name = try decl.getFullyQualifiedName(mod);
     defer self.base.allocator.free(full_name);
     symbol.name = try self.string_table.put(self.base.allocator, full_name);
     try atom.code.appendSlice(self.base.allocator, code);
     try self.resolved_symbols.put(self.base.allocator, atom.symbolLoc(), {});
+    if (code.len == 0) return;
+    atom.size = @intCast(u32, code.len);
+    atom.alignment = decl.ty.abiAlignment(self.base.options.target);
 }
 /// From a given symbol location, returns its `wasm.GlobalType`.
 @@ -1235,7 +1254,10 @@ pub fn addOrUpdateImport(
                 .kind = .{ .function = ty_index },
             };
         }
-    } else @panic("TODO: Implement undefined symbols for non-function declarations");
+    } else {
+        symbol.tag = .data;
+        return; // non-functions will not be imported from the runtime, but only resolved during link-time
+    }
 }
 /// Kind represents the type of an Atom, which is only
 @@ -1438,7 +1460,7 @@ fn setupImports(self: *Wasm) !void {
         if (std.mem.eql(u8, symbol_loc.getName(self), "__indirect_function_table")) {
             continue;
         }
-        if (symbol.tag == .data or !symbol.requiresImport()) {
+        if (!symbol.requiresImport()) {
             continue;
         }
 @@ -2007,6 +2029,7 @@ pub fn flushModule(self: *Wasm, comp: *Compilation, prog_node: *std.Progress.Nod
     }
     try self.resolveSymbolsInArchives();
+    try self.checkUndefinedSymbols();
     // When we finish/error we reset the state of the linker
     // So we can rebuild the binary file on each incremental update

src/link/Wasm/Atom.zig+6-8

 @@ -172,18 +172,16 @@ fn relocationValue(self: Atom, relocation: types.Relocation, wasm_bin: *const Wa
         .R_WASM_MEMORY_ADDR_SLEB,
         .R_WASM_MEMORY_ADDR_SLEB64,
         => {
-            if (symbol.isUndefined() and symbol.isWeak()) {
+            std.debug.assert(symbol.tag == .data and !symbol.isUndefined());
-                return 0;
-            }
-            std.debug.assert(symbol.tag == .data);
             const merge_segment = wasm_bin.base.options.output_mode != .Obj;
-            const segment_info = if (self.file) |object_index| blk: {
+            const target_atom_loc = wasm_bin.discarded.get(target_loc) orelse target_loc;
+            const target_atom = wasm_bin.symbol_atom.get(target_atom_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.items;
             const segment_name = segment_info[symbol.index].outputName(merge_segment);
-            const atom_index = wasm_bin.data_segments.get(segment_name).?;
+            const segment_index = wasm_bin.data_segments.get(segment_name).?;
-            const target_atom = wasm_bin.symbol_atom.get(target_loc).?;
+            const segment = wasm_bin.segments.items[segment_index];
-            const segment = wasm_bin.segments.items[atom_index];
             return target_atom.offset + segment.offset + (relocation.addend orelse 0);
         },
         .R_WASM_EVENT_INDEX_LEB => return symbol.index,

src/link/Wasm/Symbol.zig+1-1

 @@ -79,9 +79,9 @@ pub const Flag = enum(u32) {
 /// Verifies if the given symbol should be imported from the
 /// host environment or not
 pub fn requiresImport(self: Symbol) bool {
+    if (self.tag == .data) return false;
     if (!self.isUndefined()) return false;
     if (self.isWeak()) return false;
-    if (self.tag == .data) return false;
     // if (self.isDefined() and self.isWeak()) return true; //TODO: Only when building shared lib
     return true;

test/link.zig+6

...	@@ -52,6 +52,12 @@ fn addWasmCases(cases: *tests.StandaloneContext) void {	...	@@ -52,6 +52,12 @@ fn addWasmCases(cases: *tests.StandaloneContext) void {
52	.build_modes = true,	52	.build_modes = true,
53	.requires_stage2 = true,	53	.requires_stage2 = true,
54	});	54	});
		55
		56	cases.addBuildFile("test/link/wasm/extern/build.zig", .{
		57	.build_modes = true,
		58	.requires_stage2 = true,
		59	.use_emulation = true,
		60	});
55	}	61	}
56		62
57	fn addMachOCases(cases: *tests.StandaloneContext) void {	63	fn addMachOCases(cases: *tests.StandaloneContext) void {

test/link/wasm/extern/build.zig created+17

...	@@ -0,0 +1,17 @@
1	const std = @import("std");
2
3	pub fn build(b: *std.build.Builder) void {
4	const mode = b.standardReleaseOptions();
5	const exe = b.addExecutable("extern", "main.zig");
6	exe.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .wasi });
7	exe.setBuildMode(mode);
8	exe.addCSourceFile("foo.c", &.{});
9	exe.use_llvm = false;
10	exe.use_lld = false;
11
12	const run = exe.runEmulatable();
13	run.expectStdOutEqual("Result: 30");
14
15	const test_step = b.step("test", "Run linker test");
16	test_step.dependOn(&run.step);
17	}

test/link/wasm/extern/foo.c created+1

...	@@ -0,0 +1 @@
1	int foo = 30;

test/link/wasm/extern/main.zig created+8

...	@@ -0,0 +1,8 @@
1	const std = @import("std");
2
3	extern const foo: u32;
4
5	pub fn main() void {
6	const std_out = std.io.getStdOut();
7	std_out.writer().print("Result: {d}", .{foo}) catch {};
8	}