Commit 1cb7a01b25349c42dbe207b68f9e19b92890b3d2 | zig

author	Luuk de Gram <luuk@degram.dev> 2023-08-30 16:59:48+02:00
committer	Luuk de Gram <luuk@degram.dev> 2023-11-03 12:48:52+01:00
log	1cb7a01b25349c42dbe207b68f9e19b92890b3d2
tree	602589918ad620910c8462711492e1ffff6c2826
parent	94cee4fb27a433824c2540dc37375dc14befdf47
signature	Commit is signed but in an unrecognized format.

wasm-linker: implement `-fno-entry` flag

This adds support for the `-fno-entry` and `-fentry` flags respectively, for
zig build-{exe/lib} and the build system. For `zig cc` we use the `--no-entry`
flag to be compatible with clang and existing tooling.

In `start.zig` we now make the main function optional when the target is
WebAssembly, as to allow for the build-exe command in combination with
`-fno-entry`.

When the execution model is set, and is set to 'reactor', we now verify
when an entry name is given it matches what is expected. When no entry
point is given, we set it to `_initialize` by default. This means the user
will also be met with an error when they use the reactor model, but did
not provide the correct function.

6 files changed, 47 insertions(+), 21 deletions(-)

lib
- std
  - Build
    Step
    Compile.zig
  - start.zig
src
- Compilation.zig
- link.zig
- link
  - Wasm.zig
- main.zig

lib/std/Build/Step/Compile.zig+3

...	@@ -64,6 +64,8 @@ initial_memory: ?u64 = null,	...	@@ -64,6 +64,8 @@ initial_memory: ?u64 = null,
64	max_memory: ?u64 = null,	64	max_memory: ?u64 = null,
65	shared_memory: bool = false,	65	shared_memory: bool = false,
66	global_base: ?u64 = null,	66	global_base: ?u64 = null,
		67	/// For WebAssembly only. Tells the linker to not output an entry point.
		68	no_entry: ?bool = null,
67	c_std: std.Build.CStd,	69	c_std: std.Build.CStd,
68	/// Set via options; intended to be read-only after that.	70	/// Set via options; intended to be read-only after that.
69	zig_lib_dir: ?LazyPath,	71	zig_lib_dir: ?LazyPath,
...	@@ -1851,6 +1853,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {	...	@@ -1851,6 +1853,7 @@ fn make(step: Step, prog_node: std.Progress.Node) !void {
1851	if (self.global_base) \|global_base\| {	1853	if (self.global_base) \|global_base\| {
1852	try zig_args.append(b.fmt("--global-base={d}", .{global_base}));	1854	try zig_args.append(b.fmt("--global-base={d}", .{global_base}));
1853	}	1855	}
		1856	try addFlag(&zig_args, "entry", self.no_entry);
1854		1857
1855	if (self.code_model != .default) {	1858	if (self.code_model != .default) {
1856	try zig_args.append("-mcmodel");	1859	try zig_args.append("-mcmodel");

lib/std/start.zig+6-2

 @@ -82,11 +82,15 @@ comptime {
                     .reactor => "_initialize",
                     .command => "_start",
                 };
-                if (!@hasDecl(root, wasm_start_sym)) {
+                if (!@hasDecl(root, wasm_start_sym) and @hasDecl(root, "main")) {
+                    // Only call main when defined. For WebAssembly it's allowed to pass `-fno-entry` in which
+                    // case it's not required to provide an entrypoint such as main.
                     @export(wasi_start, .{ .name = wasm_start_sym });
                 }
             } else if (native_arch.isWasm() and native_os == .freestanding) {
-                if (!@hasDecl(root, start_sym_name)) @export(wasm_freestanding_start, .{ .name = start_sym_name });
+                // Only call main when defined. For WebAssembly it's allowed to pass `-fno-entry` in which
+                // case it's not required to provide an entrypoint such as main.
+                if (!@hasDecl(root, start_sym_name) and @hasDecl(root, "main")) @export(wasm_freestanding_start, .{ .name = start_sym_name });
             } else if (native_os != .other and native_os != .freestanding) {
                 if (!@hasDecl(root, start_sym_name)) @export(_start, .{ .name = start_sym_name });
             }

src/Compilation.zig+3

src/link.zig+1

...	@@ -166,6 +166,7 @@ pub const Options = struct {	...	@@ -166,6 +166,7 @@ pub const Options = struct {
166	export_table: bool,	166	export_table: bool,
167	initial_memory: ?u64,	167	initial_memory: ?u64,
168	max_memory: ?u64,	168	max_memory: ?u64,
		169	no_entry: bool,
169	shared_memory: bool,	170	shared_memory: bool,
170	export_symbol_names: []const []const u8,	171	export_symbol_names: []const []const u8,
171	global_base: ?u64,	172	global_base: ?u64,

src/link/Wasm.zig+5-19

 @@ -2817,14 +2817,10 @@ fn setupExports(wasm: *Wasm) !void {
 }
 fn setupStart(wasm: *Wasm) !void {
+    if (wasm.base.options.no_entry) return;
     const entry_name = wasm.base.options.entry orelse "_start";
     const symbol_loc = wasm.findGlobalSymbol(entry_name) orelse {
-        if (wasm.base.options.output_mode == .Exe) {
-            if (wasm.base.options.wasi_exec_model == .reactor) return; // Not required for reactors
-        } else {
-            return; // No entry point needed for non-executable wasm files
-        }
         log.err("Entry symbol '{s}' missing", .{entry_name});
         return error.MissingSymbol;
     };
 @@ -4544,24 +4540,14 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
         const arg = try std.fmt.allocPrint(arena, "stack-size={d}", .{stack_size});
         try argv.append(arg);
-        if (wasm.base.options.output_mode == .Exe) {
-            if (wasm.base.options.wasi_exec_model == .reactor) {
-                // Reactor execution model does not have _start so lld doesn't look for it.
-                try argv.append("--no-entry");
-                // Make sure "_initialize" and other used-defined functions are exported if this is WASI reactor.
-                // If rdynamic is true, it will already be appended, so only verify if the user did not specify
-                // the flag in which case, we ensure `--export-dynamic` is called.
-                if (!wasm.base.options.rdynamic) {
-                    try argv.append("--export-dynamic");
-                }
-            }
-        } else if (wasm.base.options.entry == null) {
-            try argv.append("--no-entry"); // So lld doesn't look for _start.
-        }
         if (wasm.base.options.import_symbols) {
             try argv.append("--allow-undefined");
         }
+        if (wasm.base.options.no_entry) {
+            try argv.append("--no-entry");
+        }
         // XXX - TODO: add when wasm-ld supports --build-id.
         // if (wasm.base.options.build_id) {
         //     try argv.append("--build-id=tree");

src/main.zig+29

 @@ -577,6 +577,8 @@ const usage_build_generic =
     \\  --shared-memory                (WebAssembly) use shared linear memory
     \\  --global-base=[addr]           (WebAssembly) where to start to place global data
     \\  --export=[value]               (WebAssembly) Force a symbol to be exported
+    \\  -fentry                        (WebAssembly) Force output an entry point
+    \\  -fno-entry                     (WebAssembly) Do not output any entry point
     \\
     \\Test Options:
     \\  --test-filter [text]           Skip tests that do not match filter
 @@ -835,6 +837,7 @@ fn buildOutputType(
     var linker_import_symbols: bool = false;
     var linker_import_table: bool = false;
     var linker_export_table: bool = false;
+    var linker_no_entry: ?bool = null;
     var linker_initial_memory: ?u64 = null;
     var linker_max_memory: ?u64 = null;
     var linker_shared_memory: bool = false;
 @@ -1503,6 +1506,10 @@ fn buildOutputType(
                         }
                     } else if (mem.eql(u8, arg, "--import-memory")) {
                         linker_import_memory = true;
+                    } else if (mem.eql(u8, arg, "-fentry")) {
+                        linker_no_entry = false;
+                    } else if (mem.eql(u8, arg, "-fno-entry")) {
+                        linker_no_entry = true;
                     } else if (mem.eql(u8, arg, "--export-memory")) {
                         linker_export_memory = true;
                     } else if (mem.eql(u8, arg, "--import-symbols")) {
 @@ -2134,6 +2141,8 @@ fn buildOutputType(
                     linker_import_table = true;
                 } else if (mem.eql(u8, arg, "--export-table")) {
                     linker_export_table = true;
+                } else if (mem.eql(u8, arg, "--no-entry")) {
+                    linker_no_entry = true;
                 } else if (mem.eql(u8, arg, "--initial-memory")) {
                     const next_arg = linker_args_it.nextOrFatal();
                     linker_initial_memory = std.fmt.parseUnsigned(u32, eatIntPrefix(next_arg, 16), 16) catch |err| {
 @@ -2618,6 +2627,25 @@ fn buildOutputType(
         if (single_threaded == null) {
             single_threaded = true;
         }
+        if (wasi_exec_model) |model| {
+            if (model == .reactor) {
+                if (linker_no_entry != null and !linker_no_entry.?) {
+                    fatal("WASI exucution model 'reactor' incompatible with flag '-fentry'. Reactor execution model has no entry point", .{});
+                }
+                if (entry) |entry_name| {
+                    if (!mem.eql(u8, "_initialize", entry_name)) {
+                        fatal("the entry symbol of the reactor model must be '_initialize', but found '{s}'", .{entry_name});
+                    }
+                } else {
+                    entry = "_initialize";
+                }
+            }
+        }
+        if (linker_no_entry) |no_entry| {
+            if (no_entry and entry != null) {
+                fatal("combination of '--entry' and `-fno-entry` are incompatible", .{});
+            }
+        }
         if (linker_shared_memory) {
             if (output_mode == .Obj) {
                 fatal("shared memory is not allowed in object files", .{});
 @@ -3465,6 +3493,7 @@ fn buildOutputType(
         .linker_import_symbols = linker_import_symbols,
         .linker_import_table = linker_import_table,
         .linker_export_table = linker_export_table,
+        .linker_no_entry = linker_no_entry orelse false,
         .linker_initial_memory = linker_initial_memory,
         .linker_max_memory = linker_max_memory,
         .linker_shared_memory = linker_shared_memory,

...	@@ -643,6 +643,7 @@ pub const InitOptions = struct {	...	@@ -643,6 +643,7 @@ pub const InitOptions = struct {
643	linker_import_symbols: bool = false,	643	linker_import_symbols: bool = false,
644	linker_import_table: bool = false,	644	linker_import_table: bool = false,
645	linker_export_table: bool = false,	645	linker_export_table: bool = false,
		646	linker_no_entry: bool = false,
646	linker_initial_memory: ?u64 = null,	647	linker_initial_memory: ?u64 = null,
647	linker_max_memory: ?u64 = null,	648	linker_max_memory: ?u64 = null,
648	linker_shared_memory: bool = false,	649	linker_shared_memory: bool = false,
...	@@ -1614,6 +1615,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {	...	@@ -1614,6 +1615,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
1614	.import_symbols = options.linker_import_symbols,	1615	.import_symbols = options.linker_import_symbols,
1615	.import_table = options.linker_import_table,	1616	.import_table = options.linker_import_table,
1616	.export_table = options.linker_export_table,	1617	.export_table = options.linker_export_table,
		1618	.no_entry = options.linker_no_entry,
1617	.initial_memory = options.linker_initial_memory,	1619	.initial_memory = options.linker_initial_memory,
1618	.max_memory = options.linker_max_memory,	1620	.max_memory = options.linker_max_memory,
1619	.shared_memory = options.linker_shared_memory,	1621	.shared_memory = options.linker_shared_memory,
...	@@ -2577,6 +2579,7 @@ fn addNonIncrementalStuffToCacheManifest(comp: Compilation, man: Cache.Manifes	...	@@ -2577,6 +2579,7 @@ fn addNonIncrementalStuffToCacheManifest(comp: Compilation, man: Cache.Manifes
2577	man.hash.addOptional(comp.bin_file.options.max_memory);	2579	man.hash.addOptional(comp.bin_file.options.max_memory);
2578	man.hash.add(comp.bin_file.options.shared_memory);	2580	man.hash.add(comp.bin_file.options.shared_memory);
2579	man.hash.addOptional(comp.bin_file.options.global_base);	2581	man.hash.addOptional(comp.bin_file.options.global_base);
		2582	man.hash.add(comp.bin_file.options.no_entry);
2580		2583
2581	// Mach-O specific stuff	2584	// Mach-O specific stuff
2582	man.hash.addListOfBytes(comp.bin_file.options.framework_dirs);	2585	man.hash.addListOfBytes(comp.bin_file.options.framework_dirs);