Stop renaming main symbol for WASI (#3804)

* Don't rename main symbol for WASI

For a long-term solution, this renaming feature should be supported on
wasm-ld because it's not a limitation of WebAssembly.

* Simplify linkerFlagsForRenamingMainFunction to simply return nil

for other than linux and darwin platforms

* Add unit tests for main renaming for each platforms

The call of checkSupportedFrontendFlags is moved from BuildPlan to test
it in file system independently. The check needs to access temp file,
but the in-memory fs doesn't allow that.

* Rename {should,can}RenameEntrypointFunctionName

Author: kateinoigakukun

Sources/Build/BuildPlan.swift

@@ -115,13 +115,16 @@ extension BuildParameters {
 
     /// Computes the linker flags to use in order to rename a module-named main function to 'main' for the target platform, or nil if the linker doesn't support it for the platform.
     fileprivate func linkerFlagsForRenamingMainFunction(of target: ResolvedTarget) -> [String]? {
-        var args: [String] = []
+        let args: [String]
         if self.triple.isDarwin() {
             args = ["-alias", "_\(target.c99name)_main", "_main"]
         }
         else if self.triple.isLinux() {
             args = ["--defsym", "main=\(target.c99name)_main"]
         }
+        else {
+            return nil
+        }
         return args.flatMap { ["-Xlinker", $0] }
     }
 
@@ -745,10 +748,9 @@ public final class SwiftTargetBuildDescription {
             // we can rename the symbol unconditionally.
             // No `-` for these flags because the set of Strings in driver.supportedFrontendFlags do
             // not have a leading `-`
-            if SwiftTargetBuildDescription.checkSupportedFrontendFlags(flags: ["entry-point-function-name"], fileSystem: self.fileSystem) {
-                if buildParameters.linkerFlagsForRenamingMainFunction(of: target) != nil {
-                    args += ["-Xfrontend", "-entry-point-function-name", "-Xfrontend", "\(target.c99name)_main"]
-                }
+            if buildParameters.canRenameEntrypointFunctionName,
+               buildParameters.linkerFlagsForRenamingMainFunction(of: target) != nil {
+                args += ["-Xfrontend", "-entry-point-function-name", "-Xfrontend", "\(target.c99name)_main"]
             }
         }
 
@@ -1228,7 +1230,8 @@ public final class ProductBuildDescription {
             // we will instead have generated a source file containing the redirect.
             // Support for linking tests againsts executables is conditional on the tools
             // version of the package that defines the executable product.
-            if product.executableModule.underlyingTarget is SwiftTarget, toolsVersion >= .v5_5 {
+            if product.executableModule.underlyingTarget is SwiftTarget, toolsVersion >= .v5_5,
+               buildParameters.canRenameEntrypointFunctionName {
                 if let flags = buildParameters.linkerFlagsForRenamingMainFunction(of: product.executableModule) {
                     args += flags
                 }

Sources/Commands/SwiftTool.swift

@@ -869,6 +869,9 @@ public class SwiftTool {
                 xcbuildFlags: options.xcbuildFlags,
                 jobs: options.jobs ?? UInt32(ProcessInfo.processInfo.activeProcessorCount),
                 shouldLinkStaticSwiftStdlib: options.shouldLinkStaticSwiftStdlib,
+                canRenameEntrypointFunctionName: SwiftTargetBuildDescription.checkSupportedFrontendFlags(
+                    flags: ["entry-point-function-name"], fileSystem: localFileSystem
+                ),
                 sanitizers: options.enabledSanitizers,
                 enableCodeCoverage: options.shouldEnableCodeCoverage,
                 indexStoreMode: options.indexStoreMode.indexStoreMode,

Sources/SPMBuildCore/BuildParameters.swift

@@ -133,6 +133,9 @@ public struct BuildParameters: Encodable {
     /// Whether to create dylibs for dynamic library products.
     public var shouldCreateDylibForDynamicProducts: Bool
 
+    /// Whether to enable the entry-point-function-name feature.
+    public var canRenameEntrypointFunctionName: Bool
+
     /// The current build environment.
     public var buildEnvironment: BuildEnvironment {
         BuildEnvironment(platform: currentPlatform, configuration: configuration)
@@ -182,6 +185,7 @@ public struct BuildParameters: Encodable {
         jobs: UInt32 = UInt32(ProcessInfo.processInfo.activeProcessorCount),
         shouldLinkStaticSwiftStdlib: Bool = false,
         shouldEnableManifestCaching: Bool = false,
+        canRenameEntrypointFunctionName: Bool = false,
         shouldCreateDylibForDynamicProducts: Bool = true,
         sanitizers: EnabledSanitizers = EnabledSanitizers(),
         enableCodeCoverage: Bool = false,
@@ -211,6 +215,7 @@ public struct BuildParameters: Encodable {
         self.shouldLinkStaticSwiftStdlib = shouldLinkStaticSwiftStdlib
         self.shouldEnableManifestCaching = shouldEnableManifestCaching
         self.shouldCreateDylibForDynamicProducts = shouldCreateDylibForDynamicProducts
+        self.canRenameEntrypointFunctionName = canRenameEntrypointFunctionName
         self.sanitizers = sanitizers
         self.enableCodeCoverage = enableCodeCoverage
         self.indexStoreMode = indexStoreMode

Tests/BuildTests/BuildPlanTests.swift

@@ -63,6 +63,7 @@ final class BuildPlanTests: XCTestCase {
         toolchain: SPMBuildCore.Toolchain = MockToolchain(),
         flags: BuildFlags = BuildFlags(),
         shouldLinkStaticSwiftStdlib: Bool = false,
+        canRenameEntrypointFunctionName: Bool = false,
         destinationTriple: TSCUtility.Triple = hostTriple,
         indexStoreMode: BuildParameters.IndexStoreMode = .off,
         useExplicitModuleBuild: Bool = false
@@ -76,6 +77,7 @@ final class BuildPlanTests: XCTestCase {
             flags: flags,
             jobs: 3,
             shouldLinkStaticSwiftStdlib: shouldLinkStaticSwiftStdlib,
+            canRenameEntrypointFunctionName: canRenameEntrypointFunctionName,
             indexStoreMode: indexStoreMode,
             useExplicitModuleBuild: useExplicitModuleBuild
         )
@@ -1826,6 +1828,51 @@ final class BuildPlanTests: XCTestCase {
         XCTAssertEqual(testPathExtension, "wasm")
     }
 
+    func testEntrypointRenaming() throws {
+        let fs = InMemoryFileSystem(emptyFiles:
+            "/Pkg/Sources/exe/main.swift"
+        )
+
+        let observability = ObservabilitySystem.makeForTesting()
+        let graph = try loadPackageGraph(
+            fs: fs,
+            manifests: [
+                Manifest.createRootManifest(
+                    name: "Pkg",
+                    path: .init("/Pkg"),
+                    toolsVersion: .v5_5,
+                    targets: [
+                        TargetDescription(name: "exe", type: .executable),
+                    ]),
+            ],
+            observabilityScope: observability.topScope
+        )
+
+        func createResult(for triple: TSCUtility.Triple) throws -> BuildPlanResult {
+            BuildPlanResult(plan: try BuildPlan(
+                buildParameters: mockBuildParameters(canRenameEntrypointFunctionName: true, destinationTriple: triple),
+                graph: graph,
+                fileSystem: fs,
+                observabilityScope: observability.topScope
+            ))
+        }
+        let supportingTriples: [TSCUtility.Triple] = [.x86_64Linux, .macOS]
+        for triple in supportingTriples {
+            let result = try createResult(for: triple)
+            let exe = try result.target(for: "exe").swiftTarget().compileArguments()
+            XCTAssertMatch(exe, ["-Xfrontend", "-entry-point-function-name", "-Xfrontend", "exe_main"])
+            let linkExe = try result.buildProduct(for: "exe").linkArguments()
+            XCTAssertMatch(linkExe, [.contains("exe_main")])
+        }
+
+        let unsupportingTriples: [TSCUtility.Triple] = [.wasi, .windows]
+        for triple in unsupportingTriples {
+            let result = try createResult(for: triple)
+            let exe = try result.target(for: "exe").swiftTarget().compileArguments()
+            XCTAssertNoMatch(exe, ["-entry-point-function-name"])
+        }
+    }
+
     func testIndexStore() throws {
         let fs = InMemoryFileSystem(emptyFiles:
             "/Pkg/Sources/exe/main.swift",