compiler: push entry symbol name resolution into the linker

This is necessary because on COFF, the entry symbol name is not known
until the linker has looked at the set of global symbol names to
determine which of the four possible main entry points is present.

Author: andrewrk

src/Compilation.zig

@@ -933,7 +933,7 @@ pub const LinkObject = struct {
     loption: bool = false,
 };
 
-pub const InitOptions = struct {
+pub const CreateOptions = struct {
     zig_lib_directory: Directory,
     local_cache_directory: Directory,
     global_cache_directory: Directory,
@@ -1063,7 +1063,7 @@ pub const InitOptions = struct {
     /// infinite recursion.
     skip_linker_dependencies: bool = false,
     hash_style: link.File.Elf.HashStyle = .both,
-    entry: ?[]const u8 = null,
+    entry: Entry = .default,
     force_undefined_symbols: std.StringArrayHashMapUnmanaged(void) = .{},
     stack_size: ?u64 = null,
     image_base: ?u64 = null,
@@ -1098,6 +1098,8 @@ pub const InitOptions = struct {
     /// (Windows) PDB output path
     pdb_out_path: ?[]const u8 = null,
     error_limit: ?Compilation.Module.ErrorInt = null,
+
+    pub const Entry = link.File.OpenOptions.Entry;
 };
 
 fn addModuleTableToCacheHash(
@@ -1168,7 +1170,7 @@ fn addModuleTableToCacheHash(
     }
 }
 
-pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
+pub fn create(gpa: Allocator, options: CreateOptions) !*Compilation {
     const output_mode = options.config.output_mode;
     const is_dyn_lib = switch (output_mode) {
         .Obj, .Exe => false,
@@ -1552,6 +1554,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
             .dynamicbase = options.linker_dynamicbase,
             .major_subsystem_version = options.major_subsystem_version,
             .minor_subsystem_version = options.minor_subsystem_version,
+            .entry = options.entry,
             .stack_size = options.stack_size,
             .image_base = options.image_base,
             .version_script = options.version_script,

src/Compilation/Config.zig

@@ -55,7 +55,6 @@ export_memory: bool,
 shared_memory: bool,
 is_test: bool,
 test_evented_io: bool,
-entry: ?[]const u8,
 debug_format: DebugFormat,
 root_strip: bool,
 root_error_tracing: bool,
@@ -100,12 +99,6 @@ pub const Options = struct {
     use_lld: ?bool = null,
     use_clang: ?bool = null,
     lto: ?bool = null,
-    entry: union(enum) {
-        default,
-        disabled,
-        enabled,
-        named: []const u8,
-    } = .default,
     /// WASI-only. Type of WASI execution model ("command" or "reactor").
     wasi_exec_model: ?std.builtin.WasiExecModel = null,
     import_memory: ?bool = null,
@@ -123,8 +116,6 @@ pub const ResolveError = error{
     ObjectFilesCannotShareMemory,
     SharedMemoryRequiresAtomicsAndBulkMemory,
     ThreadsRequireSharedMemory,
-    UnknownTargetEntryPoint,
-    NonExecutableEntryPoint,
     EmittingLlvmModuleRequiresLlvmBackend,
     LlvmLacksTargetSupport,
     ZigLacksTargetSupport,
@@ -352,25 +343,6 @@ pub fn resolve(options: Options) ResolveError!Config {
         break :b false;
     };
 
-    const entry: ?[]const u8 = switch (options.entry) {
-        .disabled => null,
-        .default => b: {
-            if (options.output_mode != .Exe) break :b null;
-
-            // When producing C source code, the decision of entry point is made
-            // when compiling the C code, not when producing the C code.
-            if (target.ofmt == .c) break :b null;
-
-            break :b target_util.defaultEntrySymbolName(target, wasi_exec_model) orelse
-                return error.UnknownTargetEntryPoint;
-        },
-        .enabled => target_util.defaultEntrySymbolName(target, wasi_exec_model) orelse
-            return error.UnknownTargetEntryPoint,
-        .named => |name| name,
-    };
-    if (entry != null and options.output_mode != .Exe)
-        return error.NonExecutableEntryPoint;
-
     const any_unwind_tables = options.any_unwind_tables or
         link_libunwind or target_util.needUnwindTables(target);
 
@@ -519,7 +491,6 @@ pub fn resolve(options: Options) ResolveError!Config {
         .use_llvm = use_llvm,
         .use_lib_llvm = use_lib_llvm,
         .use_lld = use_lld,
-        .entry = entry,
         .wasi_exec_model = wasi_exec_model,
         .debug_format = debug_format,
         .root_strip = root_strip,

src/link.zig

@@ -83,6 +83,8 @@ pub const File = struct {
         symbol_count_hint: u64 = 32,
         program_code_size_hint: u64 = 256 * 1024,
 
+        /// This may depend on what symbols are found during the linking process.
+        entry: Entry,
         /// Virtual address of the entry point procedure relative to image base.
         entry_addr: ?u64,
         stack_size: ?u64,
@@ -169,6 +171,13 @@ pub const File = struct {
         module_definition_file: ?[]const u8,
 
         wasi_emulated_libs: []const wasi_libc.CRTFile,
+
+        pub const Entry = union(enum) {
+            default,
+            disabled,
+            enabled,
+            named: []const u8,
+        };
     };
 
     /// Attempts incremental linking, if the file already exists. If

src/link/Coff.zig

@@ -17,6 +17,7 @@ dynamicbase: bool,
 major_subsystem_version: u16,
 minor_subsystem_version: u16,
 lib_dirs: []const []const u8,
+entry: link.File.OpenOptions.Entry,
 entry_addr: ?u32,
 module_definition_file: ?[]const u8,
 pdb_out_path: ?[]const u8,
@@ -303,7 +304,12 @@ pub fn createEmpty(
             .Obj => 0,
         },
 
+        // Subsystem depends on the set of public symbol names from linked objects.
+        // See LinkerDriver::inferSubsystem from the LLD project for the flow chart.
         .subsystem = options.subsystem,
+
+        .entry = options.entry,
+
         .tsaware = options.tsaware,
         .nxcompat = options.nxcompat,
         .dynamicbase = options.dynamicbase,
@@ -2498,7 +2504,20 @@ inline fn getSizeOfImage(self: Coff) u32 {
 /// Returns symbol location corresponding to the set entrypoint (if any).
 pub fn getEntryPoint(self: Coff) ?SymbolWithLoc {
     const comp = self.base.comp;
-    const entry_name = comp.config.entry orelse return null;
+
+    // TODO This is incomplete.
+    // The entry symbol name depends on the subsystem as well as the set of
+    // public symbol names from linked objects.
+    // See LinkerDriver::findDefaultEntry from the LLD project for the flow chart.
+    const entry_name = switch (self.entry) {
+        .disabled => return null,
+        .default => switch (comp.config.output_mode) {
+            .Exe => "wWinMainCRTStartup",
+            .Obj, .Lib => return null,
+        },
+        .enabled => "wWinMainCRTStartup",
+        .named => |name| name,
+    };
     const global_index = self.resolver.get(entry_name) orelse return null;
     return self.globals.items[global_index];
 }

src/link/Coff/lld.zig

@@ -52,6 +52,13 @@ pub fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Nod
     const link_in_crt = comp.config.link_libc and is_exe_or_dyn_lib;
     const target = comp.root_mod.resolved_target.result;
     const optimize_mode = comp.root_mod.optimize_mode;
+    const entry_name: ?[]const u8 = switch (self.entry) {
+        // This logic isn't quite right for disabled or enabled. No point in fixing it
+        // when the goal is to eliminate dependency on LLD anyway.
+        // https://github.com/ziglang/zig/issues/17751
+        .disabled, .default, .enabled => null,
+        .named => |name| name,
+    };
 
     // See link/Elf.zig for comments on how this mechanism works.
     const id_symlink_basename = "lld.id";
@@ -80,7 +87,7 @@ pub fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Nod
             }
         }
         try man.addOptionalFile(module_obj_path);
-        man.hash.addOptionalBytes(comp.config.entry);
+        man.hash.addOptionalBytes(entry_name);
         man.hash.add(self.base.stack_size);
         man.hash.add(self.image_base);
         man.hash.addListOfBytes(self.lib_dirs);
@@ -218,8 +225,8 @@ pub fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Nod
             try argv.append("-DLL");
         }
 
-        if (comp.config.entry) |entry| {
-            try argv.append(try allocPrint(arena, "-ENTRY:{s}", .{entry}));
+        if (entry_name) |name| {
+            try argv.append(try allocPrint(arena, "-ENTRY:{s}", .{name}));
         }
 
         if (self.tsaware) {
@@ -441,7 +448,7 @@ pub fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Nod
                     }
                 } else {
                     try argv.append("-NODEFAULTLIB");
-                    if (!is_lib and comp.config.entry == null) {
+                    if (!is_lib and entry_name == null) {
                         if (comp.module) |module| {
                             if (module.stage1_flags.have_winmain_crt_startup) {
                                 try argv.append("-ENTRY:WinMainCRTStartup");

src/link/Elf.zig

@@ -25,6 +25,7 @@ linker_script: ?[]const u8,
 version_script: ?[]const u8,
 print_icf_sections: bool,
 print_map: bool,
+entry_name: ?[]const u8,
 
 ptr_width: PtrWidth,
 
@@ -290,6 +291,13 @@ pub fn createEmpty(
         .page_size = page_size,
         .default_sym_version = default_sym_version,
 
+        .entry_name = switch (options.entry) {
+            .disabled => null,
+            .default => if (output_mode != .Exe) null else defaultEntrySymbolName(target.cpu.arch),
+            .enabled => defaultEntrySymbolName(target.cpu.arch),
+            .named => |name| name,
+        },
+
         .image_base = b: {
             if (is_dyn_lib) break :b 0;
             if (output_mode == .Exe and comp.config.pie) break :b 0;
@@ -1305,7 +1313,7 @@ pub fn flushModule(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node
 
     // Look for entry address in objects if not set by the incremental compiler.
     if (self.entry_index == null) {
-        if (comp.config.entry) |name| {
+        if (self.entry_name) |name| {
             self.entry_index = self.globalByName(name);
         }
     }
@@ -1679,9 +1687,8 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
             }
         }
 
-        if (comp.config.entry) |entry| {
-            try argv.append("--entry");
-            try argv.append(entry);
+        if (self.entry_name) |name| {
+            try argv.appendSlice(&.{ "--entry", name });
         }
 
         for (self.base.rpath_list) |rpath| {
@@ -2427,7 +2434,7 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
 
         // We can skip hashing libc and libc++ components that we are in charge of building from Zig
         // installation sources because they are always a product of the compiler version + target information.
-        man.hash.addOptionalBytes(comp.config.entry);
+        man.hash.addOptionalBytes(self.entry_name);
         man.hash.add(self.image_base);
         man.hash.add(self.base.gc_sections);
         man.hash.addOptional(self.sort_section);
@@ -2563,9 +2570,8 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
             .ReleaseFast, .ReleaseSafe => try argv.append("-O3"),
         }
 
-        if (comp.config.entry) |entry| {
-            try argv.append("--entry");
-            try argv.append(entry);
+        if (self.entry_name) |name| {
+            try argv.appendSlice(&.{ "--entry", name });
         }
 
         for (self.base.force_undefined_symbols.keys()) |sym| {
@@ -6512,6 +6518,13 @@ const RelaSectionTable = std.AutoArrayHashMapUnmanaged(u32, RelaSection);
 pub const R_X86_64_ZIG_GOT32 = elf.R_X86_64_NUM + 1;
 pub const R_X86_64_ZIG_GOTPCREL = elf.R_X86_64_NUM + 2;
 
+fn defaultEntrySymbolName(cpu_arch: std.Target.Cpu.Arch) []const u8 {
+    return switch (cpu_arch) {
+        .mips, .mipsel, .mips64, .mips64el => "__start",
+        else => "_start",
+    };
+}
+
 const std = @import("std");
 const build_options = @import("build_options");
 const builtin = @import("builtin");

src/link/MachO.zig

@@ -1,4 +1,5 @@
 base: File,
+entry_name: ?[]const u8,
 
 /// If this is not null, an object file is created by LLVM and emitted to zcu_object_sub_path.
 llvm_object: ?*LlvmObject = null,
@@ -231,6 +232,12 @@ pub fn createEmpty(
         .install_name = options.install_name,
         .entitlements = options.entitlements,
         .compatibility_version = options.compatibility_version,
+        .entry_name = switch (options.entry) {
+            .disabled => null,
+            .default => if (output_mode != .Exe) null else default_entry_symbol_name,
+            .enabled => default_entry_symbol_name,
+            .named => |name| name,
+        },
     };
     if (use_llvm and comp.config.have_zcu) {
         self.llvm_object = try LlvmObject.create(arena, comp);
@@ -1629,8 +1636,9 @@ pub fn resolveSymbols(self: *MachO) !void {
     // we search for it in libraries should there be no object files specified
     // on the linker line.
     if (output_mode == .Exe) {
-        const entry_name = comp.config.entry.?;
-        _ = try self.addUndefined(entry_name, .{});
+        if (self.entry_name) |entry_name| {
+            _ = try self.addUndefined(entry_name, .{});
+        }
     }
 
     // Force resolution of any symbols requested by the user.
@@ -5085,8 +5093,7 @@ pub fn getStubsEntryAddress(self: *MachO, sym_with_loc: SymbolWithLoc) ?u64 {
 /// Returns symbol location corresponding to the set entrypoint if any.
 /// Asserts output mode is executable.
 pub fn getEntryPoint(self: MachO) ?SymbolWithLoc {
-    const comp = self.base.comp;
-    const entry_name = comp.config.entry orelse return null;
+    const entry_name = self.entry_name orelse return null;
     const global = self.getGlobal(entry_name) orelse return null;
     return global;
 }
@@ -5645,6 +5652,8 @@ pub fn logAtom(self: *MachO, atom_index: Atom.Index, logger: anytype) void {
     }
 }
 
+const default_entry_symbol_name = "_main";
+
 pub const base_tag: File.Tag = File.Tag.macho;
 pub const N_DEAD: u16 = @as(u16, @bitCast(@as(i16, -1)));
 pub const N_BOUNDARY: u16 = @as(u16, @bitCast(@as(i16, -2)));

src/link/MachO/zld.zig

@@ -276,9 +276,8 @@ pub fn linkWithZld(
                 try argv.append("-dead_strip_dylibs");
             }
 
-            if (comp.config.entry) |entry| {
-                try argv.append("-e");
-                try argv.append(entry);
+            if (macho_file.entry_name) |entry_name| {
+                try argv.appendSlice(&.{ "-e", entry_name });
             }
 
             for (objects) |obj| {