Commit 142dbc7b82c741692dd17f8c0455203826342bba | zig

author	Luuk de Gram <luuk@degram.dev> 2023-07-18 19:55:20+02:00
committer	Luuk de Gram <luuk@degram.dev> 2023-07-19 17:22:46+02:00
log	142dbc7b82c741692dd17f8c0455203826342bba
tree	89899879d0bc08f077e3f0d2a4de1164a414eaa0
parent	1a3304ed236b60cd31c790bae929a78c58c9d33e
signature	Commit is signed but in an unrecognized format.

wasm-linker: create TLS Wasm globals correctly

Previously, they were only created when we had any TLS segment.
This meant that while the symbol existed, the global itself wouldn't.
The result of this was a crash during symbol names writing as it
would attempt to write the symbol name of a global that didn't exist.
Now we always create them, and instead update its `init` value during
`setupMemory`.

In the future, the entire symbol (and global) will be removed by
the garbage collector.

2 files changed, 63 insertions(+), 36 deletions(-)

src
- link
  - Wasm.zig
test
- link
  - wasm
    shared-memory
    build.zig

src/link/Wasm.zig+23-17

 @@ -410,7 +410,7 @@ pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Option
                 },
             );
         } else {
-            symbol.index = @as(u32, @intCast(wasm_bin.imported_globals_count + wasm_bin.wasm_globals.items.len));
+            symbol.index = @intCast(wasm_bin.imported_globals_count + wasm_bin.wasm_globals.items.len);
             symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
             const global = try wasm_bin.wasm_globals.addOne(allocator);
             global.* = .{
 @@ -433,7 +433,7 @@ pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Option
         };
         if (options.output_mode == .Obj or options.import_table) {
             symbol.setUndefined(true);
-            symbol.index = @as(u32, @intCast(wasm_bin.imported_tables_count));
+            symbol.index = @intCast(wasm_bin.imported_tables_count);
             wasm_bin.imported_tables_count += 1;
             try wasm_bin.imports.put(allocator, loc, .{
                 .module_name = try wasm_bin.string_table.put(allocator, wasm_bin.host_name),
 @@ -467,16 +467,31 @@ pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Option
             const loc = try wasm_bin.createSyntheticSymbol("__tls_base", .global);
             const symbol = loc.getSymbol(wasm_bin);
             symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
+            symbol.index = @intCast(wasm_bin.imported_globals_count + wasm_bin.wasm_globals.items.len);
+            try wasm_bin.wasm_globals.append(wasm_bin.base.allocator, .{
+                .global_type = .{ .valtype = .i32, .mutable = true },
+                .init = .{ .i32_const = undefined },
+            });
         }
         {
             const loc = try wasm_bin.createSyntheticSymbol("__tls_size", .global);
             const symbol = loc.getSymbol(wasm_bin);
             symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
+            symbol.index = @intCast(wasm_bin.imported_globals_count + wasm_bin.wasm_globals.items.len);
+            try wasm_bin.wasm_globals.append(wasm_bin.base.allocator, .{
+                .global_type = .{ .valtype = .i32, .mutable = false },
+                .init = .{ .i32_const = undefined },
+            });
         }
         {
             const loc = try wasm_bin.createSyntheticSymbol("__tls_align", .global);
             const symbol = loc.getSymbol(wasm_bin);
             symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
+            symbol.index = @intCast(wasm_bin.imported_globals_count + wasm_bin.wasm_globals.items.len);
+            try wasm_bin.wasm_globals.append(wasm_bin.base.allocator, .{
+                .global_type = .{ .valtype = .i32, .mutable = false },
+                .init = .{ .i32_const = undefined },
+            });
         }
         {
             const loc = try wasm_bin.createSyntheticSymbol("__wasm_init_tls", .function);
 @@ -2757,27 +2772,18 @@ fn setupMemory(wasm: *Wasm) !void {
         if (mem.eql(u8, entry.key_ptr.*, ".tdata")) {
             if (wasm.findGlobalSymbol("__tls_size")) |loc| {
                 const sym = loc.getSymbol(wasm);
-                sym.index = @as(u32, @intCast(wasm.wasm_globals.items.len)) + wasm.imported_globals_count;
+                wasm.wasm_globals.items[sym.index - wasm.imported_globals_count].init.i32_const = @intCast(segment.size);
-                try wasm.wasm_globals.append(wasm.base.allocator, .{
-                    .global_type = .{ .valtype = .i32, .mutable = false },
-                    .init = .{ .i32_const = @as(i32, @intCast(segment.size)) },
-                });
             }
             if (wasm.findGlobalSymbol("__tls_align")) |loc| {
                 const sym = loc.getSymbol(wasm);
-                sym.index = @as(u32, @intCast(wasm.wasm_globals.items.len)) + wasm.imported_globals_count;
+                wasm.wasm_globals.items[sym.index - wasm.imported_globals_count].init.i32_const = @intCast(segment.alignment);
-                try wasm.wasm_globals.append(wasm.base.allocator, .{
-                    .global_type = .{ .valtype = .i32, .mutable = false },
-                    .init = .{ .i32_const = @as(i32, @intCast(segment.alignment)) },
-                });
             }
             if (wasm.findGlobalSymbol("__tls_base")) |loc| {
                 const sym = loc.getSymbol(wasm);
-                sym.index = @as(u32, @intCast(wasm.wasm_globals.items.len)) + wasm.imported_globals_count;
+                wasm.wasm_globals.items[sym.index - wasm.imported_globals_count].init.i32_const = if (wasm.base.options.shared_memory)
-                try wasm.wasm_globals.append(wasm.base.allocator, .{
+                    @as(i32, 0)
-                    .global_type = .{ .valtype = .i32, .mutable = wasm.base.options.shared_memory },
+                else
-                    .init = .{ .i32_const = if (wasm.base.options.shared_memory) @as(u32, 0) else @as(i32, @intCast(memory_ptr)) },
+                    @as(i32, @intCast(memory_ptr));
-                });
             }
         }

test/link/wasm/shared-memory/build.zig+40-19

...	@@ -5,11 +5,9 @@ pub fn build(b: *std.Build) void {	...	@@ -5,11 +5,9 @@ pub fn build(b: *std.Build) void {
5	b.default_step = test_step;	5	b.default_step = test_step;
6		6
7	add(b, test_step, .Debug);	7	add(b, test_step, .Debug);
8		8	add(b, test_step, .ReleaseFast);
9	// Enable the following build modes once garbage-collection is implemented properly.	9	add(b, test_step, .ReleaseSmall);
10	// add(b, test_step, .ReleaseFast);	10	add(b, test_step, .ReleaseSafe);
11	// add(b, test_step, .ReleaseSmall);
12	// add(b, test_step, .ReleaseSafe);
13	}	11	}
14		12
15	fn add(b: std.Build, test_step: std.Build.Step, optimize_mode: std.builtin.OptimizeMode) void {	13	fn add(b: std.Build, test_step: std.Build.Step, optimize_mode: std.builtin.OptimizeMode) void {
...	@@ -47,30 +45,53 @@ fn add(b: std.Build, test_step: std.Build.Step, optimize_mode: std.builtin.Opt	...	@@ -47,30 +45,53 @@ fn add(b: std.Build, test_step: std.Build.Step, optimize_mode: std.builtin.Opt
47		45
48	// This section must be emit as the start function is set to the index	46	// This section must be emit as the start function is set to the index
49	// of __wasm_init_memory	47	// of __wasm_init_memory
50	check_lib.checkStart("Section start");	48	// release modes will have the TLS segment optimized out in our test-case.
		49	// This means we won't have __wasm_init_memory in such case, and therefore
		50	// should also not have a section "start"
		51	if (optimize_mode == .Debug) {
		52	check_lib.checkStart("Section start");
		53	}
51		54
52	// This section is only and must be emit when shared-memory is enabled	55	// This section is only and must be emit when shared-memory is enabled
53	check_lib.checkStart("Section data_count");	56	// release modes will have the TLS segment optimized out in our test-case.
54	check_lib.checkNext("count 3");	57	if (optimize_mode == .Debug) {
		58	check_lib.checkStart("Section data_count");
		59	check_lib.checkNext("count 3");
		60	}
55		61
56	check_lib.checkStart("Section custom");	62	check_lib.checkStart("Section custom");
57	check_lib.checkNext("name name");	63	check_lib.checkNext("name name");
58	check_lib.checkNext("type function");	64	check_lib.checkNext("type function");
59	check_lib.checkNext("name __wasm_init_memory");	65	if (optimize_mode == .Debug) {
		66	check_lib.checkNext("name __wasm_init_memory");
		67	}
60	check_lib.checkNext("name __wasm_init_tls");	68	check_lib.checkNext("name __wasm_init_tls");
61	check_lib.checkNext("type global");	69	check_lib.checkNext("type global");
62	check_lib.checkNext("name __tls_size");	70
63	check_lib.checkNext("name __tls_align");	71	// In debug mode the symbol __tls_base is resolved to an undefined symbol
64	check_lib.checkNext("name __tls_base");	72	// from the object file, hence its placement differs than in release modes
		73	// where the entire tls segment is optimized away, and tls_base will have
		74	// its original position.
		75	if (optimize_mode == .Debug) {
		76	check_lib.checkNext("name __tls_size");
		77	check_lib.checkNext("name __tls_align");
		78	check_lib.checkNext("name __tls_base");
		79	} else {
		80	check_lib.checkNext("name __tls_base");
		81	check_lib.checkNext("name __tls_size");
		82	check_lib.checkNext("name __tls_align");
		83	}
65		84
66	check_lib.checkNext("type data_segment");	85	check_lib.checkNext("type data_segment");
67	check_lib.checkNext("names 3");	86	if (optimize_mode == .Debug) {
68	check_lib.checkNext("index 0");	87	check_lib.checkNext("names 3");
69	check_lib.checkNext("name .rodata");	88	check_lib.checkNext("index 0");
70	check_lib.checkNext("index 1");	89	check_lib.checkNext("name .rodata");
71	check_lib.checkNext("name .bss");	90	check_lib.checkNext("index 1");
72	check_lib.checkNext("index 2");	91	check_lib.checkNext("name .bss");
73	check_lib.checkNext("name .tdata");	92	check_lib.checkNext("index 2");
		93	check_lib.checkNext("name .tdata");
		94	}
74		95
75	test_step.dependOn(&check_lib.step);	96	test_step.dependOn(&check_lib.step);
76	}	97	}